@kiwa-test/nextjs 1.0.5 → 1.2.0

package/README.md

@@ -65,11 +65,63 @@ The returned `ServerActionResult` exposes `result` (the resolved value), `error`
 
 Throw a `{ [REDIRECT_SYMBOL]: true, url, type }` from your action to signal a redirect. The helper normalizes it into `env.redirect` instead of leaking it as an error. Production code keeps using `redirect()` from `next/navigation` — only the test seam differs.
 
+## RSC streaming + Suspense boundary (v1.1+, Issue #558)
+
+`setupNextRscEnv` extends the RSC seam to streaming chunks and Suspense boundary transitions — the cases `renderServerComponent` (leaf-level + signal capture) does not model.
+
+```ts
+import { describe, expect, it } from 'vitest';
+import { setupNextRscEnv } from '@kiwa-test/nextjs';
+
+async function* streamItems() {
+  yield { type: 'div', key: null, props: { children: 'partial: 1 item' } };
+  yield { type: 'div', key: null, props: { children: 'partial: 2 items' } };
+  yield { type: 'ul', key: null, props: { children: ['a', 'b', 'c'] } };
+}
+
+const fallback = { type: 'div', key: null, props: { children: 'loading…' } };
+
+describe('streamItems', () => {
+  it('captures fallback then resolved subtree in order', async () => {
+    const env = await setupNextRscEnv({
+      dataSource: streamItems(),
+      suspenseFallback: fallback,
+      streamingTimeout: 1000,
+    });
+    expect(env.fallback).toBe(fallback);
+    expect(env.chunks).toHaveLength(4); // fallback + 3 yields
+    expect(env.chunks[0]).toBe(fallback);
+    expect(env.resolved).not.toBeNull();
+    expect(env.errorBoundary).toBeNull();
+    expect(env.timedOut).toBe(false);
+  });
+
+  it('routes a thrown chunk into errorBoundary', async () => {
+    async function* broken() {
+      yield fallback;
+      throw new Error('stream broken');
+    }
+    const env = await setupNextRscEnv({ dataSource: broken() });
+    expect(env.errorBoundary).not.toBeNull();
+    expect((env.errorBoundary?.error as Error).message).toBe('stream broken');
+    expect(env.resolved).toBeNull();
+  });
+});
+```
+
+| `env` field | Type | Meaning |
+|---|---|---|
+| `chunks` | `RscNode[]` | All chunks in arrival order. `chunks[0]` is the Suspense fallback when one is provided. |
+| `fallback` | `RscNode \| null` | The fallback markup the helper captured before streaming started. |
+| `resolved` | `RscNode \| null` | The last chunk yielded by the source — what a real page settles on. `null` when the source threw or only the fallback was emitted. |
+| `errorBoundary` | `RscErrorBoundarySignal \| null` | Set when component / stream throws or `injectError` is provided. Mirrors what `error.tsx` would see. |
+| `timedOut` | `boolean` | `true` when `streamingTimeout` elapsed before the source completed. |
+
 ## Out of scope (tracked separately)
 
-- **React Server Components (RSC) render assertions** — [#494](https://github.com/cardene777/kiwa/issues/494)
-- **`middleware.ts` invocation** — [#495](https://github.com/cardene777/kiwa/issues/495)
-- **End-to-end browser flow after the action** — use `/kiwa-e2e` or `/kiwa-play` instead
+- **Real React `renderToReadableStream` rendering / flight payload byte format** — leaf-level coverage lives in `renderServerComponent`, full wire protocol stays out of scope.
+- **Multiple concurrent Suspense boundaries interleaving** — one boundary per `setupNextRscEnv` call.
+- **End-to-end browser flow after the action** — use `/kiwa-e2e` or `/kiwa-play` instead.
 
 ## License
 

package/dist/index.cjs

@@ -22,16 +22,44 @@ var index_exports = {};
 __export(index_exports, {
   FORBIDDEN_SYMBOL: () => FORBIDDEN_SYMBOL,
   MIDDLEWARE_ACTION_SYMBOL: () => MIDDLEWARE_ACTION_SYMBOL,
+  NEXT_AXIS_TO_EVENTS: () => NEXT_AXIS_TO_EVENTS,
   NOT_FOUND_SYMBOL: () => NOT_FOUND_SYMBOL,
   PARALLEL_INTERCEPTION_SYMBOL: () => PARALLEL_INTERCEPTION_SYMBOL,
   REDIRECT_SYMBOL: () => REDIRECT_SYMBOL,
+  RSC_ERROR_BOUNDARY_SYMBOL: () => RSC_ERROR_BOUNDARY_SYMBOL,
   RSC_REDIRECT_SYMBOL: () => RSC_REDIRECT_SYMBOL,
+  assertMode: () => assertMode,
+  captureParallelError: () => captureParallelError,
+  collectFidelityCoverage: () => collectFidelityCoverage,
+  completePartialPrerendering: () => completePartialPrerendering,
   findAll: () => findAll,
+  flushStreamingBoundary: () => flushStreamingBoundary,
+  interceptCurrentSegment: () => interceptCurrentSegment,
+  interceptParentSegment: () => interceptParentSegment,
+  interceptRootCatchall: () => interceptRootCatchall,
   invokeMiddleware: () => invokeMiddleware,
   invokeParallelRoutes: () => invokeParallelRoutes,
   invokeServerAction: () => invokeServerAction,
   middlewareActions: () => middlewareActions,
+  navigateSlot: () => navigateSlot,
+  openDynamicHole: () => openDynamicHole,
+  openInterceptedModal: () => openInterceptedModal,
+  providerEventName: () => providerEventName,
+  redirectAction: () => redirectAction,
+  renderDefaultSlot: () => renderDefaultSlot,
+  renderLoadingState: () => renderLoadingState,
   renderServerComponent: () => renderServerComponent,
+  renderStaticShell: () => renderStaticShell,
+  resolveAllModes: () => resolveAllModes,
+  resolveMode: () => resolveMode,
+  revalidateActionPath: () => revalidateActionPath,
+  revalidateActionTag: () => revalidateActionTag,
+  setupNextRscEnv: () => setupNextRscEnv,
+  startInterceptionRoutes: () => startInterceptionRoutes,
+  startParallelRoutesAdvanced: () => startParallelRoutesAdvanced,
+  startPartialPrerendering: () => startPartialPrerendering,
+  startServerActionAdvanced: () => startServerActionAdvanced,
+  submitFormAction: () => submitFormAction,
   textContent: () => textContent
 });
 module.exports = __toCommonJS(index_exports);
@@ -279,20 +307,561 @@ async function invokeParallelRoutes(opts) {
   }
   return { tree, slotResults, childrenError, layoutError };
 }
+
+// src/setup-next-rsc-env.ts
+var RSC_ERROR_BOUNDARY_SYMBOL = /* @__PURE__ */ Symbol.for("kiwa.next.rsc.errorBoundary");
+var DEFAULT_STREAMING_TIMEOUT_MS = 5e3;
+function buildErrorBoundary(error) {
+  return { [RSC_ERROR_BOUNDARY_SYMBOL]: true, error };
+}
+async function runWithTimeout(promise, timeoutMs) {
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => resolve({ value: null, timedOut: true }), timeoutMs);
+  });
+  try {
+    const value = await Promise.race([
+      promise.then((v) => ({ value: v, timedOut: false })),
+      timeout
+    ]);
+    return value;
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+async function collectStream(source, fallback) {
+  const chunks = [];
+  if (typeof fallback !== "undefined" && fallback !== null) {
+    chunks.push(fallback);
+  }
+  try {
+    for await (const chunk of source) {
+      chunks.push(chunk);
+    }
+  } catch (err) {
+    return { chunks, resolved: null, thrown: err };
+  }
+  const resolved = chunks.length > 0 ? chunks[chunks.length - 1] ?? null : null;
+  const fallbackOnly = chunks.length === 1 && fallback !== null && Object.is(chunks[0], fallback);
+  return { chunks, resolved: fallbackOnly ? null : resolved, thrown: void 0 };
+}
+async function* singleChunkSource(component, props) {
+  const result = await component(props);
+  yield result;
+}
+async function setupNextRscEnv(opts = {}) {
+  const timeoutMs = opts.streamingTimeout ?? DEFAULT_STREAMING_TIMEOUT_MS;
+  const fallback = opts.suspenseFallback ?? null;
+  if (timeoutMs <= 0 && (opts.dataSource || opts.component)) {
+    return {
+      chunks: fallback !== null ? [fallback] : [],
+      fallback,
+      resolved: null,
+      errorBoundary: null,
+      timedOut: true
+    };
+  }
+  if (typeof opts.injectError !== "undefined") {
+    return {
+      chunks: fallback !== null ? [fallback] : [],
+      fallback,
+      resolved: null,
+      errorBoundary: buildErrorBoundary(opts.injectError),
+      timedOut: false
+    };
+  }
+  if (!opts.dataSource && !opts.component) {
+    return {
+      chunks: fallback !== null ? [fallback] : [],
+      fallback,
+      resolved: null,
+      errorBoundary: null,
+      timedOut: false
+    };
+  }
+  const source = opts.dataSource ? opts.dataSource : singleChunkSource(opts.component, opts.props ?? {});
+  const { value, timedOut } = await runWithTimeout(collectStream(source, fallback), timeoutMs);
+  if (timedOut || value === null) {
+    return {
+      chunks: fallback !== null ? [fallback] : [],
+      fallback,
+      resolved: null,
+      errorBoundary: null,
+      timedOut: true
+    };
+  }
+  const { chunks, resolved, thrown } = value;
+  if (typeof thrown !== "undefined") {
+    return {
+      chunks,
+      fallback,
+      resolved: null,
+      errorBoundary: buildErrorBoundary(thrown),
+      timedOut: false
+    };
+  }
+  return {
+    chunks,
+    fallback,
+    resolved,
+    errorBoundary: null,
+    timedOut: false
+  };
+}
+
+// src/semantics/types.ts
+var dialect = {
+  "app-router": {
+    "action.form_submitted": "app.server-action.form.submit",
+    "action.revalidate_path": "app.cache.revalidatePath",
+    "action.revalidate_tag": "app.cache.revalidateTag",
+    "action.redirected": "app.navigation.redirect",
+    "ppr.static_shell_rendered": "app.ppr.static-shell",
+    "ppr.dynamic_hole_opened": "app.ppr.dynamic-hole",
+    "ppr.streaming_boundary_flushed": "app.ppr.stream-boundary",
+    "ppr.completed": "app.ppr.complete",
+    "intercept.current_segment": "app.intercept.current",
+    "intercept.parent_segment": "app.intercept.parent",
+    "intercept.root_catchall": "app.intercept.root",
+    "intercept.modal_opened": "app.intercept.modal",
+    "parallel.default_rendered": "app.parallel.default",
+    "parallel.loading_rendered": "app.parallel.loading",
+    "parallel.error_boundary_captured": "app.parallel.error",
+    "parallel.slot_navigated": "app.parallel.navigate"
+  },
+  "pages-router": {
+    "action.form_submitted": "pages.api.form.submit",
+    "action.revalidate_path": "pages.isr.revalidate",
+    "action.revalidate_tag": "pages.cache.tag.noop",
+    "action.redirected": "pages.router.redirect",
+    "ppr.static_shell_rendered": "pages.ssg.shell",
+    "ppr.dynamic_hole_opened": "pages.ssr.dynamic-hole",
+    "ppr.streaming_boundary_flushed": "pages.stream.boundary",
+    "ppr.completed": "pages.render.complete",
+    "intercept.current_segment": "pages.intercept.current",
+    "intercept.parent_segment": "pages.intercept.parent",
+    "intercept.root_catchall": "pages.intercept.root",
+    "intercept.modal_opened": "pages.modal.open",
+    "parallel.default_rendered": "pages.slot.default",
+    "parallel.loading_rendered": "pages.slot.loading",
+    "parallel.error_boundary_captured": "pages.slot.error",
+    "parallel.slot_navigated": "pages.slot.navigate"
+  },
+  "edge-runtime": {
+    "action.form_submitted": "edge.action.form.submit",
+    "action.revalidate_path": "edge.cache.revalidatePath",
+    "action.revalidate_tag": "edge.cache.revalidateTag",
+    "action.redirected": "edge.response.redirect",
+    "ppr.static_shell_rendered": "edge.ppr.static-shell",
+    "ppr.dynamic_hole_opened": "edge.ppr.dynamic-hole",
+    "ppr.streaming_boundary_flushed": "edge.stream.boundary",
+    "ppr.completed": "edge.ppr.complete",
+    "intercept.current_segment": "edge.intercept.current",
+    "intercept.parent_segment": "edge.intercept.parent",
+    "intercept.root_catchall": "edge.intercept.root",
+    "intercept.modal_opened": "edge.modal.open",
+    "parallel.default_rendered": "edge.parallel.default",
+    "parallel.loading_rendered": "edge.parallel.loading",
+    "parallel.error_boundary_captured": "edge.parallel.error",
+    "parallel.slot_navigated": "edge.parallel.navigate"
+  }
+};
+function providerEventName(target, neutral) {
+  return dialect[target][neutral] ?? neutral;
+}
+
+// src/semantics/server-action-advanced.ts
+function startServerActionAdvanced(input) {
+  if (input.actionId.length === 0) {
+    throw new Error("startServerActionAdvanced: actionId must not be empty");
+  }
+  return {
+    target: input.target,
+    actionId: input.actionId,
+    state: "idle",
+    form: {},
+    revalidatedPaths: [],
+    revalidatedTags: [],
+    redirectUrl: null,
+    history: []
+  };
+}
+function submitFormAction(session, form) {
+  if (session.state !== "idle") {
+    throw new Error(`submitFormAction: session is ${session.state}, not idle`);
+  }
+  session.state = "submitted";
+  session.form = { ...form };
+  return emit(session, "action.form_submitted", {
+    fields: Object.keys(form).join(","),
+    fieldCount: Object.keys(form).length
+  });
+}
+function revalidateActionPath(session, path) {
+  if (session.state === "idle") {
+    throw new Error("revalidateActionPath: form action was not submitted");
+  }
+  if (!path.startsWith("/")) {
+    throw new Error("revalidateActionPath: path must start with /");
+  }
+  session.state = "path-revalidated";
+  session.revalidatedPaths.push(path);
+  return emit(session, "action.revalidate_path", { path, count: session.revalidatedPaths.length });
+}
+function revalidateActionTag(session, tag) {
+  if (session.state === "idle") {
+    throw new Error("revalidateActionTag: form action was not submitted");
+  }
+  if (tag.length === 0) {
+    throw new Error("revalidateActionTag: tag must not be empty");
+  }
+  session.state = "tag-revalidated";
+  session.revalidatedTags.push(tag);
+  return emit(session, "action.revalidate_tag", { tag, count: session.revalidatedTags.length });
+}
+function redirectAction(session, url) {
+  if (session.state === "idle") {
+    throw new Error("redirectAction: form action was not submitted");
+  }
+  if (url.length === 0) {
+    throw new Error("redirectAction: url must not be empty");
+  }
+  session.state = "redirected";
+  session.redirectUrl = url;
+  return emit(session, "action.redirected", { url });
+}
+function emit(session, neutralEvent, metadata) {
+  const step = {
+    neutralEvent,
+    providerEvent: providerEventName(session.target, neutralEvent),
+    state: session.state,
+    amountCents: 0,
+    metadata: { target: session.target, actionId: session.actionId, ...metadata }
+  };
+  session.history.push(step);
+  return step;
+}
+
+// src/semantics/partial-prerendering.ts
+function startPartialPrerendering(input) {
+  if (input.routeId.length === 0) {
+    throw new Error("startPartialPrerendering: routeId must not be empty");
+  }
+  return {
+    target: input.target,
+    routeId: input.routeId,
+    state: "idle",
+    shellHtml: null,
+    dynamicHoles: /* @__PURE__ */ new Map(),
+    streamedBoundaries: [],
+    history: []
+  };
+}
+function renderStaticShell(session, html) {
+  if (session.state !== "idle") {
+    throw new Error(`renderStaticShell: session is ${session.state}, not idle`);
+  }
+  if (html.length === 0) {
+    throw new Error("renderStaticShell: html must not be empty");
+  }
+  session.state = "static-shell";
+  session.shellHtml = html;
+  return emit2(session, "ppr.static_shell_rendered", { bytes: html.length });
+}
+function openDynamicHole(session, input) {
+  if (session.shellHtml === null) {
+    throw new Error("openDynamicHole: static shell must be rendered first");
+  }
+  if (input.holeId.length === 0) {
+    throw new Error("openDynamicHole: holeId must not be empty");
+  }
+  session.state = "dynamic-hole";
+  session.dynamicHoles.set(input.holeId, input.fallback);
+  return emit2(session, "ppr.dynamic_hole_opened", {
+    holeId: input.holeId,
+    fallback: input.fallback,
+    holeCount: session.dynamicHoles.size
+  });
+}
+function flushStreamingBoundary(session, input) {
+  if (!session.dynamicHoles.has(input.holeId)) {
+    throw new Error(`flushStreamingBoundary: ${input.holeId} is not an open dynamic hole`);
+  }
+  if (input.html.length === 0) {
+    throw new Error("flushStreamingBoundary: html must not be empty");
+  }
+  session.state = "streaming";
+  session.streamedBoundaries.push(input.holeId);
+  session.dynamicHoles.set(input.holeId, input.html);
+  return emit2(session, "ppr.streaming_boundary_flushed", {
+    holeId: input.holeId,
+    bytes: input.html.length
+  });
+}
+function completePartialPrerendering(session) {
+  if (session.shellHtml === null) {
+    throw new Error("completePartialPrerendering: static shell was not rendered");
+  }
+  session.state = "completed";
+  return emit2(session, "ppr.completed", {
+    holeCount: session.dynamicHoles.size,
+    streamedCount: session.streamedBoundaries.length
+  });
+}
+function emit2(session, neutralEvent, metadata) {
+  const step = {
+    neutralEvent,
+    providerEvent: providerEventName(session.target, neutralEvent),
+    state: session.state,
+    amountCents: 0,
+    metadata: { target: session.target, routeId: session.routeId, ...metadata }
+  };
+  session.history.push(step);
+  return step;
+}
+
+// src/semantics/interception-routes.ts
+function startInterceptionRoutes(input) {
+  if (input.routeId.length === 0) {
+    throw new Error("startInterceptionRoutes: routeId must not be empty");
+  }
+  return {
+    target: input.target,
+    routeId: input.routeId,
+    state: "idle",
+    matches: [],
+    modalRoute: null,
+    history: []
+  };
+}
+function interceptCurrentSegment(session, from, to) {
+  return intercept(session, "(.)", "current", "intercept.current_segment", from, to);
+}
+function interceptParentSegment(session, from, to) {
+  return intercept(session, "(..)", "parent", "intercept.parent_segment", from, to);
+}
+function interceptRootCatchall(session, from, to) {
+  return intercept(session, "(...)", "root", "intercept.root_catchall", from, to);
+}
+function openInterceptedModal(session, modalRoute) {
+  if (modalRoute.length === 0) {
+    throw new Error("openInterceptedModal: modalRoute must not be empty");
+  }
+  if (session.matches.length === 0) {
+    throw new Error("openInterceptedModal: an interception match is required first");
+  }
+  session.state = "modal-open";
+  session.modalRoute = modalRoute;
+  return emit3(session, "intercept.modal_opened", {
+    modalRoute,
+    matchCount: session.matches.length
+  });
+}
+function intercept(session, matcher, state, neutralEvent, from, to) {
+  if (!from.startsWith("/") || !to.startsWith("/")) {
+    throw new Error("intercept: from and to must start with /");
+  }
+  session.state = state;
+  session.matches.push({ matcher, from, to });
+  return emit3(session, neutralEvent, { matcher, from, to });
+}
+function emit3(session, neutralEvent, metadata) {
+  const step = {
+    neutralEvent,
+    providerEvent: providerEventName(session.target, neutralEvent),
+    state: session.state,
+    amountCents: 0,
+    metadata: { target: session.target, routeId: session.routeId, ...metadata }
+  };
+  session.history.push(step);
+  return step;
+}
+
+// src/semantics/parallel-routes-advanced.ts
+function startParallelRoutesAdvanced(input) {
+  if (input.layoutId.length === 0) {
+    throw new Error("startParallelRoutesAdvanced: layoutId must not be empty");
+  }
+  return {
+    target: input.target,
+    layoutId: input.layoutId,
+    state: "idle",
+    slots: /* @__PURE__ */ new Map(),
+    loadingSlots: /* @__PURE__ */ new Set(),
+    errors: [],
+    history: []
+  };
+}
+function renderDefaultSlot(session, slot, html) {
+  assertSlot(slot);
+  session.state = "default-rendered";
+  session.slots.set(slot, html);
+  return emit4(session, "parallel.default_rendered", { slot, html });
+}
+function renderLoadingState(session, slot) {
+  assertSlot(slot);
+  session.state = "loading-rendered";
+  session.loadingSlots.add(slot);
+  return emit4(session, "parallel.loading_rendered", {
+    slot,
+    loadingCount: session.loadingSlots.size
+  });
+}
+function captureParallelError(session, input) {
+  assertSlot(input.slot);
+  const message = typeof input.error === "string" ? input.error : input.error.message;
+  session.state = "error-captured";
+  session.errors.push({ slot: input.slot, message });
+  return emit4(session, "parallel.error_boundary_captured", {
+    slot: input.slot,
+    message,
+    errorCount: session.errors.length
+  });
+}
+function navigateSlot(session, input) {
+  assertSlot(input.slot);
+  if (!input.from.startsWith("/") || !input.to.startsWith("/")) {
+    throw new Error("navigateSlot: from and to must start with /");
+  }
+  session.state = "slot-navigated";
+  session.loadingSlots.delete(input.slot);
+  return emit4(session, "parallel.slot_navigated", input);
+}
+function assertSlot(slot) {
+  if (slot.length === 0) {
+    throw new Error("slot must not be empty");
+  }
+}
+function emit4(session, neutralEvent, metadata) {
+  const step = {
+    neutralEvent,
+    providerEvent: providerEventName(session.target, neutralEvent),
+    state: session.state,
+    amountCents: 0,
+    metadata: { target: session.target, layoutId: session.layoutId, ...metadata }
+  };
+  session.history.push(step);
+  return step;
+}
+
+// src/semantics/fidelity.ts
+var NEXT_AXIS_TO_EVENTS = {
+  "server-action-advanced": [
+    "action.form_submitted",
+    "action.revalidate_path",
+    "action.revalidate_tag",
+    "action.redirected"
+  ],
+  "partial-prerendering": [
+    "ppr.static_shell_rendered",
+    "ppr.dynamic_hole_opened",
+    "ppr.streaming_boundary_flushed",
+    "ppr.completed"
+  ],
+  "interception-routes": [
+    "intercept.current_segment",
+    "intercept.parent_segment",
+    "intercept.root_catchall",
+    "intercept.modal_opened"
+  ],
+  "parallel-routes-advanced": [
+    "parallel.default_rendered",
+    "parallel.loading_rendered",
+    "parallel.error_boundary_captured",
+    "parallel.slot_navigated"
+  ]
+};
+function collectFidelityCoverage(providers = ["app-router", "pages-router", "edge-runtime"]) {
+  const axes = Object.keys(NEXT_AXIS_TO_EVENTS);
+  const rows = [];
+  for (const provider of providers) {
+    for (const axis of axes) {
+      const neutralEvents = NEXT_AXIS_TO_EVENTS[axis];
+      rows.push({
+        provider,
+        axis,
+        neutralEvents,
+        providerEvents: neutralEvents.map((event) => providerEventName(provider, event))
+      });
+    }
+  }
+  return { providers, axes, rows };
+}
+
+// src/real-driver.ts
+var TARGET_KEY_ENV = {
+  "app-router": "NEXT_APP_URL",
+  "pages-router": "NEXT_PAGES_URL",
+  "edge-runtime": "EDGE_RUNTIME_URL"
+};
+function resolveMode(provider, env = process.env) {
+  const rawMode = env.KIWA_MODE?.toLowerCase();
+  if (rawMode !== void 0 && rawMode !== "real" && rawMode !== "mock") {
+    return { provider, mode: "mock", reason: "invalid-mode" };
+  }
+  if (rawMode !== "real") {
+    return { provider, mode: "mock", reason: "default-mock" };
+  }
+  const keyValue = env[TARGET_KEY_ENV[provider]];
+  if (typeof keyValue !== "string" || keyValue.length === 0) {
+    return { provider, mode: "mock", reason: "missing-key" };
+  }
+  return { provider, mode: "real", reason: "kiwa-mode-real" };
+}
+function resolveAllModes(env = process.env) {
+  const providers = ["app-router", "pages-router", "edge-runtime"];
+  return providers.map((provider) => resolveMode(provider, env));
+}
+function assertMode(provider, expected, env = process.env) {
+  const resolved = resolveMode(provider, env);
+  if (resolved.mode !== expected) {
+    throw new Error(
+      `expected ${provider} in ${expected} mode but resolved ${resolved.mode} (${resolved.reason})`
+    );
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   FORBIDDEN_SYMBOL,
   MIDDLEWARE_ACTION_SYMBOL,
+  NEXT_AXIS_TO_EVENTS,
   NOT_FOUND_SYMBOL,
   PARALLEL_INTERCEPTION_SYMBOL,
   REDIRECT_SYMBOL,
+  RSC_ERROR_BOUNDARY_SYMBOL,
   RSC_REDIRECT_SYMBOL,
+  assertMode,
+  captureParallelError,
+  collectFidelityCoverage,
+  completePartialPrerendering,
   findAll,
+  flushStreamingBoundary,
+  interceptCurrentSegment,
+  interceptParentSegment,
+  interceptRootCatchall,
   invokeMiddleware,
   invokeParallelRoutes,
   invokeServerAction,
   middlewareActions,
+  navigateSlot,
+  openDynamicHole,
+  openInterceptedModal,
+  providerEventName,
+  redirectAction,
+  renderDefaultSlot,
+  renderLoadingState,
   renderServerComponent,
+  renderStaticShell,
+  resolveAllModes,
+  resolveMode,
+  revalidateActionPath,
+  revalidateActionTag,
+  setupNextRscEnv,
+  startInterceptionRoutes,
+  startParallelRoutesAdvanced,
+  startPartialPrerendering,
+  startServerActionAdvanced,
+  submitFormAction,
   textContent
 });
 //# sourceMappingURL=index.cjs.map