ferrovue 0.2.0 → 0.4.0

package/dist/compiler.js

@@ -1,56 +1,29 @@
-/* ferrovue's compiler: `.vue` → Rust render functions.
- *
- * The input is not the template. It is what `@vue/compiler-sfc` compiles the template to for
- * server rendering — straight-line `_push` calls, `if`, `_ssrRenderList`, and a handful of
- * `@vue/server-renderer` helpers — so element structure, attribute order, whitespace and the
- * fragment markers are decided by Vue, and this file only has to translate a small, closed
- * vocabulary of JavaScript into Rust that writes the same bytes. The generated code calls the
- * `ferrovue` crate for everything Vue's runtime does.
- *
- * Anything outside that vocabulary is an error naming the component and the construct, never a
- * best guess: a guess that is wrong by one byte is a hydration mismatch in a browser, found by a
- * reader.
- *
- * A project describes itself in `ferrovue.config.json` at its root — see `Config` — and runs the
- * `ferrovue` command there. `generate()` is also what a drift test calls, so the committed files can
- * be held to exactly what this produces.
- *
- * This module is the public API; the translation lives in the modules beside it. */
 import { mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { join, resolve } from "node:path";
+import { join } from "node:path";
 import { ctx, loadConfig, tyOfName } from "./context.js";
 import { readComponent } from "./component.js";
-import { readRoutes } from "./router.js";
-import { readStores } from "./stores.js";
-import { i18nSource, readLocales } from "./i18n.js";
 import { scopeFor } from "./script.js";
-import { scopeFlow } from "./scoped.js";
-import { componentSource, modSource, routesSource, storesSource, typesSource } from "./rust.js";
+import { attrsFlow } from "./fallthrough.js";
+import { componentSource, isIsland, modSource } from "./rust.js";
+import { renderParams } from "./plugin.js";
+import { PLUGINS } from "./plugins/index.js";
 /** Every generated file, keyed by its name in the output directory. */
 export function generate(root, config = loadConfig(root)) {
     ctx.componentsDir = config.components.replace(/\/?$/, "/");
     ctx.helperModule = config.helpers?.module ?? null;
     ctx.trustedHtml = config.trustedHtml ?? null;
-    const router = config.router ?? (config.routes ? { routes: config.routes } : null);
-    ctx.routes = router ? readRoutes(root, router.routes) : null;
-    ctx.routerBase = router?.base ?? "";
     ctx.clientDirectives = new Set(config.clientDirectives ?? []);
-    ctx.i18n = config.i18n ? readLocales(root, config.i18n) : null;
-    ctx.linkActive = router?.linkActiveClass ?? "router-link-active";
-    ctx.linkExactActive = router?.linkExactActiveClass ?? "router-link-exact-active";
     ctx.rootDir = root;
-    ctx.scopeId = config.scopeId ?? "filepath-source";
-    ctx.viteRoot = resolve(root, config.viteRoot ?? ".");
     ctx.typeStructs = new Map();
     ctx.typeAliases = new Map();
     ctx.typeFiles = new Map();
     ctx.typeRead = new Set();
-    if (config.stores)
-        readStores(root, config.stores);
-    else {
-        ctx.stores = new Map();
-        ctx.storeStructs = new Map();
-    }
+    ctx.plugins = PLUGINS;
+    ctx.runs = new Map();
+    for (const p of PLUGINS)
+        ctx.runs.set(p, p.configure?.(config, root));
+    for (const p of PLUGINS)
+        p.prepare?.(root);
     ctx.helpers = Object.fromEntries(Object.entries(config.helpers?.functions ?? {}).map(([name, h]) => [
         name,
         { rust: h.rust, params: h.params.map(tyOfName), ret: tyOfName(h.returns), maxLen: h.maxLen ?? 0 },
@@ -63,54 +36,25 @@ export function generate(root, config = loadConfig(root)) {
     const read = files.map((f) => readComponent(f, root));
     const components = new Map(read.map((r) => [r.comp.name, r.comp]));
     ctx.components = components;
-    // Whether a component reads a store or the route is known once its setup is read; both reach
-    // every component on the way down to one that does, and the route every one on the way down to
-    // a `<RouterLink>`.
-    const children = read.map((r) => scopeFor(r.comp, r.ast, components).scope.children);
-    // Which roots may be handed scope ids, and which slot content given a slot scope id.
-    scopeFlow(read.map((r, i) => ({ comp: r.comp, ssr: r.ssr, children: children[i] })));
-    for (const c of components.values())
-        c.usesRoute = c.routerLink || c.readsRoute;
-    for (let changed = true; changed;) {
-        changed = false;
-        for (const c of components.values()) {
-            if (!c.usesRoute && [...c.imports].some((i) => components.get(i)?.usesRoute)) {
-                c.usesRoute = changed = true;
-            }
-        }
-    }
-    for (const c of components.values())
-        c.usesI18n = c.readsI18n;
-    for (let changed = true; changed;) {
-        changed = false;
-        for (const c of components.values()) {
-            if (!c.usesI18n && [...c.imports].some((i) => components.get(i)?.usesI18n)) {
-                c.usesI18n = changed = true;
-            }
-        }
-    }
-    for (const c of components.values())
-        c.usesTeleports = c.readsTeleports;
-    for (let changed = true; changed;) {
-        changed = false;
-        for (const c of components.values()) {
-            if (!c.usesTeleports && [...c.imports].some((i) => components.get(i)?.usesTeleports)) {
-                c.usesTeleports = changed = true;
-            }
-        }
-    }
+    const scopes = read.map((r) => scopeFor(r.comp, r.ast, components).scope);
+    const all = read.map((r, i) => ({ comp: r.comp, ssr: r.ssr, children: scopes[i].children, attrsBindings: scopes[i].attrsBindings }));
+    for (const p of PLUGINS)
+        p.analyse?.(all);
+    attrsFlow(all);
     for (const c of components.values())
-        c.usesStores = c.readsStores;
+        c.takes = new Set(renderParams().filter((p) => p.reads(c)).map((p) => p.name));
     for (let changed = true; changed;) {
         changed = false;
         for (const c of components.values()) {
-            if (!c.usesStores && [...c.imports].some((i) => components.get(i)?.usesStores)) {
-                c.usesStores = changed = true;
+            for (const name of [...c.imports].flatMap((i) => [...(components.get(i)?.takes ?? [])])) {
+                if (!c.takes.has(name)) {
+                    c.takes.add(name);
+                    changed = true;
+                }
             }
         }
     }
     const out = new Map();
-    // A child before its parents, which read the props its scoped slots pass.
     const ordered = [];
     const placed = new Set();
     const place = (r) => {
@@ -126,19 +70,13 @@ export function generate(root, config = loadConfig(root)) {
     };
     read.forEach(place);
     for (const r of ordered) {
-        // Numbered per component, so a file's text depends on its own source alone.
         ctx.narrowCount = 0;
         out.set(`${r.comp.module}.rs`, componentSource(r.comp, r.ast, r.ssr, components));
     }
-    out.set("mod.rs", modSource(read.map((r) => r.comp)));
-    if (ctx.routes)
-        out.set("route_table.rs", routesSource(ctx.routes, router.routes));
-    if (ctx.stores.size)
-        out.set("stores.rs", storesSource(config.stores.replace(/\/?$/, "/")));
-    if (ctx.typeStructs.size)
-        out.set("types.rs", typesSource());
-    if (ctx.i18n)
-        out.set("i18n.rs", i18nSource(ctx.i18n));
+    const modules = PLUGINS.flatMap((p) => p.modules?.() ?? []);
+    out.set("mod.rs", modSource(read.map((r) => r.comp), modules.map(([file]) => file)));
+    for (const [file, text] of modules)
+        out.set(file, text);
     return out;
 }
 /** Write what \`generate\` produces to the configured directory: only the files whose text changed,
@@ -155,7 +93,6 @@ export function write(root, config = loadConfig(root)) {
             old = readFileSync(join(target, name), "utf8");
         }
         catch {
-            // A new file.
         }
         if (old !== text) {
             writeFileSync(join(target, name), text);
@@ -165,7 +102,17 @@ export function write(root, config = loadConfig(root)) {
     const removed = readdirSync(target).filter((f) => f.endsWith(".rs") && !files.has(f));
     for (const f of removed)
         rmSync(join(target, f));
-    return { files: [...files.keys()], changed, removed };
+    const islands = Object.fromEntries([...ctx.components.values()].filter(isIsland).map((c) => [c.name, c.file]));
+    return { files: [...files.keys()], changed, removed, islands };
 }
 export { CONFIG_FILE, loadConfig, TYPES_MODULE } from "./context.js";
 export { GenError } from "./model.js";
+export const VERSION = (() => {
+    try {
+        const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+        return pkg.version ?? "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+})();

package/dist/component.js

@@ -1,14 +1,11 @@
-/* One `.vue` file read: its props, models, imported types, and Vue's SSR compilation of its template. */
 import { compileScript, compileTemplate, parse as parseSfc } from "@vue/compiler-sfc";
-import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { SourceMapConsumer } from "source-map-js";
-import { basename, relative, resolve, sep } from "node:path";
-import { fail, opt, snake, tagAst } from "./model.js";
+import { basename, relative } from "node:path";
+import { blankComponent, fail, opt, snake, tagAst } from "./model.js";
 import { ctx } from "./context.js";
 import { typesImports, declareTypes, defaultValue, definePropsType, readTypeFile, resolveImport, runtimeDefaults, structOf, tyOfTs } from "./typescript.js";
-/** A Vue compiler error's position as a node \`fail\` can point at: its line and 1-based column,
- * offset by where the template starts when the error is in the template's content. */
+import { claim } from "./plugin.js";
 function vueErrorNode(err, within) {
     const loc = err.loc;
     if (!loc)
@@ -17,17 +14,6 @@ function vueErrorNode(err, within) {
     const at = !within ? { line, column: column - 1 } : line === 1 ? { line: within.line, column: within.column - 1 + column - 1 } : { line: within.line + line - 1, column: column - 1 };
     return { type: "VueError", loc: { start: at }, __fv: "source" };
 }
-/** `getHash` in `@vitejs/plugin-vue`: the first 8 hex digits of the SHA-256 of the file's path from
- * Vite's root, with `/` between its parts, followed in `"filepath-source"` mode by its source. */
-function scopeHash(file, source) {
-    const path = relative(ctx.viteRoot, resolve(file)).split(sep).join("/");
-    return createHash("sha256")
-        .update(ctx.scopeId === "filepath" ? path : path + source)
-        .digest("hex")
-        .slice(0, 8);
-}
-/** `inheritAttrs` as `defineOptions({ inheritAttrs })` or a plain `<script>`'s `export default`
- * sets it: a literal, since it decides what reaches the root. */
 function inheritAttrs(comp, statements) {
     let found = true;
     for (const st of statements) {
@@ -54,59 +40,24 @@ export function readComponent(file, root) {
     const source = readFileSync(file, "utf8");
     const { descriptor, errors } = parseSfc(source, { filename: file });
     const rel = relative(root, file);
-    const comp = {
-        name,
-        module: snake(name),
-        file: rel,
-        props: { name: "Props", fields: [] },
-        structs: new Map(),
-        trustedName: null,
-        floatName: null,
-        childProps: new Map(),
-        imports: new Set(),
-        slotNames: [],
-        routerView: false,
-        routerLink: false,
-        readsRoute: false,
-        usesRoute: false,
-        readsStores: false,
-        usesStores: false,
-        readsI18n: false,
-        usesI18n: false,
-        readsTeleports: false,
-        usesTeleports: false,
-        models: new Map(),
-        aliases: new Map(),
-        importedTypes: new Map(),
-        slotShapes: new Map(),
-        scopeId: null,
-        slotted: false,
-        inheritAttrs: true,
-        inherits: false,
-        passesSlotIds: false,
-    };
+    const comp = blankComponent(name, snake(name), rel);
     comp.source = source;
     if (errors.length)
         fail(comp, String(errors[0]), vueErrorNode(errors[0]));
     if (!descriptor.scriptSetup || !descriptor.template) {
         fail(comp, "an island needs `<script setup lang=\"ts\">` and a `<template>`");
     }
-    // A global `<style>` block changes no markup. A scoped one adds `data-v-…` attributes, whose id is
-    // computed here as the bundler computes it. A CSS module renames classes, and `v-bind()` in CSS
-    // writes variables onto the root, neither of which the server reproduces.
     for (const st of descriptor.styles) {
         if (st.module)
             fail(comp, "`<style module>` renames classes in the bundler; use a global or scoped `<style>`, or a stylesheet");
     }
     if (descriptor.cssVars.length)
         fail(comp, "`v-bind()` in `<style>` sets variables the server does not render; bind `:style` instead");
-    if (descriptor.styles.some((st) => st.scoped))
-        comp.scopeId = `data-v-${scopeHash(file, source)}`;
-    comp.slotted = descriptor.slotted;
+    for (const p of ctx.plugins)
+        p.sfc?.(comp, descriptor, file, source);
     const script = compileScript(descriptor, { id: name });
     const ast = script.scriptSetupAst ?? [];
     tagAst(ast, "source");
-    // A plain `<script>` beside the setup one may declare the types the setup block uses.
     const plainAst = script.scriptAst ?? [];
     tagAst(plainAst, "source");
     for (const s of [...plainAst, ...ast]) {
@@ -123,7 +74,6 @@ export function readComponent(file, root) {
     }
     typesImports(comp, [...plainAst, ...ast]);
     comp.inheritAttrs = inheritAttrs(comp, [...plainAst, ...ast]);
-    // Types imported from elsewhere: a store's file, a shared `.ts` file, or another component.
     for (const st of [...plainAst, ...ast]) {
         if (st.type !== "ImportDeclaration")
             continue;
@@ -141,12 +91,8 @@ export function readComponent(file, root) {
             const typeFile = resolveImport(comp.file, from);
             if (!typeFile)
                 continue;
-            const module = typeFile.replace(/\.ts$/, "");
-            if ([...ctx.stores.values()].some((x) => x.module === module)) {
-                if (ctx.storeStructs.has(typeName))
-                    comp.importedTypes.set(sp.local.name, { k: "struct", name: typeName, store: true });
+            if (ctx.plugins.some((p) => p.importedType?.(comp, typeFile, typeName, sp.local.name)))
                 continue;
-            }
             if (ctx.helperModule !== null && from === ctx.helperModule && !isType)
                 continue;
             readTypeFile(typeFile);
@@ -156,8 +102,6 @@ export function readComponent(file, root) {
                 comp.aliases.set(sp.local.name, ctx.typeAliases.get(typeName));
         }
     }
-    // Interfaces in two passes: every name first, so one may name another declared after it, or
-    // itself — a tree node's children are tree nodes.
     const decls = declareTypes(comp, [...plainAst, ...ast], comp.structs, comp.aliases);
     for (const d of decls)
         comp.structs.set(d.name, structOf(comp, d.name, d.members, comp.structs));
@@ -172,9 +116,7 @@ export function readComponent(file, root) {
         if (found)
             propsTy = found;
     }
-    // A component without `defineProps` takes no props.
     if (!propsTy) {
-        // nothing to read
     }
     else if (propsTy.type === "TSTypeLiteral") {
         comp.props = structOf(comp, "Props", propsTy.members, comp.structs);
@@ -185,7 +127,6 @@ export function readComponent(file, root) {
     else {
         fail(comp, "`defineProps` takes a type literal or an interface declared in the same block", propsTy);
     }
-    // `defineModel`: a prop of its own (`modelValue` unless named), which the binding reads.
     for (const st of ast) {
         if (st.type !== "VariableDeclaration")
             continue;
@@ -204,8 +145,6 @@ export function readComponent(file, root) {
             comp.models.set(d.id.name, named);
         }
     }
-    // What Vue uses for an absent optional prop: the default `compileScript` resolved — from
-    // `withDefaults`, a destructured default, or `defineModel`'s options — or `false` for a boolean.
     const defaults = runtimeDefaults(comp, script.content);
     for (const f of comp.props.fields) {
         if (f.ty.k !== "opt")
@@ -219,33 +158,31 @@ export function readComponent(file, root) {
     const compiled = compileTemplate({
         source: descriptor.template.content,
         filename: file,
-        // As `@vitejs/plugin-vue` compiles it: the scope id written onto every element, and passed to
-        // slot content only with `:slotted()` styles.
-        id: comp.scopeId ?? name,
-        scoped: comp.scopeId !== null,
-        slotted: comp.slotted,
+        ...(claim((p) => p.templateOptions?.(comp)) ?? { id: name, scoped: false, slotted: false }),
         ssr: true,
         ssrCssVars: [],
         compilerOptions: { bindingMetadata: script.bindings, sourceMap: true },
     });
+    const kids = (n) => n.children.filter((c) => c.type !== 3 && !(c.type === 2 && !c.content.trim()));
+    const roots = descriptor.template.ast ? kids(descriptor.template.ast) : [];
+    const wrapper = roots.length === 1 && roots[0].type === 1 && roots[0].tagType === 1 && ["Transition", "transition", "KeepAlive", "keep-alive"].includes(roots[0].tag) ? roots[0] : null;
+    if (wrapper) {
+        const inner = kids(wrapper);
+        const lone = inner.length === 1 && inner[0].type === 1 && (inner[0].tagType === 0 || inner[0].tagType === 1) && !inner[0].props.some((p) => p.type === 7 && ["if", "else-if", "else", "for"].includes(p.name));
+        if (!lone)
+            comp.attrsDropped = { type: "VueTemplate", loc: { start: { line: wrapper.loc.start.line, column: wrapper.loc.start.column - 1 } }, __fv: "source" };
+    }
     const start = descriptor.template.loc.start;
     comp.templateStart = { line: start.line, column: start.column };
     if (compiled.map)
         comp.templateMap = new SourceMapConsumer(compiled.map);
-    // A template error's position is within the template's content.
     if (compiled.errors.length)
         fail(comp, String(compiled.errors[0]), vueErrorNode(compiled.errors[0], comp.templateStart));
     for (const m of compiled.code.matchAll(/_ssrRenderSlot\(_ctx\.\$slots, "([^"]+)"/g)) {
         if (!comp.slotNames.includes(m[1]))
             comp.slotNames.push(m[1]);
     }
-    // Resolved by name, as globally registered components are, or imported from `vue-router`.
-    const imported = (exported) => [...plainAst, ...ast].some((st) => st.type === "ImportDeclaration" && st.source.value === "vue-router" &&
-        st.specifiers.some((sp) => sp.type === "ImportSpecifier" && (sp.imported.name ?? sp.imported.value) === exported));
-    comp.routerLink = compiled.code.includes('_resolveComponent("RouterLink")') || imported("RouterLink");
-    comp.routerView = compiled.code.includes('_resolveComponent("RouterView")') || imported("RouterView");
-    comp.readsRoute = compiled.code.includes("_ctx.$route");
-    comp.readsI18n = compiled.code.includes("_ctx.$t(");
-    comp.readsTeleports = compiled.code.includes("_ssrRenderTeleport(");
+    for (const p of ctx.plugins)
+        p.compiled?.(comp, compiled.code, [...plainAst, ...ast]);
     return { comp, ast, ssr: compiled.code };
 }

package/dist/context.d.ts

@@ -1,5 +1,5 @@
-import type { I18nSetup } from "./i18n.ts";
-import { type Component, type N, type Struct, type Ty } from "./model.ts";
+import type { Plugin } from "./plugin.ts";
+import { type Component, type Struct, type Ty } from "./model.ts";
 /** A type a helper takes or returns, as the configuration spells it. */
 export type TypeName = "string" | "string?" | "int" | "int?" | "float" | "float?" | "bool";
 /** A function a template may call, and the Rust function that is its twin. */
@@ -44,7 +44,7 @@ export interface Config {
      * `v-`: `["focus", "click-outside"]`. Any other custom directive is refused, since the server
      * cannot know what its `getSSRProps` would add. */
     clientDirectives?: string[];
-    /** vue-i18n: the directory of locale files (\`en.json\`, \`nl.json\`), the locale a page renders in
+    /** vue-i18n: the directory of locale files (`en.json`, `nl.json`), the locale a page renders in
      * when it names none, and the locales a missing message falls back to. */
     i18n?: {
         messages: string;
@@ -62,50 +62,11 @@ export interface Config {
 export type ScopeIdMode = "filepath" | "filepath-source";
 export declare const CONFIG_FILE = "ferrovue.config.json";
 /** Read the project's configuration. */
-export declare function loadConfig(root: string): Config;
+export declare function loadConfig(root: string, configPath?: string): Config;
 export declare function tyOfName(name: TypeName): Ty;
-/** A route as the routes file lists it: a vue-router path, and the name it may have. */
-export interface RouteDef {
-    /** The path as written: relative to the parent's unless it starts with \`/\`. */
-    path: string;
-    name?: string;
-    /** The routes nested in it. */
-    children?: RouteDef[];
-    /** The path with its ancestors', as vue-router normalises it. */
-    fullPath: string;
-}
-/** Every route, nested ones included, parents first. */
-export declare function allRoutes(routes: RouteDef[]): RouteDef[];
-/** A getter: the parameter naming the state (an option store's), and the expression it returns.
- * \`setup\` marks a setup store's \`computed\`, which reads the state's refs and the other getters by
- * name, through \`.value\`. */
-export interface StoreGetter {
-    param: string | null;
-    body: N;
-    file: string;
-    setup?: true;
-}
-/** A Pinia option store: `export const usePrefs = defineStore("prefs", { state: (): PrefsState => ... })`. */
-export interface Store {
-    /** `usePrefs` */
-    hook: string;
-    /** `prefs`: its key in `pinia.state.value`. */
-    id: string;
-    /** `prefs`: its field in the generated `Stores`. */
-    field: string;
-    /** `PrefsState`: the interface its state is. */
-    state: string;
-    /** The file, without its extension, as an import names it once resolved. */
-    module: string;
-    /** Its getters: name → the parameter that names the state, and the expression returned. */
-    getters: Map<string, StoreGetter>;
-}
 /** Where `TrustedHtml` comes from. Only that import names the type `v-html` will write raw. */
 export declare const TYPES_MODULE = "ferrovue/types";
-/** What the configuration being compiled says, and what has been read so far: set up by
- * `generate()` at the start of each run, which is synchronous, so one run never sees another's. */
 export declare const ctx: {
-    /** The helpers of the configuration being compiled: name → Rust twin, typed. */
     helpers: Record<string, {
         rust: string;
         params: Ty[];
@@ -114,38 +75,15 @@ export declare const ctx: {
     }>;
     helperModule: string | null;
     trustedHtml: string | null;
-    /** Custom directives declared to render nothing on the server. */
     clientDirectives: Set<string>;
-    /** The configured routes, when there are any. */
-    routes: RouteDef[] | null;
-    /** The history's base, and the class names active links take, from the configured router. */
-    routerBase: string;
-    linkActive: string;
-    linkExactActive: string;
-    /** The configured stores, by hook name, and every interface their files declare. */
-    stores: Map<string, Store>;
-    storeStructs: Map<string, Struct>;
-    /** The store file each of those interfaces is declared in. */
-    storeFiles: Map<string, string>;
-    /** The project root, for resolving a component's imports. */
+    plugins: readonly Plugin[];
+    runs: Map<Plugin<unknown, unknown>, unknown>;
     rootDir: string;
-    /** Interfaces and object types declared in shared `.ts` files that components import, and type
-     * aliases there; the file each comes from. They are written once, to `types.rs`. */
     typeStructs: Map<string, Struct>;
     typeAliases: Map<string, any>;
     typeFiles: Map<string, string>;
-    /** The shared files read so far. */
     typeRead: Set<string>;
-    /** Every component being compiled, by name, for a type that names another one's props. */
     components: Map<string, Component>;
-    /** Numbers the bindings narrowing introduces, restarted per component so that a file's text
-     * depends on its own source alone. */
     narrowCount: number;
-    /** The directory the components being compiled come from, for the generated headers. */
     componentsDir: string;
-    /** The configured locales and their messages, when there are any. */
-    i18n: I18nSetup | null;
-    /** How scope ids are computed, and the directory a component's path is hashed from. */
-    scopeId: ScopeIdMode;
-    viteRoot: string;
 };

package/dist/context.js

@@ -1,16 +1,33 @@
-/* The project's configuration, and the state one `generate()` run builds up. */
 import { readFileSync } from "node:fs";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import { BOOL, FLOAT, GenError, INT, opt, STR } from "./model.js";
 export const CONFIG_FILE = "ferrovue.config.json";
 /** Read the project's configuration. */
-export function loadConfig(root) {
-    const raw = JSON.parse(readFileSync(join(root, CONFIG_FILE), "utf8"));
+export function loadConfig(root, configPath) {
+    const filePath = configPath ? resolve(root, configPath) : join(root, CONFIG_FILE);
+    const displayName = configPath ?? CONFIG_FILE;
+    let text = "";
+    try {
+        text = readFileSync(filePath, "utf8");
+    }
+    catch (e) {
+        if (e.code === "ENOENT") {
+            throw new GenError(`cannot find \`${displayName}\` in ${root}`);
+        }
+        throw e;
+    }
+    let raw;
+    try {
+        raw = JSON.parse(text);
+    }
+    catch (e) {
+        throw new GenError(`failed to parse \`${displayName}\`: ${e.message}`);
+    }
     if (typeof raw.components !== "string" || typeof raw.out !== "string") {
-        throw new GenError(`${CONFIG_FILE} needs \`components\` and \`out\` directories`);
+        throw new GenError(`${displayName} needs \`components\` and \`out\` directories`);
     }
     if (raw.scopeId !== undefined && raw.scopeId !== "filepath" && raw.scopeId !== "filepath-source") {
-        throw new GenError(`\`scopeId\` in ${CONFIG_FILE} is "filepath" or "filepath-source", as \`@vitejs/plugin-vue\` computes it`);
+        throw new GenError(`\`scopeId\` in ${displayName} is "filepath" or "filepath-source", as \`@vitejs/plugin-vue\` computes it`);
     }
     return raw;
 }
@@ -34,51 +51,21 @@ export function tyOfName(name) {
             throw new GenError(`unknown helper type \`${String(name)}\``);
     }
 }
-/** Every route, nested ones included, parents first. */
-export function allRoutes(routes) {
-    return routes.flatMap((r) => [r, ...allRoutes(r.children ?? [])]);
-}
 /** Where `TrustedHtml` comes from. Only that import names the type `v-html` will write raw. */
 export const TYPES_MODULE = "ferrovue/types";
-/** What the configuration being compiled says, and what has been read so far: set up by
- * `generate()` at the start of each run, which is synchronous, so one run never sees another's. */
 export const ctx = {
-    /** The helpers of the configuration being compiled: name → Rust twin, typed. */
     helpers: {},
     helperModule: null,
     trustedHtml: null,
-    /** Custom directives declared to render nothing on the server. */
     clientDirectives: new Set(),
-    /** The configured routes, when there are any. */
-    routes: null,
-    /** The history's base, and the class names active links take, from the configured router. */
-    routerBase: "",
-    linkActive: "router-link-active",
-    linkExactActive: "router-link-exact-active",
-    /** The configured stores, by hook name, and every interface their files declare. */
-    stores: new Map(),
-    storeStructs: new Map(),
-    /** The store file each of those interfaces is declared in. */
-    storeFiles: new Map(),
-    /** The project root, for resolving a component's imports. */
+    plugins: [],
+    runs: new Map(),
     rootDir: "",
-    /** Interfaces and object types declared in shared `.ts` files that components import, and type
-     * aliases there; the file each comes from. They are written once, to `types.rs`. */
     typeStructs: new Map(),
     typeAliases: new Map(),
     typeFiles: new Map(),
-    /** The shared files read so far. */
     typeRead: new Set(),
-    /** Every component being compiled, by name, for a type that names another one's props. */
     components: new Map(),
-    /** Numbers the bindings narrowing introduces, restarted per component so that a file's text
-     * depends on its own source alone. */
     narrowCount: 0,
-    /** The directory the components being compiled come from, for the generated headers. */
     componentsDir: "",
-    /** The configured locales and their messages, when there are any. */
-    i18n: null,
-    /** How scope ids are computed, and the directory a component's path is hashed from. */
-    scopeId: "filepath-source",
-    viteRoot: "",
 };

package/dist/diff.d.ts

@@ -0,0 +1 @@
+export declare function unifiedDiff(path: string, before: string, after: string): string;

package/dist/diff.js

@@ -0,0 +1,68 @@
+export function unifiedDiff(path, before, after) {
+    const lines = (text) => (text === "" ? [] : text.replace(/\n$/, "").split("\n"));
+    const a = lines(before);
+    const b = lines(after);
+    let head = 0;
+    while (head < a.length && head < b.length && a[head] === b[head])
+        head++;
+    let tail = 0;
+    while (tail < a.length - head && tail < b.length - head && a[a.length - 1 - tail] === b[b.length - 1 - tail])
+        tail++;
+    const midA = a.slice(head, a.length - tail);
+    const midB = b.slice(head, b.length - tail);
+    if (!midA.length && !midB.length)
+        return "";
+    const lcs = Array.from({ length: midA.length + 1 }, () => new Uint32Array(midB.length + 1));
+    for (let i = midA.length - 1; i >= 0; i--) {
+        for (let j = midB.length - 1; j >= 0; j--) {
+            lcs[i][j] = midA[i] === midB[j] ? lcs[i + 1][j + 1] + 1 : Math.max(lcs[i + 1][j], lcs[i][j + 1]);
+        }
+    }
+    const edits = a.slice(0, head).map((text) => ({ op: " ", text }));
+    let i = 0;
+    let j = 0;
+    while (i < midA.length || j < midB.length) {
+        if (i < midA.length && j < midB.length && midA[i] === midB[j]) {
+            edits.push({ op: " ", text: midA[i++] });
+            j++;
+        }
+        else if (j < midB.length && (i === midA.length || lcs[i][j + 1] > lcs[i + 1][j]))
+            edits.push({ op: "+", text: midB[j++] });
+        else
+            edits.push({ op: "-", text: midA[i++] });
+    }
+    edits.push(...a.slice(a.length - tail).map((text) => ({ op: " ", text })));
+    const CONTEXT = 3;
+    const hunks = [];
+    edits.forEach((e, k) => {
+        if (e.op === " ")
+            return;
+        const from = Math.max(0, k - CONTEXT);
+        const to = Math.min(edits.length - 1, k + CONTEXT);
+        const last = hunks.at(-1);
+        if (last && from <= last[1] + 1)
+            last[1] = to;
+        else
+            hunks.push([from, to]);
+    });
+    const out = [`--- ${a.length ? `a/${path}` : "/dev/null"}`, `+++ ${b.length ? `b/${path}` : "/dev/null"}`];
+    let lineA = 1;
+    let lineB = 1;
+    const at = edits.map((e) => {
+        const here = [lineA, lineB];
+        if (e.op !== "+")
+            lineA++;
+        if (e.op !== "-")
+            lineB++;
+        return here;
+    });
+    for (const [from, to] of hunks) {
+        const span = edits.slice(from, to + 1);
+        const countA = span.filter((e) => e.op !== "+").length;
+        const countB = span.filter((e) => e.op !== "-").length;
+        const startA = countA ? at[from][0] : at[from][0] - 1;
+        const startB = countB ? at[from][1] : at[from][1] - 1;
+        out.push(`@@ -${startA},${countA} +${startB},${countB} @@`, ...span.map((e) => `${e.op}${e.text}`));
+    }
+    return out.join("\n");
+}