@aglyn/plugins-data 1.0.0-beta.221 → 1.0.0-beta.222

package/src/lib/components/host-datasets-card.component.js

@@ -16,8 +16,8 @@
  */ 'use client';
 import { _ as _extends } from "@swc/helpers/_/_extends";
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { checkDatasetQuota, checkEntitlement, checkQuota, coerceDocumentValues, datasetIntegrityUpdate, datasetValueToInput, effectiveDatasetModel, formatDatasetValue, getCustomFieldType, modelFromFieldEntries, parseDatasetFieldEntries, pluginDocsHelp, validateDocument } from "@aglyn/aglyn";
-import { exportShortfall, mapImportColumns, parseImportRows } from "../model/index.js";
+import { TransferResumeImport } from "@aglyn/aglyn/app-utils/transfer-resume-import";
+import { checkDatasetQuota, checkEntitlement, checkQuota, getCustomFieldType, pluginDocsHelp, useTransferLauncher } from "@aglyn/aglyn";
 import { CardDisplay, useConfirmationContext } from "@aglyn/shared-ui-jsx";
 import ListFilterChips from "@aglyn/shared-ui-jsx/components/list-filter-chips.component";
 import { ListPagination } from "@aglyn/shared-ui-jsx/components/list-pagination.component";
@@ -29,7 +29,7 @@ import { useListGridFilter } from "@aglyn/shared-ui-jsx/hooks/use-list-grid-filt
 import { useSnackbar } from "@aglyn/shared-ui-snackstack";
 import { Timestamp } from "@aglyn/shared-util-timestamp";
 import { Button, Dialog, DialogActions, DialogContent, DialogTitle, MenuItem, Stack, TextField, Typography } from "@mui/material";
-import { collection, deleteDoc, deleteField, doc, documentId, getCountFromServer, getDocs, limit, orderBy, query, where, setDoc, writeBatch } from "firebase/firestore";
+import { collection, deleteDoc, deleteField, doc, getCountFromServer, getDocs, limit, query, where, setDoc, writeBatch } from "firebase/firestore";
 import { useCallback, useEffect, useMemo, useState } from "react";
 import { useFirestore, useFirestoreCollection, useHostActivityLogger, useOrgDataScope, usePagedCollection, useScopeTokens, useUser } from "@aglyn/tenant-feature-instance";
 import { listQueryConstraints } from "@aglyn/tenant-feature-instance/hooks/use-list-query";
@@ -37,19 +37,10 @@ import { authorizedFetch } from "@aglyn/shared-util-http/authorized-token";
 import { DatasetSchemaDialog } from "./dataset-schema-dialog.component.js";
 import { DatasetRecordDialog } from "./dataset-record-dialog.component.js";
 import { datasetRecordFilter, planRecordQuery, recordColumn } from "./dataset-record-filter.js";
-/**
- * How many existing records a keyed CSV import may consult.
- *
- * The upsert has to ask "does a record with this key already exist", which no
- * page can answer — so it reads its own window, once, when a key field is
- * chosen. The window is bounded because `recordsPerDataset` is unlimited on
- * the agency plan and an unbounded client read is a browser hang behind a
- * dialog button; it is the same ceiling the listener used to carry, moved from
- * every mount of the card to the one moment it is needed.
- *
- * A dataset larger than this is not silently mis-imported: the import says
- * which keys it could consult, measured against the server's exact count.
- */ const IMPORT_KEY_WINDOW = 500;
+import { coerceDocumentValues, datasetIntegrityUpdate, datasetValueToInput, effectiveDatasetModel, formatDatasetValue, modelFromFieldEntries, validateDocument } from "../model/dataset-models.js";
+import { fillRecordAddresses } from "../record-pages/record-pages.js";
+import { datasetDisplayName, parseDatasetFieldEntries } from "../model/datasets.js";
+import { datasetTransferResourceKey } from "../transfer/dataset-transfer-key.js";
 /**
  * The sentence that says who a NEW dataset is shared with, for the card and
  * for the site Data page's banner above it.
@@ -68,7 +59,7 @@ import { datasetRecordFilter, planRecordQuery, recordColumn } from "./dataset-re
  * dark-launch rule as everywhere (no plan, no gate). The host path is
  * the pre-migration fallback for hosts not yet org-wired.
  */ export function HostDatasetsCard(props) {
-    var _datasets_find, _ref, _ref1, _ref2, _ref3, _ref4, _ref5;
+    var _datasets_find, _ref, _ref1, _ref2, _ref3;
     const { hostId } = props;
     // `dataScope` is null until the async org lookup settles (AGL-1061), and
     // for a host with no owning org — there is no host fallback to act on
@@ -195,10 +186,7 @@ import { datasetRecordFilter, planRecordQuery, recordColumn } from "./dataset-re
     });
     const datasets = useMemo(()=>[
             ...datasetDocs != null ? datasetDocs : []
-        ].sort((a, b)=>{
-            var _a_displayName, _b_displayName;
-            return String((_a_displayName = a.displayName) != null ? _a_displayName : '').localeCompare(String((_b_displayName = b.displayName) != null ? _b_displayName : ''));
-        }), [
+        ].sort((a, b)=>datasetDisplayName(a).localeCompare(datasetDisplayName(b))), [
         datasetDocs
     ]);
     const [selectedId, setSelectedId] = useState(null);
@@ -507,10 +495,8 @@ import { datasetRecordFilter, planRecordQuery, recordColumn } from "./dataset-re
         // takes the same API-only route (AGL-1050) — the host-scope client
         // write that used to stand in for it is gone.
         if (!a || !b || !orgId) return;
-        const fieldFor = (target, fieldId)=>{
-            var _target_displayName;
-            return {
-                name: String((_target_displayName = target.displayName) != null ? _target_displayName : fieldId),
+        const fieldFor = (target, fieldId)=>({
+                name: datasetDisplayName(target) || fieldId,
                 type: 'reference',
                 required: true,
                 reference: {
@@ -518,10 +504,9 @@ import { datasetRecordFilter, planRecordQuery, recordColumn } from "./dataset-re
                     displayFieldId: effectiveDatasetModel(target).order[0],
                     onDelete: 'setNull'
                 }
-            };
-        };
+            });
         const payload = {
-            displayName: `${a.displayName} ↔ ${b.displayName}`,
+            displayName: `${datasetDisplayName(a)} ↔ ${datasetDisplayName(b)}`,
             fields: [
                 'aRef',
                 'bRef'
@@ -570,7 +555,7 @@ import { datasetRecordFilter, planRecordQuery, recordColumn } from "./dataset-re
         if (!selected) return;
         const confirmed = await confirm({
             title: 'Delete this collection?',
-            description: `"${selected.displayName}"` + // What is actually being destroyed, not what is loaded (AGL-1716):
+            description: `"${datasetDisplayName(selected)}"` + // What is actually being destroyed, not what is loaded (AGL-1716):
             // a 40,000-row dataset used to warn about "its 500 documents".
             (recordCount ? ` and its ${recordCount} document${recordCount === 1 ? '' : 's'}` : '') + ' stop resolving in repeatable components and bindings that ' + 'reference it.',
             confirmationText: 'Delete',
@@ -619,7 +604,7 @@ import { datasetRecordFilter, planRecordQuery, recordColumn } from "./dataset-re
         logActivity('Deleted dataset', {
             type: 'content',
             id: selected.$id,
-            name: selected.displayName
+            name: datasetDisplayName(selected)
         });
     }, [
         selected,
@@ -765,7 +750,9 @@ import { datasetRecordFilter, planRecordQuery, recordColumn } from "./dataset-re
     ]);
     const handleSaveRecord = useCallback(async ()=>{
         if (!editor || !selected || !dataScope) return;
-        const coerced = coerceDocumentValues(model, editor.values);
+        // The editor holds the record's WHOLE values, so an address it already
+        // has stays and an empty one fills in from its source (AGL-3475).
+        const coerced = fillRecordAddresses(model, coerceDocumentValues(model, editor.values));
         const errors = validateDocument(model, coerced);
         if (Object.keys(errors).length) {
             return void setEditor((prev)=>prev ? _extends({}, prev, {
@@ -821,7 +808,7 @@ import { datasetRecordFilter, planRecordQuery, recordColumn } from "./dataset-re
         logActivity(editor.id ? 'Updated record' : 'Added record', {
             type: 'content',
             id: selected.$id,
-            name: selected.displayName
+            name: datasetDisplayName(selected)
         });
     }, [
         editor,
@@ -880,7 +867,7 @@ import { datasetRecordFilter, planRecordQuery, recordColumn } from "./dataset-re
                 try {
                     snapshot = await getDocs(query(collection(firestore, dataScope[0], dataScope[1], 'datasets', other.$id, 'records'), where('referencedIds', 'array-contains', record.$id)));
                 } catch (unused) {
-                    return void enqueueSnackbar(`Cannot delete: "${other.displayName}" could not be checked for ` + 'references, so removing this record could break it. Nothing ' + 'was deleted.', {
+                    return void enqueueSnackbar(`Cannot delete: "${datasetDisplayName(other)}" could not be checked for ` + 'references, so removing this record could break it. Nothing ' + 'was deleted.', {
                         variant: 'error'
                     });
                 }
@@ -895,7 +882,7 @@ import { datasetRecordFilter, planRecordQuery, recordColumn } from "./dataset-re
                     return ((_otherModel_fields_fieldId = otherModel.fields[fieldId]) == null ? void 0 : (_otherModel_fields_fieldId_reference = _otherModel_fields_fieldId.reference) == null ? void 0 : _otherModel_fields_fieldId_reference.onDelete) === 'restrict';
                 });
                 if (restricted) {
-                    return void enqueueSnackbar(`Cannot delete: referenced by ${hits.length} document` + `${hits.length === 1 ? '' : 's'} in "${other.displayName}"`, {
+                    return void enqueueSnackbar(`Cannot delete: referenced by ${hits.length} document` + `${hits.length === 1 ? '' : 's'} in "${datasetDisplayName(other)}"`, {
                         variant: 'warning',
                         persist: false
                     });
@@ -946,276 +933,69 @@ import { datasetRecordFilter, planRecordQuery, recordColumn } from "./dataset-re
         announceRecords,
         enqueueSnackbar
     ]);
-    // CSV/JSON round-tripping (AGL-182).
-    const download = useCallback((name, mime, text)=>{
-        const url = URL.createObjectURL(new Blob([
-            text
-        ], {
-            type: mime
-        }));
-        const anchor = document.createElement('a');
-        anchor.href = url;
-        anchor.download = name;
-        anchor.click();
-        URL.revokeObjectURL(url);
-    }, []);
-    const [exporting, setExporting] = useState(null);
     /**
-   * The export is a SERVER stream now (AGL-2335).
-   *
-   * It used to serialize `records` — the card's live listener window, which
-   * is `limit(500)` with no `orderBy`. Firestore answers an unordered limit
-   * in document-id order over auto-ids, so a 2,000-row dataset did not
-   * export "the first 500": it exported 500 unpredictable rows, and running
-   * it twice could produce different ones. `sortDatasetRecords` then sorted
-   * that sample, so the file looked ordered and was arbitrary. The button
-   * said `CSV`, and the agency guide calls the result a *full handover*.
-   *
-   * Fetching the whole collection here instead was not an option — the
-   * agency plan's `recordsPerDataset` is UNLIMITED, so an unbounded
-   * client-side read is a browser hang and a large read bill behind a button
-   * labelled `CSV`. `/api/orgs/datasets/export` pages and streams it.
-   *
-   * The response is CHECKED, not trusted: the route reports a `count()`
-   * aggregate in `X-Aglyn-Export-Rows`, and a body with fewer rows than that
-   * is refused rather than saved. A stream that dies halfway produces a
-   * perfectly well-formed shorter file — nothing about the bytes says they
-   * are short, which is precisely how the old truncation stayed invisible.
-   */ const handleExport = useCallback((format)=>async ()=>{
-            if (!(selected == null ? void 0 : selected.$id) || !orgId || exporting) return;
-            setExporting(format);
-            try {
-                var _selected_displayName;
-                const response = await authorizedFetch(user, `/api/orgs/datasets/export?orgId=${encodeURIComponent(orgId)}` + `&datasetId=${encodeURIComponent(selected.$id)}` + `&format=${format}`);
-                if (!response.ok) {
-                    var _ref;
-                    const failure = await response.json().catch(()=>({}));
-                    throw new Error((_ref = failure == null ? void 0 : failure.error) != null ? _ref : 'Export failed');
-                }
-                const text = await response.text();
-                const { promised, received, short } = exportShortfall(response.headers.get('X-Aglyn-Export-Rows'), text, format);
-                if (short) {
-                    enqueueSnackbar(`Export incomplete — ${received} of ${promised} documents ` + 'arrived. Nothing was saved; try again.', {
-                        variant: 'error'
-                    });
-                    return;
-                }
-                const base = String((_selected_displayName = selected.displayName) != null ? _selected_displayName : 'collection').replace(/[^A-Za-z0-9_-]+/g, '-').toLowerCase() || 'collection';
-                download(`${base}.${format}`, format === 'csv' ? 'text/csv' : 'application/json', text);
-            } catch (error) {
-                enqueueSnackbar(error instanceof Error ? error.message : 'Export failed', {
-                    variant: 'error'
+   * Import and export (AGL-3530) open the console's import wizard and export
+   * dialog on this dataset (`data.dataset:<datasetId>`): the file is read,
+   * matched and written on the server, through the same record writes as
+   * every other create and update, and the export streams the fields the
+   * person picks. Outside the console shell there is no launcher, and no
+   * Import or Export to offer. Inside it, Import is offered to a member who
+   * may import (Manage data) and Export to any member who can see the
+   * dataset (AGL-3546) — the transfer routes' own rule.
+   */ const transfer = useTransferLauncher();
+    const transferTarget = (selected == null ? void 0 : selected.$id) ? {
+        resource: datasetTransferResourceKey(selected.$id),
+        scope: 'org'
+    } : null;
+    const canImport = Boolean(transfer && transferTarget && transfer.can('import', transferTarget));
+    const canExport = Boolean(transfer && transferTarget && transfer.can('export', transferTarget));
+    const handleImport = useCallback(()=>{
+        if (!transfer || !(selected == null ? void 0 : selected.$id)) return;
+        const dataset = {
+            id: selected.$id,
+            name: datasetDisplayName(selected)
+        };
+        transfer.openImport({
+            resource: datasetTransferResourceKey(dataset.id),
+            scope: 'org',
+            title: dataset.name ? `Import into ${dataset.name}` : 'Import records',
+            onFinished: ()=>{
+                // An import moves the record count, and the aggregate is a one-shot.
+                setRecordCountEpoch((epoch)=>epoch + 1);
+                logActivity('Imported records', {
+                    type: 'content',
+                    id: dataset.id,
+                    name: dataset.name
                 });
-            } finally{
-                setExporting(null);
-            }
-        }, [
-        selected,
-        orgId,
-        user,
-        exporting,
-        download,
-        enqueueSnackbar
-    ]);
-    // keyField (wave v6): optional unique key — matching rows update the
-    // existing record instead of appending a duplicate.
-    const [importer, setImporter] = useState(null);
-    const importPreview = useMemo(()=>{
-        if (!importer) return null;
-        const rows = parseImportRows(importer.text);
-        if (!rows || !rows.length) return null;
-        const { mapping, unmatched } = mapImportColumns(model, Object.keys(rows[0]));
-        const prepared = rows.map((raw)=>{
-            const input = {};
-            for (const [column, fieldId] of Object.entries(mapping)){
-                var _raw_column;
-                input[fieldId] = (_raw_column = raw[column]) != null ? _raw_column : '';
             }
-            const values = coerceDocumentValues(model, input);
-            const errors = validateDocument(model, values);
-            return {
-                values,
-                errors,
-                valid: !Object.keys(errors).length
-            };
         });
-        return {
-            prepared,
-            unmatched,
-            valid: prepared.filter((row)=>row.valid).length
-        };
     }, [
-        importer,
-        model
+        transfer,
+        selected,
+        logActivity
     ]);
-    const handleImport = useCallback(async ()=>{
-        var _ref, _quota_limit;
-        if (!selected || !importPreview || !dataScope) return;
-        const validRows = importPreview.prepared.filter((row)=>row.valid);
-        // Unique-key upsert (wave v6): with a key field picked, incoming rows
-        // that match an existing record's key update it in place, and
-        // duplicate keys within the import collapse to the last row.
-        const keyField = (_ref = importer == null ? void 0 : importer.keyField) != null ? _ref : '';
-        const keyOf = (values)=>{
-            var _ref;
-            return String((_ref = values == null ? void 0 : values[keyField]) != null ? _ref : '').trim().toLowerCase();
-        };
-        let updates = [];
-        let creates = validRows;
-        if (keyField) {
-            var _ref1;
-            /*
-       * The key index is its OWN read, not the table's window.
-       *
-       * It used to be built from the card's live listener, which is now a
-       * PAGE — and a page cannot answer "does this key already exist". An
-       * upsert that consults ten rows would turn nearly every update into a
-       * create: duplicate rows, and quota spent on them.
-       *
-       * So it is read here, once, at the moment a key field is actually
-       * chosen — which is also strictly cheaper than the listener it replaces,
-       * since that one paid for five hundred documents on every mount of a
-       * card nobody had scrolled.
-       *
-       * ⚠️ STILL BOUNDED, and the bound is honest rather than hidden. An
-       * unbounded client read is what AGL-2335 refused for the export, for the
-       * same reason: `recordsPerDataset` is unlimited on the agency plan, so
-       * "read them all" is a browser hang behind a dialog button. Past the
-       * ceiling the reader is TOLD which keys could be consulted instead of
-       * being handed silent duplicates — `recordCount` is the server
-       * aggregate, so that comparison is exact.
-       */ const existingByKey = new Map();
-            const keyWindow = await getDocs(query(collection(firestore, dataScope[0], dataScope[1], 'datasets', selected.$id, 'records'), orderBy(documentId()), limit(IMPORT_KEY_WINDOW))).catch(()=>null);
-            for (const snapshot of (_ref1 = keyWindow == null ? void 0 : keyWindow.docs) != null ? _ref1 : []){
-                var _snapshot_get;
-                const values = (_snapshot_get = snapshot.get('values')) != null ? _snapshot_get : {};
-                const key = keyOf(values);
-                if (key) existingByKey.set(key, {
-                    id: snapshot.id,
-                    values
-                });
-            }
-            if (recordCount > IMPORT_KEY_WINDOW) {
-                enqueueSnackbar(`Matching on "${keyField}" read the first ` + `${IMPORT_KEY_WINDOW.toLocaleString()} of ${recordCount.toLocaleString()} ` + 'records — rows keyed beyond that will be added rather than updated.', {
-                    variant: 'warning',
-                    persist: true
-                });
-            }
-            const deduped = new Map();
-            const keyless = [];
-            for (const row of validRows){
-                const key = keyOf(row.values);
-                if (key) deduped.set(key, row);
-                else keyless.push(row);
-            }
-            updates = [];
-            creates = [
-                ...keyless
-            ];
-            for (const [key, row] of deduped){
-                const existing = existingByKey.get(key);
-                // The import's columns over the record's own: a column the file
-                // does not carry keeps its value, and the filter fields are derived
-                // from the WHOLE record, not the columns imported.
-                if (existing) {
-                    updates.push({
-                        id: existing.id,
-                        values: _extends({}, existing.values, row.values)
-                    });
-                } else creates.push(row);
-            }
-        }
-        // Against the dataset's real size, not the loaded window (AGL-1716) —
-        // `room` subtracts this number from the limit, so an understated count
-        // did not merely fail to refuse, it INFLATED the slots offered.
-        const quota = checkQuota(org, 'recordsPerDataset', recordCount + creates.length - 1);
-        const room = quota.allowed ? creates.length : Math.max(0, Number((_quota_limit = quota.limit) != null ? _quota_limit : 0) - recordCount);
-        const toWrite = creates.slice(0, room);
-        if (!toWrite.length && !updates.length) {
-            return void enqueueSnackbar(`Record limit reached (${quota.limit}) — see Billing to upgrade`, {
-                variant: 'warning',
-                persist: false
-            });
-        }
-        // Updates stay client-direct (no quota consumed), chunked under
-        // Firestore's 500-writes/batch limit.
-        for(let start = 0; start < updates.length; start += 400){
-            const batch = writeBatch(firestore);
-            updates.slice(start, start + 400).forEach((update)=>{
-                const ref = doc(firestore, dataScope[0], dataScope[1], 'datasets', selected.$id, 'records', update.id);
-                batch.set(ref, _extends({
-                    values: update.values
-                }, datasetIntegrityUpdate(model, update.values, deleteField()), {
-                    updatedAt: Timestamp.now()
-                }), // Each named field replaced whole — `merge: true` would fold the
-                // `filterValues` map into the stored one and keep a cleared value.
-                {
-                    mergeFields: [
-                        'values',
-                        'referencedIds',
-                        'filterKeys',
-                        'filterValues',
-                        'updatedAt'
-                    ]
-                });
-            });
-            await batch.commit();
-        }
-        // Creates go through the quota-enforcing API (AGL-473). The legacy
-        // host-scope client batch that used to be the `else` here is gone
-        // (AGL-1050) — it was the largest of the quota bypasses, since a CSV
-        // import could create records by the hundred without ever asking.
-        try {
-            if (toWrite.length) {
-                await callDatasetApi({
-                    action: 'import-records',
-                    datasetId: selected.$id,
-                    records: toWrite.map((row)=>({
-                            values: row.values
-                        }))
-                });
-            } else if (updates.length) {
-                // An import that only UPDATED existing rows never reaches the server
-                // leg, so it has to announce for itself — otherwise the one import
-                // shape that changes every row of a dataset is the one that refreshes
-                // nothing (AGL-3113).
-                await announceRecords(selected.$id);
+    const handleExport = useCallback(()=>{
+        if (!transfer || !(selected == null ? void 0 : selected.$id)) return;
+        const name = datasetDisplayName(selected);
+        transfer.openExport(_extends({
+            resource: datasetTransferResourceKey(selected.$id),
+            scope: 'org',
+            title: name ? `Export ${name}` : 'Export records'
+        }, filteringRecords ? {
+            filter: {
+                label: 'The records the table’s filters and search show',
+                value: {
+                    clauses: recordClauses,
+                    search: gridFilter.searchWords
+                }
             }
-        } catch (error) {
-            var _ref2;
-            return void enqueueSnackbar((_ref2 = error == null ? void 0 : error.message) != null ? _ref2 : 'Import failed', {
-                variant: 'warning',
-                persist: false
-            });
-        }
-        setImporter(null);
-        // An import moves the record count and the aggregate is a one-shot —
-        // the listener refreshes the ROWS for free, the count has to be asked
-        // again or the next import prices its room off a pre-import number.
-        setRecordCountEpoch((epoch)=>epoch + 1);
-        const skippedInvalid = importPreview.prepared.length - validRows.length;
-        const skippedQuota = creates.length - toWrite.length;
-        enqueueSnackbar(`Imported ${toWrite.length} new` + (updates.length ? `, updated ${updates.length}` : '') + (skippedInvalid ? `, ${skippedInvalid} invalid skipped` : '') + (skippedQuota ? `, ${skippedQuota} over the record limit` : ''), {
-            variant: skippedInvalid || skippedQuota ? 'warning' : 'success'
-        });
-        logActivity('Imported records', {
-            type: 'content',
-            id: selected.$id,
-            name: selected.displayName
-        });
+        } : {}));
     }, [
+        transfer,
         selected,
-        importPreview,
-        importer == null ? void 0 : importer.keyField,
-        org,
-        model,
-        recordCount,
-        firestore,
-        dataScope,
-        callDatasetApi,
-        announceRecords,
-        enqueueSnackbar,
-        logActivity
+        filteringRecords,
+        recordClauses,
+        gridFilter.searchWords
     ]);
     /*
    * One column per schema field, filterable as far as `datasetRecordFilter`
@@ -1315,7 +1095,7 @@ import { datasetRecordFilter, planRecordQuery, recordColumn } from "./dataset-re
                                 },
                                 children: datasets.map((item)=>/*#__PURE__*/ _jsx(MenuItem, {
                                         value: item.$id,
-                                        children: item.displayName
+                                        children: datasetDisplayName(item)
                                     }, item.$id))
                             }),
                             /*#__PURE__*/ _jsx(Button, {
@@ -1329,29 +1109,22 @@ import { datasetRecordFilter, planRecordQuery, recordColumn } from "./dataset-re
                                 onClick: ()=>setSchemaOpen(true),
                                 children: 'Schema'
                             }),
-                            /*#__PURE__*/ _jsx(Button, {
+                            transferTarget ? /*#__PURE__*/ _jsx(TransferResumeImport, _extends({
+                                target: transferTarget
+                            }, selected ? {
+                                title: `Import into ${datasetDisplayName(selected)}`
+                            } : {}, {
+                                onFinished: ()=>setRecordCountEpoch((epoch)=>epoch + 1)
+                            })) : null,
+                            canImport ? /*#__PURE__*/ _jsx(Button, {
                                 size: "small",
-                                onClick: ()=>setImporter({
-                                        text: '',
-                                        keyField: ''
-                                    }),
+                                onClick: handleImport,
                                 children: 'Import'
-                            }),
-                            recordCount || records.length ? /*#__PURE__*/ _jsxs(_Fragment, {
-                                children: [
-                                    /*#__PURE__*/ _jsx(Button, {
-                                        size: "small",
-                                        disabled: Boolean(exporting),
-                                        onClick: handleExport('csv'),
-                                        children: exporting === 'csv' ? 'Exporting…' : 'CSV'
-                                    }),
-                                    /*#__PURE__*/ _jsx(Button, {
-                                        size: "small",
-                                        disabled: Boolean(exporting),
-                                        onClick: handleExport('json'),
-                                        children: exporting === 'json' ? 'Exporting…' : 'JSON'
-                                    })
-                                ]
+                            }) : null,
+                            canExport && (recordCount || records.length) ? /*#__PURE__*/ _jsx(Button, {
+                                size: "small",
+                                onClick: handleExport,
+                                children: 'Export'
                             }) : null,
                             /*#__PURE__*/ _jsx(Button, {
                                 size: "small",
@@ -1676,91 +1449,6 @@ import { datasetRecordFilter, planRecordQuery, recordColumn } from "./dataset-re
                     })
                 ]
             }),
-            /*#__PURE__*/ _jsxs(Dialog, {
-                open: Boolean(importer),
-                onClose: ()=>setImporter(null),
-                maxWidth: "sm",
-                fullWidth: true,
-                children: [
-                    /*#__PURE__*/ _jsx(DialogTitle, {
-                        children: 'Import records'
-                    }),
-                    /*#__PURE__*/ _jsxs(DialogContent, {
-                        sx: {
-                            display: 'flex',
-                            flexDirection: 'column',
-                            gap: 2
-                        },
-                        children: [
-                            /*#__PURE__*/ _jsx(TextField, {
-                                multiline: true,
-                                minRows: 6,
-                                size: "small",
-                                label: "CSV (with header row) or JSON array",
-                                value: (_ref4 = importer == null ? void 0 : importer.text) != null ? _ref4 : '',
-                                onChange: (event)=>setImporter((prev)=>prev ? _extends({}, prev, {
-                                            text: event.target.value
-                                        }) : prev),
-                                sx: {
-                                    mt: 1
-                                },
-                                helperText: "Columns match by field id or display name"
-                            }),
-                            /*#__PURE__*/ _jsxs(TextField, {
-                                select: true,
-                                size: "small",
-                                label: "Match on field (upsert)",
-                                value: (_ref5 = importer == null ? void 0 : importer.keyField) != null ? _ref5 : '',
-                                onChange: (event)=>setImporter((prev)=>prev ? _extends({}, prev, {
-                                            keyField: event.target.value
-                                        }) : prev),
-                                helperText: 'Rows whose value matches an existing record update it ' + 'instead of appending a duplicate.',
-                                sx: {
-                                    maxWidth: 280
-                                },
-                                children: [
-                                    /*#__PURE__*/ _jsx(MenuItem, {
-                                        value: "",
-                                        children: 'None — always append'
-                                    }),
-                                    model.order.map((fieldId)=>{
-                                        var _ref;
-                                        var _model_fields_fieldId;
-                                        return /*#__PURE__*/ _jsx(MenuItem, {
-                                            value: fieldId,
-                                            children: (_ref = (_model_fields_fieldId = model.fields[fieldId]) == null ? void 0 : _model_fields_fieldId.name) != null ? _ref : fieldId
-                                        }, fieldId);
-                                    })
-                                ]
-                            }),
-                            importPreview ? /*#__PURE__*/ _jsx(Typography, {
-                                variant: "body2",
-                                color: "text.secondary",
-                                children: `${importPreview.prepared.length} rows parsed · ` + `${importPreview.valid} valid` + (importPreview.prepared.length - importPreview.valid ? ` · ${importPreview.prepared.length - importPreview.valid} invalid (skipped)` : '') + (importPreview.unmatched.length ? ` · unmatched columns: ${importPreview.unmatched.join(', ')}` : '')
-                            }) : (importer == null ? void 0 : importer.text.trim()) ? /*#__PURE__*/ _jsx(Typography, {
-                                variant: "body2",
-                                color: "warning.main",
-                                children: 'Nothing parseable yet — CSV needs a header row.'
-                            }) : null
-                        ]
-                    }),
-                    /*#__PURE__*/ _jsxs(DialogActions, {
-                        children: [
-                            /*#__PURE__*/ _jsx(Button, {
-                                onClick: ()=>setImporter(null),
-                                children: 'Cancel'
-                            }),
-                            /*#__PURE__*/ _jsx(Button, {
-                                variant: "contained",
-                                color: "primary",
-                                disabled: !(importPreview == null ? void 0 : importPreview.valid),
-                                onClick: handleImport,
-                                children: 'Import valid rows'
-                            })
-                        ]
-                    })
-                ]
-            }),
             /*#__PURE__*/ _jsxs(Dialog, {
                 open: Boolean(joiner),
                 onClose: ()=>setJoiner(null),
@@ -1800,7 +1488,7 @@ import { datasetRecordFilter, planRecordQuery, recordColumn } from "./dataset-re
                                             }) : prev),
                                     children: datasets.map((item)=>/*#__PURE__*/ _jsx(MenuItem, {
                                             value: item.$id,
-                                            children: item.displayName
+                                            children: datasetDisplayName(item)
                                         }, item.$id))
                                 }, side);
                             })