@vexcms/next 0.1.0-alpha.27 → 0.1.0-alpha.28

package/dist/HydrationBoundaryClient.d.ts

@@ -0,0 +1,17 @@
+import { HydrationBoundary } from "@tanstack/react-query";
+/**
+ * Re-exports `@tanstack/react-query`'s own `HydrationBoundary` through an explicit
+ * `"use client"` module boundary, in its own tsup entry (`tsup.config.ts`'s client build
+ * target, `@tanstack/react-query` marked `external` there) — `NextAdminPage.tsx` (a Server
+ * Component, no banner) imports it from HERE, not directly from `@tanstack/react-query`.
+ *
+ * Importing `HydrationBoundary` directly into `NextAdminPage.tsx`'s own no-banner tsup
+ * bundle let tsup inline/bundle it into the SAME output chunk as the server component code
+ * — losing the "use client" boundary Next.js's RSC compiler needs to see at the MODULE
+ * level (boundary detection is per-file, not per-component-within-a-bundled-chunk),
+ * confirmed live: "createContext only works in Client Components" from inside
+ * `HydrationBoundary`'s own internals. The same class of issue `NextAdminLayoutClient.tsx`
+ * exists to avoid for `NextAdminLayout`'s client leaf.
+ */
+export { HydrationBoundary as HydrationBoundaryClient };
+//# sourceMappingURL=HydrationBoundaryClient.d.ts.map

package/dist/HydrationBoundaryClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HydrationBoundaryClient.d.ts","sourceRoot":"","sources":["../src/HydrationBoundaryClient.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE1D;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAE,iBAAiB,IAAI,uBAAuB,EAAE,CAAC"}

package/dist/HydrationBoundaryClient.js

@@ -0,0 +1,9 @@
+"use client";
+"use client";
+
+// src/HydrationBoundaryClient.tsx
+import { HydrationBoundary } from "@tanstack/react-query";
+export {
+  HydrationBoundary as HydrationBoundaryClient
+};
+//# sourceMappingURL=HydrationBoundaryClient.js.map

package/dist/HydrationBoundaryClient.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/HydrationBoundaryClient.tsx"],"sourcesContent":["\"use client\";\n\nimport { HydrationBoundary } from \"@tanstack/react-query\";\n\n/**\n * Re-exports `@tanstack/react-query`'s own `HydrationBoundary` through an explicit\n * `\"use client\"` module boundary, in its own tsup entry (`tsup.config.ts`'s client build\n * target, `@tanstack/react-query` marked `external` there) — `NextAdminPage.tsx` (a Server\n * Component, no banner) imports it from HERE, not directly from `@tanstack/react-query`.\n *\n * Importing `HydrationBoundary` directly into `NextAdminPage.tsx`'s own no-banner tsup\n * bundle let tsup inline/bundle it into the SAME output chunk as the server component code\n * — losing the \"use client\" boundary Next.js's RSC compiler needs to see at the MODULE\n * level (boundary detection is per-file, not per-component-within-a-bundled-chunk),\n * confirmed live: \"createContext only works in Client Components\" from inside\n * `HydrationBoundary`'s own internals. The same class of issue `NextAdminLayoutClient.tsx`\n * exists to avoid for `NextAdminLayout`'s client leaf.\n */\nexport { HydrationBoundary as HydrationBoundaryClient };\n"],"mappings":";;;;AAEA,SAAS,yBAAyB;","names":[]}

package/dist/NextAdminLayout.d.ts

@@ -1,36 +1,45 @@
 import type { ReactNode } from "react";
-import type { AdminUser } from "@vexcms/react";
+import { type VexApiAuth } from "@vexcms/core";
 /**
  * Next.js admin layout shell for VexCMS.
  *
- * A **server component** that reads the `sidebar_state` cookie server-side
- * (so the sidebar's open/closed state is correct on first paint, with no
- * client flash) and passes it, plus `user`/`organization`/`children`, to the
+ * A **server component** that reads the consolidated `vex-admin` cookie's
+ * `sidebarOpen` field server-side (Decision 51; previously a dedicated
+ * `sidebar_state` cookie) so the sidebar's open/closed state is correct on
+ * first paint, with no client flash, and passes it, plus `authPromise`/
+ * `children`, to the
  * client leaf `NextAdminLayoutClient`. Config no longer crosses this
  * boundary at all — the admin panel's client tree gets its config from the
  * app's own root `VexConfigProvider` mount
  * (`components/providers/client.tsx`), not from a prop threaded through this
  * layout.
  *
+ * Does **not** await `authPromise` itself (perf fix, Decision 44/streaming) — only
+ * `cookies()` (fast, no network). The sidebar resolves `authPromise` inside its
+ * OWN `<Suspense>` boundary (`AdminLayout`, `@vexcms/react`), so a slow
+ * `getUserOrg()` round trip only delays the sidebar nav, never `children` or
+ * this layout's own static chrome.
+ *
  * Render it from your admin `layout.tsx`. Because this is a server component,
- * your `layout.tsx` may itself be an `async` server component (e.g. to run auth
- * checks).
+ * your `layout.tsx` may itself call server-only auth helpers to build
+ * `authPromise` (e.g. `getUserOrg()` from `~/auth/server`) — started, not
+ * awaited, so `layout.tsx` itself stays synchronous and streams immediately.
  *
  * @param props - Layout props.
  * @param props.children - The page content from `[[...slug]]/page.tsx`.
- * @param props.user - Current user for the admin shell.
+ * @param props.authPromise - The in-flight `{ user, organization }` fetch (Decision 44),
+ *   optional — omit it entirely when `config.access` is absent/disabled.
  * @returns The rendered admin shell, wrapping `children` in the client boundary
  *   ({@link NextAdminLayoutClient}) with the server-read sidebar cookie state.
  * @example
  * ```tsx
  * // app/admin/layout.tsx
  * import { NextAdminLayout } from "@vexcms/next/client";
- * import { getCurrentUser } from "~/auth/serverUtils";
+ * import { getUserOrg } from "~/auth/server";
  *
- * export default async function AdminLayout({ children }: { children: ReactNode }) {
- *   const user = await getCurrentUser();
+ * export default function AdminLayout({ children }: { children: ReactNode }) {
  *   return (
- *     <NextAdminLayout user={user ?? undefined}>
+ *     <NextAdminLayout authPromise={getUserOrg()}>
  *       {children}
  *     </NextAdminLayout>
  *   );
@@ -39,7 +48,6 @@ import type { AdminUser } from "@vexcms/react";
  */
 export declare function NextAdminLayout(props: {
     children: ReactNode;
-    user?: AdminUser;
-    organization?: Record<string, unknown>;
+    authPromise?: Promise<VexApiAuth>;
 }): Promise<import("react").JSX.Element>;
 //# sourceMappingURL=NextAdminLayout.d.ts.map

package/dist/NextAdminLayout.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NextAdminLayout.d.ts","sourceRoot":"","sources":["../src/NextAdminLayout.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAI/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAsB,eAAe,CAAC,KAAK,EAAE;IAC3C,QAAQ,EAAE,SAAS,CAAC;IACpB,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACxC,wCAaA"}
+{"version":3,"file":"NextAdminLayout.d.ts","sourceRoot":"","sources":["../src/NextAdminLayout.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,EAAuC,KAAK,UAAU,EAAE,MAAM,cAAc,CAAC;AAIpF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,wBAAsB,eAAe,CAAC,KAAK,EAAE;IAC3C,QAAQ,EAAE,SAAS,CAAC;IACpB,WAAW,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;CACnC,wCASA"}

package/dist/NextAdminLayout.js

@@ -1,6 +1,6 @@
 import {
   NextAdminLayout
-} from "./chunk-UMJTAD5A.js";
+} from "./chunk-NE2VUFS2.js";
 export {
   NextAdminLayout
 };

package/dist/NextAdminLayoutClient.d.ts

@@ -1,5 +1,5 @@
 import type { ReactNode } from "react";
-import { type AdminUser } from "@vexcms/react";
+import type { VexApiAuth } from "@vexcms/core";
 /**
  * Client leaf for the Next.js admin layout.
  *
@@ -10,6 +10,11 @@ import { type AdminUser } from "@vexcms/react";
  *   admin routes.
  * - `NextLink` / `NextImage` passed as framework components so every
  *   `VexLink`/`VexImage` uses Next.js routing and image optimisation.
+ * - `useVexAdminAuthAdapter()` (`./auth/VexAdminAuthAdapterContext`) read here and
+ *   forwarded into `components.auth`, so `AdminTopNav`'s sign-in/out control picks up
+ *   whatever adapter the app mounted via `VexAdminAuthAdapterProvider`
+ *   (`@vexcms/next/auth`) — `undefined` when the app hasn't mounted one, same as the
+ *   control simply not rendering.
  *
  * Config reaches `AdminLayout`'s children through the app's own
  * `VexConfigProvider` mount, not through a prop on this component — this
@@ -20,15 +25,16 @@ import { type AdminUser } from "@vexcms/react";
  *
  * @param props - Layout props.
  * @param props.children - The page content from `[[...slug]]/page.tsx`.
- * @param props.user - Current user for the admin shell.
+ * @param props.authPromise - The in-flight `{ user, organization }` fetch (Decision 44),
+ *   forwarded to `AdminLayout` so the sidebar resolves it in its OWN `<Suspense>` boundary —
+ *   a slow auth round trip streams in the sidebar nav without blocking `children`.
  * @returns The admin shell rendered from `children`, wrapped in `NuqsAdapter`
  * and the shared `AdminLayout`, wired with the active slug/document id derived
  * from `usePathname()` and Next.js `Link`/`Image` components.
  */
 export declare function NextAdminLayoutClient(props: {
     children: ReactNode;
-    organization?: Record<string, unknown>;
+    authPromise?: Promise<VexApiAuth>;
     sidebarOpen?: boolean;
-    user?: AdminUser;
 }): import("react").JSX.Element;
 //# sourceMappingURL=NextAdminLayoutClient.d.ts.map

package/dist/NextAdminLayoutClient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NextAdminLayoutClient.d.ts","sourceRoot":"","sources":["../src/NextAdminLayoutClient.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC,OAAO,EAAe,KAAK,SAAS,EAAE,MAAM,eAAe,CAAC;AAM5D;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE;IAC3C,QAAQ,EAAE,SAAS,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACvC,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,IAAI,CAAC,EAAE,SAAS,CAAC;CAClB,+BAuBA"}
+{"version":3,"file":"NextAdminLayoutClient.d.ts","sourceRoot":"","sources":["../src/NextAdminLayoutClient.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAY/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE;IAC3C,QAAQ,EAAE,SAAS,CAAC;IACpB,WAAW,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;IAClC,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,+BA8BA"}

package/dist/NextAdminLayoutClient.js

@@ -1,5 +1,8 @@
 "use client";
 "use client";
+import {
+  useVexAdminAuthAdapter
+} from "./chunk-T7DNJLSX.js";
 
 // src/NextAdminLayoutClient.tsx
 import { AdminLayout } from "@vexcms/react";
@@ -7,22 +10,116 @@ import NextImage from "next/image";
 import NextLink from "next/link";
 import { usePathname } from "next/navigation";
 import { NuqsAdapter } from "nuqs/adapters/next/app";
+
+// src/navigation/useNextNavigationBlocker.ts
+import { useEffect, useRef } from "react";
+import { useRouter } from "next/navigation";
+function useNextNavigationBlocker(props) {
+  const router = useRouter();
+  const routerRef = useRef(router);
+  routerRef.current = router;
+  const whenRef = useRef(props.when);
+  whenRef.current = props.when;
+  const onBlockRef = useRef(props.onBlock);
+  onBlockRef.current = props.onBlock;
+  const popstateReplayRef = useRef(false);
+  const sentinelActiveRef = useRef(false);
+  useEffect(() => {
+    function onClick(event) {
+      const anchor = event.target.closest("a");
+      if (!anchor || event.defaultPrevented || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey || anchor.target || anchor.hasAttribute("download")) {
+        return;
+      }
+      const url = new URL(anchor.href, window.location.href);
+      if (url.origin !== window.location.origin) {
+        return;
+      }
+      if (url.pathname + url.search === window.location.pathname + window.location.search) {
+        return;
+      }
+      if (!whenRef.current) {
+        return;
+      }
+      event.preventDefault();
+      onBlockRef.current(() => {
+        const href = url.pathname + url.search;
+        if (isSentinelEntry()) {
+          sentinelActiveRef.current = false;
+          routerRef.current.replace(href);
+          return;
+        }
+        routerRef.current.push(href);
+      });
+    }
+    function onPopState() {
+      if (popstateReplayRef.current) {
+        popstateReplayRef.current = false;
+        return;
+      }
+      const leftSentinel = sentinelActiveRef.current;
+      sentinelActiveRef.current = false;
+      if (!whenRef.current || !leftSentinel) {
+        return;
+      }
+      pushSentinel();
+      onBlockRef.current(() => {
+        sentinelActiveRef.current = false;
+        popstateReplayRef.current = true;
+        window.history.go(-2);
+      });
+    }
+    document.addEventListener("click", onClick, true);
+    window.addEventListener("popstate", onPopState);
+    return () => {
+      document.removeEventListener("click", onClick, true);
+      window.removeEventListener("popstate", onPopState);
+      sentinelActiveRef.current = false;
+    };
+  }, []);
+  useEffect(() => {
+    if (!props.when || sentinelActiveRef.current) return;
+    pushSentinel();
+  }, [props.when]);
+  function pushSentinel() {
+    window.history.pushState({ [SENTINEL_STATE_KEY]: true }, "", window.location.href);
+    sentinelActiveRef.current = true;
+  }
+}
+var SENTINEL_STATE_KEY = "__vexNavigationSentinel";
+function isSentinelEntry() {
+  const state = window.history.state;
+  return typeof state === "object" && state !== null && SENTINEL_STATE_KEY in state;
+}
+
+// src/navigation/useNextNavigate.ts
+import { useRouter as useRouter2 } from "next/navigation";
+function useNextNavigate() {
+  const router = useRouter2();
+  return router.push;
+}
+
+// src/NextAdminLayoutClient.tsx
 import { jsx } from "react/jsx-runtime";
 function NextAdminLayoutClient(props) {
   const pathname = usePathname();
-  const segments = pathname.split("/").filter(Boolean);
-  const activeSlug = segments[1];
-  const activeDocID = segments[2];
+  const auth = useVexAdminAuthAdapter();
+  const [, section, slug, documentId] = pathname.split("/").filter(Boolean);
+  const activeSlug = section === "collections" ? slug : section;
+  const activeDocID = section === "collections" ? documentId : slug;
   return /* @__PURE__ */ jsx(NuqsAdapter, { children: /* @__PURE__ */ jsx(
     AdminLayout,
     {
       activeDocID,
       activeSlug,
-      components: { Link: NextLink, Image: NextImage },
-      organization: props.organization,
-      pathname,
+      authPromise: props.authPromise,
+      components: {
+        Link: NextLink,
+        Image: NextImage,
+        navigationBlocker: { useBlocker: useNextNavigationBlocker },
+        useNavigate: useNextNavigate,
+        auth
+      },
       sidebarOpen: props.sidebarOpen,
-      user: props.user,
       children: props.children
     }
   ) });

package/dist/NextAdminLayoutClient.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/NextAdminLayoutClient.tsx"],"sourcesContent":["\"use client\";\n// \"use client\" is injected by the tsup build banner for this entry (see\n// tsup.config.ts) so the emitted module carries the client boundary.\nimport type { ReactNode } from \"react\";\n\nimport { AdminLayout, type AdminUser } from \"@vexcms/react\";\nimport NextImage from \"next/image\";\nimport NextLink from \"next/link\";\nimport { usePathname } from \"next/navigation\";\nimport { NuqsAdapter } from \"nuqs/adapters/next/app\";\n\n/**\n * Client leaf for the Next.js admin layout.\n *\n * Owns all client-only wiring that cannot run on the server:\n * - `usePathname()` to derive the active collection slug / document id for\n *   sidebar highlighting (Next.js layouts do not receive route params).\n * - `NuqsAdapter` (`nuqs/adapters/next/app`) so URL state works inside the\n *   admin routes.\n * - `NextLink` / `NextImage` passed as framework components so every\n *   `VexLink`/`VexImage` uses Next.js routing and image optimisation.\n *\n * Config reaches `AdminLayout`'s children through the app's own\n * `VexConfigProvider` mount, not through a prop on this component — this\n * leaf never touches config at all.\n *\n * This component is internal to `@vexcms/next` — applications render\n * {@link NextAdminLayout} instead.\n *\n * @param props - Layout props.\n * @param props.children - The page content from `[[...slug]]/page.tsx`.\n * @param props.user - Current user for the admin shell.\n * @returns The admin shell rendered from `children`, wrapped in `NuqsAdapter`\n * and the shared `AdminLayout`, wired with the active slug/document id derived\n * from `usePathname()` and Next.js `Link`/`Image` components.\n */\nexport function NextAdminLayoutClient(props: {\n  children: ReactNode;\n  organization?: Record<string, unknown>;\n  sidebarOpen?: boolean;\n  user?: AdminUser;\n}) {\n  const pathname = usePathname();\n  // pathname: \"/admin\", \"/admin/posts\", \"/admin/posts/123\"\n  // Split on \"/\" and take the segment after \"admin\"\n  const segments = pathname.split(\"/\").filter(Boolean);\n  const activeSlug = segments[1]; // undefined on /admin, \"posts\" on /admin/posts\n  const activeDocID = segments[2];\n\n  return (\n    <NuqsAdapter>\n      <AdminLayout\n        activeDocID={activeDocID}\n        activeSlug={activeSlug}\n        components={{ Link: NextLink, Image: NextImage }}\n        organization={props.organization}\n        pathname={pathname}\n        sidebarOpen={props.sidebarOpen}\n        user={props.user}\n      >\n        {props.children}\n      </AdminLayout>\n    </NuqsAdapter>\n  );\n}\n"],"mappings":";;;;AAKA,SAAS,mBAAmC;AAC5C,OAAO,eAAe;AACtB,OAAO,cAAc;AACrB,SAAS,mBAAmB;AAC5B,SAAS,mBAAmB;AA0CtB;AAfC,SAAS,sBAAsB,OAKnC;AACD,QAAM,WAAW,YAAY;AAG7B,QAAM,WAAW,SAAS,MAAM,GAAG,EAAE,OAAO,OAAO;AACnD,QAAM,aAAa,SAAS,CAAC;AAC7B,QAAM,cAAc,SAAS,CAAC;AAE9B,SACE,oBAAC,eACC;AAAA,IAAC;AAAA;AAAA,MACC;AAAA,MACA;AAAA,MACA,YAAY,EAAE,MAAM,UAAU,OAAO,UAAU;AAAA,MAC/C,cAAc,MAAM;AAAA,MACpB;AAAA,MACA,aAAa,MAAM;AAAA,MACnB,MAAM,MAAM;AAAA,MAEX,gBAAM;AAAA;AAAA,EACT,GACF;AAEJ;","names":[]}
+{"version":3,"sources":["../src/NextAdminLayoutClient.tsx","../src/navigation/useNextNavigationBlocker.ts","../src/navigation/useNextNavigate.ts"],"sourcesContent":["\"use client\";\n// \"use client\" is injected by the tsup build banner for this entry (see\n// tsup.config.ts) so the emitted module carries the client boundary.\nimport type { ReactNode } from \"react\";\nimport type { VexApiAuth } from \"@vexcms/core\";\n\nimport { AdminLayout } from \"@vexcms/react\";\nimport NextImage from \"next/image\";\nimport NextLink from \"next/link\";\nimport { usePathname } from \"next/navigation\";\nimport { NuqsAdapter } from \"nuqs/adapters/next/app\";\n\nimport { useNextNavigationBlocker } from \"./navigation/useNextNavigationBlocker\";\nimport { useNextNavigate } from \"./navigation/useNextNavigate\";\nimport { useVexAdminAuthAdapter } from \"./auth/VexAdminAuthAdapterContext\";\n\n/**\n * Client leaf for the Next.js admin layout.\n *\n * Owns all client-only wiring that cannot run on the server:\n * - `usePathname()` to derive the active collection slug / document id for\n *   sidebar highlighting (Next.js layouts do not receive route params).\n * - `NuqsAdapter` (`nuqs/adapters/next/app`) so URL state works inside the\n *   admin routes.\n * - `NextLink` / `NextImage` passed as framework components so every\n *   `VexLink`/`VexImage` uses Next.js routing and image optimisation.\n * - `useVexAdminAuthAdapter()` (`./auth/VexAdminAuthAdapterContext`) read here and\n *   forwarded into `components.auth`, so `AdminTopNav`'s sign-in/out control picks up\n *   whatever adapter the app mounted via `VexAdminAuthAdapterProvider`\n *   (`@vexcms/next/auth`) — `undefined` when the app hasn't mounted one, same as the\n *   control simply not rendering.\n *\n * Config reaches `AdminLayout`'s children through the app's own\n * `VexConfigProvider` mount, not through a prop on this component — this\n * leaf never touches config at all.\n *\n * This component is internal to `@vexcms/next` — applications render\n * {@link NextAdminLayout} instead.\n *\n * @param props - Layout props.\n * @param props.children - The page content from `[[...slug]]/page.tsx`.\n * @param props.authPromise - The in-flight `{ user, organization }` fetch (Decision 44),\n *   forwarded to `AdminLayout` so the sidebar resolves it in its OWN `<Suspense>` boundary —\n *   a slow auth round trip streams in the sidebar nav without blocking `children`.\n * @returns The admin shell rendered from `children`, wrapped in `NuqsAdapter`\n * and the shared `AdminLayout`, wired with the active slug/document id derived\n * from `usePathname()` and Next.js `Link`/`Image` components.\n */\nexport function NextAdminLayoutClient(props: {\n  children: ReactNode;\n  authPromise?: Promise<VexApiAuth>;\n  sidebarOpen?: boolean;\n}) {\n  const pathname = usePathname();\n  const auth = useVexAdminAuthAdapter();\n  // pathname: \"/admin\", \"/admin/collections/posts[/<id>]\", \"/admin/globals[/<slug>]\"\n  // Split on \"/\" and read the segments after \"admin\". Collections report their\n  // slug + document id; globals keep the \"globals\" section as the active slug\n  // and the global's slug as the doc id (the sidebar/top nav contract).\n  const [, section, slug, documentId] = pathname.split(\"/\").filter(Boolean);\n  const activeSlug = section === \"collections\" ? slug : section;\n  const activeDocID = section === \"collections\" ? documentId : slug;\n\n  return (\n    <NuqsAdapter>\n      <AdminLayout\n        activeDocID={activeDocID}\n        activeSlug={activeSlug}\n        authPromise={props.authPromise}\n        components={{\n          Link: NextLink,\n          Image: NextImage,\n          navigationBlocker: { useBlocker: useNextNavigationBlocker },\n          useNavigate: useNextNavigate,\n          auth,\n        }}\n        sidebarOpen={props.sidebarOpen}\n      >\n        {props.children}\n      </AdminLayout>\n    </NuqsAdapter>\n  );\n}\n","\"use client\";\n\nimport { useEffect, useRef } from \"react\";\nimport { useRouter } from \"next/navigation\";\nimport type { NavigationBlockerAdapter } from \"@vexcms/react\";\n\n/**\n * Next.js App Router implementation of `NavigationBlockerAdapter[\"useBlocker\"]`.\n *\n * The App Router has no `routeChangeStart`-equivalent event and (spec decision 3)\n * programmatic navigation cannot be intercepted by patching\n * `history.pushState`/`replaceState` — Next's own `HistoryUpdater` calls\n * `pushState` from a `useInsertionEffect` AFTER the route has already\n * committed, and patches those methods itself. This hook therefore covers\n * only the two surfaces that fire BEFORE a route change commits: same-origin\n * `<a>` clicks (capture-phase `click` listener) and browser back/forward (a\n * `popstate` listener plus a duplicate-history-entry trap). Programmatic\n * navigation is guarded separately by `@vexcms/react`'s `useVexNavigate`,\n * which consults the guard itself before calling this adapter's\n * `useNavigate` (`useNextNavigate`, this package). `beforeunload` (tab close\n * / hard reload) is also NOT handled here — `@vexcms/react`'s\n * `useUnsavedChangesGuard` registers it directly, framework-independent.\n *\n * Provide the resulting adapter from `NextAdminLayoutClient`:\n * `components={{ …, navigationBlocker: { useBlocker: useNextNavigationBlocker } }}`.\n * `useUnsavedChangesGuard` then calls it once per mounted edit view with the\n * live dirty/autosave state.\n *\n * @param props - See `NavigationBlockerAdapter[\"useBlocker\"]` in\n *   `@vexcms/react` (`packages/react/src/config/useFrameworkComponents.ts`).\n * @returns Nothing — every intercepted navigation surfaces through\n *   `props.onBlock`, never a return value.\n * @throws Never under normal operation; a blocked navigation reports through\n *   `onBlock`, not a throw.\n */\nexport function useNextNavigationBlocker(\n  props: Parameters<NavigationBlockerAdapter[\"useBlocker\"]>[0],\n): void {\n  const router = useRouter();\n\n  // Refs, not state: the click/popstate listeners below are installed ONCE\n  // per mount (empty dep array) so `when` flipping dirty<->clean never tears\n  // down and reinstalls them, and the router's method identity (not\n  // guaranteed stable across renders) never matters. Every handler reads\n  // these refs instead of closing over the render's values.\n  const routerRef = useRef(router);\n  routerRef.current = router;\n  const whenRef = useRef(props.when);\n  whenRef.current = props.when;\n  const onBlockRef = useRef(props.onBlock);\n  onBlockRef.current = props.onBlock;\n\n  // Set just before `history.go(-2)` on a blocked back/forward's Leave, so\n  // the `popstate` that fires as a result of `history.go` is treated as the\n  // replay instead of re-blocking it.\n  const popstateReplayRef = useRef(false);\n  // Whether the top-of-stack entry is our same-URL sentinel (pushed when\n  // `when` turns true, re-pushed on a blocked popstate).\n  const sentinelActiveRef = useRef(false);\n\n  useEffect(() => {\n    function onClick(event: MouseEvent) {\n      const anchor = (event.target as Element).closest(\"a\");\n      if (\n        !anchor ||\n        event.defaultPrevented ||\n        event.metaKey ||\n        event.ctrlKey ||\n        event.shiftKey ||\n        event.altKey ||\n        anchor.target ||\n        anchor.hasAttribute(\"download\")\n      ) {\n        return;\n      }\n\n      const url = new URL(anchor.href, window.location.href);\n      if (url.origin !== window.location.origin) {\n        // External link — let the browser handle it.\n        return;\n      }\n\n      if (\n        url.pathname + url.search ===\n        window.location.pathname + window.location.search\n      ) {\n        // Same-page `#hash` anchor — not a route change.\n        return;\n      }\n\n      if (!whenRef.current) {\n        return;\n      }\n\n      event.preventDefault();\n      onBlockRef.current(() => {\n        const href = url.pathname + url.search;\n        if (isSentinelEntry()) {\n          // The sentinel is a same-URL duplicate of the guarded page: replace\n          // it, so history matches a navigation made with no guard mounted.\n          sentinelActiveRef.current = false;\n          routerRef.current.replace(href);\n          return;\n        }\n        routerRef.current.push(href);\n      });\n    }\n\n    function onPopState() {\n      if (popstateReplayRef.current) {\n        popstateReplayRef.current = false;\n        return;\n      }\n\n      const leftSentinel = sentinelActiveRef.current;\n      sentinelActiveRef.current = false;\n      // Without a sentinel the browser already left the guarded URL — the\n      // traversal can no longer be undone, so let it through.\n      if (!whenRef.current || !leftSentinel) {\n        return;\n      }\n\n      // Back/forward only stepped off the sentinel onto the guarded page's own\n      // entry (same URL). Re-push the sentinel so a Stay leaves history as it was.\n      pushSentinel();\n      onBlockRef.current(() => {\n        // \"Leave\": step past the re-pushed sentinel AND the guarded page's own\n        // entry, landing where the original back press intended.\n        sentinelActiveRef.current = false;\n        popstateReplayRef.current = true;\n        window.history.go(-2);\n      });\n    }\n\n    document.addEventListener(\"click\", onClick, true);\n    window.addEventListener(\"popstate\", onPopState);\n\n    return () => {\n      document.removeEventListener(\"click\", onClick, true);\n      window.removeEventListener(\"popstate\", onPopState);\n      // The sentinel is deliberately left in place: it is a traversable\n      // same-URL entry (Next merged its router state into it), and popping it\n      // here would start an async traversal that races — and cancels — the\n      // navigation that usually caused this unmount (e.g. Delete's redirect\n      // after the document query already returned null).\n      sentinelActiveRef.current = false;\n    };\n    // Installs once per mount; handlers read refs.\n  }, []);\n\n  // A same-URL sentinel entry, pushed as soon as the guard starts blocking, so\n  // the first back press lands on the guarded page's own entry instead of\n  // leaving it. Never popped (popping triggers a traversal); a Leave through a\n  // link replaces it instead.\n  useEffect(() => {\n    if (!props.when || sentinelActiveRef.current) return;\n    pushSentinel();\n  }, [props.when]);\n\n  function pushSentinel(): void {\n    // Next's patched `pushState` merges its own router state into this object,\n    // so the entry stays traversable by the App Router.\n    window.history.pushState({ [SENTINEL_STATE_KEY]: true }, \"\", window.location.href);\n    sentinelActiveRef.current = true;\n  }\n}\n\n/** History-state key marking the guard's same-URL sentinel entry. */\nconst SENTINEL_STATE_KEY = \"__vexNavigationSentinel\";\n\nfunction isSentinelEntry(): boolean {\n  const state: unknown = window.history.state;\n  return typeof state === \"object\" && state !== null && SENTINEL_STATE_KEY in state;\n}\n","\"use client\";\n\nimport { useRouter } from \"next/navigation\";\n\n/**\n * Next.js App Router implementation of `FrameworkComponents[\"useNavigate\"]`\n * (`packages/react/src/config/useFrameworkComponents.ts`, Step 7).\n *\n * Returns the App Router's own `router.push`, unwrapped — guarding is not\n * this hook's job. `@vexcms/react`'s `useVexNavigate`\n * (`packages/react/src/config/useVexNavigate.ts`) is the only caller: it\n * consults `useUnsavedChangesGuard`'s blocking state itself before invoking\n * the function this hook returns, so every built-in post-mutation\n * navigation (after delete, after a duplicate's create resolves) is guarded\n * without this hook knowing anything about dirty state.\n *\n * Provide it from `NextAdminLayoutClient`:\n * `components={{ …, useNavigate: useNextNavigate }}`.\n *\n * @returns A function that navigates to `href` via the App Router.\n */\nexport function useNextNavigate(): (href: string) => void {\n  const router = useRouter();\n  return router.push;\n}\n"],"mappings":"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","names":["useRouter"]}

package/dist/NextAdminPage.d.ts

@@ -1,4 +1,4 @@
-import type { VexConfig } from "@vexcms/core";
+import type { VexApiAuth, VexConfig } from "@vexcms/core";
 /**
  * VexCMS admin page server component for Next.js.
  *
@@ -15,25 +15,65 @@ import type { VexConfig } from "@vexcms/core";
  * | `[collectionSlug, "new"]` | `CollectionEditView` (empty form) |
  * | `[collectionSlug, documentId]` | `CollectionEditView` with preloaded doc |
  *
+ * Takes `tokenPromise`/`authPromise`, not resolved values (perf fix, developer-binding): the
+ * caller (`page.tsx`) starts both without awaiting them immediately, so `NextAdminPage`'s own
+ * data fetches can begin as soon as `tokenPromise` resolves (what every `fetchQuery` call
+ * actually needs) rather than waiting on the slower `authPromise` (which itself depends on
+ * the token, plus one more Convex round trip). The caller's own page-level access gate
+ * (`canAccessAdminPanel`) should `await authPromise` and redirect BEFORE rendering
+ * `NextAdminPage` at all (Polish Decision 8, developer-reported — a generic page-level
+ * skeleton rendered while the gate was still in flight made the loading state worse than no
+ * gate-level fallback at all: shifts, row-selection spinners showing where real checkboxes
+ * belong, skeletons with no matching settled element, content popping in unannounced).
+ * `NextAdminPage` streams its own real chrome (title/tabs/toolbar/controls) immediately once
+ * rendered and wraps only its OWN data-dependent regions (e.g. table rows) in their own
+ * `<Suspense>` boundaries — no page-level fallback needed or wanted.
+ *
  * @param props - Component props
  * @param props.config - The resolved server `VexConfig`, typically the default export of
  *   `vex.config.server.ts` — not the client-safe `vex.config.ts`.
  * @param props.params - Next.js 15 async params `{ path?: string[] }`
- * @param props.token - Optional session token forwarded to `fetchQuery` for authenticated reads.
+ * @param props.tokenPromise - The in-flight (or already-resolved) session token (e.g.
+ *   `getToken()`), forwarded to every `fetchQuery` call for authenticated reads. Optional —
+ *   a project with no auth at all omits it, every `fetchQuery` call runs unauthenticated.
+ * @param props.authPromise - The in-flight (or already-resolved — e.g. `Promise.resolve(auth)`
+ *   after the caller's own gate already awaited it) server-resolved caller (Decision 44),
+ *   OPTIONAL. Wraps the entire return in `VexAuthProvider` and narrows the collection list
+ *   route's search field by read permission. Omit it when `config.access` is absent or
+ *   disabled — nothing is restricted either way. An `access`-enabled project that omits it is
+ *   treated as an anonymous caller (fail-closed) with a one-time dev console warning.
  * @returns The appropriate admin view for the current URL path.
  *
  * @example
  * ```tsx
  * // app/admin/[[...slug]]/page.tsx
+ * import { canAccessAdminPanel } from "@vexcms/core";
  * import { NextAdminPage } from "@vexcms/next/server";
+ * import { redirect } from "next/navigation";
+ * import { getToken, getUserOrg } from "~/auth/server";
  * import config from "../../../../vex.config.server";
  *
- * export default function AdminPage({
+ * export default async function AdminPage({
  *   params,
  * }: {
  *   params: Promise<{ path?: string[] }>;
  * }) {
- *   return <NextAdminPage config={config} params={params} />;
+ *   const token = await getToken();
+ *   if (!token) redirect("/auth/sign-in?redirectTo=/admin");
+ *   const auth = await getUserOrg();
+ *   if (
+ *     !canAccessAdminPanel({ access: config.access, user: auth.user, organization: auth.organization })
+ *   ) {
+ *     redirect("/unauthorized");
+ *   }
+ *   return (
+ *     <NextAdminPage
+ *       config={config}
+ *       params={params}
+ *       tokenPromise={Promise.resolve(token)}
+ *       authPromise={Promise.resolve(auth)}
+ *     />
+ *   );
  * }
  * ```
  */
@@ -42,6 +82,13 @@ export declare function NextAdminPage(props: {
     params: Promise<{
         path?: string[];
     }>;
-    token?: string;
+    /**
+     * Next.js's own `searchParams` prop, forwarded by the app route (`AdminPage`). Only the
+     * collection list route reads it (`parseListViewUrlState`, Design Decision 40) — every other
+     * route ignores it.
+     */
+    searchParams?: Promise<Record<string, string | string[] | undefined>>;
+    tokenPromise?: Promise<string | undefined>;
+    authPromise?: Promise<VexApiAuth>;
 }): Promise<import("react").JSX.Element>;
 //# sourceMappingURL=NextAdminPage.d.ts.map

package/dist/NextAdminPage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NextAdminPage.d.ts","sourceRoot":"","sources":["../src/NextAdminPage.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAoC,SAAS,EAAoB,MAAM,cAAc,CAAC;AAuDlG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAsB,aAAa,CAAC,KAAK,EAAE;IACzC,MAAM,EAAE,SAAS,CAAC;IAClB,MAAM,EAAE,OAAO,CAAC;QAAE,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;IACrC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,wCAmLA"}
+{"version":3,"file":"NextAdminPage.d.ts","sourceRoot":"","sources":["../src/NextAdminPage.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,SAAS,EAIV,MAAM,cAAc,CAAC;AA4KtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6EG;AACH,wBAAsB,aAAa,CAAC,KAAK,EAAE;IACzC,MAAM,EAAE,SAAS,CAAC;IAClB,MAAM,EAAE,OAAO,CAAC;QAAE,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;IACrC;;;;OAIG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC,CAAC,CAAC;IACtE,YAAY,CAAC,EAAE,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IAC3C,WAAW,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;CACnC,wCAonBA"}

package/dist/NextAdminPage.js

@@ -1,6 +1,6 @@
 import {
   NextAdminPage
-} from "./chunk-DDH2TJTP.js";
+} from "./chunk-JB3GMZPF.js";
 export {
   NextAdminPage
 };

package/dist/auth/VexAdminAuthAdapterContext.d.ts

@@ -0,0 +1,66 @@
+import { type ReactNode } from "react";
+import type { FrameworkAuthAdapter } from "@vexcms/react";
+/**
+ * Carries the app's sign-in/out actions (`@vexcms/react`'s `FrameworkComponents.auth`,
+ * Next.js adapter) from wherever the app mounts {@link VexAdminAuthAdapterProvider} down
+ * to `NextAdminLayoutClient`, which forwards it into `AdminLayout`'s `components` prop.
+ *
+ * A context, not a prop threaded through `NextAdminLayout`/your admin `layout.tsx`,
+ * because `layout.tsx` and `NextAdminLayout` are BOTH server components — the sign-in
+ * href builder and `signOut` function are app-specific client values (closures over your
+ * own `~/auth/client` module) that cannot cross a Server→Client Component boundary as
+ * props. Mounting this provider anywhere above `NextAdminLayout` in your own CLIENT tree
+ * (e.g. alongside `VexConfigProvider`/your Better Auth client provider) sidesteps that
+ * boundary entirely — both ends are client components.
+ *
+ * `undefined` default (not an empty object) distinguishes "no provider mounted" from "a
+ * provider mounted with no adapter" — `AdminTopNav`'s own control renders nothing either
+ * way, but the distinction matters for anyone debugging why it's missing.
+ */
+export declare const VexAdminAuthAdapterContext: import("react").Context<FrameworkAuthAdapter | undefined>;
+/**
+ * Mounts the sign-in/out adapter for the admin panel's top-bar control.
+ *
+ * @example
+ * ```tsx
+ * // ~/components/providers/client.tsx ("use client")
+ * import { VexAdminAuthAdapterProvider } from "@vexcms/next/auth";
+ * import { useRouter } from "next/navigation";
+ * import { signOut } from "~/auth/client";
+ *
+ * function AuthAdapterProvider({ children }: { children: React.ReactNode }) {
+ *   const router = useRouter();
+ *   return (
+ *     <VexAdminAuthAdapterProvider
+ *       value={{
+ *         signInHref: (redirectTo) => `/auth/sign-in?redirectTo=${encodeURIComponent(redirectTo)}`,
+ *         signOut: () =>
+ *           signOut()
+ *             .then(() => router.refresh())
+ *             .catch(() => router.refresh()), // a stale client cache after a failed
+ *             // sign-out is worse than a redundant refresh — refresh either way.
+ *       }}
+ *     >
+ *       {children}
+ *     </VexAdminAuthAdapterProvider>
+ *   );
+ * }
+ * ```
+ *
+ * @param props.value - The sign-in href builder and `signOut` function.
+ * @param props.children - The subtree that should see this adapter — must contain
+ *   `NextAdminLayout` for `AdminTopNav`'s control to pick it up.
+ * @returns The context provider wrapping `props.children`.
+ */
+export declare function VexAdminAuthAdapterProvider(props: {
+    value: FrameworkAuthAdapter;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/**
+ * Reads the sign-in/out adapter mounted by {@link VexAdminAuthAdapterProvider}, if any.
+ * Consumed internally by `NextAdminLayoutClient` — not typically called from app code.
+ *
+ * @returns The adapter, or `undefined` when no provider is mounted above this point.
+ */
+export declare function useVexAdminAuthAdapter(): FrameworkAuthAdapter | undefined;
+//# sourceMappingURL=VexAdminAuthAdapterContext.d.ts.map

package/dist/auth/VexAdminAuthAdapterContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VexAdminAuthAdapterContext.d.ts","sourceRoot":"","sources":["../../src/auth/VexAdminAuthAdapterContext.tsx"],"names":[],"mappings":"AAKA,OAAO,EAA6B,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAClE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAE1D;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,0BAA0B,2DAEtC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE;IACjD,KAAK,EAAE,oBAAoB,CAAC;IAC5B,QAAQ,EAAE,SAAS,CAAC;CACrB,+BAMA;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,IAAI,oBAAoB,GAAG,SAAS,CAEzE"}

package/dist/auth/index.d.ts

@@ -0,0 +1,2 @@
+export { VexAdminAuthAdapterContext, VexAdminAuthAdapterProvider, useVexAdminAuthAdapter, } from "./VexAdminAuthAdapterContext";
+//# sourceMappingURL=index.d.ts.map

package/dist/auth/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/auth/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,0BAA0B,EAC1B,2BAA2B,EAC3B,sBAAsB,GACvB,MAAM,8BAA8B,CAAC"}

package/dist/auth/index.js

@@ -0,0 +1,12 @@
+"use client";
+import {
+  VexAdminAuthAdapterContext,
+  VexAdminAuthAdapterProvider,
+  useVexAdminAuthAdapter
+} from "../chunk-T7DNJLSX.js";
+export {
+  VexAdminAuthAdapterContext,
+  VexAdminAuthAdapterProvider,
+  useVexAdminAuthAdapter
+};
+//# sourceMappingURL=index.js.map

package/dist/auth/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}