nexus-shared 3.2.0 → 4.1.0

package/dist/Services/ImageEditorLoader.d.ts

@@ -0,0 +1,14 @@
+import type { ImageEditorModule } from "../Interfaces/FileInterfaces.ts";
+/**
+ * The image editor module, downloaded once per page. A failed download is not kept, so the next Edit tries again.
+ * Rejects with an `Error` in plain words ("The image editor is not installed on this server yet.", "The image editor
+ * could not be downloaded..."), and logs the cause (a network error, a 404, a bundler that rewrote the import) to the
+ * console, so a page that shows the message never hides why.
+ *
+ * @example
+ * const { openImageEditor } = await loadImageEditor();
+ * const picture = await openImageEditor({ src: file, aspect: 1, thumbnail: 256 });
+ */
+export declare function loadImageEditor(): Promise<ImageEditorModule>;
+/** Starts the download early, on the hover or focus of an Edit button, so the editor opens at once. Never rejects. */
+export declare function preloadImageEditor(): void;

package/dist/Services/ImageEditorLoader.js

@@ -0,0 +1,51 @@
+"use client";
+import { getFileAdapter } from "./FileApi.js";
+import { importModule } from "./ModuleImport.js";
+/*
+ * The image editor (`nexus-image-editor`, about 45 KB gzipped) is never in an app's bundle: the file backend serves it
+ * at a versioned address, and this loader downloads it the first time someone edits a picture. The address comes from
+ * the adapter (with Nexus, Drive's `Assets/File/nexus-image-editor.txt` names the current file), and the import is left
+ * alone by the bundler (`importModule`, ModuleImport.ts), so the module is fetched by the browser itself and cached by
+ * its immutable name.
+ */
+let loading = null;
+/** What a person reads when the module itself could not be downloaded or run: the cause goes to the console. */
+const NOT_DOWNLOADED = "The image editor could not be downloaded. Check the connection and try again; if it keeps failing, tell the site's support.";
+/**
+ * The image editor module, downloaded once per page. A failed download is not kept, so the next Edit tries again.
+ * Rejects with an `Error` in plain words ("The image editor is not installed on this server yet.", "The image editor
+ * could not be downloaded..."), and logs the cause (a network error, a 404, a bundler that rewrote the import) to the
+ * console, so a page that shows the message never hides why.
+ *
+ * @example
+ * const { openImageEditor } = await loadImageEditor();
+ * const picture = await openImageEditor({ src: file, aspect: 1, thumbnail: 256 });
+ */
+export function loadImageEditor() {
+    loading ??= getFileAdapter()
+        .editorModuleUrl()
+        .then(url => importModule(url).catch((cause) => {
+        console.error(`loadImageEditor(): ${url} could not be imported.`, cause);
+        throw new Error(NOT_DOWNLOADED);
+    }), (cause) => {
+        // The address could not be read: the adapter says why in plain words ("not installed on this server yet").
+        console.error("loadImageEditor(): the image editor's address could not be read.", cause);
+        throw cause instanceof Error && cause.message ? cause : new Error(NOT_DOWNLOADED);
+    })
+        .then(module => {
+        if (typeof module?.openImageEditor !== "function") {
+            console.error("loadImageEditor(): the module downloaded has no openImageEditor.", module);
+            throw new Error("The image editor on the server is not one this page can open.");
+        }
+        return module;
+    })
+        .catch((error) => {
+        loading = null;
+        throw error instanceof Error ? error : new Error(NOT_DOWNLOADED);
+    });
+    return loading;
+}
+/** Starts the download early, on the hover or focus of an Edit button, so the editor opens at once. Never rejects. */
+export function preloadImageEditor() {
+    loadImageEditor().catch(() => undefined);
+}

package/dist/Services/JoinSources.d.ts

@@ -6,27 +6,87 @@ import type { TableJoinSource, TableJoinedRecord } from "../Interfaces/TableInte
  * A join's source as the table calls it. An endpoint becomes one that POSTs the keys to it as an array and reads the
  * records it answers - a Nexus controller's `findListing` - made once per endpoint, so every table and picker naming it
  * shares one source and so one cache. A source of the page's own is used as it is.
+ *
+ * `key` is the field the records answered are filed under, `id` unless told: one whose values are another field (a
+ * person's account, which their company row carries beside its own key) is a source of its own, kept apart.
+ */
+export declare function joinSource(source: ApiEndpoint | TableJoinSource, backend?: CrudBackend, key?: string): TableJoinSource;
+/**
+ * The record a `findListing` answered for a key, or one the page remembered there (`TableJoins.remember`), at once and
+ * with no call, while it is fresh: `undefined` while it is not in, and once it was marked old (a save on that controller,
+ * a Reload), so a picker asks again and shows the record as it is now. A picker over that controller's records names a
+ * value with it (`peekOption`), and so does a CRUD's save, which takes an old one too (`aged`) over no name at all.
  */
-export declare function joinSource(source: ApiEndpoint | TableJoinSource, backend?: CrudBackend): TableJoinSource;
+export declare function peekFound(findListing: ApiEndpoint, key: string, aged?: boolean): TableJoinedRecord | undefined;
 /** The controller a picker offers records from: any with an `activeListing` and a `findListing` (`MODULES.controller(...)`). */
 export interface PickerController {
     activeListing: ApiEndpoint;
     findListing: ApiEndpoint;
 }
+/**
+ * A controller whose picker reads another listing (`CrudPickerOptions.list`): it may have no `activeListing`, and a
+ * `findListing` only when it has one - a pay run's CRUD endpoints, every run of the company in its NormalListing.
+ */
+export interface PickerListController {
+    activeListing?: ApiEndpoint;
+    findListing?: ApiEndpoint;
+}
 /** What `crudPicker` needs to know of the records: the field a person reads, and the one under it. */
 export interface CrudPickerOptions {
     /** The field shown as the option: `"regionName"`. */
     labelKey: string;
     /** A field shown under it, such as the parent's name: `"regionName"` under a sub-region. */
     descriptionKey?: string;
-    /** The field that holds the key. Default `id`. */
+    /**
+     * The field that holds the value. Default `id`: the records' own key, which is what the controller's `findListing`
+     * takes. Another field - a person's account (`userId`), which their company row carries beside its own key - needs
+     * `find` for the values the kept list does not offer.
+     */
     valueKey?: string;
+    /**
+     * Where a value the kept list does not offer is looked up when `valueKey` is not `id`: an endpoint that takes such
+     * values, POSTed as an array as `findListing` takes keys, and answers the records, each read by its `valueKey` field;
+     * or a source of the page's own. Its answers are kept apart from `findListing`'s and marked old with them, after a save
+     * on the controller. Without it such a value is never looked up - `findListing` could not answer it - so a form names it
+     * from the record it holds (`selectedOptions`), or it shows as not found.
+     */
+    find?: ApiEndpoint | TableJoinSource;
+    /**
+     * The query parameter the controller's `activeListing` narrows by on the server, for a picker another input narrows
+     * (`narrowedBy`): `"subscriptionGroupId"` asks `...?subscriptionGroupId={the group}` and keeps each answer apart. Without
+     * it, the whole list is read once and narrowed in the browser by the records' own field (`narrowedBy.key`). Narrowed by
+     * several values at once (`narrowedBy` as a list), it names the narrowings' keys the server takes as query parameters
+     * (a list of them, or one); a value the listing's path takes (`{itemId}` in `list`) always goes there, and the rest
+     * narrow in the browser.
+     */
+    narrowQuery?: string | readonly string[];
+    /**
+     * The listing the options are read from, in place of the controller's `activeListing`: a controller with none, or a
+     * picker that offers more than the usable records - every pay run of the company (`PAY_RUNS.lists.normal`), drafts too.
+     * Read once and kept for the page as the active list is, and marked old when a CRUD on that controller changes a
+     * record (`expireLookups` reads the CRUD's `lists`).
+     */
+    list?: ApiEndpoint;
+    /**
+     * Which records are usable: offered, and shown untagged when a form holds one. Default the backend's rule
+     * (`CrudBackend.isPickable`: for Nexus a record under 30, so one pending in 30-39 - an invited person - is not). A list
+     * whose records use a band of their own says so: `usable: run => run.recordStatus < NEXUS_TRASH_STATUS` offers a pay
+     * run's draft (31) beside the locked runs.
+     */
+    usable?: (record: TableJoinedRecord) => boolean;
+    /**
+     * The option shown for a record, when its words are not one field: `run => ({ ...run, label: run.monthName + " · " +
+     * run.runCode, state: STATES[run.payRunState] })` with `labelKey: "label"` and `descriptionKey: "state"`. Keep the
+     * record's fields (spread it): the value, the search and the page read the option. Made once per record read.
+     */
+    option?: (record: TableJoinedRecord) => TableJoinedRecord;
     backend?: CrudBackend;
 }
 /** The dropdown params `crudPicker` gives: spread them into a dropdown's input. */
 export interface CrudPickerParams {
     loadOptions: (request: DropdownPageRequest) => Promise<DropdownPage<TableJoinedRecord>>;
     resolveOptions: (values: OptionValue[]) => Promise<readonly TableJoinedRecord[]>;
+    peekOption: (key: string, aged?: boolean) => TableJoinedRecord | undefined;
     valueKey: string;
     labelKey: string;
     descriptionKey?: string;
@@ -37,12 +97,25 @@ export interface CrudPickerParams {
  * for every form on the page (the owner's caching rule: a second dropdown, or an Add row, never asks again), searched
  * and paged in the browser. A value the form already holds that the list does not offer - a parent since trashed - is
  * found through `findListing`, sharing the calls and answers of the tables' joins, and shows tagged, never offered again.
+ * A value that is not the records' key (`valueKey`) is found through the picker's own `find` instead.
+ *
+ * A picker can read another listing (`list`), say which records are usable (`usable`) and make each option's words
+ * (`option`): every pay run of the company, drafts too, named by month and code with its state under it.
  *
- * @example { type: "dropdown", name: "regionId", label: "Region", required: true, ...crudPicker(REGIONS, { labelKey: "regionName" }) }
+ * @example { type: EInputTypes.Dropdown, name: "regionId", label: "Region", required: true, ...crudPicker(REGIONS, { labelKey: "regionName" }) }
+ * @example crudPicker(COMPANY_USERS, { labelKey: "fullname", valueKey: "userId", find: COMPANY_USERS_BY_ACCOUNT })
+ * @example crudPicker(PAY_RUNS, { list: PAY_RUNS.lists.normal, usable: run => run.recordStatus < NEXUS_TRASH_STATUS, labelKey: "label", descriptionKey: "state", option: runOption })
  */
-export declare function crudPicker(controller: PickerController, { labelKey, descriptionKey, valueKey, backend }: CrudPickerOptions): CrudPickerParams;
+export declare function crudPicker(controller: PickerController, options: CrudPickerOptions): CrudPickerParams;
+export declare function crudPicker(controller: PickerListController, options: CrudPickerOptions & {
+    list: ApiEndpoint;
+}): CrudPickerParams;
 /**
  * Marks what the page looked up from a controller as old, after a write there may have changed it: the records its
- * `findListing` named, and the list its picker offers. Drawn as they are until the next ask brings the new ones.
+ * `findListing` named and its pickers' own finds answered, and the lists its pickers offer - its `activeListing`, and
+ * each of a CRUD's `lists` a picker reads instead (`CrudPickerOptions.list`). Drawn as they are until the next ask brings
+ * the new ones.
  */
-export declare function expireLookups(controller: Partial<PickerController>): void;
+export declare function expireLookups(controller: PickerListController & {
+    lists?: Partial<Record<string, ApiEndpoint>>;
+}): void;

package/dist/Services/JoinSources.js

@@ -1,26 +1,37 @@
 import { isApiEndpoint } from "../Helpers/ApiRoutes.js";
 import { getCrudBackend } from "../Helpers/CrudBackend.js";
+import { crudPickerNarrowAsk, crudPickerPlan, fitsNarrow, pathValueNames } from "../Helpers/CrudPickerPlan.js";
 import { filterItems } from "../Helpers/DropdownHelpers.js";
-import { joinSourceName, tableJoins } from "../Helpers/TableJoins.js";
+import { JOIN_LIFETIME, joinSourceName, tableJoins } from "../Helpers/TableJoins.js";
 import { api } from "./BrowserApi.js";
 /*
  * The browser's half of a join: the call that looks records up, and a picker that shares what it looked up. The cache
  * itself (`tableJoins`) knows nothing of the API; this is where an endpoint becomes a source it can call.
  */
 const made = new Map();
+/** The sources of the pickers' own finds (`crudPicker` `find`), by the name of the `findListing` of their controller. */
+const finds = new Map();
+/** The lists a picker asked the server for, one per narrowing value (`narrowQuery`), by the name of their whole list. */
+const narrowedLists = new Map();
+/** A field with no value: what `narrow.orUnset` adds to a narrowed list. */
+const unset = (value) => value === null || value === undefined || value === "";
 /**
  * A join's source as the table calls it. An endpoint becomes one that POSTs the keys to it as an array and reads the
  * records it answers - a Nexus controller's `findListing` - made once per endpoint, so every table and picker naming it
  * shares one source and so one cache. A source of the page's own is used as it is.
+ *
+ * `key` is the field the records answered are filed under, `id` unless told: one whose values are another field (a
+ * person's account, which their company row carries beside its own key) is a source of its own, kept apart.
  */
-export function joinSource(source, backend = getCrudBackend()) {
+export function joinSource(source, backend = getCrudBackend(), key = "id") {
     if (!isApiEndpoint(source))
         return source;
-    const name = joinSourceName(source);
+    const name = key === "id" ? joinSourceName(source) : `${joinSourceName(source)} by ${key}`;
     let found = made.get(name);
     if (!found) {
         found = {
             name,
+            ...(key !== "id" && { key }),
             async load(keys, signal) {
                 const answer = await api.send(source, { body: keys, signal, toast: false });
                 if (!answer.ok)
@@ -32,43 +43,143 @@ export function joinSource(source, backend = getCrudBackend()) {
     }
     return found;
 }
+/** What a source answered for a key, fresh, or - `aged` - also once it was marked old. */
+function peekSource(name, key, aged) {
+    if (!aged)
+        return tableJoins.peekFresh(name, key);
+    const state = tableJoins.peek(name, key);
+    return state.status === "ready" ? state.record : undefined;
+}
 /**
- * A dropdown of a controller's usable records, for picking a parent in a form: the `activeListing` read once and kept
- * for every form on the page (the owner's caching rule: a second dropdown, or an Add row, never asks again), searched
- * and paged in the browser. A value the form already holds that the list does not offer - a parent since trashed - is
- * found through `findListing`, sharing the calls and answers of the tables' joins, and shows tagged, never offered again.
- *
- * @example { type: "dropdown", name: "regionId", label: "Region", required: true, ...crudPicker(REGIONS, { labelKey: "regionName" }) }
+ * The record a `findListing` answered for a key, or one the page remembered there (`TableJoins.remember`), at once and
+ * with no call, while it is fresh: `undefined` while it is not in, and once it was marked old (a save on that controller,
+ * a Reload), so a picker asks again and shows the record as it is now. A picker over that controller's records names a
+ * value with it (`peekOption`), and so does a CRUD's save, which takes an old one too (`aged`) over no name at all.
  */
-export function crudPicker(controller, { labelKey, descriptionKey, valueKey = "id", backend = getCrudBackend() }) {
-    const listName = joinSourceName(controller.activeListing);
+export function peekFound(findListing, key, aged = false) {
+    return peekSource(joinSourceName(findListing), key, aged);
+}
+export function crudPicker(controller, options) {
+    const { labelKey, descriptionKey, find, narrowQuery, option, backend = getCrudBackend() } = options;
+    const plan = crudPickerPlan(controller, options, backend);
+    const valueKey = options.valueKey ?? "id";
+    const listName = joinSourceName(plan.list);
+    // Where a value the kept list does not offer is looked up: `findListing` while the values are the records' keys, the
+    // picker's own find for another field, and nowhere without either.
+    const lookup = plan.lookup ? joinSource(plan.lookup.source, backend, plan.lookup.key) : null;
+    if (find && lookup && controller.findListing) {
+        // Marked old with the controller's own lookups, after a save there (`expireLookups`).
+        const beside = joinSourceName(controller.findListing);
+        const kept = finds.get(beside) ?? new Set();
+        kept.add(lookup.name);
+        finds.set(beside, kept);
+    }
+    // Each record's option, made once per record read (a new read makes new records, and so new options).
+    const made = new WeakMap();
+    const shown = (record) => {
+        if (!option)
+            return record;
+        let kept = made.get(record);
+        if (!kept)
+            made.set(record, (kept = option(record)));
+        return kept;
+    };
+    const shownAll = (records) => (option ? records.map(shown) : records);
     // The words a person reads, not the key: a Nexus key is an encrypted token, and a search would find letters in it.
     const searchKeys = descriptionKey ? [labelKey, descriptionKey] : [labelKey];
-    const loadList = (signal) => api.send(controller.activeListing, { signal, toast: false }).then(answer => {
+    const loadList = (signal, query, params) => api.send(plan.list, { signal, toast: false, ...(query && { query }), ...(params && { params }) }).then(answer => {
         if (!answer.ok)
             throw new Error(answer.message ?? "The list could not be loaded.");
         return backend.readList(answer.result);
     });
+    // A listing whose path takes values (`StockBalance/Units/{storeId}/{itemId}`) is only ever read narrowed by them: its
+    // lists are kept one per values, and a saved value is named from them.
+    const pathNarrowed = pathValueNames(plan.list).length > 0;
+    const keepNarrowedName = (name) => {
+        const kept = narrowedLists.get(listName) ?? new Set();
+        kept.add(name);
+        narrowedLists.set(listName, kept);
+    };
+    /**
+     * The options narrowed by several values at once (`narrowedBy` as a list, a line's Tags of its Item in the form's Store),
+     * or by values the listing's path takes: each in the path, the query (`narrowQuery`) or the browser, as
+     * `crudPickerNarrowAsk` says.
+     */
+    const narrowedByAll = async (narrows) => {
+        const ask = crudPickerNarrowAsk(plan.list, listName, narrows, narrowQuery);
+        if (!ask)
+            return [];
+        const server = Object.keys(ask.params).length + Object.keys(ask.query).length > 0;
+        if (server)
+            keepNarrowedName(ask.name);
+        const rows = server ? await tableJoins.list(ask.name, signal => loadList(signal, Object.keys(ask.query).length ? ask.query : undefined, Object.keys(ask.params).length ? ask.params : undefined)) : await tableJoins.list(listName, loadList);
+        return ask.filters.length ? rows.filter(row => ask.filters.every(narrow => fitsNarrow(row, narrow))) : rows;
+    };
+    /** Every record the page holds of a path-narrowed listing: each list kept, fresh unless `aged`. */
+    const heldNarrowed = (lifetime = JOIN_LIFETIME) => (pathNarrowed ? [...(narrowedLists.get(listName) ?? [])].flatMap(name => tableJoins.peekList(name, lifetime) ?? []) : []);
+    /** The options narrowed by another input's value (`narrowedBy`): asked of the server by `narrowQuery`, else the kept list's. */
+    const narrowedList = async ({ key, value, orUnset }) => {
+        // The server narrows by a value; which records it adds for `orUnset` is its endpoint's rule.
+        if (typeof narrowQuery === "string" && value !== null) {
+            const name = `${listName}?${narrowQuery}=${String(value)}`;
+            keepNarrowedName(name);
+            return tableJoins.list(name, signal => loadList(signal, { [narrowQuery]: String(value) }));
+        }
+        const all = await tableJoins.list(listName, loadList);
+        return all.filter(row => (value !== null && String(row[key]) === String(value)) || (orUnset && unset(row[key])));
+    };
     return {
-        async loadOptions({ search, skip, pageSize }) {
-            const all = await tableJoins.list(listName, loadList);
+        async loadOptions({ search, skip, pageSize, narrow, narrows }) {
+            // Several values at once, or values the path takes: each where it goes. One value alone: as before.
+            const several = narrows && narrows.length > 1 ? narrows : null;
+            const all = shownAll(several || (narrow && pathNarrowed) ? await narrowedByAll(several ?? [narrow]) : narrow ? await narrowedList(narrow) : pathNarrowed ? [] : await tableJoins.list(listName, loadList));
             const matches = search ? filterItems(all, search, searchKeys) : all;
             return { items: matches.slice(skip, skip + pageSize), total: matches.length, hasMore: skip + pageSize < matches.length };
         },
-        resolveOptions: values => tableJoins.records(joinSource(controller.findListing, backend), values.map(String)),
+        // A saved value the kept list offers is named from it, with no call (a form opened on a tree's country); only one it
+        // does not offer - a parent since trashed - is looked up.
+        async resolveOptions(values) {
+            const keys = values.map(String);
+            const kept = [...(tableJoins.peekList(listName) ?? []), ...heldNarrowed()];
+            const found = kept.filter((row, index) => keys.includes(String(row[valueKey])) && kept.findIndex(other => String(other[valueKey]) === String(row[valueKey])) === index);
+            const missing = keys.filter(key => !found.some(row => String(row[valueKey]) === key));
+            if (missing.length === 0 || !lookup)
+                return shownAll(found);
+            return shownAll([...found, ...(await tableJoins.records(lookup, missing))]);
+        },
+        // The same at once, from what the page holds: a box named on its first draw, a saved record named with no call. Only
+        // what is fresh, unless an old record is asked for: a save names a value with one rather than with nothing.
+        peekOption(key, aged = false) {
+            const kept = (tableJoins.peekList(listName, aged ? Infinity : JOIN_LIFETIME) ?? heldNarrowed(aged ? Infinity : JOIN_LIFETIME)).find(row => String(row[valueKey]) === key);
+            const record = kept ?? (lookup ? peekSource(lookup.name, key, aged) : undefined);
+            return record ? shown(record) : undefined;
+        },
         valueKey,
         labelKey,
         ...(descriptionKey && { descriptionKey }),
-        isOptionInactive: item => !backend.isPickable(item),
+        isOptionInactive: item => !plan.usable(item),
     };
 }
 /**
  * Marks what the page looked up from a controller as old, after a write there may have changed it: the records its
- * `findListing` named, and the list its picker offers. Drawn as they are until the next ask brings the new ones.
+ * `findListing` named and its pickers' own finds answered, and the lists its pickers offer - its `activeListing`, and
+ * each of a CRUD's `lists` a picker reads instead (`CrudPickerOptions.list`). Drawn as they are until the next ask brings
+ * the new ones.
  */
 export function expireLookups(controller) {
-    if (controller.findListing)
-        tableJoins.expire(joinSourceName(controller.findListing));
-    if (controller.activeListing)
-        tableJoins.expireList(joinSourceName(controller.activeListing));
+    if (controller.findListing) {
+        const name = joinSourceName(controller.findListing);
+        tableJoins.expire(name);
+        for (const other of finds.get(name) ?? [])
+            tableJoins.expire(other);
+    }
+    const lists = [controller.activeListing, ...Object.values(controller.lists ?? {})];
+    for (const list of lists) {
+        if (!list)
+            continue;
+        const name = joinSourceName(list);
+        tableJoins.expireList(name);
+        for (const narrowed of narrowedLists.get(name) ?? [])
+            tableJoins.expireList(narrowed);
+    }
 }

package/dist/Services/MessageApi.d.ts

@@ -0,0 +1,18 @@
+import { type MessageBackend } from "../Helpers/MessageBackend.ts";
+import type { ApiCallOptions } from "../Interfaces/ApiInterfaces.ts";
+import type { MessageSource } from "../Interfaces/MailInterfaces.ts";
+/** Options of a mailbox's source. */
+export interface ApiMessageSourceOptions {
+    /** The backend to use, when it is not the app's registered one. */
+    backend?: MessageBackend;
+    /** Extras on every call, such as a header. */
+    call?: Omit<ApiCallOptions, "body" | "signal" | "params">;
+}
+/**
+ * A mailbox through the app's API. One is enough for a page: a thread's lines come from `threadSource(id)`.
+ *
+ * @example
+ * const mail = useMemo(() => apiMessageSource(), []);
+ * <MailThread source={mail} threadId={row.id} userId={me.id} />
+ */
+export declare function apiMessageSource(options?: ApiMessageSourceOptions): MessageSource;

package/dist/Services/MessageApi.js

@@ -0,0 +1,64 @@
+"use client";
+import { unwrapApiResult } from "../Helpers/ApiResponses.js";
+import { getMessageBackend } from "../Helpers/MessageBackend.js";
+import { api } from "./BrowserApi.js";
+/**
+ * A mailbox through the app's API. One is enough for a page: a thread's lines come from `threadSource(id)`.
+ *
+ * @example
+ * const mail = useMemo(() => apiMessageSource(), []);
+ * <MailThread source={mail} threadId={row.id} userId={me.id} />
+ */
+export function apiMessageSource(options) {
+    const backend = options?.backend ?? getMessageBackend();
+    // Each action's method is its endpoint's: these two only say whether a body goes with it.
+    const call = (signal) => ({ ...options?.call, ...(signal && { signal }), toast: false });
+    const withBody = async (action, body, signal) => unwrapApiResult(await api.send(backend.endpoint(action), { ...call(signal), body }));
+    const withoutBody = async (action, signal, params) => unwrapApiResult(await api.send(backend.endpoint(action), { ...call(signal), ...(params && { params }) }));
+    const changed = async (action, ids, signal) => backend.readChanged(await withBody(action, backend.markRequest(ids), signal));
+    const readFolders = backend.readFolders?.bind(backend);
+    return {
+        // The optional doors, only where the backend has them: a mail client hides what a source cannot do.
+        ...(readFolders && backend.supports("folders") && { folders: async (signal) => readFolders(await withoutBody("folders", signal)) }),
+        ...(backend.supports("markRead") && { markRead: (ids, signal) => changed("markRead", ids, signal) }),
+        ...(backend.supports("markUnread") && { markUnread: (ids, signal) => changed("markUnread", ids, signal) }),
+        ...(backend.supports("star") && { star: (ids, starred, signal) => changed(starred ? "star" : "unstar", ids, signal) }),
+        async inbox(request) {
+            return backend.readInbox(await withBody("inbox", backend.inboxRequest(request), request.signal));
+        },
+        async thread(id, signal) {
+            return backend.readThread(await withoutBody("thread", signal, backend.threadParams(id)));
+        },
+        threadSource(id) {
+            return {
+                async history(request) {
+                    return backend.readHistory(await withBody("history", backend.historyRequest(id, request), request.signal));
+                },
+                async send(draft, signal) {
+                    return backend.readReply(await withBody("reply", backend.replyRequest(id, draft), signal), draft);
+                },
+                async markRead(upTo, signal) {
+                    await withBody("read", backend.readMarkRequest(id, upTo), signal);
+                },
+            };
+        },
+        async compose(draft, signal) {
+            return backend.readComposed(await withBody("compose", backend.composeRequest(draft), signal));
+        },
+        async archive(ids, signal) {
+            return backend.readChanged(await withBody("archive", backend.markRequest(ids), signal));
+        },
+        async unarchive(ids, signal) {
+            return backend.readChanged(await withBody("unarchive", backend.markRequest(ids), signal));
+        },
+        async unread(signal) {
+            return backend.readUnread(await withoutBody("unread", signal));
+        },
+        async people(query) {
+            return backend.readPeople(await withBody("people", backend.peopleRequest(query), query.signal));
+        },
+        async defaults(signal) {
+            return backend.readDefaults(await withoutBody("defaults", signal));
+        },
+    };
+}

package/dist/Services/ModuleImport.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Imports an ES module by its full address, as the browser does, never through the app's bundler: a module a server
+ * serves at a versioned address (the image editor from the Nexus Drive).
+ *
+ * @example const editor = await importModule<ImageEditorModule>("https://drive.example/Assets/File/nexus-image-editor.3f2a.js");
+ */
+export declare function importModule<TModule>(url: string): Promise<TModule>;

package/dist/Services/ModuleImport.js

@@ -0,0 +1,22 @@
+/*
+ * The one dynamic `import()` of an address known only at run time, kept alone in this file on purpose.
+ *
+ * The package build rewrites "./Button.tsx" to "./Button.js" (`rewriteRelativeImportExtensions`), and for an `import()`
+ * of a variable it does so at run time: it wraps the address in a helper call, `import(helper(url))`. The bundler-ignore
+ * comments are then inside a call, so Next's Turbopack no longer leaves the import alone: it compiles it to "Cannot find
+ * module as expression is too dynamic", and the image editor never loads in an app's production build. This file imports
+ * nothing, so it is built a second time without that rewrite (`tsconfig.build.module-import.json`, after the main build,
+ * in `npm run build`), and the published file keeps the plain `import(/* webpackIgnore: true *\/ ... url)` that webpack,
+ * Turbopack and Vite all leave to the browser. `scripts/test-dist-loader.mts` (in `npm test`) fails if it ever does not.
+ *
+ * Add no import to this file: the second build would leave a "./x.ts" in it unrewritten.
+ */
+/**
+ * Imports an ES module by its full address, as the browser does, never through the app's bundler: a module a server
+ * serves at a versioned address (the image editor from the Nexus Drive).
+ *
+ * @example const editor = await importModule<ImageEditorModule>("https://drive.example/Assets/File/nexus-image-editor.3f2a.js");
+ */
+export function importModule(url) {
+    return import(/* webpackIgnore: true */ /* turbopackIgnore: true */ /* @vite-ignore */ url);
+}

package/dist/Shared.Index.d.ts

@@ -1,7 +1,9 @@
 export * from "./Components/Documents/Button.tsx";
+export * from "./Components/Documents/PrintDocument.tsx";
 export * from "./Components/Inputs/Field.tsx";
 export * from "./Components/Layouts/ThemeScript.tsx";
 export * from "./Components/Viewers/MarkdownView.tsx";
+export * from "./Components/Viewers/QrCodeImage.tsx";
 export * from "./Components/Viewers/RichTextView.tsx";
 export * from "./Helpers/ApiClient.ts";
 export * from "./Helpers/ApiFormHelpers.ts";
@@ -15,23 +17,43 @@ export * from "./Helpers/ChatStore.ts";
 export * from "./Helpers/ChatSummaries.ts";
 export * from "./Helpers/ClassHelpers.ts";
 export * from "./Helpers/CodeHelpers.ts";
+export { setAuditActorNames, type AuditActorNamesResolver } from "./Helpers/AuditEntries.ts";
 export * from "./Helpers/CrudBackend.ts";
 export * from "./Helpers/CrudColumns.ts";
+export * from "./Helpers/CrudDetailsTabs.ts";
 export * from "./Helpers/CrudHelpers.ts";
+export * from "./Helpers/DashboardHelpers.ts";
 export * from "./Helpers/DateHelpers.ts";
 export * from "./Helpers/DateTimeHelpers.ts";
+export * from "./Helpers/DomainCards.ts";
 export * from "./Helpers/DropdownHelpers.ts";
 export * from "./Helpers/ExcelBackend.ts";
 export * from "./Helpers/ExcelHelpers.ts";
+export * from "./Helpers/FileAdapter.ts";
+export * from "./Helpers/FilePrimaries.ts";
+export * from "./Helpers/NexusDriveAdapter.ts";
+export * from "./Helpers/FormConfirm.ts";
 export * from "./Helpers/FormDrafts.ts";
 export * from "./Helpers/FormStore.ts";
 export * from "./Helpers/InputParamsHelpers.ts";
+export * from "./Helpers/InputConditions.ts";
+export * from "./Helpers/InputNarrowing.ts";
+export * from "./Helpers/CrudNarrowPick.ts";
+export * from "./Helpers/CrudScopes.ts";
+export * from "./Helpers/CrudRowForms.ts";
 export * from "./Helpers/MarkdownEditing.ts";
 export * from "./Helpers/MarkdownHelpers.ts";
+export * from "./Helpers/MailClientHelpers.ts";
+export * from "./Helpers/MessageBackend.ts";
 export * from "./Helpers/MessageBuilder.ts";
+export * from "./Helpers/MessageHelpers.ts";
+export * from "./Helpers/MessageUnread.ts";
 export * from "./Helpers/NepaliCalendar.ts";
 export * from "./Helpers/NumberHelpers.ts";
+export * from "./Helpers/PagedPicker.ts";
 export * from "./Helpers/Permissions.ts";
+export * from "./Helpers/QrCode.ts";
+export * from "./Helpers/RecordCards.ts";
 export * from "./Helpers/RequestCache.ts";
 export * from "./Helpers/RichTextHelpers.ts";
 export * from "./Helpers/RowsStore.ts";
@@ -41,17 +63,23 @@ export * from "./Helpers/TableJoins.ts";
 export * from "./Helpers/TableStore.ts";
 export * from "./Helpers/ThemeHelpers.ts";
 export * from "./Helpers/TimeHelpers.ts";
+export * from "./Helpers/ToolbarFit.ts";
 export * from "./Helpers/TreeStore.ts";
 export * from "./Helpers/ValidationHelpers.ts";
 export * from "./Interfaces/ApiInterfaces.ts";
 export * from "./Interfaces/ChatInterfaces.ts";
 export * from "./Interfaces/CrudInterfaces.ts";
+export * from "./Interfaces/DashboardInterfaces.ts";
 export * from "./Interfaces/DateInterfaces.ts";
+export * from "./Interfaces/DomainInterfaces.ts";
 export * from "./Interfaces/ExcelInterfaces.ts";
+export * from "./Interfaces/FileInterfaces.ts";
 export * from "./Interfaces/FormInterfaces.ts";
 export * from "./Interfaces/InputInterfaces.ts";
+export * from "./Interfaces/MailInterfaces.ts";
 export * from "./Interfaces/MessageInterfaces.ts";
 export * from "./Interfaces/PreferenceInterfaces.ts";
+export * from "./Interfaces/RecordInterfaces.ts";
 export * from "./Interfaces/TableInterfaces.ts";
 export * from "./Interfaces/ThemeInterfaces.ts";
 export * from "./Interfaces/TypeInterfaces.ts";