@carlonicora/nextjs-jsonapi 3.24.2 → 3.26.0

package/src/components/forms/FormBlockNote.tsx

@@ -7,6 +7,14 @@ import { BlockNoteEditorContainer } from "../editors/BlockNoteEditorContainer";
 import type { MentionNameResolver, MentionResolveFn } from "../editors/BlockNoteEditorMentionInlineContent";
 import { FormFieldWrapper } from "./FormFieldWrapper";
 
+function isEmptyDocument(value: unknown): boolean {
+  return value === undefined || value === null || value === "" || (Array.isArray(value) && value.length === 0);
+}
+
+function getPath(source: unknown, path: string): unknown {
+  return path.split(".").reduce<unknown>((acc, key) => (acc == null ? undefined : (acc as Record<string, unknown>)[key]), source);
+}
+
 export function FormBlockNote({
   form,
   id,
@@ -73,6 +81,10 @@ export function FormBlockNote({
       className={cn(
         "flex w-full flex-col",
         stretch && "min-h-0 flex-1 [&>[data-slot=field]]:min-h-0 [&>[data-slot=field]]:flex-1",
+        // Phone: the sheet is too short to share with the other fields, so the
+        // editor stops filling the leftover space (2px in a long form) and grows
+        // with its content instead; the sheet body does the scrolling.
+        stretch && "max-md:min-h-64 max-md:flex-none",
         className,
       )}
     >
@@ -100,7 +112,15 @@ export function FormBlockNote({
               initialContent={initialContentRef.current}
               onChange={(content, isEmpty) => {
                 lastEditorContentRef.current = content;
-                field.onChange(content);
+                // BlockNote normalises an empty document ([] / null) to one empty
+                // paragraph as soon as it mounts. That is not a user edit: re-seed the
+                // field's default with it so an untouched form does not ask
+                // "Unsaved changes?" on close.
+                if (isEmpty && isEmptyDocument(getPath(form.formState.defaultValues, id)) && !form.getFieldState(id).isDirty) {
+                  form.resetField(id, { defaultValue: content });
+                } else {
+                  field.onChange(content);
+                }
                 onEmptyChange?.(isEmpty);
               }}
               placeholder={placeholder}

package/src/components/forms/FormCheckbox.tsx

@@ -15,7 +15,11 @@ type FormCheckboxProps = {
 export function FormCheckbox({ form, id, name, labelBefore, description, isRequired }: FormCheckboxProps) {
   const simpleLabel = () => {
     return (
-      <FieldLabel htmlFor={id} className={`font-normal ${labelBefore ? "" : "ms-3"}`}>
+      // Phone: the label fills the row and is 40px tall, so the whole row toggles the box.
+      <FieldLabel
+        htmlFor={id}
+        className={`font-normal ${labelBefore ? "" : "ms-3"} max-md:min-h-10 max-md:flex-1`}
+      >
         {name}
       </FieldLabel>
     );
@@ -36,7 +40,7 @@ export function FormCheckbox({ form, id, name, labelBefore, description, isRequi
     <div className="flex w-full flex-col">
       <FormFieldWrapper form={form} name={id} orientation="horizontal">
         {(field) => (
-          <div className="flex gap-x-4">
+          <div className="flex gap-x-4 max-md:min-h-10 max-md:items-center">
             {labelBefore && label()}
             {labelBefore && isRequired && <span className="ms-1 text-destructive">*</span>}
             <Checkbox id={id} checked={field.value ?? false} onCheckedChange={field.onChange} />

package/src/components/forms/__tests__/useEditorDialog.test.ts

@@ -169,6 +169,53 @@ describe("useEditorDialog", () => {
     });
   });
 
+  describe("escape key with an open picker / menu above the sheet", () => {
+    const pressEscape = () => {
+      const event = new KeyboardEvent("keydown", { key: "Escape", bubbles: true, cancelable: true });
+      act(() => {
+        document.dispatchEvent(event);
+      });
+      return event;
+    };
+
+    const mountLayer = (html: string) => {
+      const host = document.createElement("div");
+      host.innerHTML = html;
+      document.body.appendChild(host);
+      return () => host.remove();
+    };
+
+    it.each([
+      ['<div data-slot="popover-content" data-open></div>'],
+      ['<div data-slot="select-content" data-open></div>'],
+      ['<div data-slot="dropdown-menu-content" data-open></div>'],
+      ['<div data-slot="dialog-content" data-open></div>'],
+      ['<div class="bn-suggestion-menu"></div>'],
+    ])("leaves Escape to the open layer %s and keeps the sheet open", (html) => {
+      const { result } = renderHook(() => useEditorDialog(() => true));
+      act(() => result.current.setOpen(true));
+      const unmount = mountLayer(html);
+
+      const event = pressEscape();
+
+      expect(result.current.open).toBe(true);
+      expect(result.current.discardDialogProps.open).toBe(false);
+      expect(event.defaultPrevented).toBe(false);
+      unmount();
+    });
+
+    it("handles Escape again once the layer has closed", () => {
+      const { result } = renderHook(() => useEditorDialog(() => false));
+      act(() => result.current.setOpen(true));
+      const unmount = mountLayer('<div data-slot="popover-content" data-closed></div>');
+
+      pressEscape();
+
+      expect(result.current.open).toBe(false);
+      unmount();
+    });
+  });
+
   describe("escape key with nested editors", () => {
     const pressEscape = () =>
       act(() => {

package/src/components/forms/useEditorDialog.ts

@@ -11,6 +11,27 @@ import { useCallback, useEffect, useRef, useState } from "react";
 // editor that opened it.
 const openEditorStack: object[] = [];
 
+// Layers that open ABOVE an editor sheet and close on their own Escape: pickers
+// (popovers), selects, menus, nested dialogs, the discard confirmation, and the
+// rich-text editor's slash / mention menu. Our listener runs in the CAPTURE
+// phase on `document`, so it sees Escape before any of them — if it handled the
+// key it would stopPropagation() and close the whole sheet while the picker
+// stayed open underneath. While one of these is open, Escape is theirs.
+const INNER_LAYER_SELECTOR = [
+  "[data-slot=popover-content][data-open]",
+  "[data-slot=select-content][data-open]",
+  "[data-slot=combobox-content][data-open]",
+  "[data-slot=dropdown-menu-content][data-open]",
+  "[data-slot=context-menu-content][data-open]",
+  "[data-slot=dialog-content][data-open]",
+  "[data-slot=alert-dialog-content][data-open]",
+  ".bn-suggestion-menu",
+].join(",");
+
+export function hasOpenInnerLayer(doc: Document = document): boolean {
+  return doc.querySelector(INNER_LAYER_SELECTOR) !== null;
+}
+
 type UseEditorDialogOptions = {
   dialogOpen?: boolean;
   onDialogOpenChange?: (open: boolean) => void;
@@ -116,6 +137,7 @@ export function useEditorDialog(isFormDirty: () => boolean, options?: UseEditorD
     const handleKeyDown = (event: KeyboardEvent) => {
       if (event.key === "Escape" && open) {
         if (openEditorStack[openEditorStack.length - 1] !== dialogId.current) return;
+        if (hasOpenInnerLayer()) return;
         event.preventDefault();
         event.stopPropagation();
         handleOpenChange(false);

package/src/components/navigations/Breadcrumb.tsx

@@ -1,9 +1,9 @@
 "use client";
 
 import { useTranslations } from "next-intl";
-import { Fragment, useState } from "react";
+import { Fragment, useState, type MouseEvent } from "react";
 import { ChevronDownIcon } from "lucide-react";
-import { useIsMobile } from "../../utils";
+import { cn, useIsMobile } from "../../utils";
 import { usePageUrlGenerator } from "../../hooks";
 import { BreadcrumbItemData } from "../../interfaces";
 import {
@@ -147,24 +147,53 @@ function BreadcrumbMobile({
     );
   }
 
+  // One entry means the menu could only offer the page already on screen, so
+  // the chevron promised a choice that does not exist: show plain text.
+  if (allItems.length <= 1) {
+    return (
+      <span className="text-foreground block min-w-0 truncate px-1.5 text-xs/relaxed font-normal">
+        {lastItem?.name}
+      </span>
+    );
+  }
+
   return (
     <DropdownMenu open={open} onOpenChange={setOpen}>
-      <DropdownMenuTrigger className="text-foreground text-xs/relaxed font-normal hover:bg-accent flex items-center gap-1 rounded-md px-1.5 py-0.5 transition-colors outline-none">
-        {lastItem?.name}
-        <ChevronDownIcon className="text-muted-foreground size-3.5" />
+      {/* min-h-9: a 36px tap target, where the bare text row was ~20px. */}
+      <DropdownMenuTrigger className="text-foreground text-xs/relaxed font-normal hover:bg-accent flex min-h-9 min-w-0 items-center gap-1 rounded-md px-1.5 py-0.5 transition-colors outline-none">
+        <span className="truncate">{lastItem?.name}</span>
+        <ChevronDownIcon className="text-muted-foreground size-3.5 shrink-0" />
       </DropdownMenuTrigger>
       <DropdownMenuContent align="start">
-        {allItems.map((item, index) => (
-          <DropdownMenuItem key={index}>
-            {item.href ? (
-              <Link href={item.href} onClick={item.onClick}>
-                {item.name}
-              </Link>
-            ) : (
-              <>{item.name}</>
-            )}
-          </DropdownMenuItem>
-        ))}
+        {allItems.map((item, index) =>
+          item.href ? (
+            // The item renders AS the link, so the whole row navigates — a Link
+            // nested inside the row only answered taps on its own text.
+            <DropdownMenuItem
+              key={index}
+              className="min-h-10"
+              render={(props) => (
+                <Link
+                  {...props}
+                  href={item.href!}
+                  className={cn(props.className, "text-foreground font-normal")}
+                  onClick={(event: MouseEvent<HTMLAnchorElement>) => {
+                    props.onClick?.(event);
+                    item.onClick?.();
+                  }}
+                >
+                  {props.children}
+                </Link>
+              )}
+            >
+              {item.name}
+            </DropdownMenuItem>
+          ) : (
+            <DropdownMenuItem key={index} className="min-h-10">
+              {item.name}
+            </DropdownMenuItem>
+          ),
+        )}
       </DropdownMenuContent>
     </DropdownMenu>
   );

package/src/components/navigations/Header.tsx

@@ -15,9 +15,22 @@ type HeaderProps = {
   /** Rendered before everything else, on mobile only — where the sidebar (and its logo) is off-canvas. */
   logo?: React.ReactNode;
   className?: string;
+  /**
+   * Drop the sidebar toggle on mobile. Set by page shells that render the mobile
+   * bottom bar, whose "Menu" slot opens the same drawer — two controls for one
+   * drawer only cost header room on a phone. Desktop always keeps the toggle.
+   */
+  hideSidebarTriggerOnMobile?: boolean;
 };
 
-export function Header({ children, mobileChildren, leftContent, logo, className }: HeaderProps) {
+export function Header({
+  children,
+  mobileChildren,
+  leftContent,
+  logo,
+  className,
+  hideSidebarTriggerOnMobile,
+}: HeaderProps) {
   const { breadcrumbs } = useSharedContext();
   const rootLabel = useHeaderRootLabel();
   const isRootHidden = useIsBreadcrumbRootHidden();
@@ -42,9 +55,9 @@ export function Header({ children, mobileChildren, leftContent, logo, className
     >
       <div className="bg-sidebar flex h-12 w-full flex-row items-center justify-between ps-2 pe-4">
         {isMobile && logo && <div className="flex shrink-0 flex-row items-center pe-1">{logo}</div>}
-        {sidebar && <SidebarTrigger aria-label="Toggle sidebar" id="sidebar-trigger" />}
+        {sidebar && !(isMobile && hideSidebarTriggerOnMobile) && <SidebarTrigger aria-label="Toggle sidebar" id="sidebar-trigger" />}
         {leftContent}
-        <div className="flex w-full flex-row items-center justify-start">
+        <div className="flex w-full flex-row items-center justify-start max-md:min-w-0">
           <BreadcrumbNavigation items={breadcrumbs} rootLabel={rootLabel ?? undefined} showRoot={!isRootHidden} />
         </div>
         {isMobile

package/src/components/navigations/MobileNavigationBar.tsx

@@ -84,6 +84,18 @@ export function MobileNavigationBar({ className }: { className?: string } = {})
           </>
         );
 
+        // A slot with neither href nor onClick is self-contained: its `render`
+        // brings its own control (e.g. an avatar that opens a user menu), so it
+        // is not wrapped in a Link/button — that would nest one interactive
+        // element inside another.
+        if (!item.href && !item.onClick) {
+          return (
+            <div key={item.key} data-testid={`mobile-nav-${item.key}`} className={cn(slotClass, tone)}>
+              <SlotContent item={item} />
+            </div>
+          );
+        }
+
         return item.href ? (
           <Link
             key={item.key}

package/src/components/navigations/__tests__/MobileNavigationBar.spec.tsx

@@ -109,6 +109,23 @@ describe("MobileNavigationBar", () => {
     expect(screen.getByTestId("avatar-stub")).toBeInTheDocument();
   });
 
+  it("renders a slot with neither href nor onClick as-is, without wrapping it in a link or button", () => {
+    renderBar([
+      {
+        key: "profile",
+        label: "Account",
+        render: (
+          <button type="button" data-testid="menu-trigger">
+            Account
+          </button>
+        ),
+      },
+    ]);
+    const trigger = screen.getByTestId("menu-trigger");
+    expect(trigger.parentElement?.closest("button, a")).toBeNull();
+    expect(screen.getAllByRole("button")).toHaveLength(1);
+  });
+
   // The load-bearing case: a bare startsWith would make href="/" match everything.
   it("marks only the exactly-matching slot active when one href is '/'", () => {
     pathnameRef.current = "/conversations";

package/src/components/tables/ContentListTable.tsx

@@ -10,6 +10,7 @@ import React, { ReactNode, memo, useMemo, useState } from "react";
 import { DataListRetriever, TableContent, useTableGenerator } from "../../hooks";
 import { ModuleWithPermissions } from "../../permissions";
 import { Button, Table, TableBody, TableCell, TableFooter, TableHead, TableHeader, TableRow } from "../../shadcnui";
+import { useIsMobile } from "../../utils/use-mobile";
 import { MicroLabel } from "../typography";
 import { ContentTableSearch } from "./ContentTableSearch";
 
@@ -110,6 +111,7 @@ function renderCell(cellDef: unknown, context: unknown): ReactNode {
 export const ContentListTable = memo(function ContentListTable(props: ContentListTableProps) {
   const { data, fields, checkedIds, toggleId, allowSearch, filters: _filters, fullWidth, onRowClick } = props;
   const t = useTranslations();
+  const isMobile = useIsMobile();
   const [expanded, setExpanded] = useState<ExpandedState>(
     props.defaultExpanded === true ? true : typeof props.defaultExpanded === "object" ? props.defaultExpanded : {},
   );
@@ -212,13 +214,60 @@ export const ContentListTable = memo(function ContentListTable(props: ContentLis
   // 12px title is the mismatch the opt-in exists to avoid.
   const titleIsLarge = (props.titleSize ?? (fullWidth ? `lg` : `sm`)) === `lg`;
 
+  const titleLabel = (
+    <div
+      className={cn(
+        "text-muted-foreground flex items-center gap-x-2  font-light whitespace-nowrap",
+        titleIsLarge ? `text-lg` : `text-sm`,
+      )}
+    >
+      {props.titleActions}
+      {props.tableGeneratorType.icon && (
+        <props.tableGeneratorType.icon className={cn(`text-primary`, titleIsLarge ? `h-6 w-6` : `h-4 w-4`)} />
+      )}
+      {props.title}
+    </div>
+  );
+
+  const hasTitleControls = !!(props.functions || props.filters || allowSearch);
+  const titleControls = (
+    <>
+      {props.filters}
+      {props.functions}
+      {/* `allowSearch !== false`, not `allowSearch`: the search box has
+          always rendered here whenever `functions`/`filters` were set, and
+          most callers rely on that without passing the flag. Gating on the
+          flag alone (as the sibling ContentListGrid does) would silently
+          remove search from every such list. This only lets a caller whose
+          retriever ignores `search` — e.g. notifications, whose repository
+          has no search param and no fulltext index — opt out of a control
+          that would do nothing. */}
+      {allowSearch !== false && <ContentTableSearch data={data} />}
+    </>
+  );
+
   return (
     <div data-help="list.table" className="flex w-full flex-col">
       {/* <div className="overflow-clip rounded-md border"> */}
       <div className={cn(`overflow-clip`, fullWidth ? `` : `rounded-md border`)}>
+        {/* On a phone the title bar sits above the table instead of inside its
+            header: inside, it is as wide as the table, so on a table wider than
+            the screen "Create New", search and filters land off-screen. Above it,
+            it wraps within the card while the table scrolls sideways on its own. */}
+        {props.title && isMobile && (
+          <div
+            data-testid="content-list-table-title-bar"
+            className="bg-card text-primary flex flex-wrap items-center gap-2 border-b p-4 font-bold"
+          >
+            <div className="shrink-0">{titleLabel}</div>
+            {hasTitleControls && (
+              <div className="ms-auto flex flex-wrap items-center justify-end gap-2">{titleControls}</div>
+            )}
+          </div>
+        )}
         <Table>
           <TableHeader className="bg-muted font-semibold">
-            {props.title && (
+            {props.title && !isMobile && (
               <TableRow>
                 <TableHead
                   className="bg-card rounded-t-lg text-primary p-4 text-start font-bold"
@@ -226,37 +275,8 @@ export const ContentListTable = memo(function ContentListTable(props: ContentLis
                 >
                   <div className="flex w-full items-center justify-between gap-x-2">
                     {/* <div className="w-full">{fullWidth ? `` : props.title}</div> */}
-                    <div className="w-full">
-                      <div
-                        className={cn(
-                          "text-muted-foreground flex items-center gap-x-2  font-light whitespace-nowrap",
-                          titleIsLarge ? `text-lg` : `text-sm`,
-                        )}
-                      >
-                        {props.titleActions}
-                        {props.tableGeneratorType.icon && (
-                          <props.tableGeneratorType.icon
-                            className={cn(`text-primary`, titleIsLarge ? `h-6 w-6` : `h-4 w-4`)}
-                          />
-                        )}
-                        {props.title}
-                      </div>
-                    </div>
-                    {(props.functions || props.filters || allowSearch) && (
-                      <>
-                        {props.filters}
-                        {props.functions}
-                        {/* `allowSearch !== false`, not `allowSearch`: the search box has
-                            always rendered here whenever `functions`/`filters` were set, and
-                            most callers rely on that without passing the flag. Gating on the
-                            flag alone (as the sibling ContentListGrid does) would silently
-                            remove search from every such list. This only lets a caller whose
-                            retriever ignores `search` — e.g. notifications, whose repository
-                            has no search param and no fulltext index — opt out of a control
-                            that would do nothing. */}
-                        {allowSearch !== false && <ContentTableSearch data={data} />}
-                      </>
-                    )}
+                    <div className="w-full">{titleLabel}</div>
+                    {hasTitleControls && titleControls}
                   </div>
                 </TableHead>
               </TableRow>

package/src/core/index.ts

@@ -113,6 +113,10 @@ export * from "../features/tokenusage/tokenusage-admin.module";
 // rationale as the line above: a bootstrapper needs it, and it must not drag
 // the feature's recharts client bundle in.
 export * from "../features/tokenusage/tokenusage.modules";
+// The analytics module bundle. Same placement rationale as the tokenusage lines
+// above: a bootstrapper needs it, and it must not drag the feature's client
+// bundle in.
+export * from "../features/analytics/analytics.modules";
 // configureTokenUsage() is called from the app's bootstrap file, which is
 // evaluated on the server as well as the client. Reaching it through the
 // client-marked ./tokenusage barrel makes it a client function, and calling one

package/src/core/registry/ModuleRegistry.ts

@@ -73,6 +73,13 @@ export interface FoundationModuleDefinitions {
   TokenUsageReportSummary: ModuleWithPermissions;
   TokenUsageReportTimeline: ModuleWithPermissions;
   TokenUsageReportBreakdown: ModuleWithPermissions;
+  // First-party web analytics modules (tracker + administrative dashboard)
+  AnalyticsEvent: ModuleWithPermissions;
+  AnalyticsSummary: ModuleWithPermissions;
+  AnalyticsTimeline: ModuleWithPermissions;
+  AnalyticsBreakdown: ModuleWithPermissions;
+  AnalyticsSession: ModuleWithPermissions;
+  AnalyticsPageView: ModuleWithPermissions;
 }
 
 // App-specific modules - apps will augment this interface ONLY

package/src/features/__tests__/i18n-keys.contract.spec.ts

@@ -34,6 +34,7 @@ const DECLARED_FOR_APP_RENDERED_SURFACES = new Set<string>([
   "administration.token_usage.description",
   "administration.users.description",
   "administration.ai_connections.description",
+  "analytics.admin.description",
   "handbook.chat.delete_confirm",
   "handbook.chat.rename_placeholder",
   "handbook.contents.title",

package/src/features/analytics/__tests__/server-entry.spec.tsx

@@ -0,0 +1,64 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { AnalyticsAdminPageContainer, AnalyticsJourneyPageContainer } from "../index";
+import { AnalyticsAdminPage, AnalyticsJourneyPage } from "../server-entry";
+
+const mocks = vi.hoisted(() => ({
+  hasRole: vi.fn(),
+  redirect: vi.fn((url: string) => {
+    // next/navigation's redirect throws to stop rendering; mirror that.
+    throw new Error(`NEXT_REDIRECT:${url}`);
+  }),
+}));
+
+// ServerSession reads next/headers cookies, which only exist inside a request.
+vi.mock("../../../server", () => ({
+  ServerSession: { hasRole: mocks.hasRole },
+}));
+
+vi.mock("next/navigation", () => ({
+  redirect: mocks.redirect,
+}));
+
+describe("analytics server entry", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("AnalyticsAdminPage renders the admin container for the role holder", async () => {
+    mocks.hasRole.mockResolvedValue(true);
+
+    const element = await AnalyticsAdminPage({
+      adminRoleId: "role-admin",
+      pageUrl: "/admin/stats",
+      sessionPageUrl: "/admin/stats/sessions",
+    });
+
+    expect(mocks.hasRole).toHaveBeenCalledWith("role-admin");
+    expect(element.type).toBe(AnalyticsAdminPageContainer);
+    expect(element.props).toEqual({ pageUrl: "/admin/stats", sessionPageUrl: "/admin/stats/sessions" });
+  });
+
+  it("AnalyticsAdminPage redirects to `/` by default without the role", async () => {
+    mocks.hasRole.mockResolvedValue(false);
+
+    await expect(AnalyticsAdminPage({ adminRoleId: "role-admin" })).rejects.toThrow("NEXT_REDIRECT:/");
+    expect(mocks.redirect).toHaveBeenCalledWith("/");
+  });
+
+  it("AnalyticsJourneyPage renders the journey container for the role holder", async () => {
+    mocks.hasRole.mockResolvedValue(true);
+
+    const element = await AnalyticsJourneyPage({ adminRoleId: "role-admin", sessionId: "s1", pageUrl: "/admin/stats" });
+
+    expect(element.type).toBe(AnalyticsJourneyPageContainer);
+    expect(element.props).toEqual({ sessionId: "s1", pageUrl: "/admin/stats" });
+  });
+
+  it("AnalyticsJourneyPage redirects to deniedRedirect without the role", async () => {
+    mocks.hasRole.mockResolvedValue(false);
+
+    await expect(
+      AnalyticsJourneyPage({ adminRoleId: "role-admin", sessionId: "s1", deniedRedirect: "/401" }),
+    ).rejects.toThrow("NEXT_REDIRECT:/401");
+  });
+});

package/src/features/analytics/analytics.modules.ts

@@ -0,0 +1,30 @@
+import { ModuleFactory, ModuleWithPermissions } from "../../permissions";
+import { AnalyticsBreakdown } from "./data/analytics-breakdown";
+import { AnalyticsEvent } from "./data/analytics-event";
+import { AnalyticsPageView } from "./data/analytics-page-view";
+import { AnalyticsSession } from "./data/analytics-session";
+import { AnalyticsSummary } from "./data/analytics-summary";
+import { AnalyticsTimeline } from "./data/analytics-timeline";
+
+/**
+ * Every resource behind the analytics tracker and dashboard, as one object a
+ * consuming app spreads into its `allModules`. Same rationale as
+ * `tokenUsageModules`: one spread cannot be partially done, and a forgotten
+ * name is `undefined` at runtime even though `Modules.X` typechecks.
+ *
+ * `AnalyticsPageView` is only a child segment: the service builds
+ * `analytics/administration/sessions/{id}/pageviews` with EndpointCreator's
+ * `childEndpoint`. None has a pageUrl — these are not navigable resources.
+ *
+ * `satisfies` keeps the constraint without widening the return type to an
+ * index signature (see tokenusage.modules.ts).
+ */
+export const analyticsModules = (factory: ModuleFactory) =>
+  ({
+    AnalyticsEvent: factory({ name: "analytics/events", model: AnalyticsEvent }),
+    AnalyticsSummary: factory({ name: "analytics/administration/summary", model: AnalyticsSummary }),
+    AnalyticsTimeline: factory({ name: "analytics/administration/timeline", model: AnalyticsTimeline }),
+    AnalyticsBreakdown: factory({ name: "analytics/administration/breakdown", model: AnalyticsBreakdown }),
+    AnalyticsSession: factory({ name: "analytics/administration/sessions", model: AnalyticsSession }),
+    AnalyticsPageView: factory({ name: "pageviews", model: AnalyticsPageView }),
+  }) satisfies Record<string, ModuleWithPermissions>;