@aglyn/plugins-data 1.0.0-beta.143

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

@@ -0,0 +1,1831 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ 'use client';
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { applyDatasetQuery, checkDatasetQuota, checkEntitlement, checkQuota, coerceDocumentValues, datasetIntegrityUpdate, datasetValueToInput, effectiveDatasetModel, formatDatasetValue, getCustomFieldType, modelFromFieldEntries, parseDatasetFieldEntries, parseDatasetFilter, parseDatasetSort, pluginDocsHelp, validateDocument } from "@aglyn/aglyn";
+import { exportShortfall, mapImportColumns, parseImportRows } from "../model/index.js";
+import { CardDisplay, useConfirmationContext } from "@aglyn/shared-ui-jsx";
+import { ListPagination } from "@aglyn/shared-ui-jsx/components/list-pagination.component";
+import QuotaReadoutComponent from "@aglyn/shared-ui-jsx/components/quota-readout.component";
+import { ScrollTable } from "@aglyn/shared-ui-jsx/components/scroll-table.component";
+import { useSnackbar } from "@aglyn/shared-ui-snackstack";
+import { Timestamp } from "@aglyn/shared-util-timestamp";
+import { Button, Dialog, DialogActions, DialogContent, DialogTitle, MenuItem, Stack, TableBody, TableCell, TableHead, TableRow, TextField, Tooltip, Typography } from "@mui/material";
+import { collection, deleteDoc, deleteField, doc, documentId, getCountFromServer, getDocs, limit, orderBy, 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 { authorizedFetch } from "@aglyn/shared-util-http/authorized-token";
+import { DatasetSchemaDialog } from "./dataset-schema-dialog.component.js";
+import { DatasetRecordDialog } from "./dataset-record-dialog.component.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;
+/**
+ * The sentence that says who a NEW dataset is shared with, for the card and
+ * for the site Data page's banner above it.
+ *
+ * `siteOnly` is true only on a site's Data page in an org whose Default
+ * sharing is "Only the site they were created in". Everywhere else a new
+ * dataset starts on All sites: the org Data page has no site to limit it to.
+ */ export function newDatasetSharingNote(siteOnly) {
+    return siteOnly ? 'Datasets belong to your organization. Your default sharing starts a ' + 'new one on this site only — use Schema to share it with more.' : 'Datasets belong to your organization. A new one is shared with ' + 'every site — use Schema to narrow that.';
+}
+/**
+ * Datasets editor (AGL-102): org-shared document collections at
+ * `orgs/{orgId}/datasets` (AGL-237/239) with a `records` subcollection,
+ * consumed by repeatable components (AGL-103) via `{{item.field}}`.
+ * Starter+ (`data-store` flag) with per-plan dataset and record caps —
+ * 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;
+    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
+    // any more (AGL-1050), so every path built from it is guarded rather
+    // than redirected.
+    const { scope: dataScope, orgId } = useOrgDataScope({
+        hostId,
+        orgId: props.orgId
+    });
+    // Scoped sharing (AGL-1044). Required, not cosmetic: under the AGL-1041
+    // rules a scoped member's UNFILTERED list is rejected outright —
+    // Firestore fails the whole query if any candidate would fail — so
+    // without this the Data page errors rather than showing fewer rows.
+    // Org-wide members get no filter: they read everything, and adding one
+    // would hide any dataset the AGL-1040 backfill missed.
+    const { tokens: scopeTokens, orgWide: viewerOrgWide, loaded: scopeLoaded } = useScopeTokens(orgId);
+    // Every dataset this card can now reach is an org dataset, and org
+    // datasets are all scoped (AGL-1041) — so the filter turns purely on
+    // whether the VIEWER is org-wide. It used to also ask whether an org had
+    // resolved, for the sake of unscoped rows on the host path.
+    const needsScope = !viewerOrgWide;
+    // Two answers must be in before listing: the org path (AGL-1061) and the
+    // viewer's scope tokens (AGL-1047). `useScopeTokens` reports org-wide
+    // while loading, so without `scopeLoaded` a scoped collaborator's first
+    // render sends an UNFILTERED list that the AGL-1041 rules deny per
+    // document. It recovers on the next render, which is exactly what makes
+    // it easy to miss: the page looks right and logs a denial every mount.
+    const scopeReady = Boolean(dataScope) && scopeLoaded;
+    const firestore = useFirestore();
+    const { enqueueSnackbar } = useSnackbar();
+    const { confirm } = useConfirmationContext();
+    const { org } = props;
+    const logActivity = useHostActivityLogger(hostId);
+    const { data: user } = useUser();
+    /**
+   * The site a dataset created here is created FROM, or undefined on the
+   * organization Data page.
+   *
+   * `/api/orgs/datasets` stamps a new dataset with the org's Default sharing,
+   * and that setting can only narrow to a site the request names — so a
+   * create that names none lands on All sites whatever the org chose. The
+   * explicit `orgId` is the org Data page's own scope and already wins over
+   * `hostId` when the org is resolved, so it wins here too: a create made
+   * there names no site, even if a caller hands the card both.
+   */ const createdFromHostId = props.orgId ? undefined : hostId || undefined;
+    const createdFrom = useMemo(()=>createdFromHostId ? {
+            hostId: createdFromHostId
+        } : {}, [
+        createdFromHostId
+    ]);
+    /**
+   * Whether a dataset created here starts on this site alone: the org chose
+   * "Only the site they were created in" and there is a site to limit it to.
+   * The caption reads it so it never promises All sites to a create that
+   * will not get it.
+   */ const createsSiteOnly = Boolean(createdFromHostId) && (org == null ? void 0 : org.defaultResourceScope) === 'host';
+    // Creates go through the console API (AGL-473): rules deny client-side
+    // `create` on org datasets/records so quotas are server-enforced.
+    // Updates/deletes stay client-direct (they don't consume quota). The
+    // legacy host scope (no org resolved) keeps the old client writes.
+    const callDatasetApi = useCallback(async (payload)=>{
+        const response = await authorizedFetch(user, '/api/orgs/datasets', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(_extends({
+                orgId
+            }, payload))
+        });
+        const result = await response.json().catch(()=>({}));
+        if (!response.ok) {
+            var _ref;
+            throw new Error((_ref = result == null ? void 0 : result.error) != null ? _ref : 'Dataset operation failed');
+        }
+        return result;
+    }, [
+        user,
+        orgId
+    ]);
+    /**
+   * Refresh the live pages showing a dataset after a write the BROWSER made
+   * (AGL-3113).
+   *
+   * Record edits and deletes are client-direct — they consume no quota, so
+   * AGL-473 left them out of the server leg — which also left them with
+   * nothing to announce from. They make a page listing the rows exactly as
+   * stale as a create does, so they take the same trip the create already
+   * takes, through the route that already holds the org membership check.
+   *
+   * BEST EFFORT. The record is stored by the time this runs, and the pages
+   * catch up on their own window regardless; a refused cache must never be
+   * shown to somebody as a refused save.
+   */ const announceRecords = useCallback(async (datasetId)=>{
+        try {
+            await callDatasetApi({
+                action: 'announce-records',
+                datasetId
+            });
+        } catch (error) {
+            console.error(error);
+        }
+    }, [
+        callDatasetApi
+    ]);
+    const { data: datasetDocs, status: datasetsStatus, /**
+     * The dataset rows are unconfirmed by the server (AGL-1358). The schema
+     * dialog is seeded from one of them and writes the whole `model` plus
+     * `visibleTo` back, so the freshness verdict belongs to THIS listener —
+     * the dialog has none of its own, which is why it is handed down rather
+     * than recomputed there.
+     */ fromCache: datasetsFromCache } = useFirestoreCollection(()=>// `scopeReady` already implies a non-null `dataScope`; testing it
+        // directly is what lets the compiler see that too.
+        dataScope && scopeReady ? query(collection(firestore, dataScope[0], dataScope[1], 'datasets'), ...needsScope ? [
+            where('visibleTo', 'array-contains-any', scopeTokens)
+        ] : [], limit(100)) : null, [
+        firestore,
+        dataScope,
+        needsScope,
+        scopeTokens,
+        scopeReady
+    ], {
+        idField: '$id'
+    });
+    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 : ''));
+        }), [
+        datasetDocs
+    ]);
+    const [selectedId, setSelectedId] = useState(null);
+    const [schemaOpen, setSchemaOpen] = useState(false);
+    const selected = (_datasets_find = datasets.find((item)=>item.$id === selectedId)) != null ? _datasets_find : datasets[0];
+    // Typed model (AGL-179): drives headers, cell rendering, and the
+    // document form; v1 datasets get a derived all-text model.
+    const model = useMemo(()=>effectiveDatasetModel(selected != null ? selected : {}), [
+        selected
+    ]);
+    const fields = useMemo(()=>model.order, [
+        model
+    ]);
+    // Guarded on BOTH the scope and a real selection (AGL-1440): with no
+    // datasets, `selected` never resolves, and `datasets/-none-/records` is not
+    // an empty read for everyone — the AGL-1044 scoped-sharing rules deny it
+    // outright for a scoped collaborator, and a permanently denied listen is
+    // reopened forever by the refusal loop.
+    /**
+   * The records table PAGES (AGL-2501). It used to be `limit(500)` with no
+   * `orderBy`, every row rendered at once and no control anywhere.
+   *
+   * That was wrong twice. Five hundred documents were read and billed on
+   * every mount of a card nobody had scrolled — and past five hundred the
+   * remaining rows were not merely unrendered, they were UNREACHABLE, because
+   * nothing showed them and nothing asked for more. Firestore answers an
+   * unordered limit in document-id order over auto-ids, so which five hundred
+   * a reader got was arbitrary and could differ between two loads of the same
+   * dataset; `sortDatasetRecords` then sorted that sample by `order`, which
+   * made the table look ordered while being a sample. The export leg
+   * (AGL-2335) fixed exactly this shape for the file and left the table.
+   *
+   * ## Why the walk orders on the document id, and not on a field
+   *
+   * The usual fix is `orderBy` on the field the rows are sorted by. It cannot
+   * be used here: `orderBy` matches only documents that HAVE the field, so
+   * ordering on one that any writer omits does not mis-order the list, it
+   * hides rows from it — a worse failure than the one being fixed, and a
+   * silent one. Every candidate on this collection is omitted by some writer:
+   *
+   *  * `order` — set by `/api/orgs/datasets` and by `POST /v1/datasets/{id}
+   *    /records`, and NOT by the tenant form-submit leg or by the workflow
+   *    `appendDataset`/`updateDataset` actions, which write `values` and
+   *    `createdAt` only. Ordering on it would drop every row a public form or
+   *    an automation ever produced — the rows a lead dataset is mostly made
+   *    of.
+   *  * `createdAt` — written by all four of those, and NOT by a site import:
+   *    `IMPORTABLE_FIELDS.records` is `['values', 'order']`, so a restored
+   *    record carries no `createdAt` at all.
+   *  * `updatedAt` — the mirror image: the import stamps it, the form and
+   *    automation legs do not.
+   *
+   * A document's NAME is not a field and cannot be absent, so ordering on it
+   * drops nothing and the walk is total: every record is reachable by paging,
+   * which is the property the old query lacked. It is not insertion order —
+   * ids are random — so the rows are not claimed to be in one. What they are
+   * is stable, complete, and the same on every load.
+   *
+   * `sortDatasetRecords` is deliberately NOT applied to the page. Re-sorting a
+   * window of an id-ordered walk by `order` is the same lie the old code told:
+   * rows would run in one order within a page and another across pages.
+   */ const { rows: records, hasMore: hasMoreRecords, page: recordPage, setPage: setRecordPage, pageSize: recordPageSize, setPageSize: setRecordPageSize } = usePagedCollection((pageLimit)=>dataScope && (selected == null ? void 0 : selected.$id) ? query(collection(firestore, dataScope[0], dataScope[1], 'datasets', selected.$id, 'records'), orderBy(documentId()), limit(pageLimit)) : null, [
+        firestore,
+        dataScope,
+        selected == null ? void 0 : selected.$id
+    ], {
+        idField: '$id'
+    });
+    /**
+   * The two HEAD-COUNTS on this card are server aggregates, not the lengths
+   * of the two capped listeners above (AGL-1716, the AGL-1706 shape).
+   *
+   * Both listeners are capped correctly — 100 datasets in a picker, 500 rows
+   * in a table, nobody needs more streamed in. What neither may do is answer
+   * "how many does this org have", and both did:
+   *
+   *  * `records.length` saturated at 500 and was handed to
+   *    `checkQuota(org, 'recordsPerDataset', …)`. The bands are 1,000 /
+   *    10,000 / 100,000 / 500,000 / 1,000,000, so on EVERY paid plan the
+   *    check read 500-against-thousands and could never refuse. Worse, the
+   *    importer computed its room as `limit − records.length`, so an
+   *    understated count *inflated* the slots it offered.
+   *  * `datasets.length` saturated at 100 and fed `checkDatasetQuota`, whose
+   *    bands run to 250 / 500 / 2,000 above that window.
+   *
+   * `api/orgs/datasets` — the route that actually enforces both — counts with
+   * `collection('datasets').count()` and `collection('records').count()` on
+   * these exact paths, so this card was offering headroom the API would then
+   * refuse. It now asks the same question the same way, and the console
+   * billing page and the staff org page already read the dataset count with
+   * this identical unscoped aggregate.
+   *
+   * THE LISTS KEEP THEIR CAPS. The list and the count are different
+   * questions; only the count moved. A one-shot goes stale where a listener
+   * refreshed for free, so both are re-read after any mutation that can move
+   * them — the epochs below.
+   *
+   * No counting RULE moves: `checkQuota` and `checkDatasetQuota` are
+   * untouched entitlement inputs, and nothing here is metered by
+   * `report-usage` (it samples record counts server-side for storage, on its
+   * own read). Only this card's inputs stopped being saturated.
+   */ const [datasetCountEpoch, setDatasetCountEpoch] = useState(0);
+    const [recordCountEpoch, setRecordCountEpoch] = useState(0);
+    const [serverDatasetCount, setServerDatasetCount] = useState(null);
+    // TAGGED with the dataset it describes. A bare number would have to be
+    // cleared when the selection changes, and clearing state from inside the
+    // effect that fills it is a render loop waiting for one unstable dep;
+    // tagging answers "whose count is this?" without writing state on render.
+    const [serverRecordCount, setServerRecordCount] = useState(null);
+    useEffect(()=>{
+        if (!dataScope) return;
+        let active = true;
+        // Unscoped, exactly like `api/orgs/datasets` and the billing page: the
+        // quota is about the ORG's datasets, not the subset this collaborator
+        // can see. A scoped collaborator whom AGL-1044 denies the read falls
+        // through to the catch and keeps the visible-rows lower bound.
+        void getCountFromServer(collection(firestore, dataScope[0], dataScope[1], 'datasets')).then((snapshot)=>{
+            if (active) setServerDatasetCount(snapshot.data().count);
+        }).catch(()=>{
+        // Falls back to the listener length below — a LOWER bound, and this
+        // card's prior behaviour. Deliberately not 0: `checkDatasetQuota`
+        // answers from whatever it is handed, and 0 used is a confident
+        // wrong number in the flattering direction.
+        });
+        return ()=>{
+            active = false;
+        };
+    }, [
+        firestore,
+        dataScope,
+        datasetCountEpoch
+    ]);
+    // The dataset the counts below belong to. Distinct from `selectedId`
+    // above, which is the PICKER value and is null until the user chooses.
+    const countedDatasetId = selected == null ? void 0 : selected.$id;
+    useEffect(()=>{
+        if (!dataScope || !countedDatasetId) return;
+        let active = true;
+        void getCountFromServer(collection(firestore, dataScope[0], dataScope[1], 'datasets', countedDatasetId, 'records')).then((snapshot)=>{
+            if (active) {
+                setServerRecordCount({
+                    datasetId: countedDatasetId,
+                    count: snapshot.data().count
+                });
+            }
+        }).catch(()=>{
+        // Same fallback, same reason as above.
+        });
+        return ()=>{
+            active = false;
+        };
+    }, [
+        firestore,
+        dataScope,
+        countedDatasetId,
+        recordCountEpoch
+    ]);
+    // Pending, denied, or answered about the PREVIOUS selection, the loaded
+    // rows stand in. They can only UNDERSTATE (same collections, capped),
+    // never overstate, so nothing these figures gate fires on a count larger
+    // than the truth. Since AGL-2501 the record fallback is one PAGE, so it
+    // understates by more — which moves it further in the safe direction and
+    // changes nothing about which way it can be wrong.
+    const datasetCount = serverDatasetCount != null ? serverDatasetCount : datasets.length;
+    const recordCount = serverRecordCount && serverRecordCount.datasetId === countedDatasetId ? serverRecordCount.count : records.length;
+    // Query layer (AGL-181): the same evaluator the renderer uses, applied in
+    // memory over the rows in front of the reader. That window is now one PAGE
+    // rather than a 500-row sample (AGL-2501), which is a smaller claim and a
+    // true one — the helper text says which, because a filter box that looks
+    // like it searches the collection and does not is worse than one that says
+    // so.
+    const [filterText, setFilterText] = useState('');
+    const [sortText, setSortText] = useState('');
+    const visibleRecords = useMemo(()=>{
+        const where = parseDatasetFilter(filterText);
+        const orderBy = parseDatasetSort(sortText);
+        if (!where && !orderBy) return records;
+        const rows = records.map((record)=>{
+            var _record_values;
+            return _extends({
+                __record: record
+            }, (_record_values = record.values) != null ? _record_values : {});
+        });
+        return applyDatasetQuery(model, rows, _extends({}, where ? {
+            where: [
+                where
+            ]
+        } : {}, orderBy ? {
+            orderBy
+        } : {})).map((row)=>row.__record);
+    }, [
+        records,
+        filterText,
+        sortText,
+        model
+    ]);
+    // --- Create dataset -----------------------------------------------------
+    const [creator, setCreator] = useState(null);
+    const handleOpenCreator = useCallback(()=>{
+        if (!checkEntitlement(org, 'dataStore')) {
+            return enqueueSnackbar('Datasets require a Starter plan or higher — see Billing', {
+                variant: 'warning',
+                persist: false
+            });
+        }
+        // Addon-aware quota (AGL-132): purchased extra datasets raise the
+        // limit up to the plan's hard max; beyond that only an upgrade helps.
+        // The ORG's datasets, not the picker's window (AGL-1716).
+        const quota = checkDatasetQuota(org, datasetCount);
+        if (!quota.allowed) {
+            return enqueueSnackbar(quota.upgradeRequired ? `Dataset limit reached (${quota.limit}) — upgrade in Billing` : `Dataset limit reached (${quota.limit}) — add extra datasets ` + `for $${quota.addonPriceUsd}/mo each or upgrade in Billing`, {
+                variant: 'warning',
+                persist: false
+            });
+        }
+        setCreator({
+            name: '',
+            fields: ''
+        });
+    }, [
+        org,
+        datasetCount,
+        enqueueSnackbar
+    ]);
+    // Entries are human names — "Roast preference" → stable id
+    // `roast_preference` with the pretty name kept for headers (AGL-558).
+    const creatorEntries = parseDatasetFieldEntries((_ref = creator == null ? void 0 : creator.fields) != null ? _ref : '');
+    const creatorFields = creatorEntries.map((entry)=>entry.id);
+    const handleCreate = useCallback(async ()=>{
+        // No org, no create. The `else` that used to sit below this was the
+        // legacy host-scope client write (AGL-1050) — the one path by which a
+        // dataset could be created with NO quota check, since /api/orgs/datasets
+        // is where AGL-473 enforces it. The rules now deny that path outright;
+        // this is the client side of the same closure. The Add button is
+        // disabled without a scope, so reaching the guard means a stale closure.
+        if (!(creator == null ? void 0 : creator.name.trim()) || creatorFields.length === 0 || !orgId) return;
+        let id;
+        try {
+            const result = await callDatasetApi(_extends({
+                action: 'create-dataset',
+                displayName: creator.name.trim(),
+                fields: creatorFields,
+                // Typed model from day one (AGL-178); refine in the Schema dialog.
+                model: modelFromFieldEntries(creatorEntries)
+            }, createdFrom));
+            id = String(result.id);
+        } catch (error) {
+            var _ref;
+            return void enqueueSnackbar((_ref = error == null ? void 0 : error.message) != null ? _ref : 'Dataset create failed', {
+                variant: 'warning',
+                persist: false
+            });
+        }
+        setCreator(null);
+        setSelectedId(id);
+        setDatasetCountEpoch((epoch)=>epoch + 1);
+        enqueueSnackbar(`Dataset "${creator.name.trim()}" created`, {
+            variant: 'success',
+            persist: false
+        });
+        logActivity('Created dataset', {
+            type: 'content',
+            id,
+            name: creator.name.trim()
+        });
+    }, [
+        creator,
+        creatorEntries,
+        creatorFields,
+        orgId,
+        createdFrom,
+        callDatasetApi,
+        enqueueSnackbar,
+        logActivity
+    ]);
+    // Join collection template (AGL-180): extrinsic many-to-many as a
+    // visible, editable collection of FKey pairs — no magic.
+    const [joiner, setJoiner] = useState(null);
+    const handleCreateJoin = useCallback(async ()=>{
+        if (!(joiner == null ? void 0 : joiner.a) || !(joiner == null ? void 0 : joiner.b) || joiner.a === joiner.b) return;
+        const a = datasets.find((item)=>item.$id === joiner.a);
+        const b = datasets.find((item)=>item.$id === joiner.b);
+        // A join collection is a dataset and consumes the same quota, so it
+        // 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),
+                type: 'reference',
+                required: true,
+                reference: {
+                    datasetId: target.$id,
+                    displayFieldId: effectiveDatasetModel(target).order[0],
+                    onDelete: 'setNull'
+                }
+            };
+        };
+        const payload = {
+            displayName: `${a.displayName} ↔ ${b.displayName}`,
+            fields: [
+                'aRef',
+                'bRef'
+            ],
+            model: {
+                order: [
+                    'aRef',
+                    'bRef'
+                ],
+                fields: {
+                    aRef: fieldFor(a, 'aRef'),
+                    bRef: fieldFor(b, 'bRef')
+                }
+            }
+        };
+        let id;
+        try {
+            const result = await callDatasetApi(_extends({
+                action: 'create-dataset'
+            }, payload, createdFrom));
+            id = String(result.id);
+        } catch (error) {
+            var _ref;
+            return void enqueueSnackbar((_ref = error == null ? void 0 : error.message) != null ? _ref : 'Join create failed', {
+                variant: 'warning',
+                persist: false
+            });
+        }
+        setJoiner(null);
+        setSelectedId(id);
+        // A join collection IS a dataset and consumes the same quota.
+        setDatasetCountEpoch((epoch)=>epoch + 1);
+        enqueueSnackbar('Join collection created', {
+            variant: 'success',
+            persist: false
+        });
+    }, [
+        joiner,
+        datasets,
+        orgId,
+        createdFrom,
+        callDatasetApi,
+        enqueueSnackbar
+    ]);
+    const handleDeleteDataset = useCallback(async ()=>{
+        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):
+            // 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',
+            confirmationButtonProps: {
+                color: 'error'
+            }
+        }).then(()=>true).catch(()=>false);
+        if (!confirmed || !dataScope) return;
+        // Deleting the dataset doc client-side would strand its `records`
+        // subcollection — Firestore doesn't cascade and only the Admin SDK has
+        // `recursiveDelete`, so the delete goes through the erase route
+        // (AGL-945). Single-record deletes below stay client-direct.
+        try {
+            var _ref;
+            const response = await authorizedFetch(user, '/api/resources/erase', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    scope: dataScope[0],
+                    scopeId: dataScope[1],
+                    kind: 'datasets',
+                    id: selected.$id,
+                    // Names the site this delete was issued from, so the route can
+                    // refuse to destroy a dataset shared beyond it (AGL-1046). The
+                    // org Data page passes no host and keeps the org-wide delete.
+                    hostId
+                })
+            });
+            const result = await response.json().catch(()=>({}));
+            if (!response.ok) throw new Error((_ref = result == null ? void 0 : result.error) != null ? _ref : 'Dataset delete failed');
+        } catch (error) {
+            var _ref1;
+            return void enqueueSnackbar((_ref1 = error == null ? void 0 : error.message) != null ? _ref1 : 'Dataset delete failed', {
+                variant: 'warning',
+                persist: false
+            });
+        }
+        setSelectedId(null);
+        setDatasetCountEpoch((epoch)=>epoch + 1);
+        enqueueSnackbar('Dataset deleted', {
+            variant: 'success',
+            persist: false
+        });
+        logActivity('Deleted dataset', {
+            type: 'content',
+            id: selected.$id,
+            name: selected.displayName
+        });
+    }, [
+        selected,
+        recordCount,
+        confirm,
+        dataScope,
+        hostId,
+        user,
+        enqueueSnackbar,
+        logActivity
+    ]);
+    // Reference pickers (AGL-180): load target-collection rows for every
+    // reference field in the model (id -> display label).
+    const [refOptions, setRefOptions] = useState({});
+    useEffect(()=>{
+        let active = true;
+        const referenceFields = model.order.filter((fieldId)=>{
+            var _model_fields_fieldId, _model_fields_fieldId_reference, _model_fields_fieldId1;
+            return ((_model_fields_fieldId = model.fields[fieldId]) == null ? void 0 : _model_fields_fieldId.type) === 'reference' && ((_model_fields_fieldId1 = model.fields[fieldId]) == null ? void 0 : (_model_fields_fieldId_reference = _model_fields_fieldId1.reference) == null ? void 0 : _model_fields_fieldId_reference.datasetId);
+        });
+        if (!referenceFields.length || !dataScope) {
+            setRefOptions({});
+            return;
+        }
+        void Promise.all(referenceFields.map(async (fieldId)=>{
+            var _reference_displayFieldId, _ref;
+            const reference = model.fields[fieldId].reference;
+            const target = datasets.find((item)=>item.$id === reference.datasetId);
+            const displayFieldId = (_reference_displayFieldId = reference.displayFieldId) != null ? _reference_displayFieldId : effectiveDatasetModel(target != null ? target : {}).order[0];
+            const snapshot = await getDocs(query(collection(firestore, dataScope[0], dataScope[1], 'datasets', reference.datasetId, 'records'), limit(200))).catch(()=>null);
+            const options = ((_ref = snapshot == null ? void 0 : snapshot.docs) != null ? _ref : []).map((docSnapshot)=>{
+                var _ref;
+                var _docSnapshot_get;
+                return {
+                    id: docSnapshot.id,
+                    label: String((_ref = (_docSnapshot_get = docSnapshot.get('values')) == null ? void 0 : _docSnapshot_get[displayFieldId != null ? displayFieldId : '']) != null ? _ref : docSnapshot.id)
+                };
+            });
+            return [
+                fieldId,
+                options
+            ];
+        })).then((entries)=>{
+            if (active) setRefOptions(Object.fromEntries(entries));
+        });
+        return ()=>{
+            active = false;
+        };
+    }, [
+        model,
+        datasets,
+        firestore,
+        dataScope
+    ]);
+    /**
+   * One reference target's label, or `null` when this ID resolves to nothing.
+   *
+   * The distinction the grid cannot draw. `referenceLabel` below falls back to
+   * the raw ID, which is the only thing a cell has room for and is
+   * indistinguishable from a resolved label that happens to look like an ID.
+   * The record view has room to say which, so it asks the question that has a
+   * `null` answer.
+   *
+   * Unresolvable covers more than a deleted target: `refOptions` loads at most
+   * 200 rows per referenced collection, so a live target outside that window
+   * reports the same way. Either way the ID is shown and neither is claimed to
+   * be a working link.
+   */ const resolveReferenceLabel = useCallback((fieldId, id)=>{
+        var _ref;
+        var _refOptions_fieldId_find, _refOptions_fieldId;
+        return (_ref = (_refOptions_fieldId = refOptions[fieldId]) == null ? void 0 : (_refOptions_fieldId_find = _refOptions_fieldId.find((option)=>option.id === id)) == null ? void 0 : _refOptions_fieldId_find.label) != null ? _ref : null;
+    }, [
+        refOptions
+    ]);
+    const referenceLabel = useCallback((fieldId, value)=>{
+        const ids = Array.isArray(value) ? value : value != null ? [
+            value
+        ] : [];
+        return ids.map((id)=>{
+            var _resolveReferenceLabel;
+            return (_resolveReferenceLabel = resolveReferenceLabel(fieldId, String(id))) != null ? _resolveReferenceLabel : String(id);
+        }).join(', ');
+    }, [
+        resolveReferenceLabel
+    ]);
+    /**
+   * The record the viewer is showing, held as an ID and resolved against the
+   * page the table already has.
+   *
+   * Holding the ID rather than the row is what keeps the view live without
+   * costing a read: the same listener that draws the table re-resolves it, so
+   * an edit landing underneath updates the open dialog. When the row leaves
+   * the page — deleted, or paged past — this answers `null` and the dialog
+   * closes, which is the honest response to a record no longer in front of
+   * this reader. Nothing here queries: `records` is the page query's answer.
+   */ const [viewerId, setViewerId] = useState(null);
+    const viewerRecord = useMemo(()=>{
+        var _records_find;
+        return viewerId ? (_records_find = records.find((record)=>record.$id === viewerId)) != null ? _records_find : null : null;
+    }, [
+        viewerId,
+        records
+    ]);
+    // --- Document editor (null id = new; AGL-179 typed inputs) --------------
+    const [editor, setEditor] = useState(null);
+    const handleOpenRecord = useCallback((record)=>()=>{
+            var _record_values, _ref;
+            if (!record) {
+                // The dataset's documents, not the loaded window (AGL-1716).
+                const quota = checkQuota(org, 'recordsPerDataset', recordCount);
+                if (!quota.allowed) {
+                    return enqueueSnackbar(`Record limit reached (${quota.limit}) — see Billing to upgrade`, {
+                        variant: 'warning',
+                        persist: false
+                    });
+                }
+            }
+            const values = {};
+            for (const fieldId of model.order){
+                const field = model.fields[fieldId];
+                if (!field) continue;
+                if (record) {
+                    var _record_values1;
+                    values[fieldId] = datasetValueToInput(field, (_record_values1 = record.values) == null ? void 0 : _record_values1[fieldId]);
+                } else if (field.default != null) {
+                    values[fieldId] = String(field.default);
+                }
+            }
+            // Flag non-conforming stored values (AGL-178 policy: type changes
+            // never rewrite documents; the editor surfaces the mismatch).
+            const errors = record ? validateDocument(model, (_record_values = record.values) != null ? _record_values : {}) : {};
+            setEditor({
+                id: (_ref = record == null ? void 0 : record.$id) != null ? _ref : null,
+                values,
+                errors
+            });
+        }, [
+        org,
+        recordCount,
+        model,
+        enqueueSnackbar
+    ]);
+    const handleSaveRecord = useCallback(async ()=>{
+        if (!editor || !selected || !dataScope) return;
+        const coerced = coerceDocumentValues(model, editor.values);
+        const errors = validateDocument(model, coerced);
+        if (Object.keys(errors).length) {
+            return void setEditor((prev)=>prev ? _extends({}, prev, {
+                    errors
+                }) : prev);
+        }
+        // `values` is replaced wholesale (not merged) so orphaned values from
+        // removed fields strip here, lazily, per the documented AGL-178 policy.
+        try {
+            if (editor.id) {
+                // Updates stay client-direct (no quota consumed).
+                const recordRef = doc(firestore, dataScope[0], dataScope[1], 'datasets', selected.$id, 'records', editor.id);
+                await setDoc(recordRef, _extends({
+                    values: coerced
+                }, datasetIntegrityUpdate(model, coerced, deleteField()), {
+                    updatedAt: Timestamp.now()
+                }), {
+                    mergeFields: [
+                        'values',
+                        'referencedIds',
+                        'updatedAt'
+                    ]
+                });
+                await announceRecords(selected.$id);
+            } else {
+                // Creates go through the quota-enforcing API (AGL-473). The legacy
+                // host-scope client write that used to follow this branch is gone
+                // (AGL-1050): a non-null `dataScope` is an org scope, so `orgId` is
+                // set and there is no third case to fall into.
+                await callDatasetApi({
+                    action: 'create-record',
+                    datasetId: selected.$id,
+                    values: coerced
+                });
+            }
+        } catch (error) {
+            var _ref;
+            return void enqueueSnackbar((_ref = error == null ? void 0 : error.message) != null ? _ref : 'Record save failed', {
+                variant: 'warning',
+                persist: false
+            });
+        }
+        setEditor(null);
+        // A create moves the count; an update cannot. Same reason as the
+        // importer: the one-shot aggregate does not refresh itself.
+        if (!editor.id) setRecordCountEpoch((epoch)=>epoch + 1);
+        enqueueSnackbar(editor.id ? 'Record saved' : 'Record added', {
+            variant: 'success',
+            persist: false
+        });
+        logActivity(editor.id ? 'Updated record' : 'Added record', {
+            type: 'content',
+            id: selected.$id,
+            name: selected.displayName
+        });
+    }, [
+        editor,
+        selected,
+        firestore,
+        dataScope,
+        model,
+        callDatasetApi,
+        announceRecords,
+        enqueueSnackbar,
+        logActivity
+    ]);
+    const handleDeleteRecord = useCallback((record)=>async ()=>{
+            // Datasets whose records this delete rewrites through a reference
+            // fixup, beside the one the record belongs to. Each has pages of its
+            // own to refresh (AGL-3113).
+            const alsoChanged = new Set();
+            if (!selected || !dataScope) return;
+            /**
+       * Delete integrity (AGL-180): every collection whose model references
+       * this one is asked whether it still points at this record. `restrict`
+       * blocks the delete; `setNull` strips the FKey from the holders.
+       *
+       * The question is a QUERY over the denormalized `referencedIds` index,
+       * not a page of records filtered in the browser. A page answers for the
+       * rows it happened to fetch — an unordered `limit` is answered in
+       * document-id order over auto-ids, so it is an arbitrary sample — and a
+       * reference held by a row outside it reads as no reference at all: the
+       * delete goes through and `restrict` silently fails to restrict, leaving
+       * a document pointing at something that no longer exists. `values`
+       * itself cannot be queried (it carries a deliberate index exemption —
+       * see `datasetIntegrityFields`), which is why the index exists.
+       *
+       * The query narrows to the candidates; the per-field test below keeps it
+       * EXACT, since `referencedIds` is the union across every reference field
+       * and one of them may point at a different collection entirely.
+       *
+       * ⚠️ FAILS CLOSED. A query that rejects — a missing index, a rules
+       * refusal on a collection this member cannot read — refuses the delete
+       * rather than treating silence as "nothing references it". A check that
+       * fails open is worse than no check, because the UI then tells the user
+       * the record is safe to remove.
+       *
+       * ⚠️ Reaches the collections in `datasets`, which is this viewer's
+       * scoped, capped picker window. A referencing collection shared with no
+       * site this member can see is one the client may not read at all, so it
+       * is not consulted; only a server route could close that.
+       */ for (const other of datasets){
+                const otherModel = effectiveDatasetModel(other);
+                const referencing = otherModel.order.filter((fieldId)=>{
+                    var _otherModel_fields_fieldId, _otherModel_fields_fieldId_reference, _otherModel_fields_fieldId1;
+                    return ((_otherModel_fields_fieldId = otherModel.fields[fieldId]) == null ? void 0 : _otherModel_fields_fieldId.type) === 'reference' && ((_otherModel_fields_fieldId1 = otherModel.fields[fieldId]) == null ? void 0 : (_otherModel_fields_fieldId_reference = _otherModel_fields_fieldId1.reference) == null ? void 0 : _otherModel_fields_fieldId_reference.datasetId) === selected.$id;
+                });
+                if (!referencing.length) continue;
+                let snapshot;
+                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.', {
+                        variant: 'error'
+                    });
+                }
+                const hits = snapshot.docs.filter((docSnapshot)=>referencing.some((fieldId)=>{
+                        var _docSnapshot_get;
+                        const stored = (_docSnapshot_get = docSnapshot.get('values')) == null ? void 0 : _docSnapshot_get[fieldId];
+                        return Array.isArray(stored) ? stored.includes(record.$id) : stored === record.$id;
+                    }));
+                if (!hits.length) continue;
+                const restricted = referencing.some((fieldId)=>{
+                    var _otherModel_fields_fieldId_reference, _otherModel_fields_fieldId;
+                    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}"`, {
+                        variant: 'warning',
+                        persist: false
+                    });
+                }
+                // Chunked under Firestore's 500-writes-per-batch cap. The query is no
+                // longer bounded by a page size, so the number of holders is whatever
+                // the collection really holds.
+                for(let start = 0; start < hits.length; start += 400){
+                    const batch = writeBatch(firestore);
+                    for (const hit of hits.slice(start, start + 400)){
+                        var _hit_get;
+                        const values = _extends({}, (_hit_get = hit.get('values')) != null ? _hit_get : {});
+                        for (const fieldId of referencing){
+                            const stored = values[fieldId];
+                            if (Array.isArray(stored)) {
+                                values[fieldId] = stored.filter((id)=>id !== record.$id);
+                            } else if (stored === record.$id) {
+                                delete values[fieldId];
+                            }
+                        }
+                        batch.update(hit.ref, _extends({
+                            values
+                        }, datasetIntegrityUpdate(otherModel, values, deleteField())));
+                    }
+                    await batch.commit();
+                }
+                // The fixups rewrote rows in ANOTHER dataset, whose own pages are now
+                // showing a reference that no longer resolves.
+                alsoChanged.add(other.$id);
+            }
+            await deleteDoc(doc(firestore, dataScope[0], dataScope[1], 'datasets', selected.$id, 'records', record.$id));
+            setRecordCountEpoch((epoch)=>epoch + 1);
+            for (const datasetId of [
+                selected.$id,
+                ...alsoChanged
+            ]){
+                await announceRecords(datasetId);
+            }
+            enqueueSnackbar('Record deleted', {
+                variant: 'success',
+                persist: false
+            });
+        }, [
+        selected,
+        datasets,
+        firestore,
+        dataScope,
+        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'
+                });
+            } 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
+    ]);
+    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 key = keyOf((_snapshot_get = snapshot.get('values')) != null ? _snapshot_get : {});
+                if (key) existingByKey.set(key, snapshot.id);
+            }
+            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 existingId = existingByKey.get(key);
+                if (existingId) updates.push({
+                    id: existingId,
+                    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()
+                }), {
+                    merge: true
+                });
+            });
+            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);
+            }
+        } 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
+        });
+    }, [
+        selected,
+        importPreview,
+        importer == null ? void 0 : importer.keyField,
+        org,
+        model,
+        recordCount,
+        firestore,
+        dataScope,
+        callDatasetApi,
+        announceRecords,
+        enqueueSnackbar,
+        logActivity
+    ]);
+    return /*#__PURE__*/ _jsxs(CardDisplay, {
+        header: 'Data',
+        help: pluginDocsHelp('datasets', {
+            anchor: '#model-builder'
+        }),
+        contentGutterX: true,
+        contentGutterY: true,
+        contentBordered: "all",
+        children: [
+            /*#__PURE__*/ _jsxs(Stack, {
+                spacing: 1.5,
+                children: [
+                    orgId ? /*#__PURE__*/ _jsx(Typography, {
+                        variant: "caption",
+                        color: "text.secondary",
+                        children: newDatasetSharingNote(createsSiteOnly)
+                    }) : null,
+                    datasets.length === 0 ? /*#__PURE__*/ _jsx(Typography, {
+                        variant: "body2",
+                        color: "text.secondary",
+                        children: 'Create a dataset (e.g. Products) and repeat a component over ' + 'its records with {{item.field}} bindings.'
+                    }) : /*#__PURE__*/ _jsxs(Stack, {
+                        direction: "row",
+                        spacing: 1,
+                        sx: {
+                            alignItems: 'center'
+                        },
+                        children: [
+                            /*#__PURE__*/ _jsx(TextField, {
+                                select: true,
+                                size: "small",
+                                label: "Dataset",
+                                value: (_ref1 = selected == null ? void 0 : selected.$id) != null ? _ref1 : '',
+                                onChange: (event)=>setSelectedId(event.target.value),
+                                sx: {
+                                    minWidth: 180
+                                },
+                                children: datasets.map((item)=>/*#__PURE__*/ _jsx(MenuItem, {
+                                        value: item.$id,
+                                        children: item.displayName
+                                    }, item.$id))
+                            }),
+                            /*#__PURE__*/ _jsx(Button, {
+                                size: "small",
+                                color: "primary",
+                                onClick: handleOpenRecord(),
+                                children: 'Add record'
+                            }),
+                            /*#__PURE__*/ _jsx(Button, {
+                                size: "small",
+                                onClick: ()=>setSchemaOpen(true),
+                                children: 'Schema'
+                            }),
+                            /*#__PURE__*/ _jsx(Button, {
+                                size: "small",
+                                onClick: ()=>setImporter({
+                                        text: '',
+                                        keyField: ''
+                                    }),
+                                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,
+                            /*#__PURE__*/ _jsx(Button, {
+                                size: "small",
+                                color: "error",
+                                onClick: handleDeleteDataset,
+                                children: 'Delete'
+                            })
+                        ]
+                    }),
+                    selected ? /*#__PURE__*/ _jsx(QuotaReadoutComponent, {
+                        ready: org != null,
+                        used: recordCount,
+                        limit: checkQuota(org, 'recordsPerDataset', recordCount).limit,
+                        noun: "record"
+                    }) : null,
+                    selected && records.length > 0 ? /*#__PURE__*/ _jsxs(Stack, {
+                        direction: "row",
+                        spacing: 1,
+                        children: [
+                            /*#__PURE__*/ _jsx(TextField, {
+                                size: "small",
+                                label: "Filter",
+                                value: filterText,
+                                onChange: (event)=>setFilterText(event.target.value),
+                                helperText: 'e.g. price <= 20 · applies to this page',
+                                sx: {
+                                    minWidth: 220
+                                }
+                            }),
+                            /*#__PURE__*/ _jsx(TextField, {
+                                size: "small",
+                                label: "Sort",
+                                value: sortText,
+                                onChange: (event)=>setSortText(event.target.value),
+                                helperText: 'e.g. price desc',
+                                sx: {
+                                    minWidth: 140
+                                }
+                            })
+                        ]
+                    }) : null,
+                    selected && (records.length > 0 || recordPage > 0) ? /*#__PURE__*/ _jsxs(_Fragment, {
+                        children: [
+                            /*#__PURE__*/ _jsxs(ScrollTable, {
+                                size: "small",
+                                children: [
+                                    /*#__PURE__*/ _jsx(TableHead, {
+                                        children: /*#__PURE__*/ _jsxs(TableRow, {
+                                            children: [
+                                                fields.map((fieldId)=>{
+                                                    var _field_name, _ref;
+                                                    const field = model.fields[fieldId];
+                                                    // Field descriptions (AGL-560) surface as header hints.
+                                                    return /*#__PURE__*/ _jsx(TableCell, {
+                                                        children: (field == null ? void 0 : field.description) ? /*#__PURE__*/ _jsx(Tooltip, {
+                                                            title: field.description,
+                                                            children: /*#__PURE__*/ _jsx("span", {
+                                                                style: {
+                                                                    cursor: 'help'
+                                                                },
+                                                                children: (_field_name = field.name) != null ? _field_name : fieldId
+                                                            })
+                                                        }) : (_ref = field == null ? void 0 : field.name) != null ? _ref : fieldId
+                                                    }, fieldId);
+                                                }),
+                                                /*#__PURE__*/ _jsx(TableCell, {
+                                                    align: "right",
+                                                    children: 'Actions'
+                                                })
+                                            ]
+                                        })
+                                    }),
+                                    /*#__PURE__*/ _jsx(TableBody, {
+                                        children: visibleRecords.map((record)=>/*
+                  The row OPENS the record, read-only. Reading a record and
+                  changing one used to be the same gesture: `Edit` was the only
+                  way to see a document's full contents, so every look opened a
+                  form whose primary button writes.
+
+                  The click is the mouse affordance and nothing else — a `<tr>`
+                  cannot be made into a real activatable control without
+                  overriding the `row` role a table depends on. The keyboard's
+                  affordance is the `View` button in the actions cluster: a
+                  genuine `<button>`, in the tab order, announced as one, with
+                  the theme's focus ring. Both reach the same handler.
+                */ /*#__PURE__*/ _jsxs(TableRow, {
+                                                hover: true,
+                                                onClick: ()=>setViewerId(record.$id),
+                                                sx: {
+                                                    cursor: 'pointer'
+                                                },
+                                                children: [
+                                                    fields.map((fieldId)=>{
+                                                        var _model_fields_fieldId, _record_values, _record_values1;
+                                                        return /*#__PURE__*/ _jsx(TableCell, {
+                                                            children: ((_model_fields_fieldId = model.fields[fieldId]) == null ? void 0 : _model_fields_fieldId.type) === 'reference' ? referenceLabel(fieldId, (_record_values = record.values) == null ? void 0 : _record_values[fieldId]) || '--' : model.fields[fieldId] ? formatDatasetValue(model.fields[fieldId], (_record_values1 = record.values) == null ? void 0 : _record_values1[fieldId]) || '--' : '--'
+                                                        }, fieldId);
+                                                    }),
+                                                    /*#__PURE__*/ _jsxs(TableCell, {
+                                                        align: "right",
+                                                        sx: {
+                                                            whiteSpace: 'nowrap'
+                                                        },
+                                                        /*
+                      Every control in this cell is its OWN action. Without
+                      this the row's handler fires too, so `Delete` would open
+                      the viewer behind its own destructive write and `Edit`
+                      would leave a read-only dialog stacked under the form —
+                      the kind of defect nobody reports and everybody works
+                      around.
+                    */ onClick: (event)=>event.stopPropagation(),
+                                                        children: [
+                                                            /*#__PURE__*/ _jsx(Button, {
+                                                                size: "small",
+                                                                onClick: ()=>setViewerId(record.$id),
+                                                                children: 'View'
+                                                            }),
+                                                            /*#__PURE__*/ _jsx(Button, {
+                                                                size: "small",
+                                                                onClick: handleOpenRecord(record),
+                                                                children: 'Edit'
+                                                            }),
+                                                            /*#__PURE__*/ _jsx(Button, {
+                                                                size: "small",
+                                                                color: "error",
+                                                                onClick: handleDeleteRecord(record),
+                                                                children: 'Delete'
+                                                            })
+                                                        ]
+                                                    })
+                                                ]
+                                            }, record.$id))
+                                    })
+                                ]
+                            }),
+                            /*#__PURE__*/ _jsx(ListPagination, {
+                                page: recordPage,
+                                pageSize: recordPageSize,
+                                rowCount: records.length,
+                                hasMore: hasMoreRecords,
+                                onPageChange: setRecordPage,
+                                onPageSizeChange: setRecordPageSize
+                            })
+                        ]
+                    }) : selected ? /*#__PURE__*/ _jsx(Typography, {
+                        variant: "body2",
+                        color: "text.secondary",
+                        children: 'No records yet.'
+                    }) : null,
+                    /*#__PURE__*/ _jsxs(Stack, {
+                        direction: "row",
+                        spacing: 1,
+                        children: [
+                            /*#__PURE__*/ _jsx(Button, {
+                                size: "small",
+                                variant: "outlined",
+                                color: "primary",
+                                onClick: handleOpenCreator,
+                                children: 'Add dataset'
+                            }),
+                            datasets.length >= 2 ? /*#__PURE__*/ _jsx(Button, {
+                                size: "small",
+                                onClick: ()=>setJoiner({
+                                        a: '',
+                                        b: ''
+                                    }),
+                                children: 'Add join collection'
+                            }) : null
+                        ]
+                    })
+                ]
+            }),
+            /*#__PURE__*/ _jsxs(Dialog, {
+                open: Boolean(creator),
+                onClose: ()=>setCreator(null),
+                maxWidth: "xs",
+                fullWidth: true,
+                children: [
+                    /*#__PURE__*/ _jsx(DialogTitle, {
+                        children: 'New dataset'
+                    }),
+                    /*#__PURE__*/ _jsxs(DialogContent, {
+                        sx: {
+                            display: 'flex',
+                            flexDirection: 'column',
+                            gap: 2
+                        },
+                        children: [
+                            /*#__PURE__*/ _jsx(TextField, {
+                                label: "Name",
+                                value: (_ref2 = creator == null ? void 0 : creator.name) != null ? _ref2 : '',
+                                onChange: (event)=>setCreator((prev)=>prev ? _extends({}, prev, {
+                                            name: event.target.value
+                                        }) : prev),
+                                size: "small",
+                                autoFocus: true,
+                                sx: {
+                                    mt: 1
+                                },
+                                helperText: "e.g. Products, Team, FAQ"
+                            }),
+                            /*#__PURE__*/ _jsx(TextField, {
+                                label: "Fields",
+                                value: (_ref3 = creator == null ? void 0 : creator.fields) != null ? _ref3 : '',
+                                onChange: (event)=>setCreator((prev)=>prev ? _extends({}, prev, {
+                                            fields: event.target.value
+                                        }) : prev),
+                                size: "small",
+                                helperText: creatorEntries.length ? `Columns: ${creatorEntries.map((entry)=>entry.name).join(', ')}` : 'Comma-separated column names, e.g. Title, Unit price'
+                            })
+                        ]
+                    }),
+                    /*#__PURE__*/ _jsxs(DialogActions, {
+                        children: [
+                            /*#__PURE__*/ _jsx(Button, {
+                                onClick: ()=>setCreator(null),
+                                children: 'Cancel'
+                            }),
+                            /*#__PURE__*/ _jsx(Button, {
+                                variant: "contained",
+                                color: "primary",
+                                disabled: !scopeReady || !(creator == null ? void 0 : creator.name.trim()) || creatorFields.length === 0,
+                                onClick: handleCreate,
+                                children: 'Create'
+                            })
+                        ]
+                    })
+                ]
+            }),
+            /*#__PURE__*/ _jsx(DatasetRecordDialog, {
+                record: viewerRecord,
+                model: model,
+                resolveReference: resolveReferenceLabel,
+                onClose: ()=>setViewerId(null),
+                // Explicitly separate, and a hand-off rather than a second editor:
+                // the viewer closes and the record opens in the dialog that has
+                // always owned writing.
+                onEdit: ()=>{
+                    const record = viewerRecord;
+                    setViewerId(null);
+                    if (record) handleOpenRecord(record)();
+                }
+            }),
+            /*#__PURE__*/ _jsxs(Dialog, {
+                open: Boolean(editor),
+                onClose: ()=>setEditor(null),
+                maxWidth: "xs",
+                fullWidth: true,
+                children: [
+                    /*#__PURE__*/ _jsx(DialogTitle, {
+                        children: (editor == null ? void 0 : editor.id) ? 'Edit record' : 'New record'
+                    }),
+                    /*#__PURE__*/ _jsx(DialogContent, {
+                        sx: {
+                            display: 'flex',
+                            flexDirection: 'column',
+                            gap: 2
+                        },
+                        children: fields.map((fieldId, index)=>{
+                            var _ref;
+                            var _field_validation_options, _field_validation;
+                            const field = model.fields[fieldId];
+                            if (!field) return null;
+                            const value = (_ref = editor == null ? void 0 : editor.values[fieldId]) != null ? _ref : '';
+                            const error = editor == null ? void 0 : editor.errors[fieldId];
+                            const label = field.required ? `${field.name} *` : field.name;
+                            const setValue = (nextValue)=>setEditor((prev)=>prev ? _extends({}, prev, {
+                                        values: _extends({}, prev.values, {
+                                            [fieldId]: nextValue
+                                        }),
+                                        errors: _extends({}, prev.errors, {
+                                            [fieldId]: ''
+                                        })
+                                    }) : prev);
+                            const common = {
+                                label,
+                                value,
+                                size: 'small',
+                                autoFocus: index === 0,
+                                error: Boolean(error),
+                                helperText: error || field.description,
+                                sx: index === 0 ? {
+                                    mt: 1
+                                } : undefined,
+                                onChange: (event)=>setValue(event.target.value)
+                            };
+                            // Custom field types (AGL-434): the declaring plugin's Input
+                            // takes over; values stay in input form (strings) so the
+                            // existing coerce/validate pipeline is unchanged.
+                            const customFieldType = getCustomFieldType(field.customType);
+                            if (customFieldType == null ? void 0 : customFieldType.Input) {
+                                const CustomInput = customFieldType.Input;
+                                return /*#__PURE__*/ _jsxs(Stack, {
+                                    sx: index === 0 ? {
+                                        mt: 1
+                                    } : undefined,
+                                    children: [
+                                        /*#__PURE__*/ _jsx(CustomInput, {
+                                            value: value,
+                                            label: common.label,
+                                            onChange: (next)=>setValue(String(next != null ? next : ''))
+                                        }),
+                                        error || field.description ? /*#__PURE__*/ _jsx(Typography, {
+                                            variant: "caption",
+                                            color: error ? 'error' : 'text.secondary',
+                                            children: error || field.description
+                                        }) : null
+                                    ]
+                                }, fieldId);
+                            }
+                            // Typed inputs per FT.Tag (AGL-179).
+                            if (field.type === 'bool') {
+                                return /*#__PURE__*/ _jsxs(TextField, _extends({}, common, {
+                                    select: true,
+                                    children: [
+                                        /*#__PURE__*/ _jsx(MenuItem, {
+                                            value: "",
+                                            children: '—'
+                                        }),
+                                        /*#__PURE__*/ _jsx(MenuItem, {
+                                            value: "true",
+                                            children: 'Yes'
+                                        }),
+                                        /*#__PURE__*/ _jsx(MenuItem, {
+                                            value: "false",
+                                            children: 'No'
+                                        })
+                                    ]
+                                }), fieldId);
+                            }
+                            if (field.type === 'text' && ((_field_validation = field.validation) == null ? void 0 : (_field_validation_options = _field_validation.options) == null ? void 0 : _field_validation_options.length)) {
+                                return /*#__PURE__*/ _jsxs(TextField, _extends({}, common, {
+                                    select: true,
+                                    children: [
+                                        /*#__PURE__*/ _jsx(MenuItem, {
+                                            value: "",
+                                            children: '—'
+                                        }),
+                                        field.validation.options.map((option)=>/*#__PURE__*/ _jsx(MenuItem, {
+                                                value: option,
+                                                children: option
+                                            }, option))
+                                    ]
+                                }), fieldId);
+                            }
+                            if (field.type === 'reference') {
+                                var _refOptions_fieldId;
+                                var _field_reference;
+                                const options = (_refOptions_fieldId = refOptions[fieldId]) != null ? _refOptions_fieldId : [];
+                                const multiple = Boolean((_field_reference = field.reference) == null ? void 0 : _field_reference.multiple);
+                                const selectedIds = value.split(',').map((part)=>part.trim()).filter(Boolean);
+                                return /*#__PURE__*/ _jsxs(TextField, _extends({}, common, {
+                                    select: true,
+                                    value: multiple ? selectedIds : value,
+                                    slotProps: {
+                                        select: multiple ? {
+                                            multiple: true,
+                                            onChange: (event)=>setValue(event.target.value.join(', '))
+                                        } : undefined
+                                    },
+                                    children: [
+                                        multiple ? null : /*#__PURE__*/ _jsx(MenuItem, {
+                                            value: "",
+                                            children: '—'
+                                        }),
+                                        options.map((option)=>/*#__PURE__*/ _jsx(MenuItem, {
+                                                value: option.id,
+                                                children: option.label
+                                            }, option.id))
+                                    ]
+                                }), fieldId);
+                            }
+                            if (field.type === 'int32' || field.type === 'int64' || field.type === 'float') {
+                                return /*#__PURE__*/ _jsx(TextField, _extends({}, common, {
+                                    type: "number"
+                                }), fieldId);
+                            }
+                            if (field.type === 'timestamp') {
+                                return /*#__PURE__*/ _jsx(TextField, _extends({}, common, {
+                                    type: "datetime-local",
+                                    slotProps: {
+                                        inputLabel: {
+                                            shrink: true
+                                        }
+                                    }
+                                }), fieldId);
+                            }
+                            if (field.type === 'coordinates') {
+                                return /*#__PURE__*/ _jsx(TextField, _extends({}, common, {
+                                    helperText: error || field.description || 'lat, lon'
+                                }), fieldId);
+                            }
+                            if (field.type === 'sorted') {
+                                return /*#__PURE__*/ _jsx(TextField, _extends({}, common, {
+                                    helperText: error || field.description || 'Comma-separated list'
+                                }), fieldId);
+                            }
+                            return /*#__PURE__*/ _jsx(TextField, _extends({}, common), fieldId);
+                        })
+                    }),
+                    /*#__PURE__*/ _jsxs(DialogActions, {
+                        children: [
+                            /*#__PURE__*/ _jsx(Button, {
+                                onClick: ()=>setEditor(null),
+                                children: 'Cancel'
+                            }),
+                            /*#__PURE__*/ _jsx(Button, {
+                                variant: "contained",
+                                color: "primary",
+                                onClick: handleSaveRecord,
+                                children: (editor == null ? void 0 : editor.id) ? 'Save' : 'Add'
+                            })
+                        ]
+                    })
+                ]
+            }),
+            /*#__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),
+                maxWidth: "xs",
+                fullWidth: true,
+                children: [
+                    /*#__PURE__*/ _jsx(DialogTitle, {
+                        children: 'New join collection'
+                    }),
+                    /*#__PURE__*/ _jsxs(DialogContent, {
+                        sx: {
+                            display: 'flex',
+                            flexDirection: 'column',
+                            gap: 2
+                        },
+                        children: [
+                            /*#__PURE__*/ _jsx(Typography, {
+                                variant: "body2",
+                                color: "text.secondary",
+                                sx: {
+                                    mt: 1
+                                },
+                                children: 'Links two collections many-to-many; each row pairs one ' + 'document from each side.'
+                            }),
+                            [
+                                'a',
+                                'b'
+                            ].map((side)=>{
+                                var _ref;
+                                return /*#__PURE__*/ _jsx(TextField, {
+                                    select: true,
+                                    size: "small",
+                                    label: side === 'a' ? 'First collection' : 'Second collection',
+                                    value: (_ref = joiner == null ? void 0 : joiner[side]) != null ? _ref : '',
+                                    onChange: (event)=>setJoiner((prev)=>prev ? _extends({}, prev, {
+                                                [side]: event.target.value
+                                            }) : prev),
+                                    children: datasets.map((item)=>/*#__PURE__*/ _jsx(MenuItem, {
+                                            value: item.$id,
+                                            children: item.displayName
+                                        }, item.$id))
+                                }, side);
+                            })
+                        ]
+                    }),
+                    /*#__PURE__*/ _jsxs(DialogActions, {
+                        children: [
+                            /*#__PURE__*/ _jsx(Button, {
+                                onClick: ()=>setJoiner(null),
+                                children: 'Cancel'
+                            }),
+                            /*#__PURE__*/ _jsx(Button, {
+                                variant: "contained",
+                                color: "primary",
+                                disabled: !scopeReady || !(joiner == null ? void 0 : joiner.a) || !(joiner == null ? void 0 : joiner.b) || joiner.a === joiner.b,
+                                onClick: handleCreateJoin,
+                                children: 'Create'
+                            })
+                        ]
+                    })
+                ]
+            }),
+            /*#__PURE__*/ _jsx(DatasetSchemaDialog, {
+                hostId: hostId,
+                orgId: orgId != null ? orgId : undefined,
+                dataset: schemaOpen && selected ? selected : null,
+                datasets: datasets,
+                // The dataset's documents, not the loaded window (AGL-1716) — the
+                // dialog warns "N documents exist" before a narrowing type change,
+                // and 500 was the cap talking, not the collection.
+                recordCount: recordCount,
+                seedFromCache: datasetsFromCache,
+                seedUnreadable: datasetsStatus === 'error',
+                onClose: ()=>setSchemaOpen(false)
+            })
+        ]
+    });
+}
+HostDatasetsCard.displayName = 'HostDatasetsCard';
+export default HostDatasetsCard;
+
+//# sourceMappingURL=host-datasets-card.component.js.map