@cosmicdrift/kumiko-renderer 0.388.0 → 0.390.0

package/dist/app/base-path-context.d.ts

@@ -0,0 +1,9 @@
+import { type ReactNode } from "react";
+/** Provides the URL prefix the app is mounted under to components outside the NavProvider
+ *  (auth gates and pages). `createKumikoApp({ basePath })` mounts it. */
+export declare function BasePathProvider({ basePath, children, }: {
+    readonly basePath: string | undefined;
+    readonly children: ReactNode;
+}): ReactNode;
+/** Normalized base path ("" when the app is served from the root). */
+export declare function useBasePath(): string;

package/dist/app/base-path-context.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+import { normalizeBasePath } from "./base-path.js";
+const BasePathContext = createContext("");
+/** Provides the URL prefix the app is mounted under to components outside the NavProvider
+ *  (auth gates and pages). `createKumikoApp({ basePath })` mounts it. */
+export function BasePathProvider({ basePath, children, }) {
+    return (_jsx(BasePathContext.Provider, { value: normalizeBasePath(basePath), children: children }));
+}
+/** Normalized base path ("" when the app is served from the root). */
+export function useBasePath() {
+    return useContext(BasePathContext);
+}

package/dist/app/base-path.d.ts

@@ -0,0 +1,3 @@
+export declare function normalizeBasePath(raw: string | undefined): string;
+export declare function stripBasePath(path: string, basePath: string): string | undefined;
+export declare function prependBasePath(path: string, basePath: string): string;

package/dist/app/base-path.js

@@ -0,0 +1,27 @@
+// basePath mounts an app under a URL prefix (for example, `/admin`). Pure helpers shared by the
+// browser nav adapter and the auth pages, which sit outside the NavProvider.
+export 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
+// `undefined`. The segment boundary is strict: "/administrator" does not match "/admin".
+export function stripBasePath(path, basePath) {
+    if (basePath === "")
+        return path;
+    if (path === basePath)
+        return "/";
+    if (path.startsWith(`${basePath}/`))
+        return path.slice(basePath.length);
+    return undefined;
+}
+export function prependBasePath(path, basePath) {
+    if (basePath === "")
+        return path;
+    // An in-app path is absolute: "/" or "/screen-id" or "/screen-id/entity-id". "/" becomes basePath.
+    if (path === "/" || path === "")
+        return basePath;
+    return `${basePath}${path}`;
+}

package/dist/app/config-edit-body.d.ts

@@ -2,7 +2,7 @@ import type { ConfigEditScreenDefinition } from "@cosmicdrift/kumiko-framework/u
 import { type ReactNode } from "react";
 import type { Translate } from "../headless/index.ts";
 import type { FeatureSchema } from "./feature-schema.ts";
-export declare function ConfigEditBody({ schema, screen, translate, }: {
+export declare function ConfigEditBody({ schema, screen: declaredScreen, translate, }: {
     readonly schema: FeatureSchema;
     readonly screen: ConfigEditScreenDefinition;
     readonly translate?: Translate;

package/dist/app/config-edit-body.js

@@ -11,6 +11,7 @@ import { useTranslation } from "../i18n.js";
 import { usePrimitives } from "../primitives.js";
 import { screenFillsHeight } from "../screen-fills-height.js";
 import { buildConfigEditSchema, synthesizeConfigEditEntity, synthesizeConfigEditScreen, } from "./config-edit-shim.js";
+import { configEditWithoutSecretFields } from "./config-edit-without-secret-fields.js";
 import { buildInitialValues } from "./entity-edit-prefill.js";
 import { layoutEditFields } from "./layout-fields.js";
 import { QueryErrorBanner, QueryLoadingBanner } from "./query-state-banners.js";
@@ -89,7 +90,7 @@ function isEmptyNumericFormValue(value) {
         return true;
     return typeof value === "number" && !Number.isFinite(value);
 }
-export function ConfigEditBody({ schema, screen, translate, }) {
+export function ConfigEditBody({ schema, screen: declaredScreen, translate, }) {
     const { ConfigCascadeView } = usePrimitives();
     const t = useTranslation();
     const effectiveTranslate = translate ?? t;
@@ -98,13 +99,17 @@ export function ConfigEditBody({ schema, screen, translate, }) {
     // We map them via screen.configKeys from short to qualified name onto our
     // form field values.
     const valuesQuery = useQuery("config:query:values", {
-        scope: screen.scope,
+        scope: declaredScreen.scope,
     });
     const cascadeQuery = useQuery("config:query:cascade", {
-        scope: screen.scope,
+        scope: declaredScreen.scope,
     });
-    const secretKeys = screen.secretKeys;
-    const secretsQuery = useQuery("secrets:query:list", {}, { enabled: secretKeys !== undefined });
+    const secretsQuery = useQuery("secrets:query:list", {}, { enabled: declaredScreen.secretKeys !== undefined });
+    // The form screen's access is the union of config and secrets access, so a viewer may write
+    // the config keys without being allowed to list secrets: that must not take the form down.
+    const secretsDenied = secretsQuery.error?.code === "access_denied";
+    const screen = useMemo(() => (secretsDenied ? configEditWithoutSecretFields(declaredScreen) : declaredScreen), [secretsDenied, declaredScreen]);
+    const secretKeys = secretsDenied ? undefined : declaredScreen.secretKeys;
     const synthEntity = useMemo(() => synthesizeConfigEditEntity(screen.fields), [screen.fields]);
     const synthScreen = useMemo(() => synthesizeConfigEditScreen(screen), [screen]);
     const boundsSchema = useMemo(() => buildConfigEditSchema(screen.fields), [screen.fields]);
@@ -304,7 +309,11 @@ export function ConfigEditBody({ schema, screen, translate, }) {
     ]);
     if (valuesQuery.loading && valuesQuery.data === null)
         return _jsx(QueryLoadingBanner, {});
-    const failedQuery = valuesQuery.error ? valuesQuery : secretsQuery.error ? secretsQuery : null;
+    const failedQuery = valuesQuery.error
+        ? valuesQuery
+        : secretsQuery.error && !secretsDenied
+            ? secretsQuery
+            : null;
     if (failedQuery?.error) {
         return (_jsx(QueryErrorBanner, { error: failedQuery.error, translate: effectiveTranslate, onRetry: failedQuery.refetch }));
     }

package/dist/app/config-edit-without-secret-fields.d.ts

@@ -0,0 +1,2 @@
+import type { ConfigEditScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
+export declare function configEditWithoutSecretFields(screen: ConfigEditScreenDefinition): ConfigEditScreenDefinition;

package/dist/app/config-edit-without-secret-fields.js

@@ -0,0 +1,28 @@
+import { isFieldsEditSection, normalizeEditField } from "@cosmicdrift/kumiko-framework/ui-types";
+// A merged provider form carries the secret-backed fields of a secrets feature the viewer may
+// not read. Without the secrets list those fields cannot show or save a state, so the form
+// drops them and stays usable for the config keys.
+export function configEditWithoutSecretFields(screen) {
+    const secretFieldNames = new Set(Object.keys(screen.secretKeys ?? {}));
+    if (secretFieldNames.size === 0)
+        return screen;
+    const keepSpec = (spec) => !secretFieldNames.has(normalizeEditField(spec).field);
+    const fields = Object.fromEntries(Object.entries(screen.fields).filter(([name]) => !secretFieldNames.has(name)));
+    const sections = screen.layout.sections.flatMap((section) => {
+        if (!isFieldsEditSection(section))
+            return [section];
+        if ("groups" in section) {
+            const groups = section.groups
+                .map((group) => ({ ...group, fields: group.fields.filter(keepSpec) }))
+                .filter((group) => group.fields.length > 0);
+            return groups.length === 0 ? [] : [{ ...section, groups }];
+        }
+        const kept = section.fields.filter(keepSpec);
+        return kept.length === 0 ? [] : [{ ...section, fields: kept }];
+    });
+    return {
+        ...screen,
+        fields,
+        layout: { ...screen.layout, sections },
+    };
+}

package/dist/app/entity-list-facet-specs.d.ts

@@ -0,0 +1,3 @@
+import type { Translate } from "../headless/index.ts";
+import type { ResolvedFacetSpec } from "./list-facets.ts";
+export declare function resolveEntityFacetSpecs(fields: Readonly<Record<string, unknown>>, featureName: string, entityName: string, translate: Translate): ResolvedFacetSpec[];

package/dist/app/entity-list-facet-specs.js

@@ -0,0 +1,65 @@
+import { parseRefTarget } from "@cosmicdrift/kumiko-framework/ui-types";
+import { propertyOf } from "@cosmicdrift/kumiko-types/type-guards";
+import { fieldLabelKey, fieldOptionLabelKey } from "../headless/index.js";
+// entityList adapter — one DataTableFacet per filterable select/boolean
+// entity field, labels via the standard field/option i18n convention.
+export function resolveEntityFacetSpecs(fields, featureName, entityName, translate) {
+    const out = [];
+    for (const [field, rawDef] of Object.entries(fields)) {
+        // entity.fields is weakly typed at the renderer layer (deserialized from the schema).
+        const def = {
+            type: propertyOf(rawDef, "type"),
+            filterable: propertyOf(rawDef, "filterable"),
+            options: propertyOf(rawDef, "options"),
+            entity: propertyOf(rawDef, "entity"),
+            labelField: propertyOf(rawDef, "labelField"),
+        };
+        if (def.filterable !== true)
+            continue;
+        const label = translate(fieldLabelKey(featureName, entityName, field));
+        if (def.type === "select" && Array.isArray(def.options)) {
+            const optionValues = def.options.filter((value) => typeof value === "string");
+            out.push({
+                field,
+                type: "select",
+                label,
+                options: optionValues.map((value) => ({
+                    value,
+                    label: translate(fieldOptionLabelKey(featureName, entityName, field, value)),
+                })),
+            });
+        }
+        else if (def.type === "boolean") {
+            out.push({
+                field,
+                type: "boolean",
+                label,
+                options: [
+                    {
+                        value: "true",
+                        label: translate(fieldOptionLabelKey(featureName, entityName, field, "true")),
+                    },
+                    {
+                        value: "false",
+                        label: translate(fieldOptionLabelKey(featureName, entityName, field, "false")),
+                    },
+                ],
+            });
+        }
+        else if (def.type === "reference" && typeof def.entity === "string") {
+            const target = parseRefTarget(def.entity, featureName);
+            out.push({
+                field,
+                type: "reference",
+                label,
+                options: [],
+                reference: {
+                    refEntity: target.entityName,
+                    refFeature: target.featureName,
+                    labelField: typeof def.labelField === "string" ? def.labelField : "id",
+                },
+            });
+        }
+    }
+    return out;
+}

package/dist/app/entity-list-screen.js

@@ -1,16 +1,16 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { evalFieldCondition, parseRefTarget } from "@cosmicdrift/kumiko-framework/ui-types";
+import { evalFieldCondition } from "@cosmicdrift/kumiko-framework/ui-types";
 import { resolveActionIcon } from "@cosmicdrift/kumiko-types/action-icon";
 import { propertyOf } from "@cosmicdrift/kumiko-types/type-guards";
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { ListGroupPageBridges } from "../components/list-group-page-bridges.js";
 import { RenderList } from "../components/render-list.js";
 import { useOptionalDispatcher } from "../context/dispatcher-context.js";
 import { useIsEmbeddedScreen } from "../context/embedded-screen-context.js";
 import { useUserRoles } from "../context/user-roles-context.js";
 import { rendererWarn } from "../dev-console.js";
-import { computeRelatedListSectionViewModel, fieldLabelKey, fieldOptionLabelKey, } from "../headless/index.js";
+import { computeRelatedListSectionViewModel } from "../headless/index.js";
 import { useListUrlState } from "../hooks/use-list-url-state.js";
-import { useQuery } from "../hooks/use-query.js";
 import { useTranslation } from "../i18n.js";
 import { usePrimitives } from "../primitives.js";
 import { screenFillsHeight } from "../screen-fills-height.js";
@@ -18,73 +18,21 @@ import { DrawerHost, useDrawerAction } from "./action-form-body.js";
 import { useAppFeatures } from "./app-features-context.js";
 import { useClientActionRuntime } from "./client-actions.js";
 import { EntityListExpandedRow } from "./entity-list-expanded-row.js";
+import { resolveEntityFacetSpecs } from "./entity-list-facet-specs.js";
 import { FacetCountBridges } from "./facet-count-bridge.js";
+import { useListBulk } from "./list-bulk-actions.js";
 import { isDefaultFilterActive, isListNarrowed, useListEmptyContent, } from "./list-empty-content.js";
 import { buildEntityFilterFacets, buildFacetCountRequests, buildFilterPayload, mergeReferenceFacetOptions, normalizeDefaultFilters, } from "./list-facets.js";
 import { useNav } from "./nav.js";
 import { QueryErrorBanner, QueryLoadingBanner } from "./query-state-banners.js";
 import { ReferenceFacetBridges } from "./reference-facet-bridge.js";
 import { navigateWithReturnTo, useReturnHost } from "./return-to.js";
-import { buildClientActionRowAction, buildDefaultEditRowAction, buildDrawerRowAction, buildProjectionToolbarActions, evalRowExtractor, findRowClickAction, navigateActionSearchParams, refetchAfterWrite, runDrawerRowAction, } from "./row-actions.js";
+import { buildClientActionRowAction, buildDefaultEditRowAction, buildDrawerRowAction, buildProjectionToolbarActions, buildWriteHandlerRowAction, findRowClickAction, navigateActionSearchParams, runDrawerRowAction, } from "./row-actions.js";
 import { findEditScreenFor } from "./screen-access.js";
-import { buildListQueryPayload, entityQueryCommand, isEntityEditScreenOfEntity, pageSizeOptionsFor, useNavigateToCreateFor, } from "./screen-shared.js";
-import { dispatcherErrorText, WriteFailedError } from "./write-failed-error.js";
-// entityList adapter — one DataTableFacet per filterable select/boolean
-// entity field, labels via the standard field/option i18n convention.
-function resolveEntityFacetSpecs(fields, featureName, entityName, translate) {
-    const out = [];
-    for (const [field, rawDef] of Object.entries(fields)) {
-        // entity.fields is weakly typed at the renderer layer (Record<string,
-        // unknown>, deserialized from the schema); boundary cast like buildInitialValues.
-        const def = rawDef;
-        if (def.filterable !== true)
-            continue;
-        const label = translate(fieldLabelKey(featureName, entityName, field));
-        if (def.type === "select" && Array.isArray(def.options)) {
-            out.push({
-                field,
-                type: "select",
-                label,
-                options: def.options.map((value) => ({
-                    value,
-                    label: translate(fieldOptionLabelKey(featureName, entityName, field, value)),
-                })),
-            });
-        }
-        else if (def.type === "boolean") {
-            out.push({
-                field,
-                type: "boolean",
-                label,
-                options: [
-                    {
-                        value: "true",
-                        label: translate(fieldOptionLabelKey(featureName, entityName, field, "true")),
-                    },
-                    {
-                        value: "false",
-                        label: translate(fieldOptionLabelKey(featureName, entityName, field, "false")),
-                    },
-                ],
-            });
-        }
-        else if (def.type === "reference" && def.entity !== undefined) {
-            const target = parseRefTarget(def.entity, featureName);
-            out.push({
-                field,
-                type: "reference",
-                label,
-                options: [],
-                reference: {
-                    refEntity: target.entityName,
-                    refFeature: target.featureName,
-                    labelField: def.labelField ?? "id",
-                },
-            });
-        }
-    }
-    return out;
-}
+import { buildListQueryPayload, entityQueryCommand, isEntityEditScreenOfEntity, useNavigateToCreateFor, } from "./screen-shared.js";
+import { useEntityRangeFacets } from "./use-entity-range-facets.js";
+import { listPager, useScreenListRows } from "./use-screen-list-rows.js";
+import { useScreenListTable } from "./use-screen-list-table.js";
 export function EntityListScreen({ schema, screen, translate, onRowClick, }) {
     const { Banner, Text } = usePrimitives();
     const entity = schema.entities[screen.entity];
@@ -120,29 +68,17 @@ function EntityListBody({ schema, screen, entity, translate, onRowClick, }) {
     const paginationMode = screen.pagination ?? "pages";
     const usePager = paginationMode === "pages";
     const useInfinite = paginationMode === "infinite";
-    // Infinite scroll: local state accumulates rows across several useQuery
-    // calls (instead of replacing them like the pager). The cursor changes when
-    // the user reaches the bottom sentinel; on a sort/q change everything is
-    // reset, since the insert order of the accumulated rows would otherwise be
-    // inconsistent with the new sorting.
-    const [accumulated, setAccumulated] = useState([]);
-    const [cursor, setCursor] = useState(undefined);
-    const [hasMore, setHasMore] = useState(true);
-    // Ref so the useEffect cleanup does not see stale state.
-    const sortQRef = useRef("");
-    const sortQKey = `${urlState.q}|${effectiveSort?.field ?? ""}|${effectiveSort?.dir ?? ""}`;
-    // Reset rows + cursor on a sort/q change, before the next useQuery so the
-    // reload starts with cursor=undefined.
-    useEffect(() => {
-        if (!useInfinite)
-            return;
-        if (sortQRef.current === sortQKey)
-            return;
-        sortQRef.current = sortQKey;
-        setAccumulated([]);
-        setCursor(undefined);
-        setHasMore(true);
-    }, [useInfinite, sortQKey]);
+    // Hook order: ALL hooks before the early return for loading/error,
+    // otherwise the hook slots collide between renders.
+    const t = useTranslation();
+    const effectiveTranslate = translate ?? t;
+    const range = useEntityRangeFacets({
+        fields: entity.fields,
+        screen,
+        featureName,
+        translate: effectiveTranslate,
+        urlState,
+    });
     // User-selected faceted filters from the URL state -> payload.filters.
     // typeOf reads the field type straight from entity.fields (not gated on
     // filterable, deliberately permissive; see the buildFilterPayload doc).
@@ -162,7 +98,7 @@ function EntityListBody({ schema, screen, entity, translate, onRowClick, }) {
             usePager,
             page: urlState.page,
             useInfinite,
-            cursor,
+            cursor: undefined,
         });
         // Screen filter (tier 2.7c), declared by the author on the schema and
         // independent of the user's q search. Several buckets of the same entity
@@ -171,9 +107,9 @@ function EntityListBody({ schema, screen, entity, translate, onRowClick, }) {
         if (screen.filter !== undefined) {
             payload["filter"] = screen.filter;
         }
-        if (filterPayload.length > 0) {
-            payload["filters"] = filterPayload;
-        }
+        const filters = [...filterPayload, ...range.rangeFilters];
+        if (filters.length > 0)
+            payload["filters"] = filters;
         return payload;
     }, [
         limit,
@@ -181,82 +117,51 @@ function EntityListBody({ schema, screen, entity, translate, onRowClick, }) {
         effectiveSort,
         screen.filter,
         filterPayload,
+        range.rangeFilters,
         usePager,
         urlState.page,
         useInfinite,
-        cursor,
     ]);
-    const rowsQuery = useQuery(queryType, queryPayload, { live: true });
     // Facet counts come from their own queries, which a write leaves untouched.
     const [facetCountRefreshNonce, setFacetCountRefreshNonce] = useState(0);
     const refreshFacetCounts = useCallback(() => setFacetCountRefreshNonce((n) => n + 1), []);
-    const refreshRowsAfterWrite = useCallback(async () => {
-        refreshFacetCounts();
-        if (useInfinite) {
-            setAccumulated([]);
-            setCursor(undefined);
-            setHasMore(true);
-            return;
-        }
-        await refetchAfterWrite(rowsQuery.refetch);
-    }, [useInfinite, rowsQuery.refetch, refreshFacetCounts]);
-    // Infinite scroll: on every successful result append the rows and derive
-    // hasMore from nextCursor. Live updates (postgres NOTIFY) and initial loads
-    // both pass through here; the useEffect dependency array pins the dedup to
-    // the last processed data pointer.
-    const lastDataRef = useRef(null);
-    useEffect(() => {
-        if (!useInfinite)
-            return;
-        const data = rowsQuery.data;
-        if (data === null)
-            return;
-        if (data === lastDataRef.current)
-            return;
-        lastDataRef.current = data;
-        setAccumulated((prev) => {
-            // When cursor is undefined this is the first page after a sort/q change:
-            // replace everything instead of appending. Otherwise dedupe on id in case
-            // live updates bring in an entry on the next page that was already appended.
-            if (cursor === undefined)
-                return data.rows;
-            const seen = new Set(prev.map((r) => r["id"]));
-            const fresh = data.rows.filter((r) => !seen.has(r["id"]));
-            return [...prev, ...fresh];
-        });
-        setHasMore(data.nextCursor !== null);
-    }, [rowsQuery.data, useInfinite, cursor]);
-    const loadMore = useCallback(() => {
-        if (!useInfinite)
-            return;
-        if (rowsQuery.loading)
-            return;
-        const data = rowsQuery.data;
-        if (data?.nextCursor === undefined || data.nextCursor === null)
-            return;
-        setCursor(data.nextCursor);
-    }, [useInfinite, rowsQuery.loading, rowsQuery.data]);
-    // RowActions: schema form (handler QN + i18n key) -> resolved form
-    // (dispatcher call + translated strings). dispatcher.write knows the user
-    // internally (JWT cookie). The schema may contain raw strings as well as
-    // i18n keys; translate() returns the key when the bundle does not know it
-    // (convention everywhere in the renderer).
-    // Hook order: ALL hooks before the early return for loading/error,
-    // otherwise the hook slots collide between renders.
-    const t = useTranslation();
-    const effectiveTranslate = translate ?? t;
     // Faceted filter: one dropdown per filterable select/boolean/reference field.
     // Labels + select option labels use the same i18n convention as the column
     // headers (fieldLabelKey / :option:<value>); reference fields load their
     // options asynchronously through ReferenceFacetBridges.
     const entityFacetSpecs = useMemo(() => resolveEntityFacetSpecs(entity.fields, featureName, screen.entity, effectiveTranslate), [entity.fields, featureName, screen.entity, effectiveTranslate]);
+    const facetFilterFields = useMemo(() => [...entityFacetSpecs.map((spec) => spec.field), ...range.rangeFields], [entityFacetSpecs, range.rangeFields]);
+    const listTable = useScreenListTable({
+        screen,
+        featureName,
+        payload: queryPayload,
+        filterFields: facetFilterFields,
+        queryType,
+        pageSize: limit,
+        paging: useInfinite ? "cursor" : "offset",
+        translate: effectiveTranslate,
+    });
+    const listRows = useScreenListRows({
+        queryType,
+        payload: queryPayload,
+        infinite: useInfinite,
+        aggregates: listTable.aggregates,
+    });
+    const { refreshAfterWrite: refreshListAfterWrite } = listRows;
+    const refreshRowsAfterWrite = useCallback(async () => {
+        refreshFacetCounts();
+        await refreshListAfterWrite();
+    }, [refreshFacetCounts, refreshListAfterWrite]);
     const [entityReferenceFacetOptions, setEntityReferenceFacetOptions] = useState({});
     const handleEntityFacetOptions = useCallback((field, options) => setEntityReferenceFacetOptions((prev) => prev[field] === options ? prev : { ...prev, [field]: options }), []);
     const [facetCounts, setFacetCounts] = useState({});
     const handleFacetCount = useCallback((key, count) => setFacetCounts((prev) => (prev[key] === count ? prev : { ...prev, [key]: count })), []);
     const filterFacets = useMemo(() => buildEntityFilterFacets(mergeReferenceFacetOptions(entityFacetSpecs, entityReferenceFacetOptions), screen.facets, effectiveTranslate, facetCounts), [entityFacetSpecs, entityReferenceFacetOptions, screen.facets, effectiveTranslate, facetCounts]);
     const facetCountQueries = useMemo(() => buildFacetCountRequests(entityFacetSpecs, screen.facets, effectiveTranslate).map((request) => {
-        const filters = buildFilterPayload({ ...urlState.filters, [request.field]: request.values }, (field) => entity.fields[field]?.type);
+        const filters = [
+            ...buildFilterPayload({ ...urlState.filters, [request.field]: request.values }, (field) => entity.fields[field]?.type),
+            ...range.rangeFilters,
+        ];
         return {
             key: request.key,
             payload: {
@@ -275,6 +180,7 @@ function EntityListBody({ schema, screen, entity, translate, onRowClick, }) {
         urlState.filters,
         urlState.q,
         entity.fields,
+        range.rangeFilters,
     ]);
     // Soft dispatcher: in tests that mount without a DispatcherProvider,
     // rowActions stays undefined instead of crashing. Real apps have the
@@ -371,35 +277,7 @@ function EntityListBody({ schema, screen, entity, translate, onRowClick, }) {
             }
             if (dispatcher === undefined)
                 return null;
-            const writeAction = action;
-            const writeActionVisible = writeAction.visible;
-            return {
-                id: writeAction.id,
-                label: effectiveTranslate(writeAction.label),
-                style: writeAction.style,
-                icon: resolveActionIcon(writeAction.id, writeAction.icon),
-                confirm: writeAction.confirm !== undefined ? effectiveTranslate(writeAction.confirm) : undefined,
-                confirmLabel: writeAction.confirmLabel !== undefined
-                    ? effectiveTranslate(writeAction.confirmLabel)
-                    : undefined,
-                onTrigger: async (row) => {
-                    const buildPayload = writeAction.payload;
-                    const payload = buildPayload !== undefined
-                        ? evalRowExtractor(buildPayload, row.values)
-                        : { id: row.values["id"] };
-                    const result = await dispatcher.write(writeAction.handler, payload);
-                    // write() does not throw: a failure result MUST become an error here,
-                    // otherwise the confirm dialog closes silently and the user sees "nothing
-                    // happened" (prod bug 2026-06-07).
-                    if (!result.isSuccess) {
-                        throw new WriteFailedError(result.error, dispatcherErrorText(result.error, effectiveTranslate));
-                    }
-                    await refreshRowsAfterWrite();
-                },
-                isVisible: writeActionVisible !== undefined
-                    ? (row) => evalFieldCondition(writeActionVisible, row.values)
-                    : undefined,
-            };
+            return buildWriteHandlerRowAction(action, effectiveTranslate, refreshRowsAfterWrite, dispatcher);
         })
             .filter((a) => a !== null);
     }, [
@@ -412,6 +290,13 @@ function EntityListBody({ schema, screen, entity, translate, onRowClick, }) {
         refreshRowsAfterWrite,
         openDrawer,
     ]);
+    const bulk = useListBulk({
+        bulkActions: screen.bulkActions,
+        rowActions: screen.rowActions,
+        translate: effectiveTranslate,
+        dispatcher,
+        reload: refreshRowsAfterWrite,
+    });
     // ToolbarActions: Schema → Resolved-Form (analog rowActions), shared with
     // projectionList and relatedList sections via buildProjectionToolbarActions.
     const toolbarActions = useMemo(() => buildProjectionToolbarActions({
@@ -471,14 +356,14 @@ function EntityListBody({ schema, screen, entity, translate, onRowClick, }) {
         refreshRowsAfterWrite,
         invalidateExpansions,
     ]);
-    if (rowsQuery.loading && rowsQuery.data === null) {
+    if (listRows.firstLoad) {
         return _jsx(QueryLoadingBanner, {});
     }
-    if (rowsQuery.error && rowsQuery.data === null) {
-        return (_jsx(QueryErrorBanner, { error: rowsQuery.error, translate: effectiveTranslate, onRetry: rowsQuery.refetch }));
+    if (listRows.error && !listRows.hasData) {
+        return (_jsx(QueryErrorBanner, { error: listRows.error, translate: effectiveTranslate, onRetry: listRows.retry }));
     }
     // A failed refetch keeps the last good data on screen.
-    const refetchErrorBanner = rowsQuery.error ? (_jsx(QueryErrorBanner, { error: rowsQuery.error, translate: effectiveTranslate, onRetry: rowsQuery.refetch })) : null;
+    const refetchErrorBanner = listRows.error ? (_jsx(QueryErrorBanner, { error: listRows.error, translate: effectiveTranslate, onRetry: listRows.retry })) : null;
     // RenderList's onRowClick is a 1-arg callback; KumikoScreen's
     // 2-arg shape (row, entityName) is the public surface — thread the
     // screen's entity through here so callers don't have to re-derive
@@ -507,41 +392,24 @@ function EntityListBody({ schema, screen, entity, translate, onRowClick, }) {
     // Assemble pager props only for pagination="pages". The server total
     // arrives async; until it is there RenderList renders the table without a
     // pager (the pager has its own total>0 guard).
-    const total = rowsQuery.data?.total;
-    const pager = usePager && total !== undefined
-        ? {
-            page: urlState.page,
-            limit,
-            total,
-            onPageChange: urlState.setPage,
-            pageSizeOptions: pageSizeOptionsFor(limit),
-            onPageSizeChange: urlState.setPageSize,
-        }
-        : undefined;
-    // In infinite mode rows come from accumulated (collected across several
-    // useQuery calls), with pages/false from the current result.
-    const renderRows = useInfinite ? accumulated : (rowsQuery.data?.rows ?? []);
-    return (_jsxs(_Fragment, { children: [refetchErrorBanner, _jsx(ReferenceFacetBridges, { specs: entityFacetSpecs, onOptions: handleEntityFacetOptions }), _jsx(FacetCountBridges, { queryType: queryType, queries: facetCountQueries, onCount: handleFacetCount, refreshNonce: facetCountRefreshNonce }), _jsx(RenderList, { screen: screen, entity: entity, rows: renderRows, featureName: featureName, searchable: searchable, narrowed: isListNarrowed(urlState.q, urlState.filters, defaultFilters), defaultFilterActive: isDefaultFilterActive(urlState.q, urlState.filters, defaultFilters), ...(screen.description !== undefined && {
+    const pager = listPager({ usePager, page: listRows.page, limit, urlState });
+    return (_jsxs(_Fragment, { children: [refetchErrorBanner, _jsx(ListGroupPageBridges, { ...listTable.aggregates.groupPages }), _jsx(ReferenceFacetBridges, { specs: entityFacetSpecs, onOptions: handleEntityFacetOptions }), _jsx(FacetCountBridges, { queryType: queryType, queries: facetCountQueries, onCount: handleFacetCount, refreshNonce: facetCountRefreshNonce }), _jsx(RenderList, { screen: screen, entity: entity, rows: listRows.rows, featureName: featureName, searchable: searchable, narrowed: isListNarrowed(urlState.q, urlState.filters, defaultFilters), defaultFilterActive: isDefaultFilterActive(urlState.q, urlState.filters, defaultFilters), ...(screen.description !== undefined && {
                     description: effectiveTranslate(screen.description),
                 }), ...(emptyContent !== undefined && { emptyContent }), searchValue: urlState.q, onSearchChange: urlState.setQ, sort: effectiveSort, onSortChange: urlState.setSort, ...(isEmbeddedScreen
                     ? { screenPadding: false, chromeless: true }
-                    : { screenPadding: true }), ...(screenFillsHeight(screen) && { scrollBody: true }), ...(pager !== undefined && { pager }), ...(rowActions !== undefined && { rowActions }), ...(screen.rowActionMode !== undefined && { rowActionMode: screen.rowActionMode }), ...(toolbarActions !== undefined && toolbarActions.length > 0 && { toolbarActions }), ...(useInfinite && {
-                    onReachEnd: loadMore,
-                    loadingMore: rowsQuery.loading,
-                    hasMore,
-                }), ...(onCreate !== undefined && { onCreate }), ...(translate !== undefined && { translate }), ...(wrappedOnRowClick !== undefined && { onRowClick: wrappedOnRowClick }), ...(filterFacets.length > 0 && {
-                    filterFacets,
+                    : { screenPadding: true }), ...(screenFillsHeight(screen) && { scrollBody: true }), ...(pager !== undefined && { pager }), ...(rowActions !== undefined && { rowActions }), ...(screen.rowActionMode !== undefined && { rowActionMode: screen.rowActionMode }), ...(bulk !== undefined && { bulk }), ...(toolbarActions !== undefined && toolbarActions.length > 0 && { toolbarActions }), ...listRows.infinite, ...(onCreate !== undefined && { onCreate }), ...(translate !== undefined && { translate }), ...(wrappedOnRowClick !== undefined && { onRowClick: wrappedOnRowClick }), ...(filterFacets.length > 0 && { filterFacets, onFilterChange: urlState.setFilter }), ...(range.rangeFacets.length > 0 && {
+                    rangeFacets: range.rangeFacets,
+                    onRangeChange: range.onRangeChange,
+                }), ...((filterFacets.length > 0 || range.rangeFacets.length > 0) && {
                     filterValues: urlState.filters,
-                    onFilterChange: urlState.setFilter,
                     onFilterReset: urlState.clearFilters,
-                }), ...(expandableSection !== undefined && {
+                }), ...listTable.props, ...(expandableSection !== undefined && {
                     expandedRowIds,
                     onToggleRowExpanded: toggleRowExpanded,
                     renderExpandedRow,
                 }) }), _jsx(DrawerHost, { schema: schema, drawerAction: drawerAction, drawerScreen: drawerScreen, ...(drawerInitialValues !== undefined && { drawerInitialValues }), userRoles: userRoles, ...(translate !== undefined && { translate }), onClose: closeDrawer, onSuccess: () => {
                     closeDrawer();
                     invalidateExpansions();
-                    refreshFacetCounts();
-                    void rowsQuery.refetch();
+                    void refreshRowsAfterWrite();
                 } })] }));
 }