@uniflowed/vite 0.0.0-alpha.1

package/bun-preload.js

@@ -0,0 +1,22 @@
+// Plain JavaScript: this file registers the loader, so it cannot need one.
+//
+// `bun --preload @uniflowed/vite/bun-preload app.js` runs a Flow project on
+// Bun without a build step, through Bun's own plugin API: every module uf is
+// responsible for is transformed by `uf transform` as Bun loads it. It is the
+// Bun counterpart of `./register.js`, and the policy of which files count is
+// the same `isFlowModule`.
+
+import { isFlowModule, transformFlow } from "./transform.js";
+
+Bun.plugin({
+  name: "uniflowed-flow",
+  setup(build) {
+    build.onLoad({ filter: /\.(js|jsx|mjs)$/ }, async (args) => {
+      if (!isFlowModule(args.path)) return undefined;
+      const source = await Bun.file(args.path).text();
+      const out = await transformFlow(source, args.path, { development: true, sourceMap: false });
+      if (out == null) return undefined;
+      return { contents: out.code, loader: "js" };
+    });
+  },
+});

package/driver.js

@@ -0,0 +1,360 @@
+// Plain JavaScript: the host runs this file directly.
+//
+// The driver `uf dev`, `uf build` and `uf preview` spawn.
+//
+//   <host> driver.js dev     --root <dir> [--host <h>] [--port <n>] [--strict-port]
+//   <host> driver.js build   --root <dir> [--out-dir <dir>] [--mode <m>]
+//   <host> driver.js preview --root <dir> [--host <h>] [--port <n>]
+//   <host> driver.js config  --root <dir>
+//
+// `uf` in Rust owns the terminal; this process owns Vite. They talk over
+// stdout, one JSON event per line (see `./internal/events.js`), and the driver
+// exits when its stdin closes so it cannot outlive the command that started
+// it.
+//
+// `config` loads `uf.config.js` and prints its JSON projection. It is how the
+// Rust side reads a config that may hold functions and plugin instances: the
+// one host that can evaluate the file evaluates it.
+
+import { register } from "node:module";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+import { emit, errorEvent, eventLogger } from "./internal/events.js";
+import { loadUfConfig, projectConfig } from "./internal/config.js";
+import { VIRTUAL, scanRoutes } from "./internal/routes.js";
+
+function argument(name) {
+  const at = process.argv.indexOf(name);
+  return at === -1 ? null : process.argv[at + 1];
+}
+
+function flag(name) {
+  return process.argv.includes(name);
+}
+
+const command = process.argv[2];
+const root = path.resolve(argument("--root") ?? process.cwd());
+// Every transform in this process — the loader hooks, the config loader, the
+// Vite plugin — talks to one `uf transform` started at the project root.
+process.env.UF_PROJECT_ROOT = root;
+
+// The config imports `@uniflowed/config`, which is Flow. Node needs the loader
+// hooks for that; Bun is started with `--preload ./bun-preload.js` instead
+// and has no `register`.
+if (typeof Bun === "undefined" && typeof Deno === "undefined") {
+  register("./internal/node-hooks.js", import.meta.url, { data: { root } });
+}
+
+process.stdin.on("end", () => process.exit(0));
+process.stdin.on("error", () => process.exit(0));
+process.stdin.resume();
+
+const commands = { dev, build, preview, config: printConfig };
+const run = commands[command];
+if (run == null) {
+  emit("error", { message: `unknown driver command ${JSON.stringify(command)}` });
+  process.exit(2);
+}
+
+run().catch((error) => {
+  emit("error", errorEvent(error));
+  process.exit(1);
+});
+
+/** Load `uf.config.js`, reporting where it was found. */
+async function loadConfig() {
+  const { config, file } = await loadUfConfig(root);
+  emit("config-loaded", { file });
+  return config;
+}
+
+/** The Vite inline config a uf config describes. */
+async function viteConfig(config, mode) {
+  const { default: uniflowed } = await import("./index.js");
+  const dev = config.dev ?? {};
+  const build = config.build ?? {};
+  const userPlugins = Array.isArray(config.plugins) ? config.plugins : [];
+  const host = argument("--host") ?? dev.host ?? "127.0.0.1";
+  const port = Number(argument("--port") ?? dev.port ?? 5173);
+  const allowedHosts = Array.isArray(dev.allowedHosts) && dev.allowedHosts.length > 0 ? dev.allowedHosts : undefined;
+
+  return {
+    root,
+    configFile: false,
+    envFile: false,
+    mode,
+    clearScreen: false,
+    customLogger: eventLogger(argument("--log-level") ?? "info"),
+    plugins: [uniflowed({ root, config }), ...userPlugins],
+    server: {
+      host,
+      port,
+      strictPort: flag("--strict-port") || dev.strictPort === true,
+      allowedHosts,
+      fs: {
+        allow: dev.fs?.allow,
+        deny: dev.fs?.deny,
+      },
+    },
+    preview: { host, port },
+    build: {
+      outDir: argument("--out-dir") ?? build.outDir ?? "dist",
+      sourcemap: build.sourcemap ?? true,
+      manifest: true,
+      emptyOutDir: true,
+    },
+  };
+}
+
+/**
+ * The dev server.
+ *
+ * Vite in middleware mode serves nothing on its own: with no `index.html` at
+ * the project root it answers every navigation with "Cannot GET /", which is
+ * what `uf dev` used to do for every project it started. A uf project has no
+ * `index.html` — the document comes from a layout — so the server has to render
+ * it, which is what this middleware does:
+ *
+ *   1. load the server entry through `ssrLoadModule`, so it is transformed the
+ *      same way the browser's copy is and picks up edits without a restart;
+ *   2. render the URL, pointing the client script at the dev entry rather than
+ *      at a built asset;
+ *   3. hand the HTML to `transformIndexHtml`, which is what injects the HMR
+ *      client and lets any Vite plugin see the document.
+ *
+ * Anything Vite already serves — a module, a public file — never reaches this,
+ * because the middleware runs after Vite's own.
+ */
+async function dev() {
+  const { createServer } = await import("vite");
+  const config = await loadConfig();
+  const inline = await viteConfig(config, "development");
+  const server = await createServer({ ...inline, appType: "custom" });
+
+  // In dev the browser loads the client entry from Vite, not from a manifest;
+  // its stylesheets arrive through that module rather than as <link> tags.
+  const assets = { scripts: [`/@id/${VIRTUAL.client}`], styles: [], preloads: [] };
+
+  server.middlewares.use(async (request, response, next) => {
+    if (request.method !== "GET" && request.method !== "HEAD") {
+      next();
+      return;
+    }
+    const url = request.originalUrl ?? request.url ?? "/";
+    try {
+      const entry = await server.ssrLoadModule(VIRTUAL.server);
+      const result = await entry.render(url, assets);
+      const html = await server.transformIndexHtml(url, result.html);
+      response.statusCode = result.status ?? 200;
+      response.setHeader("content-type", "text/html; charset=utf-8");
+      response.end(html);
+    } catch (error) {
+      // Map the stack back onto the Flow source before it reaches the overlay.
+      if (error instanceof Error) server.ssrFixStacktrace(error);
+      next(error);
+    }
+  });
+
+  await server.listen();
+  const urls = server.resolvedUrls ?? { local: [], network: [] };
+  emit("listening", {
+    local: urls.local,
+    network: urls.network,
+    routes: scanRoutes(path.resolve(root, config.app?.router?.root ?? "app")).routes.map((route) => route.path),
+  });
+
+  const shutdown = async () => {
+    await server.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+
+async function preview() {
+  const { preview: startPreview } = await import("vite");
+  const config = await loadConfig();
+  const server = await startPreview(await viteConfig(config, "production"));
+  const urls = server.resolvedUrls ?? { local: [], network: [] };
+  emit("listening", { local: urls.local, network: urls.network, routes: [] });
+  const shutdown = async () => {
+    await server.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+
+async function build() {
+  const vite = await import("vite");
+  const config = await loadConfig();
+  const mode = argument("--mode") ?? "production";
+  const inline = await viteConfig(config, mode);
+  const outDir = path.resolve(root, inline.build.outDir);
+  const serverDir = path.join(root, ".uf", "build", "server");
+
+  // 1. The client: everything the browser loads, with a manifest so the
+  //    server render knows which script and stylesheet tags to write.
+  emit("phase", { name: "client" });
+  await vite.build({
+    ...inline,
+    build: {
+      ...inline.build,
+      rollupOptions: { input: { client: VIRTUAL.client } },
+    },
+  });
+  const manifest = readManifest(outDir);
+
+  // 2. The server entry, bundled for the host, outside `dist/` so it is never
+  //    deployed by accident.
+  emit("phase", { name: "server" });
+  rmSync(serverDir, { recursive: true, force: true });
+  await vite.build({
+    ...inline,
+    customLogger: eventLogger("warn"),
+    build: {
+      ...inline.build,
+      manifest: false,
+      ssr: true,
+      outDir: serverDir,
+      rollupOptions: {
+        input: { server: VIRTUAL.server },
+        output: { entryFileNames: "server.js", format: "es" },
+      },
+    },
+  });
+
+  // 3. Every static route, rendered to an HTML document.
+  emit("phase", { name: "prerender" });
+  const server = await import(pathToFileURL(path.join(serverDir, "server.js")).href);
+  const assets = assetsFromManifest(manifest);
+  const pages = await staticPaths(server.routes);
+  for (const url of pages) {
+    const result = await server.render(url, assets);
+    const file = htmlPathFor(outDir, url);
+    mkdirSync(path.dirname(file), { recursive: true });
+    writeFileSync(file, result.html);
+    emit("page", { url, file: path.relative(root, file), status: result.status, bytes: Buffer.byteLength(result.html) });
+  }
+  if (server.notFound != null) {
+    const result = await server.render("/__uf_not_found__", assets);
+    const file = path.join(outDir, "404.html");
+    writeFileSync(file, result.html);
+    emit("page", { url: "/404", file: path.relative(root, file), status: 404, bytes: Buffer.byteLength(result.html) });
+  }
+
+  emit("done", { outDir: path.relative(root, outDir), pages: pages.length });
+  process.exit(0);
+}
+
+async function printConfig() {
+  const config = await loadConfig();
+  emit("config", { config: projectConfig(config) });
+  process.exit(0);
+}
+
+function readManifest(outDir) {
+  const file = path.join(outDir, ".vite", "manifest.json");
+  if (!existsSync(file)) throw new Error(`uf: the client build wrote no manifest at ${file}`);
+  return JSON.parse(readFileSync(file, "utf8"));
+}
+
+/**
+ * Script, stylesheet and preload URLs for the client entry chunk.
+ *
+ * The entry is found by its `isEntry` flag rather than by key, because a
+ * virtual module's manifest key is an implementation detail of the bundler.
+ */
+/**
+ * The tags a prerendered document needs.
+ *
+ * Two walks over the manifest, because the two answers are different. A
+ * `modulepreload` is worth emitting only for a chunk this document will
+ * certainly load, which is the entry's *static* imports. A stylesheet has to
+ * be emitted for anything the page might render, and the router loads every
+ * route module dynamically — so a stylesheet imported by a layout is reached
+ * through `dynamicImports` and through nothing else. Following only the static
+ * graph, as this did, meant a layout could import a stylesheet and the built
+ * HTML would silently ship without it.
+ *
+ * The cost is that a project with per-route stylesheets links all of them on
+ * every page. Narrowing that needs the route table to say which chunk each
+ * route came from, which the manifest alone cannot tell us.
+ */
+function assetsFromManifest(manifest) {
+  const entry = Object.values(manifest).find((chunk) => chunk.isEntry);
+  if (entry == null) throw new Error("uf: the client manifest has no entry chunk");
+
+  const styles = new Set(entry.css ?? []);
+  const seen = new Set();
+  const collectStyles = (chunk) => {
+    for (const imported of [...(chunk.imports ?? []), ...(chunk.dynamicImports ?? [])]) {
+      if (seen.has(imported)) continue;
+      seen.add(imported);
+      const dependency = manifest[imported];
+      if (dependency == null) continue;
+      for (const css of dependency.css ?? []) styles.add(css);
+      collectStyles(dependency);
+    }
+  };
+  collectStyles(entry);
+
+  const preloads = new Set();
+  const collectPreloads = (chunk) => {
+    for (const imported of chunk.imports ?? []) {
+      const dependency = manifest[imported];
+      if (dependency == null || preloads.has(dependency.file)) continue;
+      preloads.add(dependency.file);
+      collectPreloads(dependency);
+    }
+  };
+  collectPreloads(entry);
+
+  return {
+    scripts: [`/${entry.file}`],
+    styles: [...styles].map((file) => `/${file}`),
+    preloads: [...preloads].map((file) => `/${file}`),
+  };
+}
+
+/**
+ * The URLs to prerender: every route without parameters, plus every set of
+ * parameters a page's `generateStaticParams` returns.
+ */
+async function staticPaths(routes) {
+  const urls = [];
+  for (const route of routes) {
+    if (route.params.length === 0) {
+      urls.push(route.path);
+      continue;
+    }
+    const module = await route.page();
+    const generate = module.generateStaticParams;
+    if (typeof generate !== "function") continue;
+    for (const params of await generate()) {
+      urls.push(fillParams(route.path, params));
+    }
+  }
+  return urls;
+}
+
+function fillParams(routePath, params) {
+  return routePath
+    .split("/")
+    .map((segment) => {
+      if (segment.endsWith("*")) {
+        const value = params[segment.slice(1, -1)];
+        return Array.isArray(value) ? value.map(encodeURIComponent).join("/") : encodeURIComponent(String(value ?? ""));
+      }
+      if (segment.startsWith(":")) return encodeURIComponent(String(params[segment.slice(1)] ?? ""));
+      return segment;
+    })
+    .join("/");
+}
+
+function htmlPathFor(outDir, url) {
+  const pathname = url.split("?")[0].replace(/^\/+/, "");
+  return pathname === "" ? path.join(outDir, "index.html") : path.join(outDir, pathname, "index.html");
+}

package/index.js

@@ -0,0 +1,316 @@
+// Plain JavaScript: Vite imports this module directly, before any transform.
+//
+// `@uniflowed/vite` — uf, as Vite plugins.
+//
+// Vite is the dev server, the module graph, hot module replacement, the
+// bundler and the plugin system; uf contributes what is specific to a Flow
+// React application and nothing that Vite already does:
+//
+// * `uf:flow`   — every Flow module goes through `uf transform` (the official
+//                 Flow parser, Flow's own lowering rules, the official React
+//                 Compiler, oxc), plus the React Fast Refresh wiring in
+//                 development and the virtual modules that make a directory
+//                 of pages an application: the route table, the client entry
+//                 that hydrates it, and the server entry that renders it. In
+//                 development it also renders every HTML request on the
+//                 server, so `uf dev` serves the same markup `uf build` writes.
+// * `uf:mdx`    — `@mdx-js/rollup`, configured for React with GitHub-flavoured
+//                 markdown, front matter and heading ids, so `.mdx` works with
+//                 no configuration.
+//
+// `uniflowed(options)` returns the array; a project that wants to add a plugin
+// declares it in `uf.config.js` and the driver appends it after these.
+
+import { readdirSync } from "node:fs";
+import path from "node:path";
+
+import mdx from "@mdx-js/rollup";
+import rehypeSlug from "rehype-slug";
+import remarkFrontmatter from "remark-frontmatter";
+import remarkGfm from "remark-gfm";
+import remarkMdxFrontmatter from "remark-mdx-frontmatter";
+
+import {
+  RUNTIME_PUBLIC_PATH,
+  RUNTIME_RESOLVED_ID,
+  addRefreshWrapper,
+  preambleCode,
+  refreshRuntimeSource,
+} from "./internal/refresh.js";
+import {
+  VIRTUAL,
+  clientModuleSource,
+  routesModuleSource,
+  scanRoutes,
+  serverModuleSource,
+} from "./internal/routes.js";
+import { TransformService, isFlowModule } from "./transform.js";
+
+/** A resolved virtual id: Vite's convention is a leading NUL byte. */
+const resolved = (id) => `\0${id}`;
+const VIRTUAL_IDS = new Set(Object.values(VIRTUAL));
+
+/** The URL a NUL-prefixed module is served at in development. */
+export function devUrlFor(id) {
+  return `/@id/__x00__${id}`;
+}
+
+/**
+ * Options for the plugin set.
+ *
+ * @typedef {object} UniflowedOptions
+ * @property {string} [root] absolute project root; Vite's root by default
+ * @property {object} [config] the loaded `uf.config.js` object
+ * @property {string} [command] the `uf` binary to transform through
+ */
+
+/**
+ * uf's Vite plugins.
+ *
+ * @param {UniflowedOptions} [options]
+ */
+export default function uniflowed(options = {}) {
+  const ufConfig = options.config ?? {};
+  const app = ufConfig.app ?? {};
+  const routerRoot = app.router?.root ?? "app";
+  const appEntry = app.router?.entry ?? ufConfig.build?.entries?.[0] ?? "app.js";
+  const markdown = app.builtins?.markdown ?? {};
+
+  return [flowPlugin({ routerRoot, appEntry, command: options.command }), mdxPlugin(markdown)];
+}
+
+function flowPlugin({ routerRoot, appEntry, command }) {
+  let root = process.cwd();
+  let isProduction = false;
+  let base = "/";
+  let appRoot = "";
+  let entryPath = "";
+  /** @type {import("vite").ViteDevServer | null} */
+  let server = null;
+  /** @type {TransformService | null} */
+  let service = null;
+
+  const ensureService = () => {
+    service ??= new TransformService({ command, root });
+    return service;
+  };
+
+  return {
+    name: "uf:flow",
+    enforce: "pre",
+
+    config(userConfig, env) {
+      const projectRoot = path.resolve(userConfig.root ?? process.cwd());
+      isProduction = env.mode === "production" || env.command === "build";
+      return {
+        // uf serves HTML itself; there is no index.html to fall back to.
+        appType: "custom",
+        resolve: {
+          dedupe: ["react", "react-dom"],
+        },
+        optimizeDeps: {
+          include: [
+            "react",
+            "react/jsx-runtime",
+            "react/jsx-dev-runtime",
+            "react/compiler-runtime",
+            "react-dom",
+            "react-dom/client",
+          ],
+          // uf's packages ship Flow. The dependency optimiser pre-bundles
+          // with a JavaScript parser and would reject every one of them.
+          exclude: uniflowedPackages(projectRoot),
+        },
+        ssr: {
+          // Same reason on the server: Node cannot import Flow, so these go
+          // through the plugin like project code rather than being
+          // externalised.
+          noExternal: [/^@uniflowed\//],
+        },
+      };
+    },
+
+    configResolved(config) {
+      root = config.root;
+      base = config.base;
+      appRoot = path.resolve(root, routerRoot);
+      entryPath = path.resolve(root, appEntry);
+    },
+
+    buildStart() {
+      ensureService();
+    },
+
+    resolveId(id) {
+      if (id === RUNTIME_PUBLIC_PATH) return RUNTIME_RESOLVED_ID;
+      if (VIRTUAL_IDS.has(id)) return resolved(id);
+      return null;
+    },
+
+    load(id) {
+      if (id === RUNTIME_RESOLVED_ID) return refreshRuntimeSource();
+      if (id === resolved(VIRTUAL.routes)) return routesModuleSource(scanRoutes(appRoot));
+      if (id === resolved(VIRTUAL.client)) return clientModuleSource(entryPath);
+      if (id === resolved(VIRTUAL.server)) return serverModuleSource(entryPath);
+      return null;
+    },
+
+    async transform(code, id, transformOptions) {
+      if (!isFlowModule(id)) return null;
+      const ssr = transformOptions?.ssr === true || this.environment?.name === "ssr";
+      const refresh = !isProduction && !ssr && server != null;
+      const out = await ensureService().transform(cleanId(id), code, {
+        development: !isProduction,
+        refresh,
+        sourceMap: true,
+      });
+      if (out == null) return null;
+      for (const diagnostic of out.diagnostics) {
+        this.warn?.(`${diagnostic.function ?? "a function"}: ${diagnostic.message}`);
+      }
+      const map = out.map == null ? null : JSON.parse(out.map);
+      if (!refresh) return { code: out.code, map };
+      const relative = path.relative(root, cleanId(id)).split(path.sep).join("/");
+      return addRefreshWrapper(out.code, map, relative);
+    },
+
+    buildEnd() {
+      // A dev server keeps its service for the whole session; a build is
+      // done with it here.
+      if (server == null) {
+        service?.close();
+        service = null;
+      }
+    },
+
+    transformIndexHtml() {
+      if (isProduction) return [];
+      return [
+        {
+          tag: "script",
+          attrs: { type: "module" },
+          children: preambleCode(base),
+          injectTo: "head-prepend",
+        },
+      ];
+    },
+
+    configureServer(devServer) {
+      server = devServer;
+      devServer.httpServer?.once("close", () => {
+        service?.close();
+        service = null;
+      });
+
+      // A page or layout appearing or disappearing changes the route table,
+      // which lives in a virtual module the watcher knows nothing about.
+      const reserved = /\/_uf\.(page|layout|middleware|not-found)(\.[a-z]+)?\.(js|jsx|mdx)$/;
+      const onRouteFile = (file) => {
+        if (!reserved.test(file) || !file.startsWith(appRoot)) return;
+        const routes = devServer.moduleGraph.getModuleById(resolved(VIRTUAL.routes));
+        if (routes) devServer.moduleGraph.invalidateModule(routes);
+        devServer.ws.send({ type: "full-reload", path: "*" });
+      };
+      devServer.watcher.on("add", onRouteFile);
+      devServer.watcher.on("unlink", onRouteFile);
+
+      // After Vite's own middlewares, so `/@vite/client`, `/@id/...` and
+      // static files are served first and only a document request reaches
+      // the renderer.
+      return () => {
+        devServer.middlewares.use(async (request, response, next) => {
+          if (!wantsDocument(request)) return next();
+          try {
+            const url = request.url ?? "/";
+            const { render } = await importServerEntry(devServer);
+            const result = await render(url, {
+              scripts: [devUrlFor(VIRTUAL.client)],
+              styles: [],
+              preloads: [],
+            });
+            const html = await devServer.transformIndexHtml(url, result.html);
+            response.statusCode = result.status;
+            response.setHeader("Content-Type", "text/html; charset=utf-8");
+            for (const [name, value] of Object.entries(result.headers ?? {})) {
+              response.setHeader(name, value);
+            }
+            response.end(html);
+          } catch (error) {
+            devServer.ssrFixStacktrace(error);
+            next(error);
+          }
+        });
+      };
+    },
+  };
+}
+
+function mdxPlugin(markdown) {
+  const mdxConfig = markdown.mdx ?? {};
+  if (mdxConfig.enabled === false) return { name: "uf:mdx" };
+  return {
+    enforce: "pre",
+    ...mdx({
+      jsxImportSource: "react",
+      remarkPlugins: [remarkGfm, remarkFrontmatter, [remarkMdxFrontmatter, { name: "frontmatter" }]],
+      rehypePlugins: [rehypeSlug],
+    }),
+    name: "uf:mdx",
+  };
+}
+
+/**
+ * Import `virtual:uf/server` through the dev server's module runner.
+ *
+ * Vite 6 introduced the environment API and its module runner; `ssrLoadModule`
+ * is the older path and is kept as the fallback.
+ */
+async function importServerEntry(devServer) {
+  const ssr = devServer.environments?.ssr;
+  if (ssr != null) {
+    if (ssr.runner == null) {
+      const { createServerModuleRunner } = await import("vite");
+      ssr.runner = createServerModuleRunner(ssr, { hmr: { logger: false } });
+    }
+    return ssr.runner.import(VIRTUAL.server);
+  }
+  return devServer.ssrLoadModule(VIRTUAL.server);
+}
+
+function wantsDocument(request) {
+  if (request.method !== "GET" && request.method !== "HEAD") return false;
+  const url = request.url ?? "/";
+  if (url.startsWith("/@") || url.startsWith("/node_modules/")) return false;
+  const accept = request.headers.accept ?? "";
+  if (!accept.includes("text/html")) return false;
+  const pathname = url.split("?")[0];
+  // A request for a file — `/favicon.svg`, `/assets/x.js` — that no static
+  // middleware answered is a 404, not a page.
+  return !/\.[a-z0-9]+$/i.test(pathname);
+}
+
+function cleanId(id) {
+  const at = id.indexOf("?");
+  return at === -1 ? id : id.slice(0, at);
+}
+
+/**
+ * Every `@uniflowed/*` package the project can resolve, for
+ * `optimizeDeps.exclude`, which takes names rather than patterns.
+ */
+function uniflowedPackages(root) {
+  const names = new Set();
+  let directory = root;
+  for (let depth = 0; depth < 16; depth += 1) {
+    const scope = path.join(directory, "node_modules", "@uniflowed");
+    try {
+      for (const entry of readdirSync(scope)) names.add(`@uniflowed/${entry}`);
+    } catch {
+      // no packages at this level
+    }
+    const parent = path.dirname(directory);
+    if (parent === directory) break;
+    directory = parent;
+  }
+  return [...names].sort();
+}