@haystackeditor/cli 0.24.0 → 0.25.0

package/dist/capture/adapters/rails.js

@@ -0,0 +1,171 @@
+/**
+ * Rails 6–8 (CAPTURE-V1 rule 8b).
+ *
+ * Tag: an async script before </head> of the app's one HTML layout in app/views/layouts (ERB; mailer layouts are emails
+ * and never get it; several page layouts, or Haml/Slim, are a manual step). Static output: public/.
+ *
+ * Routes: Rails' own route set, which only Rails can evaluate, so the build step is a rake file that runs after
+ * assets:precompile (when the app is booted): it writes the GET routes Rails lists (path spec, controller, action) to
+ * tmp/ and runs `haystack capture manifest --rails-routes <file>` of the CLI package.json pins, never failing the build. Path specs become
+ * patterns: (.:format) is dropped, other optional groups make their segments optional, *glob is a splat. Each route's
+ * source is its controller file. Chunks: none declared.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { withHeadTags, scanHtml } from '../html.js';
+import { gemVersion, repoPath } from '../project.js';
+import { paramName, ruleFor } from '../route-pattern.js';
+import { htmlTags } from '../tag.js';
+import { filesUnder, isFile } from './files.js';
+export const RAKE_FILE = 'lib/tasks/haystack_capture.rake';
+/** The rake file: after assets:precompile, the app's GET routes into tmp/, then the manifest command of the CLI the app
+ * pins (node_modules/.bin, never npx). The command exits 0 whatever happens, and a missing CLI is one warning. */
+export const RAKE_FILE_CONTENT = `# Written by \`haystack init\` (CAPTURE-V1 rule 4). After assets:precompile, publishes this app's route manifest into
+# public/.well-known/haystack-capture/ from the routes Rails itself lists, with the @haystackeditor/cli package.json pins.
+# It never fails the build (rule 13): a manifest that cannot be made only means the tag records nothing on this release,
+# and the previous release's current.json is removed rather than shipped.
+if Rake::Task.task_defined?('assets:precompile')
+  Rake::Task['assets:precompile'].enhance do
+    current = Rails.root.join('public', '.well-known', 'haystack-capture', 'current.json')
+    begin
+      require 'json'
+      require 'fileutils'
+      step = Rails.root.join('node_modules', '.bin', 'haystack-capture-step')
+      if File.exist?(step)
+        routes = Rails.application.routes.routes.filter_map do |route|
+          verb = route.verb.to_s
+          next unless verb.empty? || verb.split('|').include?('GET')
+          next if route.respond_to?(:internal) && route.internal
+          controller = route.defaults[:controller]
+          next unless controller
+          { path: route.path.spec.to_s, controller: controller.to_s, action: route.defaults[:action].to_s }
+        end
+        file = Rails.root.join('tmp', 'haystack-capture-routes.json')
+        FileUtils.mkdir_p(File.dirname(file))
+        File.write(file, JSON.generate(routes))
+        # The step exits 0 whatever happens and removes current.json itself when no manifest was written.
+        system(step.to_s, '--rails-routes', file.to_s, chdir: Rails.root.to_s)
+      else
+        File.delete(current) if File.exist?(current)
+        warn('haystack capture manifest: @haystackeditor/cli is not installed (node_modules/.bin/haystack-capture-step); the build goes on without a route manifest.')
+      end
+    rescue StandardError => e
+      begin
+        File.delete(current) if File.exist?(current)
+      rescue StandardError
+        nil
+      end
+      warn("haystack capture manifest: #{e.class}; the build goes on without a route manifest.")
+    end
+  end
+end
+`;
+/** A Rails path spec (`/users/:id(.:format)`, `(/:locale)/posts/*rest`) as segments (an inexact one marked, route-pattern.ts
+ * ruleFor); null when its parentheses do not balance. */
+export function railsSegments(spec) {
+    const parts = [];
+    let depth = 0;
+    let text = '';
+    let startDepth = -1;
+    const flush = () => {
+        if (text !== '')
+            parts.push({ text, optional: startDepth > 0 });
+        text = '';
+        startDepth = -1;
+    };
+    for (const char of spec.split('(.:format)').join('')) {
+        if (char === '(') {
+            depth += 1;
+            continue;
+        }
+        if (char === ')') {
+            depth -= 1;
+            if (depth < 0)
+                return null;
+            continue;
+        }
+        if (char === '/') {
+            flush();
+            continue;
+        }
+        if (startDepth === -1)
+            startDepth = depth;
+        text += char;
+    }
+    if (depth !== 0)
+        return null;
+    flush();
+    const segments = parts.map(({ text: part, optional }) => {
+        if (/^\*[A-Za-z_][A-Za-z0-9_]*$/.test(part))
+            return { kind: 'splat', name: paramName(part.slice(1)), optional };
+        if (/^:[A-Za-z_][A-Za-z0-9_]*$/.test(part))
+            return { kind: 'param', name: paramName(part.slice(1)), optional };
+        // A segment mixing text and parameters (`:id-:slug`), or an optional literal, has no exact form in the pattern syntax.
+        if (part.includes(':') || part.includes('*') || optional) {
+            return { kind: 'param', name: paramName(part), optional, inexact: `${optional ? 'an optional segment' : 'a segment mixing text and parameters'} (${part})` };
+        }
+        return { kind: 'literal', value: part };
+    });
+    return segments;
+}
+function layouts(appDir) {
+    const dir = join(appDir, 'app', 'views', 'layouts');
+    const files = filesUnder(dir).filter(file => !file.split('/').pop()?.startsWith('mailer') && !file.startsWith('mailer'));
+    const pages = files.filter(file => /\.html\.erb$/.test(file) && scanHtml(readFileSync(join(dir, file), 'utf8')).heads.length > 0);
+    return { erb: pages.map(file => join(dir, file)), other: files.filter(file => /\.html\.(haml|slim)$/.test(file)).map(file => join(dir, file)) };
+}
+export async function detectRails(ctx) {
+    const gemfile = join(ctx.appDir, 'Gemfile');
+    if (!isFile(gemfile) || !isFile(join(ctx.appDir, 'config', 'routes.rb')))
+        return null;
+    if (!/^\s*gem\s+['"]rails['"]/m.test(readFileSync(gemfile, 'utf8')))
+        return null;
+    const version = gemVersion(ctx.appDir, 'rails') ?? gemVersion(ctx.appDir, 'railties');
+    const blocked = [];
+    if (!version || version.major === null || version.major < 6 || version.major > 8) {
+        blocked.push(`init knows Rails 6–8, and this app's version is ${version ? `${version.version} (Gemfile.lock)` : 'not in a Gemfile.lock'}`);
+    }
+    const found = layouts(ctx.appDir);
+    const layoutsPath = repoPath(ctx, join(ctx.appDir, 'app', 'views', 'layouts'));
+    return {
+        id: 'rails',
+        label: `Rails ${version?.version ?? '(unknown version)'}`,
+        manifestAdapter: `rails@${version?.version ?? 'unknown'}`,
+        blocked: blocked.length > 0 ? blocked.join('; ') : null,
+        looked: [layoutsPath, repoPath(ctx, join(ctx.appDir, 'Gemfile.lock'))],
+        staticDir: 'public',
+        async integrate(tags) {
+            if (found.erb.length !== 1) {
+                const other = found.other.length > 0 ? ` (and ${found.other.map(file => repoPath(ctx, file)).join(', ')}, which init does not edit)` : '';
+                return { manual: `${layoutsPath} has ${found.erb.length} ERB page layouts with a <head>${other}, not one` };
+            }
+            const file = found.erb[0];
+            const edit = withHeadTags(readFileSync(file, 'utf8'), htmlTags(tags));
+            return 'manual' in edit ? { manual: `${repoPath(ctx, file)}: ${edit.manual}` } : [{ target: file, content: edit.content }];
+        },
+        manualTag: tags => [`In your page layout (${layoutsPath}/application.html.erb), inside <head>:`, ...htmlTags(tags)],
+        build: { kind: 'rake' },
+        async routes(inputs) {
+            if (!inputs.railsRoutes || !existsSync(inputs.railsRoutes)) {
+                return { manual: 'Rails routes come from the rake task after assets:precompile (--rails-routes); run the app\'s build' };
+            }
+            const listed = JSON.parse(readFileSync(inputs.railsRoutes, 'utf8'));
+            const routes = [];
+            for (const route of listed) {
+                if (typeof route.path !== 'string' || typeof route.controller !== 'string' || !/^[a-z0-9_/]+$/.test(route.controller))
+                    continue;
+                const segments = railsSegments(route.path);
+                // A controller outside app/controllers belongs to a gem or engine (Active Storage, Devise): its pages are not this
+                // repository's files, so they stay `unknown` rather than being joined to a file that did not define them.
+                const controller = join(ctx.appDir, 'app', 'controllers', `${route.controller}_controller.rb`);
+                if (!existsSync(controller))
+                    continue;
+                routes.push(segments ? { ...ruleFor(segments), source: repoPath(ctx, controller) }
+                    : { match: '/', source: repoPath(ctx, controller), inexact: `a path spec the pattern syntax cannot express (${route.path})` });
+            }
+            return routes;
+        },
+        chunks: () => [],
+        publishDirs: ['public'],
+    };
+}

package/dist/capture/adapters/react-router.js

@@ -0,0 +1,432 @@
+/**
+ * React Router 7 framework mode and Remix 2 (CAPTURE-V1 rule 8b).
+ *
+ * Tag: an async <script> as the last child of the root module's one <head> (app/root), which the server renders into
+ * every document. Static output: public/ (copied into <build>/client, or served as is by Remix's classic compiler).
+ *
+ * Routes: React Router's app/routes.ts read statically (route, index, layout and prefix from @react-router/dev/routes,
+ * and flatRoutes from @react-router/fs-routes); Remix 2's flat routes in app/routes/ (the same convention flatRoutes
+ * implements); a routes function or anything init cannot read without running the app is a manual step. Chunks: the JS
+ * under <build>/client (Remix classic: public/build). A preset (Vercel's and others) reshapes the build output inside
+ * the build, so with one the manifest is written into public/ before the build instead, without chunks.
+ */
+import fg from 'fast-glob';
+import { readFileSync } from 'node:fs';
+import { join, posix } from 'node:path';
+import { indentUnit, keyName, literalValue, parseFile, UNREADABLE, unwrapTs, walk } from '../js-ast.js';
+import { repoPath, resolveVersion, appFile } from '../project.js';
+import { paramName, ruleFor } from '../route-pattern.js';
+import { jsxScriptTags } from '../tag.js';
+import { chunkIds, configFile, configValue, firstFile, isDirectory } from './files.js';
+import { checkedResult, jsxElementsNamed, ourJsxElements, placeTags } from './jsx-edit.js';
+const ROUTE_EXTENSIONS = ['js', 'jsx', 'ts', 'tsx', 'md', 'mdx'];
+const ROOT_NAMES = ['root.tsx', 'root.jsx', 'root.ts', 'root.js'];
+/** React Router path text (`about`, `:id`, `:lang?`, `*`, `docs/*`) as segments. */
+export function reactRouterSegments(path) {
+    return path.split('/').filter(part => part !== '').map((part) => {
+        if (part === '*')
+            return { kind: 'splat', name: 'splat', optional: true };
+        const optional = part.endsWith('?');
+        const bare = optional ? part.slice(0, -1) : part;
+        if (bare.startsWith(':'))
+            return { kind: 'param', name: paramName(bare.slice(1)), optional };
+        // An optional literal (`en?`) has no exact form in the pattern syntax (an optional parameter would match a superset).
+        if (optional)
+            return { kind: 'param', name: paramName(bare), optional: true, inexact: `an optional literal segment (${part})` };
+        return { kind: 'literal', value: bare };
+    });
+}
+/* ------------------------------------------------------------ flat routes */
+/** One flat-route id (`concerts.$city`, `_auth.login`, `($lang)._index`, `sitemap[.]xml`) as path segments, whether it
+ * is an index route, and whether its last segment is a pathless layout (which never matches a location on its own).
+ * Text inside [] is literal: `[.]` is a dot, `[_]x` does not make a pathless segment. */
+export function flatRouteSegments(id) {
+    const raw = [];
+    let current = { text: '', escapedStart: false, escapedEnd: false };
+    let escaped = false;
+    for (const char of id) {
+        if (escaped) {
+            if (char === ']') {
+                escaped = false;
+                continue;
+            }
+            if (current.text === '')
+                current.escapedStart = true;
+            current.text += char;
+            current.escapedEnd = true;
+            continue;
+        }
+        if (char === '[') {
+            escaped = true;
+            continue;
+        }
+        if (char === '.') {
+            raw.push(current);
+            current = { text: '', escapedStart: false, escapedEnd: false };
+            continue;
+        }
+        current.text += char;
+        current.escapedEnd = false;
+    }
+    if (escaped)
+        return null;
+    raw.push(current);
+    const segments = [];
+    let index = false;
+    let pathless = false;
+    raw.forEach((part, position) => {
+        pathless = false;
+        if (part.text === '_index' && !part.escapedStart && position === raw.length - 1) {
+            index = true;
+            return;
+        }
+        if (part.text.startsWith('_') && !part.escapedStart) {
+            pathless = true;
+            return;
+        }
+        const name = part.text.endsWith('_') && !part.escapedEnd ? part.text.slice(0, -1) : part.text;
+        const optional = !part.escapedStart ? /^\((.*)\)$/.exec(name) : null;
+        const inner = optional ? optional[1] : name;
+        if (inner === '$' && !part.escapedStart)
+            segments.push({ kind: 'splat', name: 'splat', optional: false });
+        else if (inner.startsWith('$') && !part.escapedStart)
+            segments.push({ kind: 'param', name: paramName(inner.slice(1)), optional: Boolean(optional) });
+        else if (optional)
+            segments.push({ kind: 'param', name: paramName(inner), optional: true, inexact: `an optional literal segment (${part.text})` });
+        else if (inner !== '')
+            segments.push({ kind: 'literal', value: inner });
+    });
+    return { segments, index, pathless };
+}
+/** Flat routes under `routesDir` (Remix 2's convention, which @react-router/fs-routes' flatRoutes implements), under
+ * `prefix` when a route config nests them. */
+function flatRoutes(ctx, routesDir, ignored, prefix = []) {
+    if (!isDirectory(routesDir))
+        return [];
+    const extensions = `{${ROUTE_EXTENSIONS.join(',')}}`;
+    const files = fg.sync([`*.${extensions}`, `*/route.${extensions}`], { cwd: routesDir, ignore: ignored, dot: true, onlyFiles: true });
+    const routes = [];
+    for (const file of files.sort()) {
+        const id = file.includes('/') ? file.split('/')[0] : file.replace(/\.[^.]+$/, '');
+        const parsed = flatRouteSegments(id);
+        if (!parsed) {
+            routes.push({ match: '/', source: repoPath(ctx, join(routesDir, file)), inexact: `an unclosed [ in its route file name (${id})` });
+            continue;
+        }
+        if (parsed.pathless)
+            continue;
+        // Remix's `$` splat matches the rest of the path, empty included.
+        const segments = [...prefix, ...parsed.segments].map((segment, position, all) => (segment.kind === 'splat' && position === all.length - 1
+            ? { ...segment, optional: true } : segment));
+        routes.push({ ...ruleFor(segments), source: repoPath(ctx, join(routesDir, file)), rank: parsed.index ? 0 : 1 });
+    }
+    return routes;
+}
+function helpers(ast) {
+    const found = { route: null, index: null, layout: null, prefix: null, flatRoutes: null };
+    for (const statement of ast.program.body) {
+        if (statement.type !== 'ImportDeclaration')
+            continue;
+        const source = statement.source.value;
+        if (source === '@react-router/remix-routes-option-adapter')
+            return { manual: 'app/routes.ts adapts a Remix routes function, which init cannot read without running it' };
+        if (source !== '@react-router/dev/routes' && source !== '@remix-run/route-config' && source !== '@react-router/fs-routes' && source !== '@remix-run/fs-routes')
+            continue;
+        for (const specifier of statement.specifiers) {
+            if (specifier.type !== 'ImportSpecifier')
+                continue;
+            const imported = specifier.imported.name ?? specifier.imported.value;
+            if (imported in found)
+                found[imported] = specifier.local.name;
+        }
+    }
+    return found;
+}
+class Unreadable extends Error {
+}
+function stringArg(node, ast) {
+    const value = node ? literalValue(node, ast) : UNREADABLE;
+    if (typeof value !== 'string')
+        throw new Unreadable('a route path or file that is not a literal string');
+    return value;
+}
+function configRoutes(ctx, appDir, file) {
+    const code = readFileSync(file, 'utf8');
+    const ast = parseFile(code, file);
+    if (!ast)
+        return { manual: `${repoPath(ctx, file)} does not parse` };
+    const names = helpers(ast);
+    if ('manual' in names)
+        return names;
+    const exported = ast.program.body.find((statement) => statement.type === 'ExportDefaultDeclaration')?.declaration;
+    if (!exported)
+        return { manual: `${repoPath(ctx, file)} has no default export` };
+    const routes = [];
+    const add = (path, routeFile, index) => {
+        routes.push({ ...ruleFor(reactRouterSegments(path.join('/'))), source: repoPath(ctx, join(appDir, routeFile)), rank: index ? 0 : 1 });
+    };
+    const visitList = (node, path) => {
+        const list = unwrapTs(node);
+        if (list?.type === 'Identifier') {
+            const bound = ast.program.body.flatMap((statement) => (statement.type === 'VariableDeclaration' ? statement.declarations : []))
+                .find((declarator) => declarator.id.name === list.name)?.init;
+            if (bound) {
+                visitList(bound, path);
+                return;
+            }
+        }
+        if (list?.type !== 'ArrayExpression')
+            throw new Unreadable('a route list that is not an array literal');
+        for (const element of list.elements) {
+            if (!element)
+                continue;
+            if (element.type === 'SpreadElement')
+                visitSpread(element.argument, path);
+            else
+                visitEntry(element, path);
+        }
+    };
+    const visitSpread = (node, path) => {
+        const call = unwrapTs(node);
+        if (call?.type === 'CallExpression' && call.callee.type === 'Identifier' && call.callee.name === names.prefix) {
+            visitList(call.arguments[1], [...path, stringArg(call.arguments[0], ast)]);
+            return;
+        }
+        if (call?.type === 'CallExpression' && call.callee.type === 'Identifier' && call.callee.name === names.flatRoutes) {
+            const options = call.arguments[0] ? literalValue(call.arguments[0], ast) : {};
+            if (options === UNREADABLE || typeof options !== 'object' || options === null || Array.isArray(options))
+                throw new Unreadable('flatRoutes options that are not literal');
+            const rootDirectory = typeof options.rootDirectory === 'string' ? options.rootDirectory : 'routes';
+            const ignored = Array.isArray(options.ignoredRouteFiles) ? options.ignoredRouteFiles.filter((item) => typeof item === 'string') : [];
+            routes.push(...flatRoutes(ctx, join(appDir, rootDirectory), ignored, reactRouterSegments(path.join('/'))));
+            return;
+        }
+        visitList(node, path);
+    };
+    const visitEntry = (node, path) => {
+        const entry = unwrapTs(node);
+        if (entry?.type === 'CallExpression' && entry.callee.type === 'Identifier') {
+            const callee = entry.callee.name;
+            const args = entry.arguments;
+            if (callee === names.index) {
+                add(path, stringArg(args[0], ast), true);
+                return;
+            }
+            if (callee === names.route) {
+                const own = [...path, stringArg(args[0], ast)];
+                add(own, stringArg(args[1], ast), false);
+                const children = args.slice(2).find((arg) => unwrapTs(arg).type === 'ArrayExpression' || unwrapTs(arg).type === 'Identifier');
+                if (children)
+                    visitList(children, own);
+                return;
+            }
+            if (callee === names.layout) {
+                const children = args.slice(1).find((arg) => unwrapTs(arg).type === 'ArrayExpression' || unwrapTs(arg).type === 'Identifier');
+                if (children)
+                    visitList(children, path);
+                return;
+            }
+        }
+        if (entry?.type === 'ObjectExpression') {
+            const value = {};
+            for (const property of entry.properties) {
+                const name = property.type === 'ObjectProperty' ? keyName(property) : null;
+                if (name === null)
+                    throw new Unreadable('a route object init cannot read');
+                value[name] = property.value;
+            }
+            const own = value.path ? [...path, stringArg(value.path, ast)] : path;
+            const isIndex = value.index !== undefined && literalValue(value.index, ast) === true;
+            if (value.file && (value.path || isIndex))
+                add(own, stringArg(value.file, ast), isIndex);
+            if (value.children)
+                visitList(value.children, own);
+            return;
+        }
+        throw new Unreadable('a route entry that is not route(), index(), layout(), prefix() or a literal object');
+    };
+    try {
+        visitList(exported, []);
+    }
+    catch (error) {
+        if (error instanceof Unreadable)
+            return { manual: `${repoPath(ctx, file)} has ${error.message}` };
+        throw error;
+    }
+    return routes;
+}
+/* ------------------------------------------------------------ integration */
+async function rootEdit(ctx, root, tags) {
+    if (!root)
+        return { manual: 'the app has no root module (app/root)' };
+    const code = readFileSync(root, 'utf8');
+    const ast = parseFile(code, root);
+    if (!ast)
+        return { manual: `${repoPath(ctx, root)} does not parse` };
+    const heads = jsxElementsNamed(ast, 'head');
+    if (heads.length !== 1 || !heads[0].closingElement)
+        return { manual: `${repoPath(ctx, root)} has ${heads.length} <head> elements, not one with children` };
+    const rendered = jsxScriptTags(tags);
+    const edits = placeTags(code, ourJsxElements(ast, ['script']), heads[0].closingElement.start, rendered, indentUnit(code));
+    if ('manual' in edits)
+        return edits;
+    if (edits.length === 0)
+        return [{ target: root, content: code }];
+    const result = checkedResult(code, root, edits, ['script'], rendered);
+    return typeof result === 'string' ? [{ target: root, content: result }] : result;
+}
+/** The options object of the Remix Vite plugin call in vite.config, as a config-like AST, or null. */
+function remixPluginOptions(config) {
+    if (!config.ast)
+        return null;
+    const local = config.ast.program.body.flatMap((statement) => (statement.type === 'ImportDeclaration' && statement.source.value === '@remix-run/dev'
+        ? statement.specifiers.filter((specifier) => specifier.type === 'ImportSpecifier' && (specifier.imported.name ?? specifier.imported.value) === 'vitePlugin')
+            .map((specifier) => specifier.local.name) : []))[0];
+    if (!local)
+        return null;
+    let options = null;
+    walk(config.ast.program, node => {
+        if (node.type === 'CallExpression' && node.callee.type === 'Identifier' && node.callee.name === local) {
+            const arg = node.arguments[0] ? unwrapTs(node.arguments[0]) : null;
+            options = arg === null ? { type: 'ObjectExpression', properties: [] } : arg.type === 'ObjectExpression' ? arg : 'unreadable';
+        }
+    });
+    return options;
+}
+function optionValue(options, ast, name) {
+    const property = options.properties.find((candidate) => candidate.type === 'ObjectProperty' && keyName(candidate) === name);
+    if (property)
+        return literalValue(property.value, ast);
+    return options.properties.some((candidate) => candidate.type !== 'ObjectProperty') ? UNREADABLE : undefined;
+}
+export async function detectReactRouter(ctx) {
+    const reactRouter = resolveVersion(ctx, '@react-router/dev');
+    const remix = reactRouter ? null : resolveVersion(ctx, '@remix-run/dev');
+    const version = reactRouter ?? remix;
+    if (!version)
+        return null;
+    const blocked = [];
+    const looked = [];
+    let appDirectory = 'app';
+    let buildDirectory = 'build';
+    let hasPreset = false;
+    let classic = false;
+    let customRoutes = false;
+    let routeConfig = Boolean(reactRouter);
+    let ignored = [];
+    let assetsBuild = 'public/build';
+    const read = (value, name, where) => {
+        if (value === undefined)
+            return null;
+        if (typeof value === 'string')
+            return value;
+        blocked.push(`${where} sets ${name} in a way init cannot read`);
+        return null;
+    };
+    if (reactRouter) {
+        if (version.major !== 7)
+            blocked.push(`init knows React Router 7's framework mode, and this app's version is ${version.version} (${version.from})`);
+        const config = configFile(ctx.appDir, ['react-router.config.ts', 'react-router.config.js', 'react-router.config.mjs']);
+        const where = config.file ? repoPath(ctx, config.file) : appFile(ctx, 'react-router.config.ts');
+        looked.push(where);
+        for (const [name, assign] of [['appDirectory', (value) => { appDirectory = value; }], ['buildDirectory', (value) => { buildDirectory = value; }]]) {
+            const value = configValue(config, [name]);
+            if (value.state === 'unreadable')
+                blocked.push(`${where} sets ${name} in a way init cannot read`);
+            if (value.state === 'value' && typeof value.value === 'string')
+                assign(value.value);
+        }
+        const basename = configValue(config, ['basename']);
+        if (basename.state !== 'absent' && !(basename.state === 'value' && basename.value === '/')) {
+            blocked.push(`${where} sets basename: the route manifest must be published at the origin root, outside it`);
+        }
+        hasPreset = configValue(config, ['presets']).state !== 'absent';
+    }
+    else {
+        if (version.major !== 2)
+            blocked.push(`init knows Remix 2, and this app's version is ${version.version} (${version.from})`);
+        const vite = configFile(ctx.appDir, ['vite.config.ts', 'vite.config.js', 'vite.config.mjs', 'vite.config.mts']);
+        const options = remixPluginOptions(vite);
+        if (options === 'unreadable') {
+            blocked.push(`${repoPath(ctx, vite.file)} passes the Remix plugin options init cannot read`);
+        }
+        else if (options) {
+            const where = repoPath(ctx, vite.file);
+            looked.push(where);
+            appDirectory = read(optionValue(options, vite.ast, 'appDirectory'), 'appDirectory', where) ?? appDirectory;
+            buildDirectory = read(optionValue(options, vite.ast, 'buildDirectory'), 'buildDirectory', where) ?? buildDirectory;
+            const basename = optionValue(options, vite.ast, 'basename');
+            if (basename !== undefined && basename !== '/')
+                blocked.push(`${where} sets basename: the route manifest must be published at the origin root, outside it`);
+            customRoutes = optionValue(options, vite.ast, 'routes') !== undefined;
+            hasPreset = optionValue(options, vite.ast, 'presets') !== undefined;
+            const future = optionValue(options, vite.ast, 'future');
+            routeConfig = typeof future === 'object' && future !== null && !Array.isArray(future) && future.v3_routeConfig === true;
+            const ignoredValue = optionValue(options, vite.ast, 'ignoredRouteFiles');
+            if (Array.isArray(ignoredValue))
+                ignored = ignoredValue.filter((item) => typeof item === 'string');
+            else if (ignoredValue !== undefined)
+                blocked.push(`${where} sets ignoredRouteFiles in a way init cannot read`);
+        }
+        else {
+            classic = true;
+            const config = configFile(ctx.appDir, ['remix.config.js', 'remix.config.mjs', 'remix.config.cjs']);
+            const where = config.file ? repoPath(ctx, config.file) : appFile(ctx, 'remix.config.js');
+            looked.push(where);
+            for (const name of ['appDirectory', 'assetsBuildDirectory', 'publicPath', 'routes', 'ignoredRouteFiles', 'basename']) {
+                const value = configValue(config, [name]);
+                if (value.state === 'unreadable')
+                    blocked.push(`${where} sets ${name} in a way init cannot read`);
+                if (value.state !== 'value')
+                    continue;
+                if (name === 'appDirectory' && typeof value.value === 'string')
+                    appDirectory = value.value;
+                if (name === 'assetsBuildDirectory' && typeof value.value === 'string')
+                    assetsBuild = value.value;
+                if (name === 'routes')
+                    customRoutes = true;
+                if (name === 'ignoredRouteFiles' && Array.isArray(value.value))
+                    ignored = value.value.filter((item) => typeof item === 'string');
+                if (name === 'publicPath' && value.value !== '/build/')
+                    blocked.push(`${where} sets publicPath, so chunk paths are not where init would look`);
+                if (name === 'basename' && value.value !== '/')
+                    blocked.push(`${where} sets basename: the route manifest must be published at the origin root, outside it`);
+            }
+        }
+    }
+    const appDir = join(ctx.appDir, appDirectory);
+    const root = firstFile(appDir, ROOT_NAMES);
+    const routesFile = routeConfig ? firstFile(appDir, ['routes.ts', 'routes.js', 'routes.mts', 'routes.mjs']) : null;
+    looked.push(repoPath(ctx, join(appDir, 'root.*')), repoPath(ctx, join(appDir, routeConfig ? 'routes.ts' : 'routes/')));
+    if (customRoutes)
+        blocked.push('the Remix config defines routes with a function, which init cannot read without running it');
+    const label = reactRouter ? `React Router ${version.version} (framework mode)` : `Remix ${version.version}${classic ? ' (classic compiler)' : ' (Vite)'}`;
+    const scripts = ctx.pkg?.scripts ?? {};
+    const after = !hasPreset;
+    const build = typeof scripts.build === 'string'
+        ? { kind: 'package-script', script: 'build', phase: after || classic ? 'after' : 'before' }
+        : { manual: `${appFile(ctx, 'package.json')} has no build script to publish the route manifest after` };
+    const clientDir = classic ? 'public' : after ? posix.join(buildDirectory, 'client') : 'public';
+    return {
+        id: reactRouter ? 'react-router' : 'remix',
+        label,
+        manifestAdapter: `${reactRouter ? 'react-router' : 'remix'}@${version.version}`,
+        blocked: blocked.length > 0 ? blocked.join('; ') : null,
+        looked,
+        staticDir: 'public',
+        integrate: tags => rootEdit(ctx, root, tags),
+        manualTag: tags => [`In ${repoPath(ctx, join(appDir, 'root.tsx'))}, inside <head>:`, ...jsxScriptTags(tags)],
+        build,
+        async routes() {
+            if (routeConfig)
+                return routesFile ? configRoutes(ctx, appDir, routesFile) : { manual: `${repoPath(ctx, join(appDir, 'routes.ts'))} is missing` };
+            return flatRoutes(ctx, join(appDir, 'routes'), ignored);
+        },
+        chunks: () => {
+            if (classic)
+                return chunkIds(join(ctx.appDir, assetsBuild), `/${posix.relative('public', assetsBuild)}/`);
+            return after ? chunkIds(join(ctx.appDir, buildDirectory, 'client'), '/').filter(id => !id.startsWith('/_haystack/')) : [];
+        },
+        publishDirs: [clientDir],
+    };
+}