@uniflowed/vite 0.5.0 → 0.7.0

package/driver.js

@@ -767,6 +767,9 @@ async function build() {
   await vite.build({
     ...inline,
     customLogger: eventLogger("warn"),
+    // It bundles the rsc graph's output, and whatever addon that left on disk
+    // stays there; see `nativeAddonsStayOnDisk`.
+    plugins: [...(inline.plugins ?? []), nativeAddonsStayOnDisk()],
     build: {
       ...inline.build,
       manifest: false,
@@ -2504,6 +2507,39 @@ function nativeAddonGuard() {
   };
 }
 
+/**
+ * Leave a native addon out of the rsc graph, as an import of the file on disk.
+ *
+ * The rsc graph bundles every dependency (`noExternal: true`, so each resolves
+ * under `react-server`), and since the route handlers and the middleware
+ * moved into it (#1487) that includes whatever a handler imports. A `.node`
+ * file is a shared object, not a module Rolldown can read, so a handler that
+ * reached one failed `uf build` with `"default" is not exported by
+ * "….node"`, where the server build had always left the package to Node.
+ *
+ * External, then, by its absolute path: the output imports the file where it
+ * is, which is what loading the package from `node_modules` did. Used by the
+ * rsc build and by the server build that bundles its output. A build that has
+ * to stand alone (`--compile`, `--adapter`) still refuses it by name, because
+ * it bundles that output too and [`nativeAddonGuard`] sees the import there.
+ */
+function nativeAddonsStayOnDisk() {
+  return {
+    name: "uf:native-addons-stay-on-disk",
+    enforce: "pre",
+    async resolveId(source, importer, options) {
+      if (!source.endsWith(".node")) return null;
+      const resolved = await this.resolve(source, importer, { ...options, skipSelf: true });
+      const id =
+        resolved?.id ??
+        (importer != null && source.startsWith(".")
+          ? path.resolve(path.dirname(importer), source)
+          : source);
+      return { id, external: "absolute" };
+    },
+  };
+}
+
 /**
  * Say which Node built-ins the Worker being linked reaches and does not have.
  *
@@ -2591,6 +2627,7 @@ async function buildRscGraph(vite, inline, state, { outDir, conditions }) {
   const builder = await vite.createBuilder({
     ...inline,
     customLogger: eventLogger("warn"),
+    plugins: [...(inline.plugins ?? []), nativeAddonsStayOnDisk()],
     environments: { [RSC_ENVIRONMENT]: environment },
   });
   await builder.build(builder.environments[RSC_ENVIRONMENT]);
@@ -2781,6 +2818,16 @@ async function renderingPlan(server, prerender) {
       });
       continue;
     }
+    // A page that declares a schema for its query renders what the query
+    // says, and a prerendered file is one answer for every query: `/search`
+    // written once would be served for `/search?q=anything`. ubugeeei-prod/uf#1362.
+    if (module.searchParams != null) {
+      perRequest.push({
+        path: route.path,
+        why: "its page exports a `searchParams` schema, so what it renders depends on the query",
+      });
+      continue;
+    }
     if (route.params.length === 0) {
       urls.push(route.path);
       continue;
@@ -2834,11 +2881,11 @@ async function renderingPlan(server, prerender) {
 }
 
 function fillParams(routePath, params) {
-  return routePath
+  const filled = routePath
     .split("/")
     .map((segment) => {
-      if (segment.endsWith("*")) {
-        const value = params[segment.slice(1, -1)];
+      if (segment.startsWith(":") && (segment.endsWith("*") || segment.endsWith("*?"))) {
+        const value = params[segment.slice(1, segment.endsWith("?") ? -2 : -1)];
         return Array.isArray(value)
           ? value.map(encodeURIComponent).join("/")
           : encodeURIComponent(String(value ?? ""));
@@ -2848,6 +2895,9 @@ function fillParams(routePath, params) {
       return segment;
     })
     .join("/");
+  // An optional catch-all given no segments is its parent path, which is
+  // `/docs` rather than `/docs/`, and `/` rather than an empty string.
+  return filled.length > 1 && filled.endsWith("/") ? filled.slice(0, -1) : filled || "/";
 }
 
 /**

package/index.js

@@ -111,6 +111,7 @@ import {
   FLIGHT_BROWSER_DEPENDENCIES,
   FLIGHT_VIRTUAL,
   INTERCEPTED_FROM_HEADER,
+  NOT_FOUND_HEADER,
   RSC_ENVIRONMENT,
   builtBridgeSource,
   builtReferencesSource,
@@ -573,22 +574,30 @@ function flowPlugin({
       if (id === AUDIT_RESOLVED_ID) return auditRuntimeSource(accessibility?.axe);
       if (id === resolved(VIRTUAL.routes)) {
         const table = scanRoutes(appRoot, { target: routeTarget });
-        // Under React Server Components the table is split by graph rather than
-        // filtered. The rsc graph renders routes, so it gets every route and
-        // boundary and no handler or middleware: those answer a request, and
-        // importing one here would resolve its dependencies under
-        // `react-server` for nothing. The ssr graph gets exactly those two,
-        // because every route it renders reaches it as a payload.
+        // Under React Server Components the whole table is the rsc graph's:
+        // every route and boundary, and the route handlers and the middleware
+        // too. A handler used to be the ssr graph's, so a module it and a page
+        // both imported was evaluated once in each, and a `POST` the handler
+        // answered wrote to a copy the page never read (ubugeeei-prod/uf#1487).
+        // The ssr graph reaches all of it through the bridge and imports none
+        // of it itself; see `rscEntrySource`.
         if (flightState != null && this.environment?.name === RSC_ENVIRONMENT) {
           // The graph that renders routes is where a boundary has to be a
           // client reference, so this is where one that is not fails — the
           // build, and `uf dev`'s table — rather than the first page that
           // throws in production. See `./internal/error-boundaries.js`.
           refuseServerErrorBoundaries(table, root);
-          return routesModuleSource({ ...table, handlers: [], middleware: [] });
+          return routesModuleSource(table);
         }
         if (flightState != null && isSsr(this, loadOptions)) {
-          return routesModuleSource({ ...table, routes: [], notFound: [], errors: [] });
+          return routesModuleSource({
+            ...table,
+            routes: [],
+            notFound: [],
+            errors: [],
+            handlers: [],
+            middleware: [],
+          });
         }
         // The server renders every route, so the server's table is the whole
         // one and is generated with no filter at all. Only the browser's copy
@@ -699,7 +708,12 @@ function flowPlugin({
           } catch {
             return null;
           }
-          return serverActionSource(id, exported, declaresDefaultExport(source));
+          return serverActionSource(
+            id,
+            exported,
+            declaresDefaultExport(source),
+            flightState != null && this.environment?.name === RSC_ENVIRONMENT,
+          );
         }
       }
       return null;
@@ -920,9 +934,18 @@ function flowPlugin({
       const reserved = new RegExp(`/(${stems})(\\.[a-z]+)?\\.(js|jsx|mdx)$`);
       const onRouteFile = (file) => {
         if (!reserved.test(file) || !file.startsWith(appRoot)) return;
-        for (const id of [VIRTUAL.routes, VIRTUAL.server, VIRTUAL.client]) {
-          const module = devServer.moduleGraph.getModuleById(resolved(id));
-          if (module) devServer.moduleGraph.invalidateModule(module);
+        // The rsc graph's table too, where the pages, the route handlers and
+        // the middleware of an application React Server Components render
+        // live (ubugeeei-prod/uf#1487).
+        const graphs = [
+          devServer.moduleGraph,
+          devServer.environments?.[RSC_ENVIRONMENT]?.moduleGraph,
+        ].filter((graph) => graph != null);
+        for (const graph of graphs) {
+          for (const id of [VIRTUAL.routes, VIRTUAL.server, VIRTUAL.client]) {
+            const module = graph.getModuleById(resolved(id));
+            if (module) graph.invalidateModule(module);
+          }
         }
         devServer.ws.send({ type: "full-reload", path: "*" });
       };
@@ -1139,6 +1162,7 @@ function flowPlugin({
                 const answered = await entry.flight(target, {
                   onError: (error) => reportRenderError(devServer, target, error),
                   interceptedFrom,
+                  notFound: asRequest.headers.get(NOT_FOUND_HEADER) === "1",
                 });
                 if (answered.error != null) reportRenderError(devServer, target, answered.error);
                 if (request.method === "HEAD") await answered.stream?.cancel();

package/internal/flight.js

@@ -17,15 +17,14 @@
 //     renderer (`@uniflowed/router/rsc`). A module that opens with the use
 //     client directive is not evaluated here: it is replaced by a client
 //     reference per export, naming the chunk the browser loads it from.
-//   * **`ssr`**, Vite's own server environment. It holds the HTML renderer, the
-//     route handlers, the middleware — and the *server copy* of every client
-//     module, which is what renders a client component into HTML. It reaches
-//     the rsc graph through one module, the bridge, for the payload and for
-//     the server-action endpoint: the action table is the rsc graph's, so an
-//     action shares every module instance with the pages that show what it
-//     wrote (ubugeeei-prod/uf#1469). A route handler and a middleware do not
-//     yet: a module one of them imports and a page imports is evaluated once in
-//     each graph.
+//   * **`ssr`**, Vite's own server environment. It holds the HTML renderer and
+//     the *server copy* of every client module, which is what renders a client
+//     component into HTML. It reaches the rsc graph through one module, the
+//     bridge, for the payload and for everything else that answers a request
+//     with the application's own code: the server-action endpoint
+//     (ubugeeei-prod/uf#1469), the route handlers and the middleware
+//     (ubugeeei-prod/uf#1487). All three are the rsc graph's, so each shares
+//     every module instance with the pages that show what it wrote.
 //   * **`client`**, the browser's. Its entry hydrates from the payload the
 //     document carries, and it holds no page, layout or loader — only the
 //     client modules, each an entry of its own, loaded when a payload names it.
@@ -131,6 +130,9 @@ export const FLIGHT_SEGMENT = "__uf.flight";
 /** The header a browser sends when a Flight payload should render an interception. */
 export const INTERCEPTED_FROM_HEADER = "uf-intercepted-from";
 
+/** The header a browser sends, as `1`, for a URL's not-found payload rather than its route. */
+export const NOT_FOUND_HEADER = "uf-not-found";
+
 /** The document a payload path is for, or `null` for any other path. */
 export function flightDocumentPath(pathname) {
   const suffix = `/${FLIGHT_SEGMENT}`;
@@ -530,14 +532,28 @@ export function rscEntrySource(routesId, routing = {}, deployment = null, action
       ? "export const callAction = createActionDispatcher({ actions: [] });"
       : `import { actions } from ${JSON.stringify(actionsId)};
 export const callAction = createActionDispatcher({ actions });`;
-  return `import { createActionDispatcher, createFlightRenderer, installRouting } from "@uniflowed/router/rsc";
-import { routes, notFound, errors } from ${JSON.stringify(routesId)};
+  // The route handlers and the middleware are built here for the same reason
+  // (ubugeeei-prod/uf#1487): a `POST` a handler answers writes to the module
+  // the page reads, and a rate limiter a middleware keeps is the one every
+  // request is counted against. They resolve their imports under
+  // `react-server`, as the pages do; the server-components guide says what that
+  // asks of a handler.
+  return `import {
+  createActionDispatcher,
+  createDispatcher,
+  createFlightRenderer,
+  createMiddlewareRunner,
+  installRouting,
+} from "@uniflowed/router/rsc";
+import { routes, notFound, errors, handlers, middleware } from ${JSON.stringify(routesId)};
 installRouting(${JSON.stringify(settings)});
-export { routes, notFound, errors };
+export { routes, notFound, errors, handlers, middleware };
 export const renderFlight = createFlightRenderer({ routes, notFound, errors, deployment: ${JSON.stringify(
     deployment ?? null,
   )} });
 ${actions}
+export const dispatch = createDispatcher({ handlers });
+export const runMiddleware = createMiddlewareRunner({ middleware });
 `;
 }
 
@@ -563,13 +579,19 @@ export async function renderFlight(url, options) {
 export async function callAction(request, settings) {
   return (await load()).callAction(request, settings);
 }
-export const { routes, notFound, errors } = await load();
+export async function dispatch(request) {
+  return (await load()).dispatch(request);
+}
+export async function runMiddleware(request) {
+  return (await load()).runMiddleware(request);
+}
+export const { routes, notFound, errors, handlers, middleware } = await load();
 `;
 }
 
 /** `virtual:uf/rsc-bridge` in a build: the rsc build's output, bundled in. */
 export function builtBridgeSource(rscOutput) {
-  return `export { renderFlight, callAction, routes, notFound, errors } from ${JSON.stringify(rscOutput)};\n`;
+  return `export { renderFlight, callAction, dispatch, runMiddleware, routes, notFound, errors, handlers, middleware } from ${JSON.stringify(rscOutput)};\n`;
 }
 
 /**
@@ -710,9 +732,10 @@ ${clientInstrumentationSource(options.instrumentation)}hydrateFlight({ App${stri
  * `createDocumentRenderer` from `@uniflowed/router/rsc/ssr`, an entry of its own
  * for the reason `flightClientSource` gives. It renders the payload the rsc graph
  * writes rather than the route's modules, and adds `flight` for a browser that
- * is navigating. And `routes`, `notFound` and `errors` come through the bridge,
- * because the page modules they import are the rsc graph's: the driver reads a
- * page's `generateStaticParams` from the graph that renders it.
+ * is navigating. And the route table comes through the bridge, because the
+ * modules it imports are the rsc graph's: the driver reads a page's
+ * `generateStaticParams` from the graph that renders it, and the route handlers
+ * and the middleware run there too (see `rscEntrySource`).
  */
 export function flightServerSource(
   appEntry,
@@ -724,18 +747,19 @@ export function flightServerSource(
   createInstrumentation,
   instrumentRender,
   traceRequestPhase,
-  createDispatcher,
-  createMiddlewareRunner,
   installRouting,
 } from "@uniflowed/router/server";
 import { createDocumentRenderer } from "@uniflowed/router/rsc/ssr";
-import { handlers, middleware } from ${JSON.stringify(routesId)};
 import {
   renderFlight,
   callAction as callActionInRsc,
+  dispatch as dispatchInRsc,
+  runMiddleware as runMiddlewareInRsc,
   routes,
   notFound,
   errors,
+  handlers,
+  middleware,
 } from ${JSON.stringify(FLIGHT_VIRTUAL.bridge)};
 import { loadClientModule } from ${JSON.stringify(FLIGHT_VIRTUAL.references)};
 import App from ${JSON.stringify(appEntry)};
@@ -756,12 +780,12 @@ export const flight = (url, options = {}) => instrumentRender(
   (onError) => renderer.flight(url, { ...options, onError }), options.onError,
 );
 export { shellDocument } from "@uniflowed/router/server";
-const dispatchRoute = createDispatcher({ handlers });
-export const dispatch = (request) => traceRequestPhase("route", () => dispatchRoute(request));
-// Built in the rsc graph and reached through the bridge; see \`rscEntrySource\`.
+// The route handlers, the action endpoint and the middleware are built in the
+// rsc graph and reached through the bridge; see \`rscEntrySource\`.
+export const dispatch = (request) => traceRequestPhase("route", () => dispatchInRsc(request));
 export const callAction = callActionInRsc;
-const guard = createMiddlewareRunner({ middleware });
-export const runMiddleware = (request) => traceRequestPhase("middleware", () => guard(request));
+export const runMiddleware = (request) =>
+  traceRequestPhase("middleware", () => runMiddlewareInRsc(request));
 `;
 }
 

package/internal/openapi.js

@@ -165,7 +165,7 @@ function openApiPath(routePath) {
     .split("/")
     .map((segment) => {
       if (!segment.startsWith(":")) return segment;
-      return `{${segment.endsWith("*") ? segment.slice(1, -1) : segment.slice(1)}}`;
+      return `{${paramName(segment)}}`;
     })
     .join("/");
 }
@@ -191,11 +191,16 @@ function paramsFromPath(routePath) {
     .split("/")
     .filter((segment) => segment.startsWith(":"))
     .map((segment) => ({
-      name: segment.endsWith("*") ? segment.slice(1, -1) : segment.slice(1),
-      catchAll: segment.endsWith("*"),
+      name: paramName(segment),
+      catchAll: segment.endsWith("*") || segment.endsWith("*?"),
     }));
 }
 
+/** `slug` for `:slug`, `:slug*` (`[...slug]`) and `:slug*?` (`[[...slug]]`). */
+function paramName(segment) {
+  return segment.slice(1).replace(/\*\??$/, "");
+}
+
 function operationId(record, method) {
   const name = `${method.toLowerCase()} ${record.path}`;
   return name

package/internal/routes.js

@@ -593,9 +593,40 @@ export function scanRoutes(appRoot, options = {}) {
   // intercepting page is only as good as the ordinary page that serves its URL
   // to everybody the interception does not.
   refuseInterceptionsWithoutPages(appRoot, routes);
+  refuseOptionalCatchAllCollisions(routes);
   return { routes, handlers, middleware, notFound, errors };
 }
 
+/**
+ * Refuse a `[[...param]]` page that shares its parent path with a page.
+ *
+ * An optional catch-all serves the directory it sits in as well as every path
+ * below it, so `app/docs/[[...slug]]/$page.js` and `app/docs/$page.js` are two
+ * answers to `/docs`. Compared by the path's shape rather than by directory,
+ * because a `(group)` or a differently named parameter does not change which
+ * URLs a page serves. Mirrors `uf_router`'s
+ * `refuse_optional_catch_all_collisions`.
+ */
+function refuseOptionalCatchAllCollisions(routes) {
+  const shape = (routePath) => routePath.replace(/:[^/*?]+/g, ":");
+  for (const route of routes) {
+    const last = route.params.at(-1);
+    if (last == null || !route.path.endsWith(`:${last.name}*?`)) continue;
+    const parent = route.path.slice(0, route.path.lastIndexOf("/")) || "/";
+    const other = routes.find((candidate) => shape(candidate.path) === shape(parent));
+    if (other != null) {
+      throw new Error(
+        `${route.page}: \`[[...${last.name}]]\` is an optional catch-all, so it serves ` +
+          `\`${parent}\` itself as well as every path below it, and \`${other.page}\` serves ` +
+          `\`${parent}\` too — one URL with two pages, and nothing in the URL says which. ` +
+          `Remove \`${other.page}\` and render \`${parent}\` here, where \`${last.name}\` is ` +
+          `an empty list, or make it \`[...${last.name}]\`, which leaves \`${parent}\` to ` +
+          `\`${other.page}\`.`,
+      );
+    }
+  }
+}
+
 /**
  * Refuse an intercepting route whose URL no page serves.
  *
@@ -620,11 +651,13 @@ function refuseInterceptionsWithoutPages(appRoot, routes) {
             .split("/")
             .filter((part) => part !== "")
             .map((part) =>
-              part.startsWith(":") && part.endsWith("*")
-                ? `[...${part.slice(1, -1)}]`
-                : part.startsWith(":")
-                  ? `[${part.slice(1)}]`
-                  : part,
+              part.startsWith(":") && part.endsWith("*?")
+                ? `[[...${part.slice(1, -2)}]]`
+                : part.startsWith(":") && part.endsWith("*")
+                  ? `[...${part.slice(1, -1)}]`
+                  : part.startsWith(":")
+                    ? `[${part.slice(1)}]`
+                    : part,
             );
           const ordinary = path.join(appRoot, ...directories, `${RESERVED.page}.js`);
           throw new Error(
@@ -651,18 +684,23 @@ function refuseInterceptionsWithoutPages(appRoot, routes) {
  * Whether every URL the route path `intercepted` matches is one `ordinary`
  * serves: segment by segment, the way the runtime's matcher reads both. A
  * static segment serves only itself, a parameter any one segment but not a
- * catch-all's many, and a catch-all whatever is left as long as something is.
- * Mirrors `uf_router`'s `serves_every_url_of`.
+ * catch-all's many, a catch-all whatever is left as long as something is, and
+ * an optional catch-all whatever is left. Mirrors `uf_router`'s
+ * `serves_every_url_of`.
  */
 function servesEveryUrlOf(ordinary, intercepted) {
   const theirs = ordinary.split("/").filter((part) => part !== "");
   const ours = intercepted.split("/").filter((part) => part !== "");
+  const optional = (part) => part.startsWith(":") && part.endsWith("*?");
   for (let index = 0; index < theirs.length; index += 1) {
     const segment = theirs[index];
-    if (segment.startsWith(":") && segment.endsWith("*")) return ours.length > index;
+    if (optional(segment)) return true;
+    if (segment.startsWith(":") && segment.endsWith("*")) {
+      return ours.length > index && !optional(ours[index]);
+    }
     const other = ours[index];
     if (other === undefined) return false;
-    const otherIsCatchAll = other.startsWith(":") && other.endsWith("*");
+    const otherIsCatchAll = other.startsWith(":") && (other.endsWith("*") || optional(other));
     const serves = segment.startsWith(":")
       ? !otherIsCatchAll
       : !other.startsWith(":") && other === segment;
@@ -965,7 +1003,7 @@ function unsupportedSlotBoundaryRole(fileName) {
 /**
  * What one directory name means to the route path.
  *
- * Mirrors `uf_router::classify_route_segment`, which is the same six answers
+ * Mirrors `uf_router::classify_route_segment`, which is the same seven answers
  * in the same order. The order is load-bearing in one place: an interception
  * marker is a `(…)` *prefix* with a route after it, and a `(group)` is a
  * segment that ends in `)`, so the interception test has to come first or
@@ -975,6 +1013,7 @@ function unsupportedSlotBoundaryRole(fileName) {
  * @returns {{kind: "group"}
  *   | {kind: "param", name: string}
  *   | {kind: "catchAll", name: string}
+ *   | {kind: "optionalCatchAll", name: string}
  *   | {kind: "literal", name: string}
  *   | {kind: "slot", name: string}
  *   | {kind: "interception", marker: string, route: string}}
@@ -984,6 +1023,9 @@ export function classifyRouteSegment(segment) {
   const intercepted = interceptionMarker(segment);
   if (intercepted != null) return { kind: "interception", ...intercepted };
   if (segment.startsWith("(") && segment.endsWith(")")) return { kind: "group" };
+  if (segment.startsWith("[[...") && segment.endsWith("]]")) {
+    return { kind: "optionalCatchAll", name: segment.slice(5, -2) };
+  }
   if (segment.startsWith("[...") && segment.endsWith("]")) {
     return { kind: "catchAll", name: segment.slice(4, -1) };
   }
@@ -1046,7 +1088,7 @@ function readInterception(classified) {
   const climb = interceptionClimb(classified.marker);
   const route = classifyRouteSegment(classified.route);
   if (climb == null) return null;
-  if (route.kind !== "literal" && route.kind !== "param" && route.kind !== "catchAll") {
+  if (!["literal", "param", "catchAll", "optionalCatchAll"].includes(route.kind)) {
     return null;
   }
   return { climb, route };
@@ -1139,7 +1181,8 @@ function climbReason(segment, depth) {
  * Turn directory segments into a route path and its parameters.
  *
  * `(group)` segments organise files without appearing in the URL, `[name]`
- * captures one segment, and `[...name]` captures the rest of the path. A
+ * captures one segment, `[...name]` captures the rest of the path, and
+ * `[[...name]]` captures the rest of it, which may be none. A
  * `@slot` contributes nothing either — it is a named place a route renders
  * into, matched against the URL of the segment that declares it — so a slot's
  * pages are matched against ordinary paths and add none of their own.
@@ -1174,7 +1217,9 @@ export function routeFromSegments(segments) {
       out = read.climb === "root" ? [] : out.slice(0, out.length - read.climb);
       named = read.route;
     }
-    if (named.kind === "catchAll") {
+    if (named.kind === "optionalCatchAll") {
+      out.push({ spelling: `:${named.name}*?`, param: { name: named.name, catchAll: true } });
+    } else if (named.kind === "catchAll") {
       out.push({ spelling: `:${named.name}*`, param: { name: named.name, catchAll: true } });
     } else if (named.kind === "param") {
       out.push({ spelling: `:${named.name}`, param: { name: named.name, catchAll: false } });
@@ -1184,7 +1229,7 @@ export function routeFromSegments(segments) {
   }
   const routePath = out.length === 0 ? "/" : `/${out.map((entry) => entry.spelling).join("/")}`;
   const params = out.flatMap((entry) => (entry.param == null ? [] : [entry.param]));
-  return { path: routePath, pattern: routePath.replace(/:(\w+)\*/g, "*$1"), params };
+  return { path: routePath, pattern: routePath.replace(/:(\w+)\*\??/g, "*$1"), params };
 }
 
 /**

package/internal/rsc.js

@@ -446,22 +446,36 @@ export function declaresDefaultExport(source) {
  * the endpoint, a route handler and a server component call exactly what they
  * called before. See ubugeeei-prod/uf#1358.
  *
+ * In the rsc graph (`flight`) each one is also registered with React as a
+ * server reference under its id (`registerServerFunction` in
+ * `@uniflowed/router/rsc`), so a Server Component can pass it to a Client
+ * Component as a prop. An export with no manifest row is not callable, is not
+ * registered, and Flight still refuses to send it. See ubugeeei-prod/uf#1359.
+ *
  * @param {string} file absolute path of the module
  * @param {Array<{id: string, module: string, export: string}>} actions its callable exports
  * @param {boolean} hasDefault whether the file declares a default export
+ * @param {boolean} [flight] whether this is the rsc graph
  */
-export function serverActionSource(file, actions, hasDefault) {
+export function serverActionSource(file, actions, hasDefault, flight = false) {
   const impl = JSON.stringify(`${file}${SERVER_ACTION_IMPL_QUERY}`);
   const lines = [
     'import { registerServerAction } from "@uniflowed/router/action";',
+    ...(flight ? ['import { registerServerFunction } from "@uniflowed/router/rsc";'] : []),
     `import * as impl from ${impl};`,
     `export * from ${impl};`,
   ];
   if (hasDefault) lines.push(`export { default } from ${impl};`);
   for (const action of actions) {
-    lines.push(
-      `registerServerAction(impl[${JSON.stringify(action.export)}], ${JSON.stringify(action.id)});`,
-    );
+    const binding = `impl[${JSON.stringify(action.export)}]`;
+    lines.push(`registerServerAction(${binding}, ${JSON.stringify(action.id)});`);
+    if (flight) {
+      lines.push(
+        `registerServerFunction(${binding}, ${JSON.stringify(action.id)}, ${JSON.stringify(
+          `${action.module}#${action.export}`,
+        )});`,
+      );
+    }
   }
   return `${lines.join("\n")}\n`;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniflowed/vite",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "Vite, driven by uf.config.js: every Flow module through `uf transform`, MDX, the file-system router and static rendering as Vite plugins.",
   "type": "module",
   "license": "MIT",
@@ -35,10 +35,10 @@
     "@babel/core": "^7.29.7",
     "@mdx-js/rollup": "^3.1.1",
     "@shikijs/rehype": "^3.23.0",
-    "@uniflowed/host": "0.5.0",
-    "@uniflowed/router": "0.5.0",
-    "@uniflowed/server": "0.5.0",
-    "@uniflowed/validator": "0.5.0",
+    "@uniflowed/host": "0.7.0",
+    "@uniflowed/router": "0.7.0",
+    "@uniflowed/server": "0.7.0",
+    "@uniflowed/validator": "0.7.0",
     "babel-plugin-relay": "^21.0.1",
     "estree-util-value-to-estree": "^3.5.0",
     "rehype-slug": "^6.0.0",