@cosmicdrift/kumiko-renderer 0.388.0 → 0.389.0

package/dist/primitives.d.ts

@@ -1,6 +1,9 @@
 import type { ConfigCascade, ConfigScope, ConfigValueSource } from "@cosmicdrift/kumiko-framework/engine";
 import type { FieldIconKey, FormWidth, IconKey, NavIconKey, RowActionDisplay, SelectOptionTone } from "@cosmicdrift/kumiko-framework/ui-types";
 import { type ComponentType, type FormEvent, type KeyboardEvent, type ReactNode, type Ref } from "react";
+import type { DataTableBulk } from "./data-table-bulk-types.ts";
+import type { DataTableDateRangeFacet, DataTableFacet } from "./data-table-facet-types.ts";
+import type { DataTableTableBlock } from "./data-table-view-types.ts";
 import type { FieldIssue, ListColumnViewModel, ListRowViewModel, RuntimeRenderer } from "./headless/index.ts";
 export type { RuntimeRenderer };
 /** Escape hatch for `data-*` test hooks (e.g. an E2E selector) that don't
@@ -647,55 +650,11 @@ export type DataTableRowAction = {
 export declare function shouldRenderActionsIconOnly(actions: readonly {
     readonly icon?: IconKey;
 }[]): boolean;
-export type DataTableFacet = {
-    /** Entity-Feldname (= URL-State-Key + payload.filters[].field). */
-    readonly field: string;
-    /** Translated Button-Label ("Status", "Active"). */
-    readonly label: string;
-    /** Selectable values with display labels. `value` is the raw filter value
-     *  (a select option or `"true"`/`"false"`), transported as a string. */
-    readonly options: readonly {
-        readonly value: string;
-        readonly label: string;
-    }[];
-    /** Present: render the facet as a row of single-choice toggle chips instead
-     *  of a dropdown. A chip is pressed while the selection equals its values. */
-    readonly chips?: readonly DataTableFacetChip[];
-    /** Chips only: show each chip's `count` next to its label. */
-    readonly showCounts?: boolean;
-    /** Chips only: hide chips whose `count` is 0 (unless pressed). */
-    readonly hideEmpty?: boolean;
-};
-export type DataTableFacetChip = {
-    readonly id: string;
-    /** Translated chip label. */
-    readonly label: string;
-    /** Selection a click sets; `[]` clears the facet. */
-    readonly values: readonly string[];
-    /** Matching row count, undefined while unknown. */
-    readonly count?: number;
-};
-export type DataTableDateRangeFacet = {
-    /** The facet's namespace (its date field) — a key, not a filter value. */
-    readonly field: string;
-    /** Translated label ("When"). */
-    readonly label: string;
-    readonly from: string;
-    readonly to: string;
-};
-/** Splits rows into collapsible groups (order of first appearance). A
- *  renderer without grouping support shows the flat list. A group whose
- *  `headerLabel` is undefined shows its rows without a header and never
- *  collapses. */
-export type DataTableRowGrouping = {
-    readonly keyOf: (row: ListRowViewModel) => string;
-    readonly headerLabel: (groupKey: string, rows: readonly ListRowViewModel[]) => string | undefined;
-    readonly startsCollapsed: (groupKey: string) => boolean;
-};
+export type { BulkRowOutcome, DataTableBulk, DataTableBulkAction, } from "./data-table-bulk-types.ts";
+export type { DataTableDateRangeFacet, DataTableFacet, DataTableFacetChip, } from "./data-table-facet-types.ts";
 export type DataTableProps = {
     readonly columns: readonly ListColumnViewModel[];
     readonly rows: readonly ListRowViewModel[];
-    readonly rowGrouping?: DataTableRowGrouping;
     /** Tints a row. Renderers without row tinting ignore it. */
     readonly rowTone?: (row: ListRowViewModel) => SelectOptionTone | undefined;
     readonly onRowClick?: (row: ListRowViewModel) => void;
@@ -723,6 +682,8 @@ export type DataTableProps = {
      *    kebab). Actions then sit at the same x-position across all rows
      *    (no drifting with label width) and all lists in an app look alike. */
     readonly rowActionMode?: DataTableRowActionMode;
+    /** Present: row checkboxes plus a selection bar that runs these actions once per selected row. */
+    readonly bulk?: DataTableBulk;
     /** Custom empty-state content (e.g. Icon + Heading + CTA-Button).
      *  The default renderer wraps it in a dashed-border box. */
     readonly emptyState?: ReactNode;
@@ -832,7 +793,8 @@ export type DataTableProps = {
     /** Content of the area under an expanded row. Native renderers implement
      *  the same three props. */
     readonly renderExpandedRow?: (row: ListRowViewModel) => ReactNode;
-};
+} & DataTableTableBlock;
+export type DataTableTableBlockProps = Pick<DataTableProps, keyof DataTableTableBlock>;
 /** Cell type for one column of an embedded-list field. Mirrors
  *  EmbeddedListCellViewModel["type"] from `@cosmicdrift/kumiko-renderer/headless`. */
 export type EmbeddedListCellType = "text" | "number" | "boolean" | "date" | "money" | "decimal" | "select" | "reference" | "timestamp";
@@ -1403,6 +1365,8 @@ export type JsonViewProps = {
  *  PDFs, an inline preview. Used for `renderer: { format: "file" }` on a detail field. */
 export type FileValueListProps = {
     readonly fileIds: readonly string[];
+    /** Starts the inline PDF preview of the first file open. */
+    readonly previewOpenByDefault?: boolean;
     readonly testId?: string;
 };
 /** Band above the tabs of a record detail: optional subtitle line plus the

package/dist/web/app/create-app.d.ts

@@ -92,6 +92,11 @@ export type CreateKumikoAppOptions = {
         readonly hasWorkspaces?: boolean;
         readonly features?: readonly FeatureSchema[];
     }) => NavApi;
+    /** URL prefix the app is mounted under (for example "/admin"). The default nav adapter reads
+     *  and writes URLs relative to it, and the auth gates and pages, which sit outside the
+     *  NavProvider, use it to match and build their paths. A custom `navAdapter` handles its own
+     *  prefix. */
+    readonly basePath?: string;
     /** App-wide default width for form/detail screens that don't set their
      *  own `layout.width`. Default "4xl" (unchanged behavior) — a
      *  consumer app that wants e.g. bundled-feature screens to match its own

package/dist/web/app/create-app.js

@@ -3,7 +3,7 @@ import { isOpenToAllGranted } from "@cosmicdrift/kumiko-framework/ui-types";
 import { createContext, useContext, useEffect, useMemo, useRef, useState, } from "react";
 import { createRoot } from "react-dom/client";
 import { rendererError, rendererWarn } from "../../dev-console.js";
-import { AppFeaturesProvider, ClientActionsProvider, ColumnRenderersProvider, ContentEditorsProvider, CustomScreensProvider, createSessionEndedSignal, DashboardBodyProvider, DispatcherProvider, DraftStorageProvider, ErrorBoundary, ExtensionSectionsProvider, hasDetailScreen, KumikoScreen, kumikoDefaultTranslations, LeaveGuardDialog, LiveEventsProvider, LocaleProvider, mergeTranslations, NavProvider, navigateWithReturnTo, PrimitivesProvider, qualifyScreenId, ScreenMissingState, SessionEndedSignalProvider, TokensProvider, toAppSchema, translationsByLocaleFromKeys, useNav, usePrimitives, useTranslation, withSessionEndedDetection, } from "../../index.js";
+import { AppFeaturesProvider, BasePathProvider, ClientActionsProvider, ColumnRenderersProvider, ContentEditorsProvider, CustomScreensProvider, createSessionEndedSignal, DashboardBodyProvider, DispatcherProvider, DraftStorageProvider, ErrorBoundary, ExtensionSectionsProvider, hasDetailScreen, KumikoScreen, kumikoDefaultTranslations, LeaveGuardDialog, LiveEventsProvider, LocaleProvider, mergeTranslations, NavProvider, navigateWithReturnTo, PrimitivesProvider, qualifyScreenId, ScreenMissingState, SessionEndedSignalProvider, TokensProvider, toAppSchema, translationsByLocaleFromKeys, useNav, usePrimitives, useTranslation, withSessionEndedDetection, } from "../../index.js";
 import { createLiveDispatcher } from "../../live/index.js";
 import { lastSegment } from "../layout/nav-tree.js";
 import { clearFileMetaCache } from "../primitives/file-thumbnail.js";
@@ -19,6 +19,7 @@ import { stackWrappers } from "./client-plugin.js";
 import { WebDashboardBody } from "./dashboard-body.js";
 import { DocumentLangSync } from "./document-lang-sync.js";
 import { createBrowserDraftStorage } from "./draft-storage.js";
+import { ListStateStoreBoot } from "./list-state-store-boot.js";
 import { useBrowserNavApi } from "./nav.js";
 import { NavProvidersProvider } from "./nav-providers-context.js";
 import { ResolversProvider } from "./resolvers-context.js";
@@ -237,7 +238,7 @@ function KumikoAppRoot(props) {
             warnMissingCustomScreens(loaded, props.customScreens);
             setApp(loaded);
         }, schemaIsRoleProjected: isFetchMode, ...(isFetchMode && { onUnmountResetSchema: () => setApp(undefined) }), ...(props.translate !== undefined && { translate: props.translate }), ...(props.onRowClick !== undefined && { onRowClick: props.onRowClick }), ...(props.shell !== undefined && { shell: props.shell }) }));
-    return (_jsx(TokensBoot, { children: _jsxs(LocaleProvider, { resolver: props.localeResolver, fallbackBundles: fallbackBundles, children: [_jsx(DocumentLangSync, { resolver: props.localeResolver }), _jsx(PrimitivesProvider, { value: props.primitives, children: _jsx(ScreenWidthProvider, { width: props.screenWidth, children: _jsx(AppFeaturesProvider, { features: app?.features ?? EMPTY_FEATURES, children: _jsx(DispatcherProvider, { dispatcher: props.dispatcher, children: _jsx(DraftStorageProvider, { value: props.draftStorage, children: _jsx(LiveEventsProvider, { value: props.liveEvents, children: _jsx(DashboardBodyProvider, { value: WebDashboardBody, children: _jsx(CustomScreensProvider, { value: props.customScreens, children: _jsx(ColumnRenderersProvider, { value: props.columnRenderers, children: _jsx(ContentEditorsProvider, { value: props.contentEditors, children: _jsx(ExtensionSectionsProvider, { value: props.extensionSectionComponents, children: _jsx(ClientActionsProvider, { value: props.clientActions, children: _jsx(NavProvidersProvider, { value: navProviders, entities: navEntities, children: _jsx(ResolversProvider, { resolvers: props.resolvers, children: _jsx(ToastProvider, { children: _jsxs(ToastActionNotifier, { children: [_jsx(UpdateChecker, {}), _jsx(LeaveGuardDialog, {}), _jsx(SessionEndedSignalProvider, { signal: props.sessionEndedSignal, children: stackWrappers(props.providers, stackWrappers(props.gates, screenNode)) })] }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) })] }) }));
+    return (_jsx(TokensBoot, { children: _jsxs(LocaleProvider, { resolver: props.localeResolver, fallbackBundles: fallbackBundles, children: [_jsx(DocumentLangSync, { resolver: props.localeResolver }), _jsx(PrimitivesProvider, { value: props.primitives, children: _jsx(ScreenWidthProvider, { width: props.screenWidth, children: _jsx(AppFeaturesProvider, { features: app?.features ?? EMPTY_FEATURES, children: _jsx(DispatcherProvider, { dispatcher: props.dispatcher, children: _jsx(DraftStorageProvider, { value: props.draftStorage, children: _jsx(LiveEventsProvider, { value: props.liveEvents, children: _jsx(DashboardBodyProvider, { value: WebDashboardBody, children: _jsx(CustomScreensProvider, { value: props.customScreens, children: _jsx(ColumnRenderersProvider, { value: props.columnRenderers, children: _jsx(ContentEditorsProvider, { value: props.contentEditors, children: _jsx(ExtensionSectionsProvider, { value: props.extensionSectionComponents, children: _jsx(ClientActionsProvider, { value: props.clientActions, children: _jsx(NavProvidersProvider, { value: navProviders, entities: navEntities, children: _jsx(ResolversProvider, { resolvers: props.resolvers, children: _jsx(ToastProvider, { children: _jsxs(ToastActionNotifier, { children: [_jsx(UpdateChecker, {}), _jsx(LeaveGuardDialog, {}), _jsx(SessionEndedSignalProvider, { signal: props.sessionEndedSignal, children: stackWrappers(props.providers, stackWrappers(props.gates, _jsx(ListStateStoreBoot, { children: screenNode }))) })] }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) })] }) }));
 }
 // Sits INSIDE the clientFeature gates (e.g. an auth gate) — a gate that
 // renders a login placeholder instead of children keeps this component
@@ -340,7 +341,9 @@ export function createKumikoApp(options = {}) {
         }
     }
     const localeResolver = options.locale ?? createBrowserLocaleResolver();
-    const navAdapter = options.navAdapter ?? useBrowserNavApi;
+    const { basePath } = options;
+    const useBrowserNavApiWithBasePath = (navOptions) => useBrowserNavApi({ ...navOptions, ...(basePath !== undefined && { basePath }) });
+    const navAdapter = options.navAdapter ?? useBrowserNavApiWithBasePath;
     const reporter = options.reportClientErrors === false ? undefined : createClientErrorReporter();
     reporter?.installGlobalHandlers();
     const handleBoundaryError = (error, info, context) => {
@@ -353,7 +356,7 @@ export function createKumikoApp(options = {}) {
         options.onError?.(error, info, context);
     };
     const root = createRoot(container);
-    root.render(_jsx(ErrorBoundary, { scope: "root", onError: handleBoundaryError, fallback: ({ errorId }) => _jsx(RootErrorFallback, { errorId: errorId }), children: _jsx(BoundaryErrorHandlerContext.Provider, { value: handleBoundaryError, children: _jsx(KumikoAppRoot, { initialApp: initialApp, screenQn: options.screenQn, ...(options.schemaUrl !== undefined && { schemaUrl: options.schemaUrl }), clientFeatures: clientFeatures, providers: providers, gates: gates, customScreens: customScreens, columnRenderers: columnRenderers, extensionSectionComponents: extensionSectionComponents, clientActions: clientActions, contentEditors: contentEditors, resolvers: resolvers, dispatcher: dispatcher, sessionEndedSignal: sessionEndedSignal, draftStorage: draftStorage, primitives: primitives, liveEvents: liveEvents, localeResolver: localeResolver, navAdapter: navAdapter, screenWidth: options.screenWidth, ...(options.translate !== undefined && { translate: options.translate }), ...(options.onRowClick !== undefined && { onRowClick: options.onRowClick }), ...(options.shell !== undefined && { shell: options.shell }) }) }) }));
+    root.render(_jsx(ErrorBoundary, { scope: "root", onError: handleBoundaryError, fallback: ({ errorId }) => _jsx(RootErrorFallback, { errorId: errorId }), children: _jsx(BoundaryErrorHandlerContext.Provider, { value: handleBoundaryError, children: _jsx(BasePathProvider, { basePath: basePath, children: _jsx(KumikoAppRoot, { initialApp: initialApp, screenQn: options.screenQn, ...(options.schemaUrl !== undefined && { schemaUrl: options.schemaUrl }), clientFeatures: clientFeatures, providers: providers, gates: gates, customScreens: customScreens, columnRenderers: columnRenderers, extensionSectionComponents: extensionSectionComponents, clientActions: clientActions, contentEditors: contentEditors, resolvers: resolvers, dispatcher: dispatcher, sessionEndedSignal: sessionEndedSignal, draftStorage: draftStorage, primitives: primitives, liveEvents: liveEvents, localeResolver: localeResolver, navAdapter: navAdapter, screenWidth: options.screenWidth, ...(options.translate !== undefined && { translate: options.translate }), ...(options.onRowClick !== undefined && { onRowClick: options.onRowClick }), ...(options.shell !== undefined && { shell: options.shell }) }) }) }) }));
     return { root };
 }
 // TokensBoot uses the browser-backed TokensApi hook (class-based

package/dist/web/app/history-leave-guard.d.ts

@@ -0,0 +1,6 @@
+export declare function committedUrl(): string;
+/** Adopts the entry the browser currently shows as the committed one. */
+export declare function adoptCurrentEntry(): void;
+export declare function pushEntry(url: string): void;
+export declare function replaceEntry(url: string): void;
+export declare function handlePopstate(notify: () => void): void;

package/dist/web/app/history-leave-guard.js

@@ -0,0 +1,115 @@
+import { propertyOf } from "@cosmicdrift/kumiko-types/type-guards";
+import { hasUnsavedInput, requestLeave } from "../../index.js";
+// Back/Forward cannot be vetoed, so the browser has already moved by the time the guard asks.
+// Each entry we create carries its position in history.state; with it a declined move is
+// undone with history.go(-delta) and a confirmed one replayed with history.go(delta), so the
+// stack keeps its shape (no duplicated or truncated entries).
+const INDEX_KEY = "kumikoNavIndex";
+const committed = { url: "", index: 0 };
+let leaveRequestOpen = false;
+// Each history.go() we issue produces one popstate that must not be treated as user navigation.
+const pendingMoves = [];
+// Entries without a position (written by other code) cannot be undone relatively.
+let fallbackTargetUrl;
+function readUrl() {
+    return `${window.location.pathname}${window.location.search}${window.location.hash}`;
+}
+function stateAt(index) {
+    return { [INDEX_KEY]: index };
+}
+function readIndex() {
+    const value = propertyOf(window.history.state, INDEX_KEY);
+    return typeof value === "number" ? value : undefined;
+}
+export function committedUrl() {
+    return committed.url;
+}
+/** Adopts the entry the browser currently shows as the committed one. */
+export function adoptCurrentEntry() {
+    const index = readIndex();
+    committed.url = readUrl();
+    if (index === undefined) {
+        window.history.replaceState(stateAt(committed.index), "", committed.url);
+    }
+    else {
+        committed.index = index;
+    }
+}
+function commitCurrentUrl() {
+    committed.url = readUrl();
+    committed.index = readIndex() ?? committed.index;
+}
+export function pushEntry(url) {
+    window.history.pushState(stateAt(committed.index + 1), "", url);
+    committed.index += 1;
+    committed.url = readUrl();
+}
+export function replaceEntry(url) {
+    window.history.replaceState(stateAt(committed.index), "", url);
+    commitCurrentUrl();
+}
+export function handlePopstate(notify) {
+    const move = pendingMoves.shift();
+    if (move !== undefined) {
+        if (move === "replay") {
+            commitCurrentUrl();
+            notify();
+        }
+        // skip: this popstate is the echo of our own history.go()
+        return;
+    }
+    if (fallbackTargetUrl !== undefined) {
+        const target = fallbackTargetUrl;
+        fallbackTargetUrl = undefined;
+        // After a forward move the entry below our restore-push is not the target.
+        if (readUrl() !== target)
+            window.history.replaceState(stateAt(committed.index), "", target);
+        commitCurrentUrl();
+        notify();
+        // skip: the pending fallback move is settled
+        return;
+    }
+    const newIndex = readIndex();
+    const delta = newIndex === undefined ? 0 : newIndex - committed.index;
+    if (leaveRequestOpen) {
+        // Another Back/Forward while the dialog is open must neither stack an entry nor replace the
+        // open request: step back to the entry the dialog is about.
+        if (delta !== 0) {
+            pendingMoves.push("undo");
+            window.history.go(-delta);
+        }
+        else {
+            window.history.replaceState(stateAt(committed.index), "", committed.url);
+        }
+        // skip: the open leave dialog keeps the decision
+        return;
+    }
+    if (!hasUnsavedInput()) {
+        commitCurrentUrl();
+        notify();
+        // skip: nothing unsaved, the move stands
+        return;
+    }
+    const targetUrl = readUrl();
+    leaveRequestOpen = true;
+    const settle = () => {
+        leaveRequestOpen = false;
+    };
+    if (delta !== 0) {
+        pendingMoves.push("undo");
+        window.history.go(-delta);
+        requestLeave(() => {
+            settle();
+            pendingMoves.push("replay");
+            window.history.go(delta);
+        }, settle);
+        // skip: the leave request owns the rest of the move
+        return;
+    }
+    window.history.pushState(stateAt(committed.index), "", committed.url);
+    requestLeave(() => {
+        settle();
+        fallbackTargetUrl = targetUrl;
+        window.history.back();
+    }, settle);
+}

package/dist/web/app/list-state-store-boot.d.ts

@@ -0,0 +1,6 @@
+import { type ReactNode } from "react";
+/** Provides the tab-scoped list-state store and drops state remembered under
+ *  another user or tenant. Mount below the auth gates so the user is known. */
+export declare function ListStateStoreBoot({ children }: {
+    readonly children: ReactNode;
+}): ReactNode;

package/dist/web/app/list-state-store-boot.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo } from "react";
+import { ListStateStoreProvider } from "../../components/list-state-store.js";
+import { useOptionalCurrentUser } from "../../current-user.js";
+import { resolveListStateStore } from "./session-list-state-store.js";
+/** Provides the tab-scoped list-state store and drops state remembered under
+ *  another user or tenant. Mount below the auth gates so the user is known. */
+export function ListStateStoreBoot({ children }) {
+    const user = useOptionalCurrentUser();
+    const userId = user?.id;
+    const tenantId = user?.tenantId;
+    // Must run before the first list renders; an effect would let it read the previous identity's state.
+    const store = useMemo(() => resolveListStateStore(userId === undefined ? undefined : { userId, tenantId }), [userId, tenantId]);
+    return _jsx(ListStateStoreProvider, { store: store, children: children });
+}

package/dist/web/app/nav.js

@@ -12,7 +12,9 @@ import { jsx as _jsx } from "react/jsx-runtime";
 // notification triggers (our pushPath and the popstate event), so this is not
 // generalizable.
 import { useCallback, useMemo, useSyncExternalStore, } from "react";
+import { normalizeBasePath, prependBasePath, stripBasePath } from "../../app/base-path.js";
 import { formatPath, hasUnsavedInput, parsePath, requestLeave, resolveTarget, useNav, } from "../../index.js";
+import { adoptCurrentEntry, handlePopstate, pushEntry, replaceEntry, } from "./history-leave-guard.js";
 // basePath allows the app to be mounted under a URL prefix
 // (for example, `/admin`). The read path strips the prefix before parsePath;
 // the write path prepends it before pushState/replaceState/href.
@@ -22,45 +24,11 @@ import { formatPath, hasUnsavedInput, parsePath, requestLeave, resolveTarget, us
 // returns route=undefined, and the app renders its "outside" state
 // (Not-Found, marketing layer, server-routing pickup, …). There is no
 // automatic redirect to the app root—the host app decides.
-function normalizeBasePath(raw) {
-    if (raw === undefined || raw === "" || raw === "/")
-        return "";
-    const withLeading = raw.startsWith("/") ? raw : `/${raw}`;
-    return withLeading.endsWith("/") ? withLeading.slice(0, -1) : withLeading;
-}
-// Returns the in-app (basePath-relative) path when `path` is under basePath;
-// otherwise returns `undefined`. The segment boundary is strict: "/administrator"
-// does not match "/admin"—otherwise a string-level prefix check would produce
-// false matches.
-function stripBasePath(path, basePath) {
-    if (basePath === "")
-        return path;
-    if (path === basePath)
-        return "/";
-    if (path.startsWith(`${basePath}/`))
-        return path.slice(basePath.length);
-    return undefined;
-}
-function prependBasePath(path, basePath) {
-    if (basePath === "")
-        return path;
-    // formatPath always returns an absolute in-app path: "/" or "/screen-id"
-    // or "/screen-id/entity-id". "/" becomes basePath; otherwise, concatenate.
-    if (path === "/" || path === "")
-        return basePath;
-    return `${basePath}${path}`;
-}
 // pushState does not fire popstate, so we maintain a listener set that
 // navigate() notifies. Back/Forward navigation goes through a window listener
 // wired exactly once.
 const listeners = new Set();
 let popstateWired = false;
-// URL the app currently shows; popstate has already moved the browser to the
-// target by the time we can ask, so a declined leave must restore this one.
-let committedUrl = "";
-function readUrl() {
-    return `${window.location.pathname}${window.location.search}${window.location.hash}`;
-}
 // Stable identity for the omitted-features case — `?? []` would create a
 // fresh array every render, busting the useMemo below on every render for
 // every existing useBrowserNavApi() call site (none of which pass features).
@@ -71,19 +39,7 @@ function ensurePopstateWired() {
     if (typeof window === "undefined")
         return;
     window.addEventListener("popstate", () => {
-        if (!hasUnsavedInput()) {
-            committedUrl = readUrl();
-            for (const l of listeners)
-                l();
-            return;
-        }
-        const targetUrl = readUrl();
-        window.history.pushState(null, "", committedUrl);
-        requestLeave(() => {
-            // replaceState, not history.back(): the declined entry is already ours
-            // and a forward navigation would otherwise land on the wrong entry.
-            window.history.replaceState(null, "", targetUrl);
-            committedUrl = targetUrl;
+        handlePopstate(() => {
             for (const l of listeners)
                 l();
         });
@@ -99,7 +55,7 @@ function ensurePopstateWired() {
 function subscribe(listener) {
     ensurePopstateWired();
     if (typeof window !== "undefined" && listeners.size === 0)
-        committedUrl = readUrl();
+        adoptCurrentEntry();
     listeners.add(listener);
     return () => {
         listeners.delete(listener);
@@ -146,8 +102,7 @@ function applySearchParamUpdates(updates) {
     if (nextSearch === window.location.search)
         return;
     const url = `${window.location.pathname}${nextSearch}${window.location.hash}`;
-    window.history.replaceState(null, "", url);
-    committedUrl = readUrl();
+    replaceEntry(url);
     for (const l of listeners)
         l();
 }
@@ -168,8 +123,7 @@ function pushPath(path, search) {
     if (unchanged)
         return;
     requestLeave(() => {
-        window.history.pushState(null, "", `${path}${search ?? ""}`);
-        committedUrl = readUrl();
+        pushEntry(`${path}${search ?? ""}`);
         for (const l of listeners)
             l();
     });
@@ -185,8 +139,7 @@ function replacePath(path, search) {
     const leavesCurrentPage = window.location.pathname !== path ||
         (search !== undefined && window.location.search !== search);
     const apply = () => {
-        window.history.replaceState(null, "", nextUrl);
-        committedUrl = readUrl();
+        replaceEntry(nextUrl);
         for (const l of listeners)
             l();
     };

package/dist/web/app/session-list-state-store.d.ts

@@ -0,0 +1,15 @@
+import type { ListStateStore } from "../../components/list-state-store.tsx";
+export type ListStateIdentity = {
+    readonly userId: string;
+    readonly tenantId?: string | undefined;
+};
+/** Remembered list state for the lifetime of the browser tab, keyed per tenant
+ *  and user. Every storage failure (blocked, full) degrades to "nothing remembered". */
+export declare function createSessionListStateStore(storage: Storage, identity: ListStateIdentity): ListStateStore;
+/** Forgets all remembered list state and the identity marker. Logout calls it
+ *  before a page reload, which would otherwise hide the identity change. */
+export declare function clearRememberedListState(): void;
+/** The store for the current identity. State remembered under another identity,
+ *  or under one that has since gone away, is dropped first. Without an identity
+ *  (app without auth) only the in-memory store is used and nothing is persisted. */
+export declare function resolveListStateStore(identity: ListStateIdentity | undefined): ListStateStore;

package/dist/web/app/session-list-state-store.js

@@ -0,0 +1,117 @@
+import { getDefaultMemoryListStateStore } from "../../components/list-state-store.js";
+import { parseStoredListStateJson } from "../../hooks/list-state-schema.js";
+const KEY_PREFIX = "kumiko.list.";
+const IDENTITY_KEY = `${KEY_PREFIX}identity`;
+const NO_TENANT = "-";
+function identityMarker(identity) {
+    return `${identity.tenantId ?? NO_TENANT}.${identity.userId}`;
+}
+function openSessionStorage() {
+    try {
+        return typeof window === "undefined" ? undefined : window.sessionStorage;
+    }
+    catch {
+        // Access itself throws when storage is blocked (privacy modes, sandboxed frames).
+        return undefined;
+    }
+}
+function prefixedKeys(storage) {
+    return Array.from({ length: storage.length }, (_, index) => storage.key(index)).filter((key) => key !== null && key.startsWith(KEY_PREFIX));
+}
+function removeAllRemembered(storage) {
+    for (const key of prefixedKeys(storage))
+        storage.removeItem(key);
+}
+/** Remembered list state for the lifetime of the browser tab, keyed per tenant
+ *  and user. Every storage failure (blocked, full) degrades to "nothing remembered". */
+export function createSessionListStateStore(storage, identity) {
+    const keyPrefix = `${KEY_PREFIX}${identityMarker(identity)}.`;
+    return {
+        read: (key) => {
+            try {
+                const raw = storage.getItem(`${keyPrefix}${key}`);
+                return raw === null ? undefined : parseStoredListStateJson(raw);
+            }
+            catch {
+                return undefined;
+            }
+        },
+        write: (key, state) => {
+            try {
+                storage.setItem(`${keyPrefix}${key}`, JSON.stringify(state));
+            }
+            catch {
+                // Quota or blocked storage: the list keeps working, it just is not remembered.
+            }
+        },
+        remove: (key) => {
+            try {
+                storage.removeItem(`${keyPrefix}${key}`);
+            }
+            catch {
+                // See write.
+            }
+        },
+        clear: () => {
+            try {
+                for (const key of prefixedKeys(storage).filter((k) => k !== IDENTITY_KEY)) {
+                    storage.removeItem(key);
+                }
+            }
+            catch {
+                // See write.
+            }
+        },
+    };
+}
+/** Forgets all remembered list state and the identity marker. Logout calls it
+ *  before a page reload, which would otherwise hide the identity change. */
+export function clearRememberedListState() {
+    getDefaultMemoryListStateStore().clear();
+    lastMemoryIdentity = undefined;
+    const storage = openSessionStorage();
+    // skip: no sessionStorage available, memory store already cleared
+    if (storage === undefined)
+        return;
+    try {
+        removeAllRemembered(storage);
+    }
+    catch {
+        // See createSessionListStateStore.
+    }
+}
+// The in-memory store survives SPA identity changes, so it needs its own marker.
+let lastMemoryIdentity;
+/** The store for the current identity. State remembered under another identity,
+ *  or under one that has since gone away, is dropped first. Without an identity
+ *  (app without auth) only the in-memory store is used and nothing is persisted. */
+export function resolveListStateStore(identity) {
+    const storage = openSessionStorage();
+    const memory = getDefaultMemoryListStateStore();
+    const marker = identity === undefined ? undefined : identityMarker(identity);
+    if (lastMemoryIdentity !== marker) {
+        if (lastMemoryIdentity !== undefined)
+            memory.clear();
+        lastMemoryIdentity = marker;
+    }
+    if (storage === undefined)
+        return memory;
+    try {
+        const storedMarker = storage.getItem(IDENTITY_KEY);
+        if (marker === undefined) {
+            if (storedMarker !== null) {
+                removeAllRemembered(storage);
+                memory.clear();
+            }
+            return memory;
+        }
+        if (storedMarker !== marker) {
+            removeAllRemembered(storage);
+            storage.setItem(IDENTITY_KEY, marker);
+        }
+    }
+    catch {
+        return memory;
+    }
+    return identity === undefined ? memory : createSessionListStateStore(storage, identity);
+}

package/dist/web/index.d.ts

@@ -13,6 +13,7 @@ export { KumikoLink, useBrowserNavApi } from "./app/nav.tsx";
 export { PlainContentEditor } from "./app/plain-content-editor.tsx";
 export { useResolvers } from "./app/resolvers-context.tsx";
 export { RichContentEditor } from "./app/rich-content-editor.tsx";
+export { clearRememberedListState } from "./app/session-list-state-store.ts";
 export type { NavIconKey } from "./icons.tsx";
 export { Icon } from "./icons.tsx";
 export type { AppLayoutProps } from "./layout/app-layout.tsx";

package/dist/web/index.js

@@ -12,6 +12,7 @@ export { KumikoLink, useBrowserNavApi } from "./app/nav.js";
 export { PlainContentEditor } from "./app/plain-content-editor.js";
 export { useResolvers } from "./app/resolvers-context.js";
 export { RichContentEditor } from "./app/rich-content-editor.js";
+export { clearRememberedListState } from "./app/session-list-state-store.js";
 export { Icon } from "./icons.js";
 export { AppLayout } from "./layout/app-layout.js";
 export { Avatar } from "./layout/avatar.js";

package/dist/web/lib/export-xlsx-request.d.ts

@@ -0,0 +1,11 @@
+import type { DataTableExport } from "../../data-table-view-types.ts";
+export type XlsxExportResult = {
+    readonly status: "ok";
+    readonly blob: Blob;
+} | {
+    readonly status: "too-many";
+    readonly maxRows: number | undefined;
+} | {
+    readonly status: "failed";
+};
+export declare function requestXlsxExport(source: DataTableExport): Promise<XlsxExportResult>;

package/dist/web/lib/export-xlsx-request.js

@@ -0,0 +1,46 @@
+import { isPlainObject } from "@cosmicdrift/kumiko-types/type-guards";
+import { CSRF_HEADER_NAME, LOCALE_HEADER_NAME, readActiveLocale, readCsrfToken, } from "../../live/index.js";
+const TOO_MANY_ROWS_HTTP_STATUS = 413;
+async function readMaxRows(res) {
+    try {
+        const body = await res.json();
+        const error = isPlainObject(body) ? body["error"] : undefined;
+        const details = isPlainObject(error) ? error["details"] : undefined;
+        const maxRows = isPlainObject(details) ? details["maxRows"] : undefined;
+        return typeof maxRows === "number" ? maxRows : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function requestXlsxExport(source) {
+    const headers = { "Content-Type": "application/json" };
+    const csrf = readCsrfToken();
+    if (csrf !== undefined)
+        headers[CSRF_HEADER_NAME] = csrf;
+    const locale = readActiveLocale();
+    if (locale !== undefined)
+        headers[LOCALE_HEADER_NAME] = locale;
+    try {
+        const res = await fetch("/api/export/xlsx", {
+            method: "POST",
+            credentials: "include",
+            headers,
+            body: JSON.stringify({
+                screen: source.screen,
+                payload: source.payload,
+                columns: source.columns,
+                timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+            }),
+        });
+        if (res.ok)
+            return { status: "ok", blob: await res.blob() };
+        if (res.status === TOO_MANY_ROWS_HTTP_STATUS) {
+            return { status: "too-many", maxRows: await readMaxRows(res) };
+        }
+        return { status: "failed" };
+    }
+    catch {
+        return { status: "failed" };
+    }
+}

package/dist/web/primitives/data-table/actions-column.d.ts

@@ -0,0 +1,16 @@
+import type { CSSProperties, ReactNode } from "react";
+export declare const ACTIONS_CONTENT_ATTRIBUTE = "data-actions-content";
+export declare function stickyActionsCellClass(fillsHeight: boolean): string;
+export declare function ActionsHeaderCell({ label, style, absorbsLeftover, }: {
+    readonly label: string;
+    readonly style?: CSSProperties | undefined;
+    /** Fixed table layout: `w-px` would pin this column to 1px, so it must size as auto and take the leftover width. */
+    readonly absorbsLeftover: boolean;
+}): ReactNode;
+export declare function ActionsBodyCell({ testId, fillsHeight, measureContent, children, }: {
+    readonly testId: string;
+    readonly fillsHeight: boolean;
+    /** Wraps the content so the column's natural width stays measurable under a fixed table layout. */
+    readonly measureContent: boolean;
+    readonly children: ReactNode;
+}): ReactNode;