@haystackeditor/cli 0.24.1 → 0.25.1

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

@@ -0,0 +1,439 @@
+/**
+ * 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,
+        // The routes come from the source, so whatever stops init placing the tag stops the manifest too.
+        manifestBlocked: blocked.length > 0 ? blocked.join('; ') : null,
+        fromBuild: false,
+        rewriting: null,
+        publishNote: null,
+        buildPublishDirs: () => [],
+        buildNotes: () => [],
+        looked,
+        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],
+    };
+}

package/dist/capture/adapters/sveltekit.js

@@ -0,0 +1,109 @@
+/**
+ * SvelteKit 1–2 (CAPTURE-V1 rule 8b).
+ *
+ * Tag: an async script in <head> of src/app.html (kit.files.appTemplate), before </head>. Static output: static/
+ * (kit.files.assets), which every adapter copies into its output. Routes: directories under src/routes with a +page
+ * component ((group) directories add no segment; [x], [[x]], [...rest] and [x=matcher] are parameters). The adapter
+ * (node, static, Vercel, Cloudflare, auto) assembles the final output inside `vite build`, so the build step publishes
+ * the manifest into static/ BEFORE the build, without chunks. A base path (kit.paths.base) is a manual step.
+ */
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { withHeadTags } from '../html.js';
+import { repoPath, resolveVersion, appFile } from '../project.js';
+import { paramName, ruleFor } from '../route-pattern.js';
+import { htmlTags } from '../tag.js';
+import { configFile, configValue, filesUnder, isFile } from './files.js';
+/** A SvelteKit route directory name as a segment; null for a (group). */
+export function svelteSegment(name) {
+    if (/^\(.+\)$/.test(name))
+        return null;
+    // [x=matcher]: the matcher constrains the parameter, which the pattern syntax cannot say.
+    const constrained = (matcher) => (matcher ? { inexact: `a parameter with a matcher (${name})` } : {});
+    const optional = /^\[\[([^\]=]+)(=[^\]]+)?\]\]$/.exec(name);
+    if (optional)
+        return { kind: 'param', name: paramName(optional[1]), optional: true, ...constrained(optional[2]) };
+    const rest = /^\[\.\.\.([^\]=]+)(=[^\]]+)?\]$/.exec(name);
+    if (rest)
+        return { kind: 'splat', name: paramName(rest[1]), optional: true, ...constrained(rest[2]) };
+    const param = /^\[([^\]=]+)(=[^\]]+)?\]$/.exec(name);
+    if (param)
+        return { kind: 'param', name: paramName(param[1]), optional: false, ...constrained(param[2]) };
+    // [x+2f] and [u+0041] encode characters that cannot appear in a directory name.
+    const decoded = name.replace(/\[x\+([0-9a-fA-F]{2})\]/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)))
+        .replace(/\[u\+([0-9a-fA-F]{4,6})\]/g, (_, hex) => String.fromCodePoint(parseInt(hex, 16)));
+    if (decoded.includes('['))
+        return { kind: 'param', name: paramName(decoded), optional: false, inexact: `a segment mixing text and a parameter (${name})` };
+    return { kind: 'literal', value: decoded };
+}
+export async function detectSvelteKit(ctx) {
+    const version = resolveVersion(ctx, '@sveltejs/kit');
+    if (!version)
+        return null;
+    const config = configFile(ctx.appDir, ['svelte.config.js', 'svelte.config.mjs', 'svelte.config.ts']);
+    const where = config.file ? repoPath(ctx, config.file) : appFile(ctx, 'svelte.config.js');
+    const blocked = [];
+    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 routesDir = read(['kit', 'files', 'routes'], 'src/routes');
+    const assets = read(['kit', 'files', 'assets'], 'static');
+    const template = read(['kit', 'files', 'appTemplate'], 'src/app.html');
+    const base = read(['kit', 'paths', 'base'], '');
+    if (base !== '')
+        blocked.push(`${where} sets paths.base ${base}: the route manifest must be published at the origin root, outside it`);
+    const extensionsRead = configValue(config, ['extensions']);
+    const extensions = extensionsRead.state === 'value' && Array.isArray(extensionsRead.value) ? extensionsRead.value.filter((item) => typeof item === 'string') : ['.svelte'];
+    if (extensionsRead.state === 'unreadable')
+        blocked.push(`${where} sets extensions in a way init cannot read`);
+    if (version.major !== 1 && version.major !== 2)
+        blocked.push(`init knows SvelteKit 1–2, and this app's version is ${version.version} (${version.from})`);
+    const templateFile = join(ctx.appDir, template);
+    const templatePath = repoPath(ctx, templateFile);
+    const scripts = ctx.pkg?.scripts ?? {};
+    return {
+        id: 'sveltekit',
+        label: `SvelteKit ${version.version}`,
+        manifestAdapter: `sveltekit@${version.version}`,
+        blocked: blocked.length > 0 ? blocked.join('; ') : null,
+        // The routes come from the source, so whatever stops init placing the tag stops the manifest too.
+        manifestBlocked: blocked.length > 0 ? blocked.join('; ') : null,
+        fromBuild: false,
+        rewriting: null,
+        publishNote: null,
+        buildPublishDirs: () => [],
+        buildNotes: () => [],
+        looked: [templatePath, where, repoPath(ctx, join(ctx.appDir, routesDir))],
+        staticDir: assets,
+        async integrate(tags) {
+            if (!isFile(templateFile))
+                return { manual: `${templatePath} is missing` };
+            const edit = withHeadTags(readFileSync(templateFile, 'utf8'), htmlTags(tags));
+            return 'manual' in edit ? { manual: `${templatePath}: ${edit.manual}` } : [{ target: templateFile, content: edit.content }];
+        },
+        manualTag: tags => [`In ${templatePath}, inside <head>:`, ...htmlTags(tags)],
+        build: typeof scripts.build === 'string' ? { kind: 'package-script', script: 'build', phase: 'before' }
+            : { manual: `${appFile(ctx, 'package.json')} has no build script to publish the route manifest before` },
+        async routes() {
+            const root = join(ctx.appDir, routesDir);
+            const routes = [];
+            for (const file of filesUnder(root)) {
+                const parts = file.split('/');
+                const name = parts.pop();
+                // +page@.svelte and +page@<layout>.svelte reset the layout; they are pages of the same route.
+                if (!extensions.some(extension => name.endsWith(extension) && /^\+page(@[^/]*)?$/.test(name.slice(0, -extension.length))))
+                    continue;
+                const segments = parts.map(svelteSegment).filter((segment) => segment !== null);
+                routes.push({ ...ruleFor(segments), source: repoPath(ctx, join(root, file)) });
+            }
+            return routes;
+        },
+        chunks: () => [],
+        publishDirs: [assets],
+    };
+}

package/dist/capture/adapters/types.js

@@ -0,0 +1,4 @@
+/** What every framework adapter tells init's capture setup and `haystack capture manifest` (CAPTURE-V1 rule 8b). */
+export function isManual(value) {
+    return typeof value === 'object' && value !== null && 'manual' in value;
+}