@haystackeditor/cli 0.24.0 → 0.25.0

package/dist/capture/adapters/jsx-edit.js

@@ -0,0 +1,81 @@
+/** Placing init's tags in a JSX document (Next.js layouts and _app, React Router / Remix root): exactly once, replacing
+ * an earlier version in place, and checked by parsing the result. */
+import { applyEdits, jsxName, jsxStringAttribute, lineIndent, parseFile, startsLine, walk } from '../js-ast.js';
+import { ourScriptKind } from '../tag.js';
+export function jsxElementsNamed(ast, name) {
+    const found = [];
+    walk(ast.program, node => { if (node.type === 'JSXElement' && jsxName(node) === name)
+        found.push(node); });
+    return found;
+}
+/** init's own script elements: one of `components` (Script, script) whose src is one of init's files. */
+export function ourJsxElements(ast, components) {
+    const found = [];
+    walk(ast.program, node => {
+        if (node.type !== 'JSXElement')
+            return;
+        const name = jsxName(node);
+        const src = name !== null && components.includes(name) ? jsxStringAttribute(node, 'src') : null;
+        if (src !== null && ourScriptKind(src) !== null)
+            found.push(node);
+    });
+    return found;
+}
+function lineRange(code, node) {
+    const lineStart = code.lastIndexOf('\n', node.start - 1) + 1;
+    const lineEnd = code.indexOf('\n', node.end);
+    const end = lineEnd === -1 ? code.length : lineEnd + 1;
+    return code.slice(lineStart, node.start).trim() === '' && code.slice(node.end, end).trim() === ''
+        ? { start: lineStart, end } : { start: node.start, end: node.end };
+}
+/**
+ * Edits that leave exactly `tags` as init's elements: none when they are already there; the first earlier element
+ * replaced in place and the others removed when they differ; else inserted before `closingStart` (a `</body>`, `</head>`
+ * or `</>`), one per line at the children's indentation when the closing tag starts its own line.
+ */
+export function placeTags(code, ours, closingStart, tags, unit) {
+    if (ours.length > 0) {
+        const current = ours.map(node => code.slice(node.start, node.end));
+        if (current.length === tags.length && current.every((text, index) => text === tags[index]))
+            return [];
+        const indent = lineIndent(code, ours[0].start);
+        return [
+            { start: ours[0].start, end: ours[0].end, text: tags.join(`\n${indent}`) },
+            ...ours.slice(1).map(node => ({ ...lineRange(code, node), text: '' })),
+        ];
+    }
+    if (closingStart === null)
+        return { manual: 'there is no place for the tag' };
+    if (startsLine(code, closingStart)) {
+        const indent = lineIndent(code, closingStart) + unit;
+        const lineStart = code.lastIndexOf('\n', closingStart - 1) + 1;
+        return [{ start: lineStart, end: lineStart, text: tags.map(tag => `${indent}${tag}\n`).join('') }];
+    }
+    return [{ start: closingStart, end: closingStart, text: tags.join('') }];
+}
+/** Applies the edits and proves the result: it parses, and init's elements in it are exactly `tags`. */
+export function checkedResult(code, file, edits, components, tags) {
+    const next = applyEdits(code, edits);
+    const ast = parseFile(next, file);
+    if (!ast)
+        return { manual: 'the edited file would not parse' };
+    const placed = ourJsxElements(ast, components).map(node => next.slice(node.start, node.end));
+    if (placed.length !== tags.length || placed.some((text, index) => text !== tags[index])) {
+        return { manual: 'the edit did not leave exactly one tag' };
+    }
+    return next;
+}
+/** `text` with every line after the first indented by one more `unit`, or null when the text holds a multi-line template
+ * literal or string (a JSX attribute string may span lines), whose content would change. JSX text is insensitive to the
+ * indentation of its lines. */
+export function reindented(node, code, unit) {
+    let multilineTemplate = false;
+    walk(node, inner => {
+        if ((inner.type === 'TemplateLiteral' || inner.type === 'StringLiteral') && code.slice(inner.start, inner.end).includes('\n')) {
+            multilineTemplate = true;
+        }
+    });
+    if (multilineTemplate)
+        return null;
+    return code.slice(node.start, node.end).split('\n').map((line, index) => index === 0 || line === '' ? line : `${unit}${line}`).join('\n');
+}

package/dist/capture/adapters/next.js

@@ -0,0 +1,327 @@
+/**
+ * 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
+ * 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/).
+ *
+ * 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.
+ */
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { defaultImportNames, importInsertion, indentUnit, lineIndent, parseFile, pathOf, 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 { 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']);
+/** 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 };
+}
+/** 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);
+    }
+    return null;
+}
+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)) });
+    }
+    return routes;
+}
+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)) });
+    }
+    return routes;
+}
+/** 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}` } };
+}
+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)' };
+    }
+    const code = readFileSync(layout, 'utf8');
+    const ast = parseFile(code, layout);
+    if (!ast)
+        return { manual: `${layout} does not parse` };
+    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 script = scriptImport(ast, code, bodies[0]);
+    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));
+    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, extensions, tags) {
+    const app = extensions.map(extension => join(pagesRouter, `_app.${extension}`)).find(isFile);
+    if (!app) {
+        const typescript = isFile(join(ctx.appDir, 'tsconfig.json'));
+        return { target: join(pagesRouter, typescript ? '_app.tsx' : '_app.jsx'), 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;
+}
+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 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 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 scripts = ctx.pkg?.scripts ?? {};
+    return {
+        id: 'next',
+        label: `Next.js ${version.version} (${routers})`,
+        manifestAdapter: `next@${version.version}`,
+        blocked: blocked.length > 0 ? blocked.join('; ') : null,
+        looked,
+        staticDir: 'public',
+        async integrate(tags) {
+            const edits = [];
+            for (const edit of [appRouter && await rootLayoutEdit(appRouter, extensions, tags), pagesRouter && await pagesAppEdit(ctx, pagesRouter, extensions, tags)]) {
+                if (!edit)
+                    continue;
+                if ('manual' in edit)
+                    return edit;
+                edits.push(edit);
+            }
+            return edits;
+        },
+        manualTag: tags => [
+            `In the root layout (app/layout, 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) : [])];
+        },
+        chunks: () => (distDirRead.state === 'unreadable' ? [] : chunkIds(join(ctx.appDir, distDir, 'static'), '/_next/static/')),
+        publishDirs: exported ? ['out'] : ['public'],
+    };
+}

package/dist/capture/adapters/nuxt.js

@@ -0,0 +1,192 @@
+/**
+ * Nuxt 3–4 (CAPTURE-V1 rule 8b).
+ *
+ * Tag: an entry of nuxt.config's app.head.script ({ src, integrity, 'data-key', async: true }), which Nuxt renders into
+ * every page's <head>; init creates app, head or script where missing and leaves a config it cannot read to a manual
+ * step. Static output: public/ (Nuxt 4: at the root; Nuxt 3: under srcDir). Routes: the pages directory (index for the
+ * parent's path, [id], [[id]], [...slug], (group) directories); an app without pages/ is one page, `/`. Nitro presets
+ * reshape the output inside `nuxt build`, so the build step publishes the manifest into public/ BEFORE the build,
+ * without chunks. app.baseURL other than / is a manual step.
+ */
+import { readFileSync } from 'node:fs';
+import { join, posix } from 'node:path';
+import { applyEdits, configObject, indentUnit, keyName, lineIndent, parseFile, startsLine, unwrapTs } from '../js-ast.js';
+import { repoPath, resolveVersion, appFile } from '../project.js';
+import { paramName, ruleFor } from '../route-pattern.js';
+import { nuxtScriptEntries, ourScriptKind } from '../tag.js';
+import { configFile, configValue, filesUnder, isDirectory, isFile } from './files.js';
+const PAGE_EXTENSIONS = ['.vue', '.tsx', '.jsx', '.ts', '.js', '.mjs'];
+export function nuxtSegment(name) {
+    if (/^\(.+\)$/.test(name))
+        return null;
+    const optional = /^\[\[([^\]]+)\]\]$/.exec(name);
+    if (optional)
+        return { kind: 'param', name: paramName(optional[1]), optional: true };
+    const rest = /^\[\.\.\.([^\]]+)\]$/.exec(name);
+    if (rest)
+        return { kind: 'splat', name: paramName(rest[1]), optional: true };
+    const param = /^\[([^\]]+)\]$/.exec(name);
+    if (param)
+        return { kind: 'param', name: paramName(param[1]), optional: false };
+    if (name.includes('['))
+        return { kind: 'param', name: paramName(name), optional: false, inexact: `a segment mixing text and a parameter (${name})` };
+    return { kind: 'literal', value: name };
+}
+function property(object, name) {
+    return object.properties.find((candidate) => candidate.type === 'ObjectProperty' && keyName(candidate) === name) ?? null;
+}
+/** Text that adds `text` as the first property of `object`. */
+function firstProperty(code, object, text, unit) {
+    if (object.properties.length === 0) {
+        const indent = lineIndent(code, object.start);
+        return { start: object.start, end: object.end, text: `{\n${indent}${unit}${text},\n${indent}}` };
+    }
+    const first = object.properties[0];
+    if (startsLine(code, first.start)) {
+        const lineStart = code.lastIndexOf('\n', first.start - 1) + 1;
+        return { start: lineStart, end: lineStart, text: `${lineIndent(code, first.start)}${text},\n` };
+    }
+    return { start: first.start, end: first.start, text: `${text}, ` };
+}
+function ourEntries(array) {
+    return array.elements.filter((element) => {
+        if (element?.type !== 'ObjectExpression')
+            return false;
+        const src = property(element, 'src')?.value;
+        return src?.type === 'StringLiteral' && ourScriptKind(src.value) !== null;
+    });
+}
+function configEdit(file, tags) {
+    const code = readFileSync(file, 'utf8');
+    const ast = parseFile(code, file);
+    if (!ast)
+        return { manual: `${file} does not parse` };
+    const config = configObject(ast);
+    if (!config)
+        return { manual: 'nuxt.config does not export a config object init can read' };
+    const unit = indentUnit(code);
+    const entries = nuxtScriptEntries(tags);
+    const array = `[${entries.join(', ')}]`;
+    let edits;
+    const app = property(config, 'app');
+    const head = app && unwrapTs(app.value).type === 'ObjectExpression' ? property(unwrapTs(app.value), 'head') : null;
+    const script = head && unwrapTs(head.value).type === 'ObjectExpression' ? property(unwrapTs(head.value), 'script') : null;
+    if (!app) {
+        edits = [firstProperty(code, config, `app: { head: { script: ${array} } }`, unit)];
+    }
+    else if (unwrapTs(app.value).type !== 'ObjectExpression') {
+        return { manual: 'nuxt.config\'s app is not an object literal' };
+    }
+    else if (!head) {
+        edits = [firstProperty(code, unwrapTs(app.value), `head: { script: ${array} }`, unit)];
+    }
+    else if (unwrapTs(head.value).type !== 'ObjectExpression') {
+        return { manual: 'nuxt.config\'s app.head is not an object literal' };
+    }
+    else if (!script) {
+        edits = [firstProperty(code, unwrapTs(head.value), `script: ${array}`, unit)];
+    }
+    else {
+        const list = unwrapTs(script.value);
+        if (list.type !== 'ArrayExpression')
+            return { manual: 'nuxt.config\'s app.head.script is not an array literal' };
+        const ours = ourEntries(list);
+        const current = ours.map(node => code.slice(node.start, node.end));
+        if (current.length === entries.length && current.every((text, index) => text === entries[index]))
+            return [{ target: file, content: code }];
+        if (ours.length > 0) {
+            edits = [{ start: ours[0].start, end: ours[0].end, text: entries.join(', ') },
+                ...ours.slice(1).map(node => {
+                    const after = code.slice(node.end).match(/^\s*,/);
+                    return { start: node.start, end: node.end + (after ? after[0].length : 0), text: '' };
+                })];
+        }
+        else {
+            const last = list.elements[list.elements.length - 1];
+            if (!last) {
+                edits = [{ start: list.start, end: list.end, text: array }];
+            }
+            else {
+                const between = code.slice(last.end, list.end - 1);
+                const comma = between.indexOf(',');
+                const separator = startsLine(code, last.start) ? `\n${lineIndent(code, last.start)}` : ' ';
+                edits = comma === -1
+                    ? [{ start: last.end, end: last.end, text: entries.map(entry => `,${separator}${entry}`).join('') }]
+                    : [{ start: last.end + comma + 1, end: last.end + comma + 1, text: entries.map(entry => `${separator}${entry},`).join('') }];
+            }
+        }
+    }
+    const next = applyEdits(code, edits);
+    const check = parseFile(next, file);
+    const checkConfig = check ? configObject(check) : null;
+    const checkApp = checkConfig ? property(checkConfig, 'app') : null;
+    const checkHead = checkApp ? property(unwrapTs(checkApp.value), 'head') : null;
+    const checkScript = checkHead ? property(unwrapTs(checkHead.value), 'script') : null;
+    const placed = checkScript ? ourEntries(unwrapTs(checkScript.value)).map(node => next.slice(node.start, node.end)) : [];
+    if (placed.length !== entries.length || placed.some((text, index) => text !== entries[index])) {
+        return { manual: 'the edit to nuxt.config did not leave exactly one tag' };
+    }
+    return [{ target: file, content: next }];
+}
+export async function detectNuxt(ctx) {
+    const version = resolveVersion(ctx, 'nuxt');
+    if (!version)
+        return null;
+    const config = configFile(ctx.appDir, ['nuxt.config.ts', 'nuxt.config.js', 'nuxt.config.mjs', 'nuxt.config.mts']);
+    const where = config.file ? repoPath(ctx, config.file) : appFile(ctx, 'nuxt.config.ts');
+    const blocked = [];
+    const compatibility = configValue(config, ['future', 'compatibilityVersion']);
+    const four = version.major === 4 || (compatibility.state === 'value' && compatibility.value === 4);
+    if (version.major !== 3 && version.major !== 4)
+        blocked.push(`init knows Nuxt 3–4, and this app's version is ${version.version} (${version.from})`);
+    const read = (path, fallback) => {
+        const value = configValue(config, path);
+        if (value.state === 'unreadable' || (value.state === 'value' && typeof value.value !== 'string')) {
+            blocked.push(`${where} sets ${path.join('.')} in a way init cannot read`);
+            return fallback;
+        }
+        return value.state === 'value' ? value.value : fallback;
+    };
+    const srcDir = read(['srcDir'], four ? 'app' : '.');
+    const pagesDir = read(['dir', 'pages'], 'pages');
+    const publicDir = posix.join(four ? '.' : srcDir, read(['dir', 'public'], 'public'));
+    const baseURL = read(['app', 'baseURL'], '/');
+    if (baseURL !== '/')
+        blocked.push(`${where} sets app.baseURL ${baseURL}: the route manifest must be published at the origin root, outside it`);
+    const pages = join(ctx.appDir, srcDir, pagesDir);
+    const scripts = ctx.pkg?.scripts ?? {};
+    const buildScript = typeof scripts.build === 'string' ? 'build' : typeof scripts.generate === 'string' ? 'generate' : null;
+    return {
+        id: 'nuxt',
+        label: `Nuxt ${version.version}`,
+        manifestAdapter: `nuxt@${version.version}`,
+        blocked: blocked.length > 0 ? blocked.join('; ') : null,
+        looked: [where, repoPath(ctx, pages)],
+        staticDir: publicDir,
+        integrate: async (tags) => (config.file ? configEdit(config.file, tags) : { manual: `${where} is missing` }),
+        manualTag: tags => [`In ${where}, under app.head.script:`, ...nuxtScriptEntries(tags)],
+        build: buildScript ? { kind: 'package-script', script: buildScript, phase: 'before' }
+            : { manual: `${appFile(ctx, 'package.json')} has no build or generate script to publish the route manifest before` },
+        async routes() {
+            if (!isDirectory(pages)) {
+                const app = ['app.vue'].map(name => join(ctx.appDir, srcDir, name)).find(isFile);
+                return [{ match: '/', source: repoPath(ctx, app ?? config.file) }];
+            }
+            const routes = [];
+            for (const file of filesUnder(pages)) {
+                const extension = PAGE_EXTENSIONS.find(candidate => file.endsWith(candidate));
+                if (!extension)
+                    continue;
+                const parts = file.slice(0, -extension.length).split('/');
+                const index = parts[parts.length - 1] === 'index';
+                if (index)
+                    parts.pop();
+                const segments = parts.map(nuxtSegment).filter((segment) => segment !== null);
+                routes.push({ ...ruleFor(segments), source: repoPath(ctx, join(pages, file)), rank: index ? 0 : 1 });
+            }
+            return routes;
+        },
+        chunks: () => [],
+        publishDirs: [publicDir],
+    };
+}