@rangojs/router 0.22.1 → 0.24.0

package/src/ssr/index.tsx

@@ -1,3 +1,4 @@
+import { AsyncLocalStorage } from "node:async_hooks";
 import React from "react";
 import { createSsrRootComponent, deserializeSsrPayload } from "./ssr-root.js";
 import { injectRSCPayloadEager } from "./inject-rsc-eager.js";
@@ -263,23 +264,40 @@ export interface SSRDependencies<TEnv = unknown> {
  */
 const activeCaptureClientLoads = new Set<Set<PromiseLike<unknown>>>();
 
-/** The loader wrapper {@link captureClientLoads} last installed. */
+/**
+ * Dev only: the client-reference loads requested by the Flight decode of the
+ * document render whose context this is (see settleDocumentClientLoads).
+ *
+ * Gated on `process.env.NODE_ENV`, the router's dev signal, not on the
+ * `import.meta.env.DEV` that adds plugin-rsc's cache tag: a build folds it
+ * (the app's NODE_ENV define, or the Cloudflare plugin), so the hold is
+ * compiled out. A server where the two disagree loses nothing: a dev server
+ * run with NODE_ENV=production streams as it did before the hold, and an
+ * unfolded production server collects only loads still pending, the first
+ * load of each module, bounded like any other.
+ */
+const documentClientLoads =
+  process.env.NODE_ENV !== "production"
+    ? new AsyncLocalStorage<Set<PromiseLike<unknown>>>()
+    : undefined;
+
+/** Bound on settleDocumentClientLoads; a later load flushes as before. */
+const DEV_DOCUMENT_CLIENT_LOAD_WAIT_MS = 5_000;
+
+/** The loader wrapper {@link installClientLoadRecorder} last installed. */
 let recordingClientReferenceLoader: ((id: string) => unknown) | undefined;
 
 /**
- * Start collecting the client-reference loads requested during a capture;
- * call the returned `stop` when the capture ends. Wraps plugin-rsc's SSR
- * loader (`globalThis.__vite_rsc_client_require__`, which
- * `__vite_rsc_require__` reads per call) on the first capture, so an isolate
- * that never captures keeps the bare loader. Wraps again when another wrapper
- * replaced this one (the build shell phase bridges hashed ids the same way,
+ * Wrap plugin-rsc's SSR loader (`globalThis.__vite_rsc_client_require__`,
+ * which `__vite_rsc_require__` reads per call) to collect pending loads into
+ * every running capture's set and the current dev document's set. Installed
+ * on the first capture or dev document, so a production isolate that never
+ * captures keeps the bare loader. Wraps again when another wrapper replaced
+ * this one (the build shell phase bridges hashed ids the same way,
  * vite/discovery/shell-prerender-phase.ts). Collects nothing without the
  * loader.
  */
-function captureClientLoads(): {
-  loads: Set<PromiseLike<unknown>>;
-  stop: () => void;
-} {
+function installClientLoadRecorder(): void {
   const g = globalThis as {
     __vite_rsc_client_require__?: (id: string) => unknown;
   };
@@ -287,24 +305,104 @@ function captureClientLoads(): {
   if (typeof load === "function" && load !== recordingClientReferenceLoader) {
     recordingClientReferenceLoader = (id) => {
       const loading = load(id);
+      const documentLoads = documentClientLoads?.getStore();
       // plugin-rsc memoizes one promise per id and the Flight client stamps
       // status "fulfilled" on it once loaded: a warm module is not collected.
       if (
-        activeCaptureClientLoads.size > 0 &&
+        (activeCaptureClientLoads.size > 0 || documentLoads) &&
         isThenable(loading) &&
         (loading as { status?: string }).status !== "fulfilled"
       ) {
         for (const loads of activeCaptureClientLoads) loads.add(loading);
+        if (documentLoads) {
+          // The document's set holds only loads still pending.
+          documentLoads.add(loading);
+          const drop = (): void => {
+            documentLoads.delete(loading);
+          };
+          loading.then(drop, drop);
+        }
       }
       return loading;
     };
     g.__vite_rsc_client_require__ = recordingClientReferenceLoader;
   }
+}
+
+/**
+ * Start collecting the client-reference loads requested during a capture;
+ * call the returned `stop` when the capture ends.
+ */
+function captureClientLoads(): {
+  loads: Set<PromiseLike<unknown>>;
+  stop: () => void;
+} {
+  installClientLoadRecorder();
   const loads = new Set<PromiseLike<unknown>>();
   activeCaptureClientLoads.add(loads);
   return { loads, stop: () => activeCaptureClientLoads.delete(loads) };
 }
 
+/**
+ * Dev only: when the shell is ready, hold the first flush until the
+ * client-reference loads still pending at that moment have settled, so a
+ * boundary waiting on one completes in place, as in a build (#1106).
+ *
+ * plugin-rsc tags client reference ids with a per-render cache tag in dev
+ * (createClientManifest in @vitejs/plugin-rsc core/rsc.js), so its SSR loader
+ * memo misses on every request and each reference loads through the module
+ * runner again: an RPC per import on workerd. A client component a loader's
+ * answer draws under an inline <Suspense> resolved after the shell flushed,
+ * and the document streamed the fallback, which a browser without JavaScript
+ * never replaces. A build loads each reference once per isolate and reads it
+ * synchronously after that.
+ *
+ * Only that snapshot is waited for: a load starts when the row naming it
+ * arrives, so its data is already in the payload. A load requested later
+ * belongs to data that arrives after the shell, which streams as in a build,
+ * and nothing pending means no wait at all: the router adds no wait of its
+ * own, so a loading() skeleton or an inline fallback still streams.
+ */
+async function settleDocumentClientLoads(
+  pending: Set<PromiseLike<unknown>>,
+): Promise<void> {
+  const snapshot = [...pending];
+  if (snapshot.length === 0) return;
+  const deadline = createCancelableTimeout(DEV_DOCUMENT_CLIENT_LOAD_WAIT_MS);
+  try {
+    const expired = await Promise.race([
+      Promise.allSettled(snapshot).then(() => false),
+      deadline.promise.then(() => true),
+    ]);
+    if (expired) return;
+    // A settled load pings the Fizz task that waited on it, which retries on
+    // a setTimeout(0) turn (pingTask).
+    await macrotask();
+    await macrotask();
+  } finally {
+    deadline.cancel();
+  }
+}
+
+/**
+ * Run a document's Flight decode. In dev it runs in its own client-load set,
+ * and `settle` holds the first flush until the loads pending when the shell
+ * is ready have settled (settleDocumentClientLoads); a build gets the decode
+ * alone.
+ */
+function trackDocumentClientLoads<T>(decode: () => T): {
+  value: T;
+  settle?: () => Promise<void>;
+} {
+  if (!documentClientLoads) return { value: decode() };
+  installClientLoadRecorder();
+  const loads = new Set<PromiseLike<unknown>>();
+  return {
+    value: documentClientLoads.run(loads, decode),
+    settle: () => settleDocumentClientLoads(loads),
+  };
+}
+
 /**
  * Route an SSR error through the deps.onError notification callback with the
  * "rendering" phase. Swallows callback failures so a broken reporter never
@@ -708,10 +806,10 @@ export function createSSRHandler<TEnv = unknown>(deps: SSRDependencies<TEnv>) {
       // The parallel no-op catch keeps a payload rejection off the
       // unhandledRejection path if fizz errors before consuming the promise;
       // SsrRoot's React.use() on the SAME promise still observes the rejection.
-      const payload = deserializeSsrPayload(
-        createFromReadableStream,
-        rscStream1,
-      );
+      const { value: payload, settle: settleClientLoads } =
+        trackDocumentClientLoads(() =>
+          deserializeSsrPayload(createFromReadableStream, rscStream1),
+        );
       payload.catch(() => {});
 
       const SsrRoot = createSsrRootComponent({
@@ -763,6 +861,10 @@ export function createSSRHandler<TEnv = unknown>(deps: SSRDependencies<TEnv>) {
         }),
       );
 
+      // Dev only: the client-reference loads the decode requested settle
+      // before the first flush (trackDocumentClientLoads).
+      if (settleClientLoads) await settleClientLoads();
+
       // Wait for all Suspense boundaries to resolve when streamMode is "allReady".
       // This buffers the entire HTML before flushing — used for bots that
       // cannot process streamed HTML.

package/src/testing/action-form.ts

@@ -12,8 +12,7 @@
  * Post the result with `serveShellRequest(router, url, { form })`.
  */
 
-import * as RSDServer from "@vitejs/plugin-rsc/vendor/react-server-dom/server.edge";
-import { registerServerModule } from "./internal/server-modules.js";
+import { registerTestAction } from "./internal/test-action.js";
 
 /** Options for {@link createActionForm}. */
 export interface CreateActionFormOptions {
@@ -41,15 +40,7 @@ export function createActionForm(
   options: CreateActionFormOptions,
 ): FormData {
   const { id, useActionState = true, fields = {} } = options;
-  const [moduleId, name] = id.split("#");
-  if (!moduleId || !name) {
-    throw new Error(
-      `createActionForm: id must be "<module id>#<export name>", received ${JSON.stringify(id)}`,
-    );
-  }
-  registerServerModule(moduleId, {
-    [name]: RSDServer.registerServerReference(action, moduleId, name),
-  });
+  registerTestAction(action, id, "createActionForm");
 
   const form = new FormData();
   if (useActionState) {

package/src/testing/dispatch.ts

@@ -106,16 +106,15 @@ import {
   runWithRequestContext,
   setRequestContextParams,
 } from "../server/request-context.js";
+import { REWRITE_HEADER, runRewritePasses } from "../rsc/rewrite-passes.js";
+import { defineRewrittenFrom } from "../server/rewrite-trail.js";
 import { resolveRouterVersions } from "../server/build-version-table.js";
 import { executeMiddleware, matchMiddleware } from "../router/middleware.js";
 import type {
   MiddlewareEntry,
   MiddlewareFn,
 } from "../router/middleware-types.js";
-import {
-  createReverseFunction,
-  stripInternalParams,
-} from "../router/handler-context.js";
+import { createReverseFunction } from "../router/handler-context.js";
 import { NOCACHE_SYMBOL } from "../cache/taint.js";
 import {
   compileSearchParamsFilter,
@@ -135,6 +134,7 @@ import { RESPONSE_TYPE_MIME } from "../router/content-negotiation.js";
 import { RouterError } from "../errors.js";
 import { createProblemDetails } from "../rsc/response-error.js";
 import {
+  createReloadResponse,
   createResponseWithMergedHeaders,
   createSimpleRedirectResponse,
   finalizeResponse,
@@ -143,7 +143,7 @@ import {
 } from "../rsc/helpers.js";
 import { guardOutgoingRedirect } from "../rsc/redirect-guard.js";
 import { stringifyJsonRouteResult } from "../rsc/json-route-result.js";
-import { isWebSocketUpgradeResponse } from "../response-utils.js";
+import { isWebSocketUpgradeResponse, trySetHeader } from "../response-utils.js";
 import { invokeOnError } from "../router/error-handling.js";
 import type { OnErrorCallback } from "../types/error-types.js";
 import type { Rango } from "../router/router-interfaces.js";
@@ -321,6 +321,68 @@ function serializeResponseRouteError(
   });
 }
 
+/** What one pass of a dispatch matched (the visitor's URL, or a rewrite target). */
+interface DispatchPass<TEnv> {
+  req: Request;
+  url: URL;
+  redirectTo?: string;
+  isUnmatched: boolean;
+  preview: Awaited<ReturnType<DispatchableRouter<TEnv>["previewMatch"]>>;
+  responseType?: string;
+  handler?: Function;
+  params: Record<string, string>;
+  routeKey?: string;
+}
+
+async function matchDispatchPass<TEnv>(
+  router: DispatchableRouter<TEnv>,
+  req: Request,
+  env: TEnv,
+): Promise<DispatchPass<TEnv>> {
+  const url = new URL(req.url);
+  // findMatch carries trailing-slash/redirect targets and null on no match.
+  // previewMatch swallows redirects, so detect them here first.
+  const match = await router.findMatch(url.pathname);
+  const redirectTo = match?.redirectTo;
+  const isUnmatched = !match;
+
+  // previewMatch resolves responseType, the response-route handler, and the
+  // route middleware from the matched entry tree (with content negotiation).
+  // Skip it for a redirect/unmatched path — there is no response route to
+  // resolve, and previewMatch would return null / a redirect marker anyway.
+  const preview =
+    redirectTo || isUnmatched ? null : await router.previewMatch(req, { env });
+
+  // A bare match with no responseType is an RSC route. The RSC-route throw is a
+  // hard boundary of this primitive (no Flight runtime), distinct from the
+  // 308/404 outcomes, so it stays a pre-middleware guard.
+  const responseType = preview?.responseType;
+  const handler = preview?.handler;
+  if (
+    !redirectTo &&
+    !isUnmatched &&
+    (!responseType || typeof handler !== "function")
+  ) {
+    throw new Error(
+      `dispatch() does not render RSC routes — the route matched at ` +
+        `"${url.pathname}" is a React Server Component route, not a response ` +
+        `route. Use renderHandler/renderServerTree/renderToFlightString or an ` +
+        `e2e test to exercise component rendering.`,
+    );
+  }
+  return {
+    req,
+    url,
+    redirectTo,
+    isUnmatched,
+    preview,
+    responseType,
+    handler,
+    params: preview?.params ?? match?.params ?? {},
+    routeKey: preview?.routeKey ?? match?.routeKey,
+  };
+}
+
 /**
  * Run a request through the router in-process and return the Response.
  *
@@ -353,39 +415,10 @@ export async function dispatch<TEnv = any>(
     setRouterManifest(routerId, router.routeMap as Record<string, string>);
   }
 
-  // findMatch carries trailing-slash/redirect targets and null on no match.
-  // previewMatch swallows redirects, so detect them here first.
-  const match = await router.findMatch(url.pathname);
-  const redirectTo = match?.redirectTo;
-  const isUnmatched = !match;
-
-  // previewMatch resolves responseType, the response-route handler, and the
-  // route middleware from the matched entry tree (with content negotiation).
-  // Skip it for a redirect/unmatched path — there is no response route to
-  // resolve, and previewMatch would return null / a redirect marker anyway.
-  const preview =
-    redirectTo || isUnmatched ? null : await router.previewMatch(req, { env });
-
-  // A bare match with no responseType is an RSC route. The RSC-route throw is a
-  // hard boundary of this primitive (no Flight runtime), distinct from the
-  // 308/404 outcomes below, so it stays a pre-middleware guard.
-  const responseType = preview?.responseType;
-  const handler = preview?.handler;
-  const params = preview?.params ?? match?.params ?? {};
-  const routeKey = preview?.routeKey ?? match?.routeKey;
-
-  if (
-    !redirectTo &&
-    !isUnmatched &&
-    (!responseType || typeof handler !== "function")
-  ) {
-    throw new Error(
-      `dispatch() does not render RSC routes — the route matched at ` +
-        `"${url.pathname}" is a React Server Component route, not a response ` +
-        `route. Use renderHandler/renderServerTree/renderToFlightString or an ` +
-        `e2e test to exercise component rendering.`,
-    );
-  }
+  // The visitor's URL is matched before any middleware runs, so an RSC route
+  // fails here, before a middleware side effect. A rewrite target is matched
+  // the same way, at the start of its pass (below).
+  const firstPass = await matchDispatchPass(router, req, env);
 
   const variables: Record<string, unknown> = {};
 
@@ -474,29 +507,28 @@ export async function dispatch<TEnv = any>(
     // Set params before middleware/handler run, so global middleware sees
     // ctx.params (production sets them during matching, before middleware).
     // On a redirect/unmatched path there are no route params.
-    if (routeKey !== undefined) {
-      setRequestContextParams(params, routeKey);
-    } else {
-      requestContext.params = params;
-    }
+    const recordPassParams = (pass: DispatchPass<TEnv>): void => {
+      if (pass.routeKey !== undefined) {
+        setRequestContextParams(pass.params, pass.routeKey);
+      } else {
+        requestContext.params = pass.params;
+      }
+    };
 
     // The response-route handler (with its own route middleware) lives inside
     // coreHandler below, mirroring production where handleResponseRoute is
     // nested inside coreHandler. Built lazily so a redirect/404 path never
     // touches it.
-    const callResponseRoute = async (): Promise<Response> => {
+    const callResponseRoute = async (
+      pass: DispatchPass<TEnv>,
+    ): Promise<Response> => {
+      const { req, url, preview, params, responseType, handler } = pass;
       // Match production: a partial (client-navigation) request to a response
       // route is short-circuited to X-RSC-Reload (handleResponseRoute), BEFORE
       // route-level middleware runs. Route-level middleware is skipped on a
       // partial, exactly as production skips it.
       const partialFinalHandler = async (): Promise<Response> =>
-        createResponseWithMergedHeaders(null, {
-          status: 200,
-          headers: {
-            "X-RSC-Reload": stripInternalParams(url).toString(),
-            "content-type": "text/x-component;charset=utf-8",
-          },
-        });
+        createReloadResponse(requestContext, url);
 
       const cleanUrl = new URL(req.url);
       for (const key of [...cleanUrl.searchParams.keys()]) {
@@ -523,6 +555,7 @@ export async function dispatch<TEnv = any>(
       // Brand as request-scoped so a "use cache" inside a response-route handler
       // is detected as a request-scope violation here exactly as in production
       // (response-route-handler.ts brands the same shape).
+      defineRewrittenFrom(responseHandlerCtx, requestContext);
       (responseHandlerCtx as Record<symbol, unknown>)[NOCACHE_SYMBOL] = true;
 
       const callHandler = async (): Promise<Response> => {
@@ -668,8 +701,11 @@ export async function dispatch<TEnv = any>(
     // onTimeout Response is RETURNED from coreHandler so it flows back out
     // through the global chain and finalizeResponse, identical to production
     // (handler.ts:857 returns handleTimeoutResponse into the same next() path).
-    const runResponseRoute = async (): Promise<Response> => {
-      const responseWork = callResponseRoute();
+    const runResponseRoute = async (
+      pass: DispatchPass<TEnv>,
+    ): Promise<Response> => {
+      const { routeKey } = pass;
+      const responseWork = callResponseRoute(pass);
       const renderOutcome = await withTimeout(
         responseWork,
         router.timeouts?.renderStartMs,
@@ -752,7 +788,8 @@ export async function dispatch<TEnv = any>(
     // wins, never reaching the 308/404. The renderStartMs deadline lives inside
     // runResponseRoute (below the chain), never covering the 308/404 paths —
     // production only wraps the response-route plan (handler.ts:834-856).
-    const coreHandler = async (): Promise<Response> => {
+    const coreHandler = async (pass: DispatchPass<TEnv>): Promise<Response> => {
+      const { redirectTo, isUnmatched, url } = pass;
       if (redirectTo) {
         return createResponseWithMergedHeaders(null, {
           status: 308,
@@ -765,7 +802,7 @@ export async function dispatch<TEnv = any>(
           headers: { "content-type": "text/plain;charset=utf-8" },
         });
       }
-      return runResponseRoute();
+      return runResponseRoute(pass);
     };
 
     // request.start opens the match transaction, mirroring match-handlers.ts.
@@ -790,18 +827,49 @@ export async function dispatch<TEnv = any>(
       // only the response-route unit inside coreHandler (see runResponseRoute),
       // mirroring handler.ts:845 so global middleware time is never counted
       // toward the deadline.
-      const globalMatches = matchMiddleware(url.pathname, router.middleware);
-      const mwResponse =
-        globalMatches.length === 0
-          ? await coreHandler()
-          : await executeMiddleware<TEnv>(
-              globalMatches,
-              req,
-              env,
-              variables,
-              coreHandler,
-              reverse,
-            );
+      // A throw rewrite() re-dispatches the same request context as the
+      // target, through the production handler's pass loop
+      // (rsc/rewrite-passes.ts). Each pass matches its URL and builds its own
+      // core handler.
+      let passIndex = 0;
+      const { response: mwResponse, rewrittenTo } = await runRewritePasses({
+        reqCtx: requestContext,
+        request: req,
+        url,
+        routeMap: () => router.routeMap as Record<string, string>,
+        basename: router.basename,
+        runPass: async (passRequest) => {
+          const pass =
+            passIndex++ === 0
+              ? firstPass
+              : await matchDispatchPass(router, passRequest, env);
+          recordPassParams(pass);
+          const globalMatches = matchMiddleware(
+            pass.url.pathname,
+            router.middleware,
+          );
+          const passCore = (): Promise<Response> => coreHandler(pass);
+          return globalMatches.length === 0
+            ? passCore()
+            : executeMiddleware<TEnv>(
+                globalMatches,
+                pass.req,
+                env,
+                variables,
+                passCore,
+                reverse,
+              );
+        },
+        report: (error, at) => {
+          invokeOnError(
+            router.onError,
+            error,
+            "routing",
+            { request: at.request, url: at.url, env, handledByBoundary: false },
+            "RSC",
+          );
+        },
+      });
 
       // Match production's global-chain exit (handler.ts): on a partial/action
       // request a middleware 3xx redirect is converted to a Flight-safe response
@@ -832,6 +900,9 @@ export async function dispatch<TEnv = any>(
       } else {
         finalResponse = finalizeResponse(mwResponse);
       }
+      if (rewrittenTo !== undefined) {
+        trySetHeader(finalResponse, REWRITE_HEADER, rewrittenTo);
+      }
 
       // request.end closes the transaction. dispatch produces no RSC segments and
       // holds no match-cache state, so segmentCount/cacheHit are 0/false — the

package/src/testing/e2e/page-helpers.ts

@@ -3,6 +3,7 @@
 // returned from `createPageHelpers(expect)`; the rest are standalone.
 
 import type { ConsoleMessage, Expect, Locator, Page } from "@playwright/test";
+import { PREFETCH_HEADER } from "../../prefetch-markers.js";
 
 // ============================================================================
 //  Standalone helpers (need only a page/locator)
@@ -170,7 +171,8 @@ export async function measureTime<T>(
 export function isPrefetchRequest(req: {
   headers: () => Record<string, string>;
 }): boolean {
-  return !!req.headers()["x-rango-prefetch"];
+  // Playwright lowercases header names.
+  return !!req.headers()[PREFETCH_HEADER.toLowerCase()];
 }
 
 // Module-level matcher + handler so blockPrefetch/unblockPrefetch share

package/src/testing/flight.entry.ts

@@ -64,6 +64,7 @@ export {
   resetShellTestState,
 } from "./serve-shell-request.js";
 export type {
+  ServeShellRequestAction,
   ServeShellRequestOptions,
   ServeShellRequestResult,
   ShellRequestHandles,

package/src/testing/index.ts

@@ -26,7 +26,7 @@
  *   condition and would throw if pulled into this barrel.
  *
  * Layers:
- * - Unit:        runMiddleware, runLoader, runClientRevalidate
+ * - Unit:        runMiddleware, runLoader, runRevalidate, runTransitionWhen
  * - Integration: dispatch (request -> Response)
  * - Cross-cut:   assertCacheStatus, assertShellStatus, assertGeneratedRoutesMatch
  * - Component:   see @rangojs/router/testing/dom (renderRoute)
@@ -38,6 +38,7 @@ export { runMiddleware } from "./run-middleware.js";
 export type {
   RunMiddlewareOptions,
   RunMiddlewareResult,
+  RunMiddlewareRewrite,
 } from "./run-middleware.js";
 export { runLoader, runLoaderResult } from "./run-loader.js";
 export type {
@@ -55,8 +56,11 @@ export type {
   RunTransitionWhenResult,
 } from "./run-transition-when.js";
 
-export { runClientRevalidate } from "./run-client-revalidate.js";
-export type { RunClientRevalidateOptions } from "./run-client-revalidate.js";
+export { runRevalidate } from "./run-revalidate.js";
+export type {
+  RunRevalidateAction,
+  RunRevalidateOptions,
+} from "./run-revalidate.js";
 
 export { dispatch } from "./dispatch.js";
 export type { DispatchOptions } from "./dispatch.js";

package/src/testing/internal/action-id.ts

@@ -1,5 +1,20 @@
 import { resolveActionRefId } from "../../router/is-action.js";
 
+/** An imported server action, as a testing primitive's `action` option takes it. */
+export type ImportedAction = (...args: never[]) => unknown;
+
+/**
+ * Normalizes a testing primitive's `action` option: a bare imported action or
+ * actionId string becomes `{ ref }`; the object form passes through.
+ */
+export function normalizeTestAction<
+  T extends { ref?: ImportedAction | string },
+>(action: ImportedAction | string | T | undefined): T | undefined {
+  return typeof action === "function" || typeof action === "string"
+    ? ({ ref: action } as T)
+    : action;
+}
+
 /**
  * The id a testing primitive's `action` option names: a single imported
  * server action (its `$id ?? $$id`, as the action boundary derives it) or a
@@ -7,7 +22,7 @@ import { resolveActionRefId } from "../../router/is-action.js";
  * primitive.
  */
 export function resolveTestActionId(
-  action: ((...args: never[]) => unknown) | string | undefined,
+  action: ImportedAction | string | undefined,
   primitive: string,
 ): string | undefined {
   if (action === undefined) return undefined;