vinext 0.0.49 → 0.0.50

package/dist/shims/dynamic.js.map

@@ -1 +1 @@
-{"version":3,"file":"dynamic.js","names":[],"sources":["../../src/shims/dynamic.ts"],"sourcesContent":["/**\n * next/dynamic shim\n *\n * SSR-safe dynamic imports. On the server, uses React.lazy + Suspense so that\n * renderToReadableStream suspends until the dynamically-imported component is\n * available. On the client, also uses React.lazy for code splitting.\n *\n * Works in RSC, SSR, and client environments:\n * - RSC: Uses React.lazy + Suspense (available in React 19.x react-server).\n *   Falls back to async component pattern if a future React version\n *   strips lazy from react-server.\n * - SSR: React.lazy + Suspense (renderToReadableStream suspends)\n * - Client: React.lazy + Suspense (standard code splitting)\n *\n * Supports:\n * - dynamic(() => import('./Component'))\n * - dynamic(() => import('./Component'), { loading: () => <Spinner /> })\n * - dynamic(() => import('./Component'), { ssr: false })\n */\nimport React, { type ComponentType } from \"react\";\n\ntype DynamicOptions = {\n  loading?: ComponentType<{ error?: Error | null; isLoading?: boolean; pastDelay?: boolean }>;\n  ssr?: boolean;\n};\n\ntype Loader<P> = () => Promise<{ default: ComponentType<P> } | ComponentType<P>>;\n\n/**\n * Lightweight error boundary that renders the loading component with the error\n * when a dynamic() loader rejects. Without this, loader failures would propagate\n * uncaught through React's rendering — this preserves the Next.js behavior where\n * the `loading` component can display errors.\n *\n * Lazily created because React.Component is not available in the RSC environment\n * (server components use a slimmed-down React that doesn't include class components).\n */\n// oxlint-disable-next-line typescript/no-explicit-any\nlet DynamicErrorBoundary: any;\nfunction getDynamicErrorBoundary() {\n  if (DynamicErrorBoundary) return DynamicErrorBoundary;\n  if (!React.Component) return null;\n  DynamicErrorBoundary = class extends (\n    React.Component<\n      {\n        fallback: ComponentType<{ error?: Error | null; isLoading?: boolean; pastDelay?: boolean }>;\n        children: React.ReactNode;\n      },\n      { error: Error | null }\n    >\n  ) {\n    // oxlint-disable-next-line typescript/no-explicit-any\n    constructor(props: any) {\n      super(props);\n      this.state = { error: null };\n    }\n    static getDerivedStateFromError(error: unknown) {\n      return { error: error instanceof Error ? error : new Error(String(error)) };\n    }\n    render() {\n      if (this.state.error) {\n        return React.createElement(this.props.fallback, {\n          isLoading: false,\n          pastDelay: true,\n          error: this.state.error,\n        });\n      }\n      return this.props.children;\n    }\n  };\n  return DynamicErrorBoundary;\n}\n\n// Detect server vs client\nconst isServer = typeof window === \"undefined\";\n\n// Legacy preload queue — kept for backward compatibility with Pages Router\n// which calls flushPreloads() before rendering. The App Router uses React.lazy\n// + Suspense instead, so this queue is no longer populated.\nconst preloadQueue: Promise<void>[] = [];\n\n/**\n * Wait for all pending dynamic() preloads to resolve, then clear the queue.\n * Called by the Pages Router SSR handler before rendering.\n * No-op for the App Router path which uses React.lazy + Suspense.\n */\nexport function flushPreloads(): Promise<void[]> {\n  const pending = preloadQueue.splice(0);\n  return Promise.all(pending);\n}\n\nfunction dynamic<P extends object = object>(\n  loader: Loader<P>,\n  options?: DynamicOptions,\n): ComponentType<P> {\n  const { loading: LoadingComponent, ssr = true } = options ?? {};\n\n  // ssr: false — render nothing on the server, lazy-load on client\n  if (!ssr) {\n    if (isServer) {\n      // On the server (SSR or RSC), just render the loading state or nothing\n      const SSRFalse = (_props: P) =>\n        LoadingComponent\n          ? React.createElement(LoadingComponent, { isLoading: true, pastDelay: true, error: null })\n          : null;\n      SSRFalse.displayName = \"DynamicSSRFalse\";\n      return SSRFalse;\n    }\n\n    // Client: use lazy with Suspense\n    const LazyComponent = React.lazy(async () => {\n      const mod = await loader();\n      if (\"default\" in mod) return mod as { default: ComponentType<P> };\n      return { default: mod as ComponentType<P> };\n    });\n\n    const ClientSSRFalse = (props: P) => {\n      const [mounted, setMounted] = React.useState(false);\n      React.useEffect(() => setMounted(true), []);\n\n      if (!mounted) {\n        return LoadingComponent\n          ? React.createElement(LoadingComponent, { isLoading: true, pastDelay: true, error: null })\n          : null;\n      }\n\n      const fallback = LoadingComponent\n        ? React.createElement(LoadingComponent, { isLoading: true, pastDelay: true, error: null })\n        : null;\n      return React.createElement(\n        React.Suspense,\n        { fallback },\n        React.createElement(LazyComponent, props),\n      );\n    };\n\n    ClientSSRFalse.displayName = \"DynamicClientSSRFalse\";\n    return ClientSSRFalse;\n  }\n\n  // SSR-enabled path\n  if (isServer) {\n    // Defensive fallback: if a future React version strips React.lazy from the\n    // react-server condition, fall back to an async component pattern.\n    // In React 19.x, React.lazy IS available in react-server, so this branch\n    // does not execute — it exists for forward compatibility only.\n    if (typeof React.lazy !== \"function\") {\n      const AsyncServerDynamic = async (props: P) => {\n        // Note: LoadingComponent is not used here — in the RSC environment,\n        // async components suspend natively and parent <Suspense> boundaries\n        // provide loading states. Error handling also defers to the nearest\n        // error boundary in the component tree.\n        const mod = await loader();\n        const Component =\n          \"default\" in mod\n            ? (mod as { default: ComponentType<P> }).default\n            : (mod as ComponentType<P>);\n        return React.createElement(Component, props);\n      };\n      AsyncServerDynamic.displayName = \"DynamicAsyncServer\";\n      // Cast is safe: async components are natively supported by the RSC renderer,\n      // but TypeScript's ComponentType<P> doesn't account for async return types.\n      return AsyncServerDynamic as unknown as ComponentType<P>;\n    }\n\n    // SSR path: Use React.lazy so that renderToReadableStream can suspend\n    // until the dynamically-imported component is available.\n    const LazyServer = React.lazy(async () => {\n      const mod = await loader();\n      if (\"default\" in mod) return mod as { default: ComponentType<P> };\n      return { default: mod as ComponentType<P> };\n    });\n\n    const ServerDynamic = (props: P) => {\n      const fallback = LoadingComponent\n        ? React.createElement(LoadingComponent, { isLoading: true, pastDelay: true, error: null })\n        : null;\n      const lazyElement = React.createElement(LazyServer, props);\n      // Wrap with error boundary so loader rejections render the loading\n      // component with the error instead of propagating uncaught.\n      const ErrorBoundary = LoadingComponent ? getDynamicErrorBoundary() : null;\n      const content = ErrorBoundary\n        ? React.createElement(ErrorBoundary, { fallback: LoadingComponent }, lazyElement)\n        : lazyElement;\n      return React.createElement(React.Suspense, { fallback }, content);\n    };\n\n    ServerDynamic.displayName = \"DynamicServer\";\n    return ServerDynamic;\n  }\n\n  // Client path: standard React.lazy with Suspense\n  const LazyComponent = React.lazy(async () => {\n    const mod = await loader();\n    if (\"default\" in mod) return mod as { default: ComponentType<P> };\n    return { default: mod as ComponentType<P> };\n  });\n\n  const ClientDynamic = (props: P) => {\n    const fallback = LoadingComponent\n      ? React.createElement(LoadingComponent, { isLoading: true, pastDelay: true, error: null })\n      : null;\n    return React.createElement(\n      React.Suspense,\n      { fallback },\n      React.createElement(LazyComponent, props),\n    );\n  };\n\n  ClientDynamic.displayName = \"DynamicClient\";\n  return ClientDynamic;\n}\n\nexport default dynamic;\n"],"mappings":"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"}
+{"version":3,"file":"dynamic.js","names":[],"sources":["../../src/shims/dynamic.ts"],"sourcesContent":["/**\n * next/dynamic shim\n *\n * SSR-safe dynamic imports. On the server, uses React.lazy + Suspense so that\n * renderToReadableStream suspends until the dynamically-imported component is\n * available. On the client, also uses React.lazy for code splitting.\n *\n * Works in RSC, SSR, and client environments:\n * - RSC: Uses React.lazy + Suspense (available in React 19.x react-server).\n *   Falls back to async component pattern if a future React version\n *   strips lazy from react-server.\n * - SSR: React.lazy + Suspense (renderToReadableStream suspends)\n * - Client: React.lazy + Suspense (standard code splitting)\n *\n * Supports:\n * - dynamic(import('./Component'))\n * - dynamic(() => import('./Component'))\n * - dynamic({ loader })\n * - dynamic(() => import('./Component'), { loading: () => <Spinner /> })\n * - dynamic(() => import('./Component'), { ssr: false })\n */\nimport React, { type ComponentType } from \"react\";\n\ntype DynamicLoadingProps = {\n  error?: Error | null;\n  isLoading?: boolean;\n  pastDelay?: boolean;\n  retry?: () => void;\n  timedOut?: boolean;\n};\n\ntype ComponentModule<P> = { default: ComponentType<P> };\ntype LoaderComponent<P> = Promise<ComponentModule<P> | ComponentType<P>>;\ntype LoaderFn<P> = () => LoaderComponent<P>;\n\ntype DynamicOptions<P> = {\n  loading?: ComponentType<DynamicLoadingProps>;\n  loader?: Loader<P>;\n  ssr?: boolean;\n};\n\ntype Loader<P> = LoaderFn<P> | LoaderComponent<P>;\ntype DynamicInput<P> = DynamicOptions<P> | Loader<P>;\n\nconst noopRetry = () => {};\n\nfunction createDynamicLoadingProps(\n  overrides: Partial<DynamicLoadingProps> = {},\n): DynamicLoadingProps {\n  return {\n    error: null,\n    isLoading: true,\n    pastDelay: true,\n    retry: noopRetry,\n    timedOut: false,\n    ...overrides,\n  };\n}\n\nfunction hasDefaultExport<P>(\n  mod: ComponentModule<P> | ComponentType<P>,\n): mod is ComponentModule<P> {\n  return (typeof mod === \"object\" || typeof mod === \"function\") && mod !== null && \"default\" in mod;\n}\n\nfunction normalizeLoader<P extends object>(loader: Loader<P>): LoaderFn<P> {\n  if (typeof loader === \"function\") {\n    return loader;\n  }\n  return () => loader;\n}\n\nfunction normalizeDynamicOptions<P extends object>(\n  dynamicInput: DynamicInput<P>,\n  options?: DynamicOptions<P>,\n): DynamicOptions<P> {\n  let normalizedOptions: DynamicOptions<P>;\n\n  if (dynamicInput instanceof Promise || typeof dynamicInput === \"function\") {\n    normalizedOptions = { loader: normalizeLoader(dynamicInput) };\n  } else {\n    normalizedOptions = dynamicInput;\n  }\n\n  return {\n    ...normalizedOptions,\n    ...options,\n  };\n}\n\nfunction createLazyComponent<P extends object>(loader: LoaderFn<P>) {\n  return React.lazy(async () => {\n    const mod = await loader();\n    if (hasDefaultExport(mod)) return mod;\n    return { default: mod };\n  });\n}\n\nfunction useRetryableLazyComponent<P extends object>(\n  loader: LoaderFn<P>,\n  initialLazyComponent: ReturnType<typeof createLazyComponent<P>>,\n) {\n  const [LazyComponent, setLazyComponent] = React.useState(() => initialLazyComponent);\n  const [retryKey, setRetryKey] = React.useState(0);\n  const retry = React.useCallback(() => {\n    setLazyComponent(() => createLazyComponent(loader));\n    setRetryKey((key) => key + 1);\n  }, [loader]);\n  return { LazyComponent, retry, retryKey };\n}\n\ntype DynamicErrorBoundaryProps = {\n  fallback: ComponentType<DynamicLoadingProps>;\n  retry: () => void;\n  resetKey: number;\n  children?: React.ReactNode;\n};\n\ntype DynamicErrorBoundaryState = {\n  error: Error | null;\n  resetKey: number;\n};\n\n/**\n * Lightweight error boundary that renders the loading component with the error\n * when a dynamic() loader rejects. Without this, loader failures would propagate\n * uncaught through React's rendering — this preserves the Next.js behavior where\n * the `loading` component can display errors.\n *\n * Lazily created because React.Component is not available in the RSC environment\n * (server components use a slimmed-down React that doesn't include class components).\n */\nlet DynamicErrorBoundary: ComponentType<DynamicErrorBoundaryProps> | null | undefined;\nfunction getDynamicErrorBoundary() {\n  if (DynamicErrorBoundary) return DynamicErrorBoundary;\n  if (!React.Component) return null;\n  DynamicErrorBoundary = class extends (\n    React.Component<DynamicErrorBoundaryProps, DynamicErrorBoundaryState>\n  ) {\n    constructor(props: DynamicErrorBoundaryProps) {\n      super(props);\n      this.state = { error: null, resetKey: props.resetKey };\n    }\n    static getDerivedStateFromProps(\n      props: DynamicErrorBoundaryProps,\n      state: DynamicErrorBoundaryState,\n    ) {\n      if (props.resetKey !== state.resetKey) {\n        return { error: null, resetKey: props.resetKey };\n      }\n      return null;\n    }\n    static getDerivedStateFromError(error: unknown) {\n      return { error: error instanceof Error ? error : new Error(String(error)) };\n    }\n    render() {\n      if (this.state.error) {\n        return React.createElement(\n          this.props.fallback,\n          createDynamicLoadingProps({\n            isLoading: false,\n            error: this.state.error,\n            retry: this.props.retry,\n          }),\n        );\n      }\n      return this.props.children;\n    }\n  };\n  return DynamicErrorBoundary;\n}\n\n// Detect server vs client\nconst isServer = typeof window === \"undefined\";\n\n// Legacy preload queue — kept for backward compatibility with Pages Router\n// which calls flushPreloads() before rendering. The App Router uses React.lazy\n// + Suspense instead, so this queue is no longer populated.\nconst preloadQueue: Promise<void>[] = [];\n\n/**\n * Wait for all pending dynamic() preloads to resolve, then clear the queue.\n * Called by the Pages Router SSR handler before rendering.\n * No-op for the App Router path which uses React.lazy + Suspense.\n */\nexport function flushPreloads(): Promise<void[]> {\n  const pending = preloadQueue.splice(0);\n  return Promise.all(pending);\n}\n\nfunction dynamic<P extends object = object>(\n  dynamicInput: DynamicInput<P>,\n  options?: DynamicOptions<P>,\n): ComponentType<P> {\n  const {\n    loader: dynamicLoader,\n    loading: LoadingComponent,\n    ssr = true,\n  } = normalizeDynamicOptions(dynamicInput, options);\n  const loader = dynamicLoader ? normalizeLoader(dynamicLoader) : () => Promise.resolve(() => null);\n\n  // ssr: false — render nothing on the server, lazy-load on client\n  if (!ssr) {\n    if (isServer) {\n      // On the server (SSR or RSC), just render the loading state or nothing\n      const SSRFalse = (_props: P) =>\n        LoadingComponent\n          ? React.createElement(LoadingComponent, createDynamicLoadingProps({ pastDelay: false }))\n          : null;\n      SSRFalse.displayName = \"DynamicSSRFalse\";\n      return SSRFalse;\n    }\n\n    const InitialLazyComponent = createLazyComponent(loader);\n\n    const ClientSSRFalse = (props: P) => {\n      const [mounted, setMounted] = React.useState(false);\n      const { LazyComponent, retry, retryKey } = useRetryableLazyComponent(\n        loader,\n        InitialLazyComponent,\n      );\n      React.useEffect(() => setMounted(true), []);\n\n      if (!mounted) {\n        return LoadingComponent\n          ? React.createElement(LoadingComponent, createDynamicLoadingProps({ retry }))\n          : null;\n      }\n\n      const fallback = LoadingComponent\n        ? React.createElement(LoadingComponent, createDynamicLoadingProps({ retry }))\n        : null;\n      const lazyElement = React.createElement(LazyComponent, props);\n      let content: React.ReactNode = lazyElement;\n      if (LoadingComponent) {\n        const ErrorBoundary = getDynamicErrorBoundary();\n        if (ErrorBoundary) {\n          content = React.createElement(\n            ErrorBoundary,\n            { fallback: LoadingComponent, retry, resetKey: retryKey },\n            lazyElement,\n          );\n        }\n      }\n      return React.createElement(React.Suspense, { fallback }, content);\n    };\n\n    ClientSSRFalse.displayName = \"DynamicClientSSRFalse\";\n    return ClientSSRFalse;\n  }\n\n  // SSR-enabled path\n  if (isServer) {\n    // Defensive fallback: if a future React version strips React.lazy from the\n    // react-server condition, fall back to an async component pattern.\n    // In React 19.x, React.lazy IS available in react-server, so this branch\n    // does not execute — it exists for forward compatibility only.\n    if (typeof React.lazy !== \"function\") {\n      const AsyncServerDynamic = async (props: P) => {\n        // Note: LoadingComponent is not used here — in the RSC environment,\n        // async components suspend natively and parent <Suspense> boundaries\n        // provide loading states. Error handling also defers to the nearest\n        // error boundary in the component tree.\n        const mod = await loader();\n        const Component =\n          \"default\" in mod\n            ? (mod as { default: ComponentType<P> }).default\n            : (mod as ComponentType<P>);\n        return React.createElement(Component, props);\n      };\n      AsyncServerDynamic.displayName = \"DynamicAsyncServer\";\n      // Cast is safe: async components are natively supported by the RSC renderer,\n      // but TypeScript's ComponentType<P> doesn't account for async return types.\n      return AsyncServerDynamic as unknown as ComponentType<P>;\n    }\n\n    // SSR path: Use React.lazy so that renderToReadableStream can suspend\n    // until the dynamically-imported component is available.\n    const LazyServer = createLazyComponent(loader);\n\n    const ServerDynamic = (props: P) => {\n      const fallback = LoadingComponent\n        ? React.createElement(LoadingComponent, createDynamicLoadingProps())\n        : null;\n      const lazyElement = React.createElement(LazyServer, props);\n      // Wrap with error boundary so loader rejections render the loading\n      // component with the error instead of propagating uncaught.\n      let content: React.ReactNode = lazyElement;\n      if (LoadingComponent) {\n        const ErrorBoundary = getDynamicErrorBoundary();\n        if (ErrorBoundary) {\n          content = React.createElement(\n            ErrorBoundary,\n            { fallback: LoadingComponent, retry: noopRetry, resetKey: 0 },\n            lazyElement,\n          );\n        }\n      }\n      return React.createElement(React.Suspense, { fallback }, content);\n    };\n\n    ServerDynamic.displayName = \"DynamicServer\";\n    return ServerDynamic;\n  }\n\n  const InitialLazyComponent = createLazyComponent(loader);\n\n  const ClientDynamic = (props: P) => {\n    const { LazyComponent, retry, retryKey } = useRetryableLazyComponent(\n      loader,\n      InitialLazyComponent,\n    );\n    const fallback = LoadingComponent\n      ? React.createElement(LoadingComponent, createDynamicLoadingProps({ retry }))\n      : null;\n    const lazyElement = React.createElement(LazyComponent, props);\n    let content: React.ReactNode = lazyElement;\n    if (LoadingComponent) {\n      const ErrorBoundary = getDynamicErrorBoundary();\n      if (ErrorBoundary) {\n        content = React.createElement(\n          ErrorBoundary,\n          { fallback: LoadingComponent, retry, resetKey: retryKey },\n          lazyElement,\n        );\n      }\n    }\n    return React.createElement(React.Suspense, { fallback }, content);\n  };\n\n  ClientDynamic.displayName = \"DynamicClient\";\n  return ClientDynamic;\n}\n\nexport default dynamic;\n"],"mappings":"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"}

package/dist/shims/error-boundary.d.ts

@@ -8,17 +8,37 @@ type ErrorBoundaryProps = {
     reset: () => void;
   }>;
   children: React.ReactNode;
+  resetKey?: string | null;
 };
 type CapturedError = {
   thrownValue: unknown;
 };
+type RedirectBoundaryState = {
+  redirect: string | null;
+  redirectType: "push" | "replace" | null;
+};
 type ErrorBoundaryInnerProps = {
   pathname: string;
 } & ErrorBoundaryProps;
 type ErrorBoundaryState = {
   error: CapturedError | null;
   previousPathname: string;
+  previousResetKey: string | null;
 };
+declare class RedirectErrorBoundary extends React.Component<{
+  children?: React.ReactNode;
+}, RedirectBoundaryState> {
+  constructor(props: {
+    children?: React.ReactNode;
+  });
+  static getDerivedStateFromError(error: unknown): RedirectBoundaryState;
+  render(): string | number | bigint | boolean | _$react_jsx_runtime0.JSX.Element | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | null | undefined;
+}
+declare function RedirectBoundary({
+  children
+}: {
+  children?: React.ReactNode;
+}): _$react_jsx_runtime0.JSX.Element;
 /**
  * Generic ErrorBoundary used to wrap route segments with error.tsx.
  * This must be a client component since error boundaries use
@@ -33,23 +53,27 @@ declare class ErrorBoundaryInner extends React.Component<ErrorBoundaryInnerProps
 }
 declare function ErrorBoundary({
   fallback,
-  children
+  children,
+  resetKey
 }: ErrorBoundaryProps): _$react_jsx_runtime0.JSX.Element;
 type NotFoundBoundaryProps = {
   fallback: React.ReactNode;
   children: React.ReactNode;
+  resetKey?: string | null;
 };
 /**
  * Wrapper that reads the current pathname and passes it to the inner class
- * component. This enables automatic reset on client-side navigation.
+ * component. Segment reset keys own App Router remount semantics when present.
  */
 declare function NotFoundBoundary({
   fallback,
-  children
+  children,
+  resetKey
 }: NotFoundBoundaryProps): _$react_jsx_runtime0.JSX.Element;
 type ForbiddenBoundaryProps = {
   fallback: React.ReactNode;
   children: React.ReactNode;
+  resetKey?: string | null;
 };
 type ForbiddenBoundaryInnerProps = {
   pathname: string;
@@ -57,6 +81,7 @@ type ForbiddenBoundaryInnerProps = {
 type ForbiddenBoundaryState = {
   forbidden: boolean;
   previousPathname: string;
+  previousResetKey: string | null;
 };
 declare class ForbiddenBoundaryInner extends React.Component<ForbiddenBoundaryInnerProps, ForbiddenBoundaryState> {
   constructor(props: ForbiddenBoundaryInnerProps);
@@ -66,11 +91,13 @@ declare class ForbiddenBoundaryInner extends React.Component<ForbiddenBoundaryIn
 }
 declare function ForbiddenBoundary({
   fallback,
-  children
+  children,
+  resetKey
 }: ForbiddenBoundaryProps): _$react_jsx_runtime0.JSX.Element;
 type UnauthorizedBoundaryProps = {
   fallback: React.ReactNode;
   children: React.ReactNode;
+  resetKey?: string | null;
 };
 type UnauthorizedBoundaryInnerProps = {
   pathname: string;
@@ -78,6 +105,7 @@ type UnauthorizedBoundaryInnerProps = {
 type UnauthorizedBoundaryState = {
   unauthorized: boolean;
   previousPathname: string;
+  previousResetKey: string | null;
 };
 declare class UnauthorizedBoundaryInner extends React.Component<UnauthorizedBoundaryInnerProps, UnauthorizedBoundaryState> {
   constructor(props: UnauthorizedBoundaryInnerProps);
@@ -87,7 +115,8 @@ declare class UnauthorizedBoundaryInner extends React.Component<UnauthorizedBoun
 }
 declare function UnauthorizedBoundary({
   fallback,
-  children
+  children,
+  resetKey
 }: UnauthorizedBoundaryProps): _$react_jsx_runtime0.JSX.Element;
 type DevRecoveryBoundaryProps = {
   resetKey: number;
@@ -106,5 +135,5 @@ declare class DevRecoveryBoundary extends React.Component<DevRecoveryBoundaryPro
   render(): React.ReactNode;
 }
 //#endregion
-export { DevRecoveryBoundary, DevRecoveryBoundaryProps, ErrorBoundary, ErrorBoundaryInner, ErrorBoundaryProps, ErrorBoundaryState, ForbiddenBoundary, ForbiddenBoundaryInner, NotFoundBoundary, UnauthorizedBoundary, UnauthorizedBoundaryInner };
+export { DevRecoveryBoundary, DevRecoveryBoundaryProps, ErrorBoundary, ErrorBoundaryInner, ErrorBoundaryProps, ErrorBoundaryState, ForbiddenBoundary, ForbiddenBoundaryInner, NotFoundBoundary, RedirectBoundary, RedirectErrorBoundary, UnauthorizedBoundary, UnauthorizedBoundaryInner };
 //# sourceMappingURL=error-boundary.d.ts.map

package/dist/shims/error-boundary.js

@@ -1,8 +1,91 @@
 "use client";
-import { usePathname } from "./navigation.js";
+import { usePathname, useRouter } from "./navigation.js";
+import { getErrorDigest, isNavigationSignalError } from "../utils/navigation-signal.js";
 import React from "react";
 import { jsx } from "react/jsx-runtime";
 //#region src/shims/error-boundary.tsx
+function normalizeBoundaryResetKey(resetKey) {
+	return resetKey === void 0 || resetKey === null || resetKey === "" ? null : resetKey;
+}
+function readBoundaryResetState(props) {
+	return {
+		previousPathname: props.pathname,
+		previousResetKey: normalizeBoundaryResetKey(props.resetKey)
+	};
+}
+function shouldResetBoundary(nextResetState, previousResetState) {
+	const nextResetKey = normalizeBoundaryResetKey(nextResetState.previousResetKey);
+	const previousResetKey = normalizeBoundaryResetKey(previousResetState.previousResetKey);
+	if (nextResetKey !== null || previousResetKey !== null) return nextResetKey !== previousResetKey;
+	return nextResetState.previousPathname !== previousResetState.previousPathname;
+}
+function isRedirectError(error) {
+	return getErrorDigest(error)?.startsWith("NEXT_REDIRECT;") ?? false;
+}
+function decodeRedirectTarget(target) {
+	try {
+		return decodeURIComponent(target);
+	} catch {
+		return target;
+	}
+}
+function getURLFromRedirectError(error) {
+	const parts = error.digest.split(";");
+	const encodedTarget = parts.length >= 5 ? parts.slice(2, -2).join(";") : parts[2];
+	return encodedTarget ? decodeRedirectTarget(encodedTarget) : null;
+}
+function getRedirectTypeFromError(error) {
+	return error.digest.split(";", 2)[1] === "push" ? "push" : "replace";
+}
+function HandleRedirect({ redirect, redirectType }) {
+	const router = useRouter();
+	React.useEffect(() => {
+		React.startTransition(() => {
+			if (redirectType === "push") router.push(redirect);
+			else router.replace(redirect);
+		});
+	}, [
+		redirect,
+		redirectType,
+		router
+	]);
+	return null;
+}
+var RedirectErrorBoundary = class extends React.Component {
+	constructor(props) {
+		super(props);
+		this.state = {
+			redirect: null,
+			redirectType: null
+		};
+	}
+	static getDerivedStateFromError(error) {
+		if (isRedirectError(error)) {
+			if (error.handled) return {
+				redirect: null,
+				redirectType: null
+			};
+			const url = getURLFromRedirectError(error);
+			if (url === null) throw error;
+			return {
+				redirect: url,
+				redirectType: getRedirectTypeFromError(error)
+			};
+		}
+		throw error;
+	}
+	render() {
+		const { redirect, redirectType } = this.state;
+		if (redirect !== null && redirectType !== null) return /* @__PURE__ */ jsx(HandleRedirect, {
+			redirect,
+			redirectType
+		});
+		return this.props.children;
+	}
+};
+function RedirectBoundary({ children }) {
+	return /* @__PURE__ */ jsx(RedirectErrorBoundary, { children });
+}
 /**
 * Generic ErrorBoundary used to wrap route segments with error.tsx.
 * This must be a client component since error boundaries use
@@ -13,24 +96,22 @@ var ErrorBoundaryInner = class extends React.Component {
 		super(props);
 		this.state = {
 			error: null,
-			previousPathname: props.pathname
+			...readBoundaryResetState(props)
 		};
 	}
 	static getDerivedStateFromProps(props, state) {
-		if (props.pathname !== state.previousPathname && state.error) return {
+		const nextResetState = readBoundaryResetState(props);
+		if (state.error && shouldResetBoundary(nextResetState, state)) return {
 			error: null,
-			previousPathname: props.pathname
+			...nextResetState
 		};
 		return {
 			error: state.error,
-			previousPathname: props.pathname
+			...nextResetState
 		};
 	}
 	static getDerivedStateFromError(error) {
-		if (error && typeof error === "object" && "digest" in error) {
-			const digest = String(error.digest);
-			if (digest === "NEXT_NOT_FOUND" || digest.startsWith("NEXT_HTTP_ERROR_FALLBACK;") || digest.startsWith("NEXT_REDIRECT;")) throw error;
-		}
+		if (isNavigationSignalError(error)) throw error;
 		return { error: { thrownValue: error } };
 	}
 	reset = () => {
@@ -47,17 +128,18 @@ var ErrorBoundaryInner = class extends React.Component {
 		return this.props.children;
 	}
 };
-function ErrorBoundary({ fallback, children }) {
+function ErrorBoundary({ fallback, children, resetKey }) {
 	return /* @__PURE__ */ jsx(ErrorBoundaryInner, {
 		pathname: usePathname(),
+		resetKey,
 		fallback,
 		children
 	});
 }
 /**
 * Inner class component that catches notFound() errors and renders the
-* not-found.tsx fallback. Resets when the pathname changes (client navigation)
-* so a previous notFound() doesn't permanently stick.
+* not-found.tsx fallback. Resets on the caller's segment reset key when one is
+* provided, otherwise falls back to pathname changes for legacy callers.
 *
 * The ErrorBoundary above re-throws notFound errors so they propagate up to this
 * boundary. This must be placed above the ErrorBoundary in the component tree.
@@ -67,17 +149,18 @@ var NotFoundBoundaryInner = class extends React.Component {
 		super(props);
 		this.state = {
 			notFound: false,
-			previousPathname: props.pathname
+			...readBoundaryResetState(props)
 		};
 	}
 	static getDerivedStateFromProps(props, state) {
-		if (props.pathname !== state.previousPathname && state.notFound) return {
+		const nextResetState = readBoundaryResetState(props);
+		if (state.notFound && shouldResetBoundary(nextResetState, state)) return {
 			notFound: false,
-			previousPathname: props.pathname
+			...nextResetState
 		};
 		return {
 			notFound: state.notFound,
-			previousPathname: props.pathname
+			...nextResetState
 		};
 	}
 	static getDerivedStateFromError(error) {
@@ -94,11 +177,12 @@ var NotFoundBoundaryInner = class extends React.Component {
 };
 /**
 * Wrapper that reads the current pathname and passes it to the inner class
-* component. This enables automatic reset on client-side navigation.
+* component. Segment reset keys own App Router remount semantics when present.
 */
-function NotFoundBoundary({ fallback, children }) {
+function NotFoundBoundary({ fallback, children, resetKey }) {
 	return /* @__PURE__ */ jsx(NotFoundBoundaryInner, {
 		pathname: usePathname(),
+		resetKey,
 		fallback,
 		children
 	});
@@ -108,17 +192,18 @@ var ForbiddenBoundaryInner = class extends React.Component {
 		super(props);
 		this.state = {
 			forbidden: false,
-			previousPathname: props.pathname
+			...readBoundaryResetState(props)
 		};
 	}
 	static getDerivedStateFromProps(props, state) {
-		if (props.pathname !== state.previousPathname && state.forbidden) return {
+		const nextResetState = readBoundaryResetState(props);
+		if (state.forbidden && shouldResetBoundary(nextResetState, state)) return {
 			forbidden: false,
-			previousPathname: props.pathname
+			...nextResetState
 		};
 		return {
 			forbidden: state.forbidden,
-			previousPathname: props.pathname
+			...nextResetState
 		};
 	}
 	static getDerivedStateFromError(error) {
@@ -132,9 +217,10 @@ var ForbiddenBoundaryInner = class extends React.Component {
 		return this.props.children;
 	}
 };
-function ForbiddenBoundary({ fallback, children }) {
+function ForbiddenBoundary({ fallback, children, resetKey }) {
 	return /* @__PURE__ */ jsx(ForbiddenBoundaryInner, {
 		pathname: usePathname(),
+		resetKey,
 		fallback,
 		children
 	});
@@ -144,17 +230,18 @@ var UnauthorizedBoundaryInner = class extends React.Component {
 		super(props);
 		this.state = {
 			unauthorized: false,
-			previousPathname: props.pathname
+			...readBoundaryResetState(props)
 		};
 	}
 	static getDerivedStateFromProps(props, state) {
-		if (props.pathname !== state.previousPathname && state.unauthorized) return {
+		const nextResetState = readBoundaryResetState(props);
+		if (state.unauthorized && shouldResetBoundary(nextResetState, state)) return {
 			unauthorized: false,
-			previousPathname: props.pathname
+			...nextResetState
 		};
 		return {
 			unauthorized: state.unauthorized,
-			previousPathname: props.pathname
+			...nextResetState
 		};
 	}
 	static getDerivedStateFromError(error) {
@@ -168,9 +255,10 @@ var UnauthorizedBoundaryInner = class extends React.Component {
 		return this.props.children;
 	}
 };
-function UnauthorizedBoundary({ fallback, children }) {
+function UnauthorizedBoundary({ fallback, children, resetKey }) {
 	return /* @__PURE__ */ jsx(UnauthorizedBoundaryInner, {
 		pathname: usePathname(),
+		resetKey,
 		fallback,
 		children
 	});
@@ -191,10 +279,7 @@ var DevRecoveryBoundary = class extends React.Component {
 		};
 	}
 	static getDerivedStateFromError(error) {
-		if (error && typeof error === "object" && "digest" in error) {
-			const digest = String(error.digest);
-			if (digest === "NEXT_NOT_FOUND" || digest.startsWith("NEXT_HTTP_ERROR_FALLBACK;") || digest.startsWith("NEXT_REDIRECT;")) throw error;
-		}
+		if (isNavigationSignalError(error)) throw error;
 		return { error: { thrownValue: error } };
 	}
 	componentDidCatch() {
@@ -206,6 +291,6 @@ var DevRecoveryBoundary = class extends React.Component {
 	}
 };
 //#endregion
-export { DevRecoveryBoundary, ErrorBoundary, ErrorBoundaryInner, ForbiddenBoundary, ForbiddenBoundaryInner, NotFoundBoundary, UnauthorizedBoundary, UnauthorizedBoundaryInner };
+export { DevRecoveryBoundary, ErrorBoundary, ErrorBoundaryInner, ForbiddenBoundary, ForbiddenBoundaryInner, NotFoundBoundary, RedirectBoundary, RedirectErrorBoundary, UnauthorizedBoundary, UnauthorizedBoundaryInner };
 
 //# sourceMappingURL=error-boundary.js.map

package/dist/shims/error-boundary.js.map

@@ -1 +1 @@
-{"version":3,"file":"error-boundary.js","names":[],"sources":["../../src/shims/error-boundary.tsx"],"sourcesContent":["\"use client\";\n\nimport React from \"react\";\n// Import the local shim, not the public next/navigation alias. The built\n// package may execute this file before the plugin's resolveId hook is active.\nimport { usePathname } from \"./navigation.js\";\n\nexport type ErrorBoundaryProps = {\n  fallback: React.ComponentType<{ error: unknown; reset: () => void }>;\n  children: React.ReactNode;\n};\n\ntype CapturedError = {\n  thrownValue: unknown;\n};\n\ntype ErrorBoundaryInnerProps = {\n  pathname: string;\n} & ErrorBoundaryProps;\n\nexport type ErrorBoundaryState = {\n  error: CapturedError | null;\n  previousPathname: string;\n};\n\n/**\n * Generic ErrorBoundary used to wrap route segments with error.tsx.\n * This must be a client component since error boundaries use\n * componentDidCatch / getDerivedStateFromError.\n */\nexport class ErrorBoundaryInner extends React.Component<\n  ErrorBoundaryInnerProps,\n  ErrorBoundaryState\n> {\n  constructor(props: ErrorBoundaryInnerProps) {\n    super(props);\n    this.state = { error: null, previousPathname: props.pathname };\n  }\n\n  static getDerivedStateFromProps(\n    props: ErrorBoundaryInnerProps,\n    state: ErrorBoundaryState,\n  ): ErrorBoundaryState | null {\n    if (props.pathname !== state.previousPathname && state.error) {\n      return { error: null, previousPathname: props.pathname };\n    }\n    return { error: state.error, previousPathname: props.pathname };\n  }\n\n  static getDerivedStateFromError(error: unknown): Partial<ErrorBoundaryState> {\n    // notFound(), forbidden(), unauthorized(), and redirect() must propagate\n    // past error boundaries. Re-throw them so they bubble up to the\n    // framework's HTTP access fallback / redirect handler.\n    if (error && typeof error === \"object\" && \"digest\" in error) {\n      const digest = String(error.digest);\n      if (\n        digest === \"NEXT_NOT_FOUND\" || // legacy compat\n        digest.startsWith(\"NEXT_HTTP_ERROR_FALLBACK;\") ||\n        digest.startsWith(\"NEXT_REDIRECT;\")\n      ) {\n        throw error;\n      }\n    }\n    return { error: { thrownValue: error } };\n  }\n\n  reset = () => {\n    this.setState({ error: null });\n  };\n\n  render() {\n    if (this.state.error) {\n      const FallbackComponent = this.props.fallback;\n      return <FallbackComponent error={this.state.error.thrownValue} reset={this.reset} />;\n    }\n    return this.props.children;\n  }\n}\n\nexport function ErrorBoundary({ fallback, children }: ErrorBoundaryProps) {\n  const pathname = usePathname();\n  return (\n    <ErrorBoundaryInner pathname={pathname} fallback={fallback}>\n      {children}\n    </ErrorBoundaryInner>\n  );\n}\n\n// ---------------------------------------------------------------------------\n// NotFoundBoundary — catches notFound() on the client and renders not-found.tsx\n// ---------------------------------------------------------------------------\n\ntype NotFoundBoundaryProps = {\n  fallback: React.ReactNode;\n  children: React.ReactNode;\n};\n\ntype NotFoundBoundaryInnerProps = {\n  pathname: string;\n} & NotFoundBoundaryProps;\n\ntype NotFoundBoundaryState = {\n  notFound: boolean;\n  previousPathname: string;\n};\n\n/**\n * Inner class component that catches notFound() errors and renders the\n * not-found.tsx fallback. Resets when the pathname changes (client navigation)\n * so a previous notFound() doesn't permanently stick.\n *\n * The ErrorBoundary above re-throws notFound errors so they propagate up to this\n * boundary. This must be placed above the ErrorBoundary in the component tree.\n */\nclass NotFoundBoundaryInner extends React.Component<\n  NotFoundBoundaryInnerProps,\n  NotFoundBoundaryState\n> {\n  constructor(props: NotFoundBoundaryInnerProps) {\n    super(props);\n    this.state = { notFound: false, previousPathname: props.pathname };\n  }\n\n  static getDerivedStateFromProps(\n    props: NotFoundBoundaryInnerProps,\n    state: NotFoundBoundaryState,\n  ): NotFoundBoundaryState | null {\n    // Reset the boundary when the route changes so a previous notFound()\n    // doesn't permanently stick after client-side navigation.\n    if (props.pathname !== state.previousPathname && state.notFound) {\n      return { notFound: false, previousPathname: props.pathname };\n    }\n    return { notFound: state.notFound, previousPathname: props.pathname };\n  }\n\n  static getDerivedStateFromError(error: unknown): Partial<NotFoundBoundaryState> {\n    if (error && typeof error === \"object\" && \"digest\" in error) {\n      const digest = String(error.digest);\n      if (digest === \"NEXT_NOT_FOUND\" || digest === \"NEXT_HTTP_ERROR_FALLBACK;404\") {\n        return { notFound: true };\n      }\n    }\n    // Not a notFound error — re-throw so it reaches an ErrorBoundary or propagates\n    throw error;\n  }\n\n  render() {\n    if (this.state.notFound) {\n      return this.props.fallback;\n    }\n    return this.props.children;\n  }\n}\n\n/**\n * Wrapper that reads the current pathname and passes it to the inner class\n * component. This enables automatic reset on client-side navigation.\n */\nexport function NotFoundBoundary({ fallback, children }: NotFoundBoundaryProps) {\n  const pathname = usePathname();\n  return (\n    <NotFoundBoundaryInner pathname={pathname} fallback={fallback}>\n      {children}\n    </NotFoundBoundaryInner>\n  );\n}\n\n// ---------------------------------------------------------------------------\n// ForbiddenBoundary — catches forbidden() on the client and renders forbidden.tsx\n// ---------------------------------------------------------------------------\n\ntype ForbiddenBoundaryProps = {\n  fallback: React.ReactNode;\n  children: React.ReactNode;\n};\n\ntype ForbiddenBoundaryInnerProps = {\n  pathname: string;\n} & ForbiddenBoundaryProps;\n\ntype ForbiddenBoundaryState = {\n  forbidden: boolean;\n  previousPathname: string;\n};\n\nexport class ForbiddenBoundaryInner extends React.Component<\n  ForbiddenBoundaryInnerProps,\n  ForbiddenBoundaryState\n> {\n  constructor(props: ForbiddenBoundaryInnerProps) {\n    super(props);\n    this.state = { forbidden: false, previousPathname: props.pathname };\n  }\n\n  static getDerivedStateFromProps(\n    props: ForbiddenBoundaryInnerProps,\n    state: ForbiddenBoundaryState,\n  ): ForbiddenBoundaryState | null {\n    if (props.pathname !== state.previousPathname && state.forbidden) {\n      return { forbidden: false, previousPathname: props.pathname };\n    }\n    return { forbidden: state.forbidden, previousPathname: props.pathname };\n  }\n\n  static getDerivedStateFromError(error: unknown): Partial<ForbiddenBoundaryState> {\n    if (error && typeof error === \"object\" && \"digest\" in error) {\n      const digest = String(error.digest);\n      if (digest === \"NEXT_HTTP_ERROR_FALLBACK;403\") {\n        return { forbidden: true };\n      }\n    }\n    throw error;\n  }\n\n  render() {\n    if (this.state.forbidden) {\n      return this.props.fallback;\n    }\n    return this.props.children;\n  }\n}\n\nexport function ForbiddenBoundary({ fallback, children }: ForbiddenBoundaryProps) {\n  const pathname = usePathname();\n  return (\n    <ForbiddenBoundaryInner pathname={pathname} fallback={fallback}>\n      {children}\n    </ForbiddenBoundaryInner>\n  );\n}\n\n// ---------------------------------------------------------------------------\n// UnauthorizedBoundary — catches unauthorized() on the client and renders unauthorized.tsx\n// ---------------------------------------------------------------------------\n\ntype UnauthorizedBoundaryProps = {\n  fallback: React.ReactNode;\n  children: React.ReactNode;\n};\n\ntype UnauthorizedBoundaryInnerProps = {\n  pathname: string;\n} & UnauthorizedBoundaryProps;\n\ntype UnauthorizedBoundaryState = {\n  unauthorized: boolean;\n  previousPathname: string;\n};\n\nexport class UnauthorizedBoundaryInner extends React.Component<\n  UnauthorizedBoundaryInnerProps,\n  UnauthorizedBoundaryState\n> {\n  constructor(props: UnauthorizedBoundaryInnerProps) {\n    super(props);\n    this.state = { unauthorized: false, previousPathname: props.pathname };\n  }\n\n  static getDerivedStateFromProps(\n    props: UnauthorizedBoundaryInnerProps,\n    state: UnauthorizedBoundaryState,\n  ): UnauthorizedBoundaryState | null {\n    if (props.pathname !== state.previousPathname && state.unauthorized) {\n      return { unauthorized: false, previousPathname: props.pathname };\n    }\n    return { unauthorized: state.unauthorized, previousPathname: props.pathname };\n  }\n\n  static getDerivedStateFromError(error: unknown): Partial<UnauthorizedBoundaryState> {\n    if (error && typeof error === \"object\" && \"digest\" in error) {\n      const digest = String(error.digest);\n      if (digest === \"NEXT_HTTP_ERROR_FALLBACK;401\") {\n        return { unauthorized: true };\n      }\n    }\n    throw error;\n  }\n\n  render() {\n    if (this.state.unauthorized) {\n      return this.props.fallback;\n    }\n    return this.props.children;\n  }\n}\n\nexport function UnauthorizedBoundary({ fallback, children }: UnauthorizedBoundaryProps) {\n  const pathname = usePathname();\n  return (\n    <UnauthorizedBoundaryInner pathname={pathname} fallback={fallback}>\n      {children}\n    </UnauthorizedBoundaryInner>\n  );\n}\n\n// ---------------------------------------------------------------------------\n// DevRecoveryBoundary — dev-only top-level boundary inside BrowserRoot.\n// Catches any render error that isn't already handled by a user-defined\n// error.tsx (or the access-fallback boundaries above), renders nothing, and\n// keeps BrowserRoot mounted so HMR can dispatch a new RSC payload without a\n// full page reload. Resets on resetKey change — the caller bumps that key\n// (e.g. via treeState.renderId) when a fresh tree is dispatched.\n//\n// Routing sentinels are re-thrown so notFound()/redirect()/forbidden()/\n// unauthorized() still reach their dedicated boundaries above.\n// ---------------------------------------------------------------------------\n\nexport type DevRecoveryBoundaryProps = {\n  resetKey: number;\n  // Called from componentDidCatch with the current resetKey so the host can\n  // run any pending side effects that NavigationCommitSignal would normally\n  // drive on commit — most importantly the URL update for the in-flight\n  // soft-nav. Without this, a navigation that fails mid-render leaves the\n  // browser on the previous URL even though the boundary recovered.\n  //\n  // The error itself is intentionally not passed: React's onCaughtError option\n  // already routes the error to the dev overlay, so this callback is only for\n  // commit-side effects keyed by resetKey.\n  onCatch?: (resetKey: number) => void;\n  // Children come through React.Component's PropsWithChildren default; declared\n  // optional so callers can pass them positionally to createElement without\n  // tripping the eslint no-children-prop rule.\n  children?: React.ReactNode;\n};\n\ntype DevRecoveryBoundaryState = {\n  error: CapturedError | null;\n  previousResetKey: number;\n};\n\nexport class DevRecoveryBoundary extends React.Component<\n  DevRecoveryBoundaryProps,\n  DevRecoveryBoundaryState\n> {\n  constructor(props: DevRecoveryBoundaryProps) {\n    super(props);\n    this.state = { error: null, previousResetKey: props.resetKey };\n  }\n\n  static getDerivedStateFromProps(\n    props: DevRecoveryBoundaryProps,\n    state: DevRecoveryBoundaryState,\n  ): DevRecoveryBoundaryState | null {\n    if (props.resetKey === state.previousResetKey) {\n      return null;\n    }\n    return { error: null, previousResetKey: props.resetKey };\n  }\n\n  static getDerivedStateFromError(error: unknown): Partial<DevRecoveryBoundaryState> {\n    if (error && typeof error === \"object\" && \"digest\" in error) {\n      const digest = String(error.digest);\n      if (\n        digest === \"NEXT_NOT_FOUND\" ||\n        digest.startsWith(\"NEXT_HTTP_ERROR_FALLBACK;\") ||\n        digest.startsWith(\"NEXT_REDIRECT;\")\n      ) {\n        throw error;\n      }\n    }\n    return { error: { thrownValue: error } };\n  }\n\n  componentDidCatch(): void {\n    this.props.onCatch?.(this.props.resetKey);\n  }\n\n  render() {\n    if (this.state.error) {\n      // Render nothing — the dev overlay (mounted in a separate React root)\n      // shows the actual error to the developer. HMR pushing a new payload\n      // bumps resetKey above, clearing this state and letting the children\n      // re-render with the fixed code.\n      return null;\n    }\n    return this.props.children;\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"error-boundary.js","names":[],"sources":["../../src/shims/error-boundary.tsx"],"sourcesContent":["\"use client\";\n\nimport React from \"react\";\n// Import the local shim, not the public next/navigation alias. The built\n// package may execute this file before the plugin's resolveId hook is active.\nimport { usePathname, useRouter } from \"./navigation.js\";\nimport { getErrorDigest, isNavigationSignalError } from \"../utils/navigation-signal.js\";\n\nexport type ErrorBoundaryProps = {\n  fallback: React.ComponentType<{ error: unknown; reset: () => void }>;\n  children: React.ReactNode;\n  resetKey?: string | null;\n};\n\ntype CapturedError = {\n  thrownValue: unknown;\n};\n\ntype RedirectBoundaryState = {\n  redirect: string | null;\n  redirectType: \"push\" | \"replace\" | null;\n};\n\ntype RedirectError = Error & {\n  digest: string;\n  handled?: boolean;\n};\n\ntype ErrorBoundaryInnerProps = {\n  pathname: string;\n} & ErrorBoundaryProps;\n\nexport type ErrorBoundaryState = {\n  error: CapturedError | null;\n  previousPathname: string;\n  previousResetKey: string | null;\n};\n\ntype BoundaryResetProps = {\n  pathname: string;\n  resetKey?: string | null;\n};\n\ntype BoundaryResetState = {\n  previousPathname: string;\n  previousResetKey: string | null;\n};\n\nfunction normalizeBoundaryResetKey(resetKey: string | null | undefined): string | null {\n  return resetKey === undefined || resetKey === null || resetKey === \"\" ? null : resetKey;\n}\n\nfunction readBoundaryResetState(props: BoundaryResetProps): BoundaryResetState {\n  return {\n    previousPathname: props.pathname,\n    previousResetKey: normalizeBoundaryResetKey(props.resetKey),\n  };\n}\n\nfunction shouldResetBoundary(\n  nextResetState: BoundaryResetState,\n  previousResetState: BoundaryResetState,\n): boolean {\n  const nextResetKey = normalizeBoundaryResetKey(nextResetState.previousResetKey);\n  const previousResetKey = normalizeBoundaryResetKey(previousResetState.previousResetKey);\n\n  if (nextResetKey !== null || previousResetKey !== null) {\n    return nextResetKey !== previousResetKey;\n  }\n\n  return nextResetState.previousPathname !== previousResetState.previousPathname;\n}\n\nfunction isRedirectError(error: unknown): error is RedirectError {\n  return getErrorDigest(error)?.startsWith(\"NEXT_REDIRECT;\") ?? false;\n}\n\nfunction decodeRedirectTarget(target: string): string {\n  try {\n    return decodeURIComponent(target);\n  } catch {\n    return target;\n  }\n}\n\nfunction getURLFromRedirectError(error: RedirectError): string | null {\n  const parts = error.digest.split(\";\");\n  // vinext emits 3-part (redirect: `NEXT_REDIRECT;;<encoded>`) or 4-part\n  // (permanentRedirect: `NEXT_REDIRECT;<type>;<encoded>;308`) digests;\n  // Next.js emits 5-part digests (`NEXT_REDIRECT;<type>;<url>;<status>;<isClient>`).\n  // vinext's `isRedirectError` is more permissive (just `startsWith(\"NEXT_REDIRECT;\")`)\n  // so we branch on length rather than always using `slice(2, -2)`.\n  const encodedTarget = parts.length >= 5 ? parts.slice(2, -2).join(\";\") : parts[2];\n  return encodedTarget ? decodeRedirectTarget(encodedTarget) : null;\n}\n\nfunction getRedirectTypeFromError(error: RedirectError): \"push\" | \"replace\" {\n  const type = error.digest.split(\";\", 2)[1];\n  return type === \"push\" ? \"push\" : \"replace\";\n}\n\nfunction HandleRedirect({\n  redirect,\n  redirectType,\n}: {\n  redirect: string;\n  redirectType: \"push\" | \"replace\";\n}) {\n  const router = useRouter();\n\n  React.useEffect(() => {\n    React.startTransition(() => {\n      if (redirectType === \"push\") {\n        router.push(redirect);\n      } else {\n        router.replace(redirect);\n      }\n      // Intentionally no reset() here. The boundary stays in its \"redirect\n      // caught\" state (rendering this component, which returns null) until\n      // router.push()/replace() triggers a new render at the destination\n      // route. That naturally unmounts this boundary and mounts a fresh one.\n      // Calling reset() would clear the boundary state, causing React to\n      // re-render children — which re-mounts the page component that threw\n      // redirect() in the first place. For deterministic redirects (e.g.\n      // auth guards), that creates an infinite redirect loop.\n      // Matches Next.js's HandleRedirect in redirect-boundary.tsx.\n    });\n  }, [redirect, redirectType, router]);\n\n  return null;\n}\n\nexport class RedirectErrorBoundary extends React.Component<\n  { children?: React.ReactNode },\n  RedirectBoundaryState\n> {\n  constructor(props: { children?: React.ReactNode }) {\n    super(props);\n    this.state = {\n      redirect: null,\n      redirectType: null,\n    };\n  }\n\n  static getDerivedStateFromError(error: unknown): RedirectBoundaryState {\n    if (isRedirectError(error)) {\n      // Next.js parity: an outer RedirectBoundary that has already started\n      // handling a redirect marks the error as `handled` so that, if React\n      // re-throws the same error during a retry render, an inner boundary\n      // doesn't re-dispatch the same `router.replace()`. Vinext doesn't\n      // currently emit `handled` itself (we never assign it on the error\n      // object), but we keep the branch so behavior matches Next.js if a\n      // host or future change ever does.\n      if (error.handled) {\n        return {\n          redirect: null,\n          redirectType: null,\n        };\n      }\n\n      const url = getURLFromRedirectError(error);\n      if (url === null) {\n        // Malformed digest (e.g. `NEXT_REDIRECT;push;` with an empty URL\n        // segment). The server-side parser at next-error-digest.ts:51 also\n        // rejects this. Re-throw so the error reaches a regular error\n        // boundary instead of being silently swallowed.\n        throw error;\n      }\n\n      return {\n        redirect: url,\n        redirectType: getRedirectTypeFromError(error),\n      };\n    }\n\n    throw error;\n  }\n\n  render() {\n    const { redirect, redirectType } = this.state;\n    if (redirect !== null && redirectType !== null) {\n      return <HandleRedirect redirect={redirect} redirectType={redirectType} />;\n    }\n\n    return this.props.children;\n  }\n}\n\nexport function RedirectBoundary({ children }: { children?: React.ReactNode }) {\n  return <RedirectErrorBoundary>{children}</RedirectErrorBoundary>;\n}\n\n/**\n * Generic ErrorBoundary used to wrap route segments with error.tsx.\n * This must be a client component since error boundaries use\n * componentDidCatch / getDerivedStateFromError.\n */\nexport class ErrorBoundaryInner extends React.Component<\n  ErrorBoundaryInnerProps,\n  ErrorBoundaryState\n> {\n  constructor(props: ErrorBoundaryInnerProps) {\n    super(props);\n    this.state = { error: null, ...readBoundaryResetState(props) };\n  }\n\n  static getDerivedStateFromProps(\n    props: ErrorBoundaryInnerProps,\n    state: ErrorBoundaryState,\n  ): ErrorBoundaryState | null {\n    const nextResetState = readBoundaryResetState(props);\n    if (state.error && shouldResetBoundary(nextResetState, state)) {\n      return { error: null, ...nextResetState };\n    }\n    return { error: state.error, ...nextResetState };\n  }\n\n  static getDerivedStateFromError(error: unknown): Partial<ErrorBoundaryState> {\n    // notFound(), forbidden(), unauthorized(), and redirect() must propagate\n    // past error boundaries. Re-throw them so they bubble up to the\n    // framework's HTTP access fallback / redirect handler.\n    if (isNavigationSignalError(error)) {\n      throw error;\n    }\n    return { error: { thrownValue: error } };\n  }\n\n  reset = () => {\n    this.setState({ error: null });\n  };\n\n  render() {\n    if (this.state.error) {\n      const FallbackComponent = this.props.fallback;\n      return <FallbackComponent error={this.state.error.thrownValue} reset={this.reset} />;\n    }\n    return this.props.children;\n  }\n}\n\nexport function ErrorBoundary({ fallback, children, resetKey }: ErrorBoundaryProps) {\n  const pathname = usePathname();\n  return (\n    <ErrorBoundaryInner pathname={pathname} resetKey={resetKey} fallback={fallback}>\n      {children}\n    </ErrorBoundaryInner>\n  );\n}\n\n// ---------------------------------------------------------------------------\n// NotFoundBoundary — catches notFound() on the client and renders not-found.tsx\n// ---------------------------------------------------------------------------\n\ntype NotFoundBoundaryProps = {\n  fallback: React.ReactNode;\n  children: React.ReactNode;\n  resetKey?: string | null;\n};\n\ntype NotFoundBoundaryInnerProps = {\n  pathname: string;\n} & NotFoundBoundaryProps;\n\ntype NotFoundBoundaryState = {\n  notFound: boolean;\n  previousPathname: string;\n  previousResetKey: string | null;\n};\n\n/**\n * Inner class component that catches notFound() errors and renders the\n * not-found.tsx fallback. Resets on the caller's segment reset key when one is\n * provided, otherwise falls back to pathname changes for legacy callers.\n *\n * The ErrorBoundary above re-throws notFound errors so they propagate up to this\n * boundary. This must be placed above the ErrorBoundary in the component tree.\n */\nclass NotFoundBoundaryInner extends React.Component<\n  NotFoundBoundaryInnerProps,\n  NotFoundBoundaryState\n> {\n  constructor(props: NotFoundBoundaryInnerProps) {\n    super(props);\n    this.state = { notFound: false, ...readBoundaryResetState(props) };\n  }\n\n  static getDerivedStateFromProps(\n    props: NotFoundBoundaryInnerProps,\n    state: NotFoundBoundaryState,\n  ): NotFoundBoundaryState | null {\n    const nextResetState = readBoundaryResetState(props);\n    if (state.notFound && shouldResetBoundary(nextResetState, state)) {\n      return { notFound: false, ...nextResetState };\n    }\n    return { notFound: state.notFound, ...nextResetState };\n  }\n\n  static getDerivedStateFromError(error: unknown): Partial<NotFoundBoundaryState> {\n    if (error && typeof error === \"object\" && \"digest\" in error) {\n      const digest = String(error.digest);\n      if (digest === \"NEXT_NOT_FOUND\" || digest === \"NEXT_HTTP_ERROR_FALLBACK;404\") {\n        return { notFound: true };\n      }\n    }\n    // Not a notFound error — re-throw so it reaches an ErrorBoundary or propagates\n    throw error;\n  }\n\n  render() {\n    if (this.state.notFound) {\n      return this.props.fallback;\n    }\n    return this.props.children;\n  }\n}\n\n/**\n * Wrapper that reads the current pathname and passes it to the inner class\n * component. Segment reset keys own App Router remount semantics when present.\n */\nexport function NotFoundBoundary({ fallback, children, resetKey }: NotFoundBoundaryProps) {\n  const pathname = usePathname();\n  return (\n    <NotFoundBoundaryInner pathname={pathname} resetKey={resetKey} fallback={fallback}>\n      {children}\n    </NotFoundBoundaryInner>\n  );\n}\n\n// ---------------------------------------------------------------------------\n// ForbiddenBoundary — catches forbidden() on the client and renders forbidden.tsx\n// ---------------------------------------------------------------------------\n\ntype ForbiddenBoundaryProps = {\n  fallback: React.ReactNode;\n  children: React.ReactNode;\n  resetKey?: string | null;\n};\n\ntype ForbiddenBoundaryInnerProps = {\n  pathname: string;\n} & ForbiddenBoundaryProps;\n\ntype ForbiddenBoundaryState = {\n  forbidden: boolean;\n  previousPathname: string;\n  previousResetKey: string | null;\n};\n\nexport class ForbiddenBoundaryInner extends React.Component<\n  ForbiddenBoundaryInnerProps,\n  ForbiddenBoundaryState\n> {\n  constructor(props: ForbiddenBoundaryInnerProps) {\n    super(props);\n    this.state = { forbidden: false, ...readBoundaryResetState(props) };\n  }\n\n  static getDerivedStateFromProps(\n    props: ForbiddenBoundaryInnerProps,\n    state: ForbiddenBoundaryState,\n  ): ForbiddenBoundaryState | null {\n    const nextResetState = readBoundaryResetState(props);\n    if (state.forbidden && shouldResetBoundary(nextResetState, state)) {\n      return { forbidden: false, ...nextResetState };\n    }\n    return { forbidden: state.forbidden, ...nextResetState };\n  }\n\n  static getDerivedStateFromError(error: unknown): Partial<ForbiddenBoundaryState> {\n    if (error && typeof error === \"object\" && \"digest\" in error) {\n      const digest = String(error.digest);\n      if (digest === \"NEXT_HTTP_ERROR_FALLBACK;403\") {\n        return { forbidden: true };\n      }\n    }\n    throw error;\n  }\n\n  render() {\n    if (this.state.forbidden) {\n      return this.props.fallback;\n    }\n    return this.props.children;\n  }\n}\n\nexport function ForbiddenBoundary({ fallback, children, resetKey }: ForbiddenBoundaryProps) {\n  const pathname = usePathname();\n  return (\n    <ForbiddenBoundaryInner pathname={pathname} resetKey={resetKey} fallback={fallback}>\n      {children}\n    </ForbiddenBoundaryInner>\n  );\n}\n\n// ---------------------------------------------------------------------------\n// UnauthorizedBoundary — catches unauthorized() on the client and renders unauthorized.tsx\n// ---------------------------------------------------------------------------\n\ntype UnauthorizedBoundaryProps = {\n  fallback: React.ReactNode;\n  children: React.ReactNode;\n  resetKey?: string | null;\n};\n\ntype UnauthorizedBoundaryInnerProps = {\n  pathname: string;\n} & UnauthorizedBoundaryProps;\n\ntype UnauthorizedBoundaryState = {\n  unauthorized: boolean;\n  previousPathname: string;\n  previousResetKey: string | null;\n};\n\nexport class UnauthorizedBoundaryInner extends React.Component<\n  UnauthorizedBoundaryInnerProps,\n  UnauthorizedBoundaryState\n> {\n  constructor(props: UnauthorizedBoundaryInnerProps) {\n    super(props);\n    this.state = { unauthorized: false, ...readBoundaryResetState(props) };\n  }\n\n  static getDerivedStateFromProps(\n    props: UnauthorizedBoundaryInnerProps,\n    state: UnauthorizedBoundaryState,\n  ): UnauthorizedBoundaryState | null {\n    const nextResetState = readBoundaryResetState(props);\n    if (state.unauthorized && shouldResetBoundary(nextResetState, state)) {\n      return { unauthorized: false, ...nextResetState };\n    }\n    return { unauthorized: state.unauthorized, ...nextResetState };\n  }\n\n  static getDerivedStateFromError(error: unknown): Partial<UnauthorizedBoundaryState> {\n    if (error && typeof error === \"object\" && \"digest\" in error) {\n      const digest = String(error.digest);\n      if (digest === \"NEXT_HTTP_ERROR_FALLBACK;401\") {\n        return { unauthorized: true };\n      }\n    }\n    throw error;\n  }\n\n  render() {\n    if (this.state.unauthorized) {\n      return this.props.fallback;\n    }\n    return this.props.children;\n  }\n}\n\nexport function UnauthorizedBoundary({ fallback, children, resetKey }: UnauthorizedBoundaryProps) {\n  const pathname = usePathname();\n  return (\n    <UnauthorizedBoundaryInner pathname={pathname} resetKey={resetKey} fallback={fallback}>\n      {children}\n    </UnauthorizedBoundaryInner>\n  );\n}\n\n// ---------------------------------------------------------------------------\n// DevRecoveryBoundary — dev-only top-level boundary inside BrowserRoot.\n// Catches any render error that isn't already handled by a user-defined\n// error.tsx (or the access-fallback boundaries above), renders nothing, and\n// keeps BrowserRoot mounted so HMR can dispatch a new RSC payload without a\n// full page reload. Resets on resetKey change — the caller bumps that key\n// (e.g. via treeState.renderId) when a fresh tree is dispatched.\n//\n// Routing sentinels are re-thrown so notFound()/redirect()/forbidden()/\n// unauthorized() still reach their dedicated boundaries above.\n// ---------------------------------------------------------------------------\n\nexport type DevRecoveryBoundaryProps = {\n  resetKey: number;\n  // Called from componentDidCatch with the current resetKey so the host can\n  // run any pending side effects that NavigationCommitSignal would normally\n  // drive on commit — most importantly the URL update for the in-flight\n  // soft-nav. Without this, a navigation that fails mid-render leaves the\n  // browser on the previous URL even though the boundary recovered.\n  //\n  // The error itself is intentionally not passed: React's onCaughtError option\n  // already routes the error to the dev overlay, so this callback is only for\n  // commit-side effects keyed by resetKey.\n  onCatch?: (resetKey: number) => void;\n  // Children come through React.Component's PropsWithChildren default; declared\n  // optional so callers can pass them positionally to createElement without\n  // tripping the eslint no-children-prop rule.\n  children?: React.ReactNode;\n};\n\ntype DevRecoveryBoundaryState = {\n  error: CapturedError | null;\n  previousResetKey: number;\n};\n\nexport class DevRecoveryBoundary extends React.Component<\n  DevRecoveryBoundaryProps,\n  DevRecoveryBoundaryState\n> {\n  constructor(props: DevRecoveryBoundaryProps) {\n    super(props);\n    this.state = { error: null, previousResetKey: props.resetKey };\n  }\n\n  static getDerivedStateFromProps(\n    props: DevRecoveryBoundaryProps,\n    state: DevRecoveryBoundaryState,\n  ): DevRecoveryBoundaryState | null {\n    if (props.resetKey === state.previousResetKey) {\n      return null;\n    }\n    return { error: null, previousResetKey: props.resetKey };\n  }\n\n  static getDerivedStateFromError(error: unknown): Partial<DevRecoveryBoundaryState> {\n    // Re-throw routing sentinels so they still reach NotFoundBoundary /\n    // RedirectBoundary / Forbidden / Unauthorized above.\n    if (isNavigationSignalError(error)) {\n      throw error;\n    }\n    return { error: { thrownValue: error } };\n  }\n\n  componentDidCatch(): void {\n    this.props.onCatch?.(this.props.resetKey);\n  }\n\n  render() {\n    if (this.state.error) {\n      // Render nothing — the dev overlay (mounted in a separate React root)\n      // shows the actual error to the developer. HMR pushing a new payload\n      // bumps resetKey above, clearing this state and letting the children\n      // re-render with the fixed code.\n      return null;\n    }\n    return this.props.children;\n  }\n}\n"],"mappings":"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"}

package/dist/shims/error.js.map

@@ -1 +1 @@
-{"version":3,"file":"error.js","names":[],"sources":["../../src/shims/error.tsx"],"sourcesContent":["/**\n * next/error shim\n *\n * Provides the default Next.js error page component.\n * Used by apps that import `import Error from 'next/error'` for\n * custom error handling in getServerSideProps or API routes.\n */\nimport React from \"react\";\n\ntype ErrorProps = {\n  statusCode: number;\n  title?: string;\n  withDarkMode?: boolean;\n};\n\nfunction ErrorComponent({ statusCode, title }: ErrorProps): React.ReactElement {\n  const defaultTitle =\n    statusCode === 404 ? \"This page could not be found\" : \"Internal Server Error\";\n\n  const displayTitle = title ?? defaultTitle;\n\n  return React.createElement(\n    \"div\",\n    {\n      style: {\n        fontFamily:\n          '-apple-system, BlinkMacSystemFont, \"Segoe UI\", Roboto, \"Helvetica Neue\", Arial, sans-serif',\n        height: \"100vh\",\n        textAlign: \"center\" as const,\n        display: \"flex\",\n        flexDirection: \"column\" as const,\n        alignItems: \"center\",\n        justifyContent: \"center\",\n      },\n    },\n    React.createElement(\n      \"div\",\n      null,\n      React.createElement(\n        \"h1\",\n        {\n          style: {\n            display: \"inline-block\",\n            margin: \"0 20px 0 0\",\n            padding: \"0 23px 0 0\",\n            fontSize: 24,\n            fontWeight: 500,\n            verticalAlign: \"top\",\n            lineHeight: \"49px\",\n            borderRight: \"1px solid rgba(0, 0, 0, .3)\",\n          },\n        },\n        statusCode,\n      ),\n      React.createElement(\n        \"div\",\n        { style: { display: \"inline-block\" } },\n        React.createElement(\n          \"h2\",\n          {\n            style: {\n              fontSize: 14,\n              fontWeight: 400,\n              lineHeight: \"49px\",\n              margin: 0,\n            },\n          },\n          displayTitle + \".\",\n        ),\n      ),\n    ),\n  );\n}\n\nexport default ErrorComponent;\n"],"mappings":";;;;;;;;;AAeA,SAAS,eAAe,EAAE,YAAY,SAAyC;CAI7E,MAAM,eAAe,UAFnB,eAAe,MAAM,iCAAiC;AAIxD,QAAO,MAAM,cACX,OACA,EACE,OAAO;EACL,YACE;EACF,QAAQ;EACR,WAAW;EACX,SAAS;EACT,eAAe;EACf,YAAY;EACZ,gBAAgB;EACjB,EACF,EACD,MAAM,cACJ,OACA,MACA,MAAM,cACJ,MACA,EACE,OAAO;EACL,SAAS;EACT,QAAQ;EACR,SAAS;EACT,UAAU;EACV,YAAY;EACZ,eAAe;EACf,YAAY;EACZ,aAAa;EACd,EACF,EACD,WACD,EACD,MAAM,cACJ,OACA,EAAE,OAAO,EAAE,SAAS,gBAAgB,EAAE,EACtC,MAAM,cACJ,MACA,EACE,OAAO;EACL,UAAU;EACV,YAAY;EACZ,YAAY;EACZ,QAAQ;EACT,EACF,EACD,eAAe,IAChB,CACF,CACF,CACF"}
+{"version":3,"file":"error.js","names":[],"sources":["../../src/shims/error.tsx"],"sourcesContent":["/**\n * next/error shim\n *\n * Provides the default Next.js error page component.\n * Used by apps that import `import Error from 'next/error'` for\n * custom error handling in getServerSideProps or API routes.\n */\nimport React from \"react\";\n\ntype ErrorProps = {\n  statusCode: number;\n  title?: string;\n  withDarkMode?: boolean;\n};\n\nfunction ErrorComponent({ statusCode, title }: ErrorProps): React.ReactElement {\n  const defaultTitle =\n    statusCode === 404 ? \"This page could not be found\" : \"Internal Server Error\";\n\n  const displayTitle = title ?? defaultTitle;\n\n  return React.createElement(\n    \"div\",\n    {\n      style: {\n        fontFamily:\n          '-apple-system, BlinkMacSystemFont, \"Segoe UI\", Roboto, \"Helvetica Neue\", Arial, sans-serif',\n        height: \"100vh\",\n        textAlign: \"center\" as const,\n        display: \"flex\",\n        flexDirection: \"column\" as const,\n        alignItems: \"center\",\n        justifyContent: \"center\",\n      },\n    },\n    React.createElement(\n      \"div\",\n      null,\n      React.createElement(\n        \"h1\",\n        {\n          style: {\n            display: \"inline-block\",\n            margin: \"0 20px 0 0\",\n            padding: \"0 23px 0 0\",\n            fontSize: 24,\n            fontWeight: 500,\n            verticalAlign: \"top\",\n            lineHeight: \"49px\",\n            borderRight: \"1px solid rgba(0, 0, 0, .3)\",\n          },\n        },\n        statusCode,\n      ),\n      React.createElement(\n        \"div\",\n        { style: { display: \"inline-block\" } },\n        React.createElement(\n          \"h2\",\n          {\n            style: {\n              fontSize: 14,\n              fontWeight: 400,\n              lineHeight: \"49px\",\n              margin: 0,\n            },\n          },\n          displayTitle + \".\",\n        ),\n      ),\n    ),\n  );\n}\n\nexport default ErrorComponent;\n"],"mappings":";;;;;;;;;AAeA,SAAS,eAAe,EAAE,YAAY,SAAyC;CAI7E,MAAM,eAAe,UAFnB,eAAe,MAAM,iCAAiC;CAIxD,OAAO,MAAM,cACX,OACA,EACE,OAAO;EACL,YACE;EACF,QAAQ;EACR,WAAW;EACX,SAAS;EACT,eAAe;EACf,YAAY;EACZ,gBAAgB;EACjB,EACF,EACD,MAAM,cACJ,OACA,MACA,MAAM,cACJ,MACA,EACE,OAAO;EACL,SAAS;EACT,QAAQ;EACR,SAAS;EACT,UAAU;EACV,YAAY;EACZ,eAAe;EACf,YAAY;EACZ,aAAa;EACd,EACF,EACD,WACD,EACD,MAAM,cACJ,OACA,EAAE,OAAO,EAAE,SAAS,gBAAgB,EAAE,EACtC,MAAM,cACJ,MACA,EACE,OAAO;EACL,UAAU;EACV,YAAY;EACZ,YAAY;EACZ,QAAQ;EACT,EACF,EACD,eAAe,IAChB,CACF,CACF,CACF"}

package/dist/shims/fetch-cache.d.ts

@@ -23,6 +23,11 @@ type NextFetchOptions = {
   revalidate?: number | false;
   tags?: string[];
 };
+type FetchDedupeEntry = {
+  key: string;
+  promise: Promise<Response>;
+  response: Response | null;
+};
 declare global {
   interface RequestInit {
     next?: NextFetchOptions;
@@ -34,6 +39,8 @@ type FetchCacheState = {
   currentRequestTags: string[];
   currentFetchSoftTags: string[];
   currentFetchCacheMode: FetchCacheMode | null;
+  isFetchDedupeActive: boolean;
+  currentFetchDedupeEntries: Map<string, FetchDedupeEntry[]>;
 };
 type FetchCacheMode = "auto" | "default-cache" | "default-no-store" | "force-cache" | "force-no-store" | "only-cache" | "only-no-store";
 /**
@@ -69,6 +76,20 @@ declare function withFetchCache(): () => void;
  * of collected fetch tags in concurrent server environments.
  */
 declare function runWithFetchCache<T>(fn: () => Promise<T>): Promise<T>;
+/**
+ * Activate per-render fetch memoization without resetting request fetch tags.
+ * Next.js request memoization is scoped to React render work, not the whole
+ * request pipeline, so route handlers and middleware stay observable.
+ *
+ * ALS scope lifetime: when `fn` returns synchronously (e.g. wrapping a
+ * `renderToReadableStream` call), the ALS scope established here only covers
+ * the synchronous portion. Any fetch work that happens later during async
+ * stream consumption falls back to the parent ALS store, which is fine when
+ * the parent already activated dedupe (the common dispatch case) but means
+ * standalone callers must keep the dedupe scope alive across consumption.
+ */
+declare function runWithFetchDedupe<T>(fn: () => T): T;
+declare function runWithFetchDedupe<T>(fn: () => Promise<T>): Promise<T>;
 /**
  * Install the patched fetch without creating a standalone ALS scope.
  *
@@ -84,5 +105,5 @@ declare function ensureFetchPatch(): void;
  */
 declare function getOriginalFetch(): typeof globalThis.fetch;
 //#endregion
-export { FetchCacheMode, FetchCacheState, _resetPendingRefetches, ensureFetchPatch, getCollectedFetchTags, getOriginalFetch, runWithFetchCache, setCurrentFetchCacheMode, setCurrentFetchSoftTags, withFetchCache };
+export { FetchCacheMode, FetchCacheState, _resetPendingRefetches, ensureFetchPatch, getCollectedFetchTags, getOriginalFetch, runWithFetchCache, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchSoftTags, withFetchCache };
 //# sourceMappingURL=fetch-cache.d.ts.map