fimo 0.9.0-experimental.1 → 0.9.0-experimental.11

package/dist/scripts/frameworks/nuxt/routes.js

@@ -1,22 +1,6 @@
 import { readdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
-const titleCase = (seg) => seg
-    .replace(/[_\-]+/g, ' ')
-    .replace(/([a-z])([A-Z])/g, '$1 $2')
-    .split(/\s+/)
-    .filter(Boolean)
-    .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
-    .join(' ');
-function pushRoute(routes, parts) {
-    const routePath = `/${parts.join('/')}`.replace(/\/+/g, '/');
-    const lastStatic = [...parts].reverse().find((part) => !part.startsWith(':'));
-    routes.push({
-        id: routePath === '/' ? 'home' : parts.map((part) => part.replace(/^:/, '')).join('-'),
-        path: routePath,
-        label: routePath === '/' ? 'Home' : titleCase(lastStatic ?? parts[parts.length - 1] ?? routePath),
-    });
-}
-const toSegment = (name) => name.replace(/^\[\.\.\.(.+)\]$/, ':$1').replace(/^\[(.+)\]$/, ':$1');
+import { pushRoute, toSegment } from '../discovered-route.js';
 /** Nuxt file-based routes under pages/ (index.vue maps to the dir path). */
 export function discoverNuxtRoutes(pagesDir) {
     const routes = [];
@@ -45,7 +29,7 @@ export function discoverNuxtRoutes(pagesDir) {
                 continue;
             }
             const base = entry.replace(/\.vue$/, '');
-            pushRoute(routes, base === 'index' ? segments : [...segments, toSegment(base)]);
+            pushRoute(routes, base === 'index' ? segments : [...segments, toSegment(base)], full);
         }
     };
     walk(pagesDir, []);

package/dist/scripts/frameworks/remix/routes.js

@@ -1,20 +1,6 @@
 import { readdirSync } from 'node:fs';
-const titleCase = (seg) => seg
-    .replace(/[_\-]+/g, ' ')
-    .replace(/([a-z])([A-Z])/g, '$1 $2')
-    .split(/\s+/)
-    .filter(Boolean)
-    .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
-    .join(' ');
-function pushRoute(routes, parts) {
-    const routePath = `/${parts.join('/')}`.replace(/\/+/g, '/');
-    const lastStatic = [...parts].reverse().find((part) => !part.startsWith(':'));
-    routes.push({
-        id: routePath === '/' ? 'home' : parts.map((part) => part.replace(/^:/, '')).join('-'),
-        path: routePath,
-        label: routePath === '/' ? 'Home' : titleCase(lastStatic ?? parts[parts.length - 1] ?? routePath),
-    });
-}
+import { join } from 'node:path';
+import { pushRoute } from '../discovered-route.js';
 const FILE_EXT = /\.(tsx|jsx|ts|js|mdx)$/;
 /** Remix v2 flat routes under app/routes: dots are slashes, $param is dynamic. */
 export function discoverRemixRoutes(routesDir) {
@@ -32,7 +18,7 @@ export function discoverRemixRoutes(routesDir) {
         }
         const base = entry.replace(FILE_EXT, '');
         if (base === '_index') {
-            pushRoute(routes, []);
+            pushRoute(routes, [], join(routesDir, entry));
             continue;
         }
         // Pathless layout segments start with _ ; trailing ._index maps to the parent.
@@ -42,7 +28,7 @@ export function discoverRemixRoutes(routesDir) {
             .filter((seg) => !seg.startsWith('_'))
             .map((seg) => (seg.startsWith('$') ? `:${seg.slice(1) || 'splat'}` : seg));
         if (parts.length > 0) {
-            pushRoute(routes, parts);
+            pushRoute(routes, parts, join(routesDir, entry));
         }
     }
     routes.sort((a, b) => a.path.localeCompare(b.path));

package/dist/scripts/frameworks/sveltekit/routes.js

@@ -1,22 +1,6 @@
 import { readdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
-const titleCase = (seg) => seg
-    .replace(/[_\-]+/g, ' ')
-    .replace(/([a-z])([A-Z])/g, '$1 $2')
-    .split(/\s+/)
-    .filter(Boolean)
-    .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
-    .join(' ');
-function pushRoute(routes, parts) {
-    const routePath = `/${parts.join('/')}`.replace(/\/+/g, '/');
-    const lastStatic = [...parts].reverse().find((part) => !part.startsWith(':'));
-    routes.push({
-        id: routePath === '/' ? 'home' : parts.map((part) => part.replace(/^:/, '')).join('-'),
-        path: routePath,
-        label: routePath === '/' ? 'Home' : titleCase(lastStatic ?? parts[parts.length - 1] ?? routePath),
-    });
-}
-const toSegment = (name) => name.replace(/^\[\.\.\.(.+)\]$/, ':$1').replace(/^\[(.+)\]$/, ':$1');
+import { pushRoute, toSegment } from '../discovered-route.js';
 /** SvelteKit routes: every directory under src/routes holding a +page file. */
 export function discoverSvelteKitRoutes(routesDir) {
     const routes = [];
@@ -28,9 +12,10 @@ export function discoverSvelteKitRoutes(routesDir) {
         catch {
             return;
         }
-        if (entries.some((entry) => /^\+page\.(svelte|md)$/.test(entry))) {
+        const pageFile = entries.find((entry) => /^\+page\.(svelte|md)$/.test(entry));
+        if (pageFile) {
             // Route groups (parens) are layout-only segments.
-            pushRoute(routes, segments.filter((seg) => !seg.startsWith('(')));
+            pushRoute(routes, segments.filter((seg) => !seg.startsWith('(')), join(dir, pageFile));
         }
         for (const entry of entries) {
             const full = join(dir, entry);

package/dist/scripts/frameworks/vite/routes.d.ts

@@ -1,3 +1,4 @@
+import { type RouteFileResolution, type RouteLike } from '../../routes/module-resolve.js';
 import type { DiscoveredRoute } from '../next/routes.js';
 /**
  * Route discovery for Vite React SPAs: there is no file convention, so the
@@ -13,3 +14,7 @@ import type { DiscoveredRoute } from '../next/routes.js';
  * anything the scan cannot see, and scanned routes only ever ADD to it.
  */
 export declare function discoverReactRouterDomRoutes(rootDir: string): DiscoveredRoute[];
+/** Registry-routed (frameworkRouteFiles): registry route ids → the SPA
+ *  component files that render them, via <Route element>/object-form route
+ *  declarations and import resolution (lazy() included). */
+export declare function resolveSpaRouteFiles(cwd: string, routes: Record<string, RouteLike>): RouteFileResolution[];

package/dist/scripts/frameworks/vite/routes.js

@@ -1,12 +1,7 @@
 import { readdirSync, readFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
-const titleCase = (seg) => seg
-    .replace(/[_\-]+/g, ' ')
-    .replace(/([a-z])([A-Z])/g, '$1 $2')
-    .split(/\s+/)
-    .filter(Boolean)
-    .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
-    .join(' ');
+import { discoveredRouteLabel } from '../../lib/humanize.js';
+import { componentImports, resolveModuleFile, walkFiles, } from '../../routes/module-resolve.js';
 const ROUTE_SOURCE = /\.(tsx|jsx|ts|js)$/;
 const SKIP_DIRS = new Set(['node_modules', 'dist', 'build', '.git']);
 /**
@@ -81,13 +76,68 @@ export function discoverReactRouterDomRoutes(rootDir) {
                 continue;
             }
             const parts = path.split('/').filter(Boolean);
-            const lastStatic = [...parts].reverse().find((part) => !part.startsWith(':'));
             routes.set(path, {
                 id: path === '/' ? 'home' : parts.map((part) => part.replace(/^:/, '')).join('-'),
                 path,
-                label: path === '/' ? 'Home' : titleCase(lastStatic ?? parts[parts.length - 1] ?? path),
+                label: discoveredRouteLabel(path),
             });
         }
     }
     return [...routes.values()].sort((a, b) => a.path.localeCompare(b.path));
 }
+/** Registry-routed (frameworkRouteFiles): registry route ids → the SPA
+ *  component files that render them, via <Route element>/object-form route
+ *  declarations and import resolution (lazy() included). */
+export function resolveSpaRouteFiles(cwd, routes) {
+    const srcDir = join(cwd, 'src');
+    const files = [];
+    walkFiles(srcDir, (name) => ROUTE_SOURCE.test(name), files);
+    const byPath = new Map();
+    for (const [routeId, route] of Object.entries(routes)) {
+        if (typeof route?.path === 'string') {
+            byPath.set(route.path, routeId);
+        }
+    }
+    const resolutions = new Map();
+    for (const file of files) {
+        let code;
+        try {
+            code = readFileSync(file, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        if (!/from\s+['"]react-router(?:-dom)?['"]/.test(code)) {
+            continue;
+        }
+        const imports = componentImports(code);
+        const pairs = [];
+        // JSX shape: one <Route …> tag carries both path and element, in either
+        // attribute order.
+        for (const tag of code.matchAll(/<Route\b((?:"[^"]*"|'[^']*'|\{[^{}]*\}|[^>"'{}])*)\/?>/g)) {
+            const attrs = tag[1];
+            const routePath = attrs.match(/\bpath\s*=\s*(?:"([^"]+)"|'([^']+)')/);
+            const element = attrs.match(/\belement\s*=\s*\{\s*<(\w+)[\s/>]/) ?? attrs.match(/\bComponent\s*=\s*\{(\w+)\}/);
+            if (routePath && element) {
+                pairs.push({ path: routePath[1] ?? routePath[2], component: element[1] });
+            }
+        }
+        // Object shape: { path: '/x', element: <X …/> } or { path: '/x', Component: X }.
+        for (const entry of code.matchAll(/path\s*:\s*(?:"([^"]+)"|'([^']+)')\s*,\s*(?:element\s*:\s*<(\w+)[\s/>]|Component\s*:\s*(\w+))/g)) {
+            pairs.push({ path: entry[1] ?? entry[2], component: entry[3] ?? entry[4] });
+        }
+        for (const pair of pairs) {
+            const normalized = pair.path !== '/' && pair.path.endsWith('/') ? pair.path.slice(0, -1) : pair.path;
+            const routeId = byPath.get(normalized);
+            if (!routeId || resolutions.has(routeId)) {
+                continue;
+            }
+            const spec = imports.get(pair.component);
+            const componentFile = spec ? resolveModuleFile(cwd, file, spec) : null;
+            if (componentFile) {
+                resolutions.set(routeId, componentFile);
+            }
+        }
+    }
+    return [...resolutions.entries()].map(([routeId, file]) => ({ routeId, file }));
+}

package/dist/scripts/frameworks/vite/wiring.d.ts

@@ -8,3 +8,15 @@ import type { RootWiringResult } from '../next/wiring.js';
  * Anything else bails with the reason and stays agent work via the recipe.
  */
 export declare function ensureSpaEntryWiring(cwd: string): RootWiringResult;
+/**
+ * The `fimo()` Vite plugin serves the virtual modules the generated content
+ * clients import (`virtual:fimo-config`, …). Without it, the first
+ * dependency re-optimization 500s every page the moment an agent uses a
+ * generated client — both run-5 agents had to discover and add it by hand.
+ * Insert `fimo()` into the config's plugins array; unusual configs bail
+ * with the recipe.
+ */
+export declare function ensureViteFimoPlugin(cwd: string): {
+    changes: string[];
+    warnings: string[];
+};

package/dist/scripts/frameworks/vite/wiring.js

@@ -33,52 +33,53 @@ export function ensureSpaEntryWiring(cwd) {
     catch {
         return bail('entry file could not be parsed', rel);
     }
-    // The JSX argument of the root render call, found structurally: a call
-    // whose callee property is `render` with a JSX element first argument
-    // (covers `createRoot(…).render(<X/>)` and `ReactDOM.render(<X/>, node)`).
-    const renderArg = (function find(node) {
+    // EVERY root-mount JSX argument, found structurally: `render(<X/>)` calls
+    // (createRoot/ReactDOM) AND `hydrateRoot(container, <X/>)` — a prerendered
+    // SPA mounts through BOTH branches, and wiring only the createRoot one
+    // left the production hydrate path without providers (run-5 finding).
+    const renderArgs = [];
+    (function find(node) {
         if (!node || typeof node !== 'object') {
-            return null;
+            return;
         }
         const candidate = node;
-        if (candidate.type === 'CallExpression' &&
-            candidate.callee?.type === 'MemberExpression' &&
-            candidate.callee?.property?.name === 'render' &&
-            (candidate.arguments?.[0]?.type === 'JSXElement' || candidate.arguments?.[0]?.type === 'JSXFragment')) {
-            return candidate.arguments[0];
+        if (candidate.type === 'CallExpression') {
+            const isRender = candidate.callee?.type === 'MemberExpression' && candidate.callee?.property?.name === 'render';
+            const isHydrate = candidate.callee?.name === 'hydrateRoot' ||
+                (candidate.callee?.type === 'MemberExpression' && candidate.callee?.property?.name === 'hydrateRoot');
+            const arg = isRender ? candidate.arguments?.[0] : isHydrate ? candidate.arguments?.[1] : undefined;
+            if (arg && (arg.type === 'JSXElement' || arg.type === 'JSXFragment')) {
+                renderArgs.push(arg);
+            }
         }
         for (const value of Object.values(candidate)) {
             if (Array.isArray(value)) {
                 for (const entry of value) {
-                    const found = find(entry);
-                    if (found) {
-                        return found;
-                    }
+                    find(entry);
                 }
             }
             else if (value && typeof value === 'object') {
-                const found = find(value);
-                if (found) {
-                    return found;
-                }
+                find(value);
             }
         }
-        return null;
     })(program);
-    if (!renderArg) {
+    if (renderArgs.length === 0) {
         return bail('no root render call with a JSX argument found', rel);
     }
     const configImportPath = path
         .relative(path.dirname(entryFile), path.join(cwd, 'fimo-config.json'))
         .split(path.sep)
         .join('/');
-    const jsx = code.slice(renderArg.start, renderArg.end);
     const open = '<FimoSpaProviders\n' +
         '    config={fimoConfig}\n' +
         '    apiUrl={import.meta.env.VITE_API_URL}\n' +
         '    previewScriptUrl={import.meta.env.DEV ? import.meta.env.VITE_FIMO_PREVIEW_SCRIPT_URL : undefined}\n' +
         '  >';
-    let next = code.slice(0, renderArg.start) + `${open}\n    ${jsx}\n  </FimoSpaProviders>` + code.slice(renderArg.end);
+    let next = code;
+    for (const renderArg of [...renderArgs].sort((a, b) => b.start - a.start)) {
+        const jsx = next.slice(renderArg.start, renderArg.end);
+        next = next.slice(0, renderArg.start) + `${open}\n    ${jsx}\n  </FimoSpaProviders>` + next.slice(renderArg.end);
+    }
     // AST-positioned like ensureFimoImport: a multiline import's first line is
     // not the end of the imports.
     const importBlock = `import { FimoSpaProviders } from 'fimo/react';\nimport fimoConfig from '${configImportPath.startsWith('.') ? configImportPath : `./${configImportPath}`}';`;
@@ -95,5 +96,49 @@ export function ensureSpaEntryWiring(cwd) {
             ? `${next.slice(0, lastImportEnd)}\n${importBlock}${next.slice(lastImportEnd)}`
             : `${importBlock}\n${next}`;
     fs.writeFileSync(entryFile, next);
-    return { changes: [`wired FimoSpaProviders into ${rel}`], warnings: [], wired: true };
+    const changes = [`wired FimoSpaProviders into ${rel} (${renderArgs.length} mount point(s))`];
+    const pluginResult = ensureViteFimoPlugin(cwd);
+    return {
+        changes: [...changes, ...pluginResult.changes],
+        warnings: pluginResult.warnings,
+        wired: true,
+    };
+}
+/**
+ * The `fimo()` Vite plugin serves the virtual modules the generated content
+ * clients import (`virtual:fimo-config`, …). Without it, the first
+ * dependency re-optimization 500s every page the moment an agent uses a
+ * generated client — both run-5 agents had to discover and add it by hand.
+ * Insert `fimo()` into the config's plugins array; unusual configs bail
+ * with the recipe.
+ */
+export function ensureViteFimoPlugin(cwd) {
+    const configFile = ['vite.config.ts', 'vite.config.js', 'vite.config.mts', 'vite.config.mjs']
+        .map((candidate) => path.join(cwd, candidate))
+        .find((candidate) => fs.existsSync(candidate));
+    if (!configFile) {
+        return { changes: [], warnings: ['No vite.config found — add the fimo() plugin per the agent-prompt recipe.'] };
+    }
+    const rel = path.relative(cwd, configFile);
+    const code = fs.readFileSync(configFile, 'utf8');
+    if (/\bfimo\s*\(/.test(code) && code.includes('fimo/vite')) {
+        return { changes: [], warnings: [] };
+    }
+    const pluginsMatch = code.match(/\bplugins\s*:\s*\[/);
+    if (!pluginsMatch || pluginsMatch.index === undefined) {
+        return {
+            changes: [],
+            warnings: [`No plugins array found in ${rel} — add the fimo() plugin per the agent-prompt recipe.`],
+        };
+    }
+    const insertAt = pluginsMatch.index + pluginsMatch[0].length;
+    let next = `${code.slice(0, insertAt)}fimo(), ${code.slice(insertAt)}`;
+    const importLine = `import { fimo } from 'fimo/vite';`;
+    const lastImport = [...next.matchAll(/^import .*$/gm)].pop();
+    next =
+        lastImport && lastImport.index !== undefined
+            ? `${next.slice(0, lastImport.index + lastImport[0].length)}\n${importLine}${next.slice(lastImport.index + lastImport[0].length)}`
+            : `${importLine}\n${next}`;
+    fs.writeFileSync(configFile, next);
+    return { changes: [`added the fimo() plugin to ${rel}`], warnings: [] };
 }

package/dist/scripts/lib/humanize.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Human-facing names derived from slugs and identifiers — route labels, page
+ * names, field titles. One rule set so "ai-stack" reads "AI Stack" and
+ * "agentic-cms" reads "Agentic CMS" everywhere the machine writes a name.
+ */
+/** "ai-stack" → "AI Stack"; "agenticCms" → "Agentic CMS"; "blog" → "Blog". */
+export declare function humanizeSegment(segment: string): string;
+/**
+ * The discovery-time label for a route path. Dynamic templates never share
+ * the parent index page's name (the run-4 tree showed "Blog" twice): the
+ * param joins the label ("/blog/:slug" → "Blog Slug") until a schema
+ * binding upgrades it to the schema's name ("Blog Post").
+ */
+export declare function discoveredRouteLabel(path: string): string;

package/dist/scripts/lib/humanize.js

@@ -0,0 +1,54 @@
+/**
+ * Human-facing names derived from slugs and identifiers — route labels, page
+ * names, field titles. One rule set so "ai-stack" reads "AI Stack" and
+ * "agentic-cms" reads "Agentic CMS" everywhere the machine writes a name.
+ */
+const ACRONYMS = new Set([
+    'ai',
+    'api',
+    'cd',
+    'ci',
+    'cli',
+    'cms',
+    'cta',
+    'faq',
+    'geo',
+    'llm',
+    'sdk',
+    'seo',
+    'spa',
+    'ssg',
+    'ssr',
+    'ui',
+    'url',
+    'ux',
+]);
+/** "ai-stack" → "AI Stack"; "agenticCms" → "Agentic CMS"; "blog" → "Blog". */
+export function humanizeSegment(segment) {
+    return segment
+        .replace(/[_\-]+/g, ' ')
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        .split(/\s+/)
+        .filter(Boolean)
+        .map((word) => ACRONYMS.has(word.toLowerCase()) ? word.toUpperCase() : word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join(' ');
+}
+/**
+ * The discovery-time label for a route path. Dynamic templates never share
+ * the parent index page's name (the run-4 tree showed "Blog" twice): the
+ * param joins the label ("/blog/:slug" → "Blog Slug") until a schema
+ * binding upgrades it to the schema's name ("Blog Post").
+ */
+export function discoveredRouteLabel(path) {
+    if (path === '/') {
+        return 'Home';
+    }
+    const parts = path.split('/').filter(Boolean);
+    const lastStatic = [...parts].reverse().find((part) => !part.startsWith(':'));
+    const base = humanizeSegment(lastStatic ?? parts[parts.length - 1]?.replace(/^:/, '') ?? path);
+    const lastPart = parts[parts.length - 1];
+    if (lastPart?.startsWith(':') && lastStatic) {
+        return `${base} ${humanizeSegment(lastPart.replace(/^:|\*$/g, ''))}`;
+    }
+    return base;
+}

package/dist/scripts/lib/validation-report.d.ts

@@ -34,12 +34,9 @@ export interface ValidationReport {
         sync: PhaseResult;
     };
 }
-export declare function emptyPhase(name: string): PhaseResult;
 export declare function skippedPhase(name: string, reason: string): PhaseResult;
 export declare function computeExitCode(report: ValidationReport): 0 | 1 | 2;
 export declare function finalizeReport(report: Omit<ValidationReport, 'ok' | 'exitCode'>): ValidationReport;
 export declare function authorError(opts: Omit<ValidationError, 'kind'>): ValidationError;
-export declare function infraError(opts: Omit<ValidationError, 'kind'>): ValidationError;
 export declare function infraErrorFromException(rule: string, error: unknown): ValidationError;
-export declare function formatReportJson(report: ValidationReport): string;
 export declare function formatReportHuman(report: ValidationReport): string;

package/dist/scripts/lib/validation-report.js

@@ -6,9 +6,6 @@
  * (the Fimo backend is unreachable or returned a server error — agent should
  * surface to the human and stop). Exit codes follow the same split.
  */
-export function emptyPhase(name) {
-    return { name, ok: true, errors: [] };
-}
 export function skippedPhase(name, reason) {
     return { name, ok: false, errors: [], skipped: { reason } };
 }
@@ -32,9 +29,6 @@ export function finalizeReport(report) {
 export function authorError(opts) {
     return { kind: 'author', ...opts };
 }
-export function infraError(opts) {
-    return { kind: 'infra', ...opts };
-}
 export function infraErrorFromException(rule, error) {
     return {
         kind: 'infra',
@@ -42,9 +36,6 @@ export function infraErrorFromException(rule, error) {
         message: error instanceof Error ? error.message : String(error),
     };
 }
-export function formatReportJson(report) {
-    return JSON.stringify(report, null, 2);
-}
 export function formatReportHuman(report) {
     const lines = [];
     for (const phase of [report.phases.checks, report.phases.codegen, report.phases.sync]) {

package/dist/scripts/render-parity/capture.d.ts

@@ -26,15 +26,23 @@ export declare class CaptureError extends Error {
     readonly stderrTail: string;
     constructor(message: string, stderrTail?: string);
 }
+/**
+ * pnpm's minimumReleaseAge setting refuses freshly published packages —
+ * exactly what a just-published fimo experimental is. The refusal surfaces
+ * deep in install/boot output; detect it and hand back the one-line fix
+ * instead of leaving an opaque boot failure.
+ */
+export declare function pnpmReleaseAgeHint(output: string): string | null;
 export declare function findFreePort(): Promise<number>;
 /**
  * Build workspace packages the app needs BEFORE booting its dev server. Fimo
  * runs the app's bare `next dev`, but in a Turborepo/pnpm monorepo the
  * internal deps (`@repo/*`) aren't built by that — `turbo dev` would build
- * them first. This detects unbuilt internal deps and runs the monorepo's
- * build once (the root `build` script, else `turbo run build`); turbo's cache
- * makes an already-built repo near-instant. A build failure is surfaced with
- * an actionable message instead of a cryptic `Cannot find module` at boot.
+ * them first. Builds are SCOPED to the flagged packages (turbo/pnpm/npm
+ * filters) — the root build script builds the whole app too and fails for
+ * reasons unrelated to the deps; it is only the last resort when no filter
+ * mechanism exists. A build failure is surfaced with an actionable message
+ * instead of a cryptic `Cannot find module` at boot.
  */
 export declare function ensureWorkspaceDepsBuilt(cwd: string, packageManager: string, onProgress?: (message: string) => void): void;
 interface DevServer {