@haystackeditor/cli 0.24.1 → 0.25.1

package/dist/capture/adapters/next.js

@@ -0,0 +1,494 @@
+/**
+ * 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; 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, several top-level segments) are 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 { readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+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, 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);
+    if (optionalCatchAll)
+        return { kind: 'splat', name: paramName(optionalCatchAll[1]), optional: true };
+    const catchAll = /^\[\.\.\.(.+)\]$/.exec(name);
+    if (catchAll)
+        return { kind: 'splat', name: paramName(catchAll[1]), optional: false };
+    const dynamic = /^\[(.+)\]$/.exec(name);
+    if (dynamic)
+        return { kind: 'param', name: paramName(dynamic[1]), optional: false };
+    if (name.includes('['))
+        return { kind: 'param', name: paramName(name), optional: false, inexact: `a segment mixing text and a parameter (${name})` };
+    let literal = name;
+    try {
+        literal = decodeURIComponent(name);
+    }
+    catch { /* a name that is not percent-encoding stays as it is */ }
+    return { kind: 'literal', value: literal };
+}
+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` };
+    }
+    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` };
+}
+/** The files in `dir` named `<base>.<anything>`. */
+function namedLike(dir, base) {
+    let names;
+    try {
+        names = readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    return names.filter(name => name.startsWith(`${base}.`) && isFile(join(dir, name)));
+}
+/** 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 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) {
+    const first = ast.program.body.find((statement) => statement.type === 'ImportDeclaration');
+    if (!first)
+        return { quote: '\'', semicolon: ';' };
+    return { quote: code[first.source.start], semicolon: code.slice(first.start, first.end).trimEnd().endsWith(';') ? ';' : '' };
+}
+const ALIASES = ['Script', 'HaystackScript', 'HaystackCaptureScript', 'HaystackNextScript'];
+/** The name for next/script's Script at `site` (the element the tag goes into): an import whose binding the site actually
+ * sees, else a new import under an alias nothing along the site's scope chain binds and the module does not use as a
+ * global; neither is a manual step (a local `Script` would shadow the import there). */
+function scriptImport(ast, code, site) {
+    const sitePath = pathOf(ast, site);
+    if (!sitePath)
+        return { manual: 'init could not resolve the names in scope where the tag goes' };
+    const components = defaultImportNames(ast, 'next/script');
+    for (const local of components) {
+        const binding = sitePath.scope.getBinding(local);
+        if (binding?.kind === 'module' && binding.path.parent?.source?.value === 'next/script')
+            return { name: local, components, edit: null };
+    }
+    const program = sitePath.scope.getProgramParent();
+    const name = ALIASES.find(candidate => !sitePath.scope.hasBinding(candidate, { noGlobals: true }) && !program.hasBinding(candidate, { noGlobals: true })
+        && !program.hasGlobal(candidate));
+    if (!name)
+        return { manual: `every name init would import next/script's Script as (${ALIASES.join(', ')}) is taken where the tag goes` };
+    const { quote, semicolon } = importStyle(ast, code);
+    const at = importInsertion(ast, code);
+    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}` } };
+}
+/** 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');
+    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, body);
+    if ('manual' in script)
+        return script;
+    const rendered = nextScriptTags(tags, script.name);
+    const edits = placeTags(code, ourJsxElements(ast, script.components), body.closingElement.start, rendered, indentUnit(code));
+    if ('manual' in edits)
+        return edits;
+    if (edits.length === 0)
+        return { target: layout, content: code };
+    const result = checkedResult(code, layout, script.edit ? [...edits, script.edit] : edits, script.components, rendered);
+    return typeof result === 'string' ? { target: layout, content: result } : result;
+}
+/** The JSX the default-exported App component returns (through HOC wrappers and class render methods). */
+function appReturn(ast) {
+    const exported = ast.program.body.find((statement) => statement.type === 'ExportDefaultDeclaration')?.declaration;
+    if (!exported)
+        return { manual: 'pages/_app has no default export' };
+    const resolveComponent = (node, depth) => {
+        const current = unwrapTs(node);
+        if (!current || depth > 5)
+            return null;
+        if (current.type === 'CallExpression' && current.arguments.length > 0)
+            return resolveComponent(current.arguments[0], depth + 1);
+        if (current.type !== 'Identifier')
+            return current;
+        for (const statement of ast.program.body) {
+            const declaration = statement.type === 'ExportNamedDeclaration' ? statement.declaration : statement;
+            if ((declaration?.type === 'FunctionDeclaration' || declaration?.type === 'ClassDeclaration') && declaration.id?.name === current.name)
+                return declaration;
+            if (declaration?.type === 'VariableDeclaration') {
+                const found = declaration.declarations.find((item) => item.id.type === 'Identifier' && item.id.name === current.name);
+                if (found?.init)
+                    return resolveComponent(found.init, depth + 1);
+            }
+        }
+        return null;
+    };
+    let component = resolveComponent(exported, 0);
+    if (component?.type === 'ClassDeclaration' || component?.type === 'ClassExpression') {
+        component = component.body.body.find((member) => member.type === 'ClassMethod' && member.key.name === 'render') ?? null;
+    }
+    if (!component || !['FunctionDeclaration', 'FunctionExpression', 'ArrowFunctionExpression', 'ClassMethod'].includes(component.type)) {
+        return { manual: 'pages/_app\'s default export is not a component init can read' };
+    }
+    if (component.body.type !== 'BlockStatement')
+        return unwrapTs(component.body);
+    const returns = [];
+    walk(component.body, node => {
+        if (node !== component.body && /Function|ClassMethod|ObjectMethod/.test(node.type))
+            return false;
+        if (node.type === 'ReturnStatement' && node.argument)
+            returns.push(unwrapTs(node.argument));
+    });
+    return returns.length === 1 ? returns[0] : { manual: `pages/_app's component has ${returns.length} return statements, not one` };
+}
+function newApp(name, tags, typescript) {
+    const rendered = nextScriptTags(tags, name).map(tag => `      ${tag}\n`).join('');
+    return `${typescript ? 'import type { AppProps } from \'next/app\';\n' : ''}import ${name} from 'next/script';
+
+export default function App({ Component, pageProps }${typescript ? ': AppProps' : ''}) {
+  return (
+    <>
+      <Component {...pageProps} />
+${rendered}    </>
+  );
+}
+`;
+}
+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'));
+        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);
+    if (!ast)
+        return { manual: `${app} does not parse` };
+    const ours = ourJsxElements(ast, defaultImportNames(ast, 'next/script'));
+    const returned = ours.length > 0 ? ours[0] : appReturn(ast);
+    if ('manual' in returned)
+        return returned;
+    const script = scriptImport(ast, code, returned);
+    if ('manual' in script)
+        return script;
+    const rendered = nextScriptTags(tags, script.name);
+    const unit = indentUnit(code);
+    let edits;
+    if (ours.length > 0) {
+        edits = placeTags(code, ours, null, rendered, unit);
+    }
+    else {
+        if (returned.type === 'JSXFragment') {
+            edits = placeTags(code, [], returned.closingFragment.start, rendered, unit);
+        }
+        else if (returned.type === 'JSXElement') {
+            const inner = startsLine(code, returned.start) ? reindented(returned, code, unit) : null;
+            const indent = lineIndent(code, returned.start);
+            const text = inner === null
+                ? `<>${code.slice(returned.start, returned.end)}${rendered.join('')}</>`
+                : `<>\n${indent}${unit}${inner}\n${rendered.map(tag => `${indent}${unit}${tag}\n`).join('')}${indent}</>`;
+            edits = [{ start: returned.start, end: returned.end, text }];
+        }
+        else {
+            return { manual: 'pages/_app\'s component does not return JSX' };
+        }
+    }
+    if ('manual' in edits)
+        return edits;
+    if (edits.length === 0)
+        return { target: app, content: code };
+    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)
+        return null;
+    const rootRouters = isDirectory(join(ctx.appDir, 'app')) || isDirectory(join(ctx.appDir, 'pages'));
+    const base = rootRouters ? ctx.appDir : join(ctx.appDir, 'src');
+    const appRouter = isDirectory(join(base, 'app')) ? join(base, 'app') : null;
+    const pagesRouter = isDirectory(join(base, 'pages')) ? join(base, 'pages') : null;
+    if (!appRouter && !pagesRouter)
+        return null;
+    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.*'))]
+        .filter((item) => Boolean(item));
+    const supported = appRouter ? [13, 14, 15, 16] : [11, 12, 13, 14, 15, 16];
+    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,
+        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(ctx, appRouter, tags, extensions),
+                pagesRouter && await pagesAppEdit(ctx, pagesRouter, tags, extensions)]) {
+                if (!edit)
+                    continue;
+                if ('manual' in edit)
+                    return edit;
+                edits.push(edit);
+            }
+            return edits;
+        },
+        manualTag: tags => [
+            `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(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'];
+        },
+    };
+}