@kiwa-test/nextjs 1.1.0 → 1.2.0

package/dist/index.js

@@ -0,0 +1,800 @@
+// src/invoke-server-action.ts
+var REDIRECT_SYMBOL = /* @__PURE__ */ Symbol.for("kiwa.next.redirect");
+function createCookieJar(initial) {
+  const store = new Map(Object.entries(initial));
+  return {
+    get(name) {
+      return store.get(name);
+    },
+    set(name, value) {
+      store.set(name, value);
+    },
+    delete(name) {
+      store.delete(name);
+    },
+    entries() {
+      return Array.from(store.entries());
+    }
+  };
+}
+function isRedirectSignal(value) {
+  return typeof value === "object" && value !== null && value[REDIRECT_SYMBOL] === true;
+}
+async function invokeServerAction(opts) {
+  const headers = /* @__PURE__ */ new Map();
+  for (const [name, value] of Object.entries(opts.headers ?? {})) {
+    headers.set(name.toLowerCase(), value);
+  }
+  const env = {
+    cookies: createCookieJar(opts.cookies ?? {}),
+    headers,
+    revalidated: { paths: [], tags: [] },
+    redirect: null
+  };
+  const callArgs = [opts.formData ?? new FormData(), ...opts.args ?? []];
+  let result;
+  let error;
+  try {
+    result = await opts.action(...callArgs);
+  } catch (caught) {
+    if (isRedirectSignal(caught)) {
+      env.redirect = caught;
+    } else {
+      error = caught;
+    }
+  }
+  return { result, error, env };
+}
+
+// src/invoke-middleware.ts
+var MIDDLEWARE_ACTION_SYMBOL = /* @__PURE__ */ Symbol.for("kiwa.next.middleware.action");
+function buildRequest(opts) {
+  const url = new URL(opts.url);
+  const headers = /* @__PURE__ */ new Map();
+  for (const [name, value] of Object.entries(opts.headers ?? {})) {
+    headers.set(name.toLowerCase(), value);
+  }
+  const cookies = new Map(Object.entries(opts.cookies ?? {}));
+  return {
+    url: opts.url,
+    method: opts.method ?? "GET",
+    headers,
+    cookies,
+    nextUrl: {
+      pathname: url.pathname,
+      search: url.search,
+      searchParams: url.searchParams
+    },
+    geo: opts.geo ?? {}
+  };
+}
+var middlewareActions = {
+  next() {
+    return { [MIDDLEWARE_ACTION_SYMBOL]: true, kind: "next" };
+  },
+  redirect(url, status = 307) {
+    return { [MIDDLEWARE_ACTION_SYMBOL]: true, kind: "redirect", url, status };
+  },
+  rewrite(url) {
+    return { [MIDDLEWARE_ACTION_SYMBOL]: true, kind: "rewrite", url };
+  },
+  json(body, status = 200) {
+    return { [MIDDLEWARE_ACTION_SYMBOL]: true, kind: "json", body, status };
+  }
+};
+async function invokeMiddleware(opts) {
+  const req = buildRequest(opts);
+  const responseHeaders = /* @__PURE__ */ new Map();
+  const responseCookies = /* @__PURE__ */ new Map();
+  const seam = {
+    setHeader(name, value) {
+      responseHeaders.set(name.toLowerCase(), value);
+    },
+    setCookie(name, value) {
+      responseCookies.set(name, value);
+    }
+  };
+  let action = middlewareActions.next();
+  let error;
+  try {
+    const result = await opts.middleware(req, seam);
+    action = result;
+  } catch (caught) {
+    error = caught;
+    action = { [MIDDLEWARE_ACTION_SYMBOL]: true, kind: "noop" };
+  }
+  return {
+    env: {
+      responseHeaders,
+      responseCookies,
+      action
+    },
+    error
+  };
+}
+
+// src/render-server-component.ts
+var NOT_FOUND_SYMBOL = /* @__PURE__ */ Symbol.for("kiwa.next.rsc.notFound");
+var FORBIDDEN_SYMBOL = /* @__PURE__ */ Symbol.for("kiwa.next.rsc.forbidden");
+var RSC_REDIRECT_SYMBOL = /* @__PURE__ */ Symbol.for("kiwa.next.rsc.redirect");
+function isRscElement(node) {
+  if (typeof node !== "object" || node === null) return false;
+  const candidate = node;
+  return typeof candidate.type !== "undefined" && typeof candidate.props === "object" && candidate.props !== null;
+}
+function isNotFound(value) {
+  return typeof value === "object" && value !== null && value[NOT_FOUND_SYMBOL] === true;
+}
+function isForbidden(value) {
+  return typeof value === "object" && value !== null && value[FORBIDDEN_SYMBOL] === true;
+}
+function isRscRedirect(value) {
+  return typeof value === "object" && value !== null && value[RSC_REDIRECT_SYMBOL] === true;
+}
+function findAll(tree, predicate) {
+  const out = [];
+  function visit(node) {
+    if (Array.isArray(node)) {
+      node.forEach(visit);
+      return;
+    }
+    if (!isRscElement(node)) return;
+    if (predicate(node)) out.push(node);
+    const children = node.props.children;
+    if (typeof children !== "undefined") {
+      visit(children);
+    }
+  }
+  visit(tree);
+  return out;
+}
+function textContent(tree) {
+  const parts = [];
+  function visit(node) {
+    if (Array.isArray(node)) {
+      node.forEach(visit);
+      return;
+    }
+    if (typeof node === "string" || typeof node === "number") {
+      parts.push(String(node));
+      return;
+    }
+    if (isRscElement(node)) {
+      const children = node.props.children;
+      if (typeof children !== "undefined") visit(children);
+    }
+  }
+  visit(tree);
+  return parts.filter((p) => p.length > 0).join(" ");
+}
+async function renderServerComponent(opts) {
+  let tree = null;
+  let signal = null;
+  let error;
+  const props = opts.props ?? {};
+  try {
+    const result = await opts.component(props);
+    tree = result;
+  } catch (caught) {
+    if (isNotFound(caught) || isForbidden(caught) || isRscRedirect(caught)) {
+      signal = caught;
+    } else {
+      error = caught;
+    }
+  }
+  return { tree, signal, error };
+}
+
+// src/invoke-parallel-routes.ts
+var PARALLEL_INTERCEPTION_SYMBOL = /* @__PURE__ */ Symbol.for("kiwa.next.parallel.interception");
+async function renderSlot(input) {
+  let tree = null;
+  let usedDefault = false;
+  let error;
+  const interception = input.intercepting ? {
+    [PARALLEL_INTERCEPTION_SYMBOL]: true,
+    slot: input.slot,
+    variant: input.intercepting.variant,
+    url: input.intercepting.url,
+    distance: input.intercepting.distance ?? "sibling"
+  } : null;
+  const useDefault = input.component === null || interception?.variant === "default";
+  try {
+    if (useDefault) {
+      if (typeof input.defaultFallback !== "function") {
+        throw new Error(`slot ${input.slot}: no default.tsx fallback supplied`);
+      }
+      tree = await input.defaultFallback();
+      usedDefault = true;
+    } else if (input.component !== null) {
+      tree = await input.component(input.props ?? {});
+    }
+  } catch (caught) {
+    error = caught;
+  }
+  return { slot: input.slot, tree, usedDefault, interception, error };
+}
+async function invokeParallelRoutes(opts) {
+  let childrenTree = null;
+  let childrenError;
+  let layoutError;
+  try {
+    childrenTree = await opts.children(opts.childrenProps ?? {});
+  } catch (caught) {
+    childrenError = caught;
+  }
+  const slotResults = await Promise.all(opts.slots.map((input) => renderSlot(input)));
+  const slotMap = {};
+  for (const result of slotResults) {
+    slotMap[result.slot] = result.tree;
+  }
+  let tree = null;
+  try {
+    const props = {
+      ...opts.layoutProps ?? {},
+      children: childrenTree,
+      slots: slotMap
+    };
+    tree = await opts.layout(props);
+  } catch (caught) {
+    layoutError = caught;
+  }
+  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})`
+    );
+  }
+}
+export {
+  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.js.map