@rebasepro/admin 0.13.0 → 0.13.1-canary.g06dbe5b

package/dist/components/DrawerNavigationItem.d.ts

@@ -1,16 +1,26 @@
 import React from "react";
-export declare function DrawerNavigationItem({ name, icon, drawerOpen, adminMenuOpen, tooltipsOpen, url, onClick, indented }: {
+/**
+ * Props of a drawer navigation row, named so an app overriding
+ * `Shell.DrawerNavigationItem` can type its wrapper against them.
+ */
+export type DrawerNavigationItemProps = {
     icon: React.ReactElement;
     name: string;
-    tooltipsOpen: boolean;
+    /** @deprecated No longer read: the tooltip is uncontrolled. */
+    tooltipsOpen?: boolean;
     drawerOpen: boolean;
+    /** @deprecated No longer read: the tooltip is uncontrolled. */
     adminMenuOpen?: boolean;
     url: string;
     onClick?: () => void;
     /**
-     * Render as a child of an icon-bearing group: no icon of its own, indented to
-     * sit under the group's label. Set by {@link DrawerNavigationGroup} only when
-     * the group actually has an icon and the drawer is expanded.
+     * Drop the row's icon and indent the label into the space it occupied, so the
+     * row reads as a child of the group header above it.
+     *
+     * Nothing in the framework sets this: the stock drawer always passes `false`,
+     * and an app that wants the categorised look opts into it by overriding
+     * `Shell.DrawerNavigationItem` and deciding for itself which rows get it.
      */
     indented?: boolean;
-}): React.JSX.Element;
+};
+export declare function DrawerNavigationItem({ name, icon, drawerOpen, url, onClick, indented }: DrawerNavigationItemProps): React.JSX.Element;

package/dist/components/EditViewBinding.d.ts

@@ -10,6 +10,19 @@ export type BarActionsParams = {
     status: EntityStatus;
     path: string;
     entityId?: string | number;
+    /** Whether `values` differ from what is stored. */
+    dirty: boolean;
+    /**
+     * Hand the edit in progress to the layout this action is about to open, so
+     * the record arrives showing — and still holding — what the user typed here.
+     * Call it from any action that changes layout without leaving the record;
+     * it decides on its own whether there is anything worth carrying, so a
+     * record nobody edited still arrives clean.
+     *
+     * Only supplied where there is a form to carry: the detail view passes no
+     * such thing.
+     */
+    carryEdit?: () => void;
 };
 export type OnTabChangeParams<M extends Record<string, unknown>> = {
     path: string;
@@ -33,6 +46,16 @@ export interface EditViewBindingProps<M extends Record<string, unknown> = Record
     onSaved?: (params: OnUpdateParams) => void;
     onTabChange?: (props: OnTabChangeParams<M>) => void;
     navigateBack?: () => void;
+    /**
+     * Dismiss this record — the ✕ at the identity bar's trailing edge, and what
+     * "save and close" reaches once the save lands.
+     *
+     * Set by the layouts that own the record's place on screen but are not side
+     * dialogs: the split, where dismissing is navigating back to the collection.
+     * The side panel and the dialog close through {@link useSideDialogContext}
+     * instead, which is what runs their unsaved-changes prompt.
+     */
+    onCloseRequest?: () => void;
     layout?: "side_panel" | "full_screen" | "split" | "dialog";
     barActions?: (params: BarActionsParams) => React.ReactNode;
     /**
@@ -40,6 +63,12 @@ export interface EditViewBindingProps<M extends Record<string, unknown> = Record
      * of the breadcrumb — the side panel's close button.
      */
     barActionsStart?: React.ReactNode;
+    /**
+     * Full screen only: bring the list back beside this record. Set when the
+     * record was opened out of a split collection, so folding the list away is
+     * reversible; it takes the place of the back arrow when present.
+     */
+    onShowList?: () => void;
     formProps?: Partial<EntityFormBindingProps<M>>;
     /**
      * Pre-populate the form with these values when creating a new entity.
@@ -53,7 +82,7 @@ export interface EditViewBindingProps<M extends Record<string, unknown> = Record
  * a record is opened.
  */
 export declare function EditViewBinding<M extends Record<string, unknown>>({ entityId, ...props }: EditViewBindingProps<M>): React.JSX.Element;
-export declare function EditViewBindingInner<M extends Record<string, unknown>>({ path, entityId, selectedTab: selectedTabProp, collection, parentCollectionSlugs, parentEntityIds, onValuesModified, onSaved, onTabChange, navigateBack, entity, initialDirtyValues, dataLoading, layout, barActions, barActionsStart, status, setStatus, formProps, canEdit }: EditViewBindingProps<M> & {
+export declare function EditViewBindingInner<M extends Record<string, unknown>>({ path, entityId, selectedTab: selectedTabProp, collection, parentCollectionSlugs, parentEntityIds, onValuesModified, onSaved, onTabChange, navigateBack, onCloseRequest, entity, initialDirtyValues, dataLoading, layout, barActions, barActionsStart, onShowList, status, setStatus, formProps, canEdit }: EditViewBindingProps<M> & {
     entity?: Entity<M>;
     initialDirtyValues?: Partial<M>;
     dataLoading: boolean;

package/dist/components/EntityDisplayHeader.d.ts

@@ -0,0 +1,53 @@
+import type { AdminCollection } from "@rebasepro/admin-types";
+import type { Entity } from "@rebasepro/types";
+import React from "react";
+/**
+ * The roles whose property the read-only view takes out of its grid.
+ *
+ * A role rendered here and left in the grid prints the value twice, so the
+ * header's own rendering and this list have to agree — but the list is *not*
+ * simply "every role the header draws". Two are deliberately absent:
+ *
+ * `title`, because the heading above a record and a labelled field are not the
+ * same thing. `Order #` is a column with a name, a description and a format that
+ * someone reads the record to find; `ORD-2026-0043` sitting in the identity bar
+ * beside the breadcrumb is a label for the page. Removing the field because the
+ * page is named after it takes a value out of the record on the grounds that its
+ * text appears elsewhere, which is not a reason — a value in the database is
+ * shown.
+ *
+ * `date`, because the rail's record block already carries the timestamps, and a
+ * collection whose `date` role points at a business date — an order date, a due
+ * date — wants that field where it declared it.
+ */
+export declare const HEADER_DISPLAY_ROLES: readonly ["subtitle", "image", "status", "tags"];
+export interface EntityDisplayHeaderProps<M extends Record<string, unknown>> {
+    entity: Entity<M>;
+    collection: AdminCollection<M>;
+    /**
+     * Render the title. Off when an identity bar above already shows it — which
+     * is every full-page use — and on inside a dialog that has no bar.
+     */
+    showTitle?: boolean;
+    className?: string;
+}
+/**
+ * What the record *is*, above the fields that say what it holds.
+ *
+ * A record's picture, name, state and labels are the things you opened the page
+ * to see; on the plain grid they were fields like any other, so an order's
+ * status sat in the second cell of the first row at the same size and weight as
+ * its shipping cost, and its tags were a wrapped list of grey text.
+ *
+ * Every role here comes from `admin.display` and nothing is derived except the
+ * title, which was already derived for the identity bar. A collection that
+ * declares no display block therefore gets no header at all rather than a
+ * heuristic guess at which of its enums is a "status" — the panel does not know
+ * what these records are, and a wrong guess here is louder than no guess.
+ *
+ * A role filled by a *property* renders through {@link PropertyPreview}, so a
+ * status keeps its enum's colour and an image stays a storage thumbnail. A role
+ * filled by a resolver has no property behind it and renders as what it
+ * returned.
+ */
+export declare function EntityDisplayHeader<M extends Record<string, unknown>>({ entity, collection, showTitle, className }: EntityDisplayHeaderProps<M>): React.JSX.Element | null;

package/dist/components/EntityIdentityBar.d.ts

@@ -4,6 +4,15 @@ import React from "react";
 export interface EntityIdentityBarProps {
     /** Plural collection name, shown as the breadcrumb ahead of the title. */
     collection: AdminCollection;
+    /**
+     * Where the breadcrumb points. Without it the collection name is inert text
+     * that still reads as a breadcrumb — worse than no breadcrumb at all, and
+     * the only way back once a layout drops its back arrow.
+     *
+     * Left unset by the overlays (side panel, dialog), where the collection is
+     * already underneath and navigating would dismiss the record instead.
+     */
+    collectionUrl?: string;
     /** Resolved record title, already guarded against showing a field default. */
     title: string;
     entityId?: string | number;
@@ -20,10 +29,43 @@ export interface EntityIdentityBarProps {
      * action is "done with this record" rather than "keep editing".
      */
     onSaveAndClose?: () => void;
+    /**
+     * Where {@link onSaveAndClose} is offered.
+     *
+     * `"button"` — its own filled button, and Save demotes to text. For the
+     * overlays, where you opened the record to do one thing to it and closing is
+     * the dominant intent.
+     *
+     * `"menu"` — a `▾` welded to the Save button. For the split, where the list
+     * is right there and `j`/`k` walk from record to record: there, saving and
+     * *staying* is the common case, so it keeps the filled button and dismissing
+     * is one step further in. The gesture still exists, so muscle memory carried
+     * over from the side panel finds it.
+     */
+    saveAndClosePlacement?: "button" | "menu";
+    /**
+     * Dismiss this record, from the ✕ at the bar's trailing edge.
+     *
+     * Fenced off from Save by a separator: it is chrome, not the last item in
+     * the action row. The panel that supplies it decides what dismissing means —
+     * in the split it is a navigation, which the layout's unsaved-changes
+     * blocker already guards, so the ✕ cannot drop an edit without asking.
+     */
+    onClose?: () => void;
     onBack?: () => void;
     onInspect?: () => void;
     /** Opens the inspector straight on its history tab. */
     onViewHistory?: () => void;
+    /**
+     * Where this record appears on the live site, from `entityLinkBuilder`.
+     *
+     * Here rather than above the record, where it used to be a single unlabelled
+     * icon alone on its own right-aligned row — the only thing between the bar
+     * and the first field, and the only control in the view that did not say
+     * what it was. It is a thing you do *to* a record, so it belongs with the
+     * others.
+     */
+    externalLink?: string;
     /**
      * Actions performed *on* the record — copy, delete, whatever the collection
      * adds — as menu items under the overflow button. They live here rather
@@ -50,4 +92,4 @@ export interface EntityIdentityBarProps {
  * editing. They live here instead, and the left half of a bar that was
  * previously empty now does the work.
  */
-export declare function EntityIdentityBar({ collection, title, entityId, status, dirty, saving, onSave, onDiscard, saveDisabled, hasErrors, onSaveAndClose, onBack, onInspect, onViewHistory, recordActions, pluginActions, trailing, leading }: EntityIdentityBarProps): React.JSX.Element;
+export declare function EntityIdentityBar({ collection, collectionUrl, title, entityId, status, dirty, saving, onSave, onDiscard, saveDisabled, hasErrors, onSaveAndClose, saveAndClosePlacement, onClose, onBack, onInspect, onViewHistory, externalLink, recordActions, pluginActions, trailing, leading }: EntityIdentityBarProps): React.JSX.Element;

package/dist/components/EntityViewBinding.d.ts

@@ -1,6 +1,30 @@
 import type { AdminCollection } from "@rebasepro/admin-types";
+import type { FormContext } from "../types/fields";
 import React from "react";
 import { Entity } from "@rebasepro/types";
+/**
+ * The fields the read-only view lays out, in render order.
+ *
+ * The same set the form uses, minus two groups. Both are dropped *before* the
+ * layout resolves rather than skipped while rendering, because the resolver has
+ * by then given each one a place on the grid — skipping later leaves that place
+ * as a hole.
+ *
+ * - The `additionalFields` when there is no form context to hand them: those
+ *   entries are arbitrary components, not values, and one rendered against no
+ *   context is nothing at all.
+ * - `headerKeys` — the properties {@link EntityDisplayHeader} has already
+ *   rendered as the record's picture, subtitle, state and labels. Leaving one in
+ *   prints its value twice on one screen.
+ *
+ * The record's **title property is not among them**, deliberately. It names the
+ * page in the identity bar, but a heading and a labelled field are different
+ * things: `Order #` is a column with a name and a description that someone opens
+ * the record to read, and dropping it because its text also appears in the
+ * breadcrumb removes a value from the record on the grounds that it is legible
+ * somewhere else. See {@link HEADER_DISPLAY_ROLES}.
+ */
+export declare function readOnlyFieldKeys(collection: AdminCollection, hasFormContext: boolean, headerKeys?: ReadonlySet<string>): string[];
 /**
  * @group Components
  */
@@ -9,14 +33,44 @@ export interface EntityViewBindingProps<M extends Record<string, unknown>> {
     collection: AdminCollection<M>;
     path: string;
     className?: string;
+    /**
+     * Lay the record out as a page: a centred, scrolling column with the
+     * metadata rail beside it, exactly as the form does. Off for the inline
+     * uses — the delete dialog renders the record inside a box it already owns.
+     */
+    asPage?: boolean;
+    /** Padding preset, matching the form's. Only read when `asPage`. */
+    openEntityMode?: "side_panel" | "full_screen" | "split" | "dialog";
+    /**
+     * Needed only to render `additionalFields`, which are arbitrary components
+     * that take a form context. Without one those entries are left out rather
+     * than rendered against a fake context.
+     */
+    formContext?: FormContext<M>;
 }
 /**
  * The read-only rendering of a record's values.
  *
- * This used to prepend a synthetic `Id` row of its own. Between that row, the
- * collection's own id property, and the `path/id` chip above it, the same UUID
- * appeared three times — and in the ~340px split pane each copy wrapped over
- * four lines, so most of the first screen was one id repeated. The id is now a
- * copyable chip in the identity bar, once.
+ * This is the same layout as {@link EntityForm}: the sections, the grid spans,
+ * the labels and the rail all come from the one resolver, so the record does
+ * not rearrange itself when you press Edit. Only the controls differ — each
+ * field renders its {@link PropertyPreview} instead of an input.
+ *
+ * It used to be a flat two-column table of every value in the record: no
+ * grouping, no widths, a label column sized for short names and a value column
+ * that wrapped emails over two lines while the pane beside it stayed empty. A
+ * boolean and a markdown body were given the same room.
+ *
+ * The synthetic `Id` row it used to prepend is gone with the same reasoning the
+ * form applies: between that row, the collection's own id property and the
+ * `path/id` chip above them, one UUID appeared three times. The id is a
+ * copyable chip in the identity bar, and the rail's record block, once each.
+ *
+ * The labels are the form's labels, icon and all: a field is the same field
+ * whether or not you are editing it. What `mode: "read"` drops is the per-field
+ * *description*, which is input help rather than part of the label — and what it
+ * adds is room. A control is a bordered box that separates itself from the next
+ * one; a value is bare text, so the rows and sections are opened up rather than
+ * inheriting spacing sized for inputs.
  */
-export declare function EntityViewBinding<M extends Record<string, unknown>>({ entity, collection, path, className }: EntityViewBindingProps<M>): React.JSX.Element;
+export declare function EntityViewBinding<M extends Record<string, unknown>>({ entity, collection, className, asPage, openEntityMode, formContext }: EntityViewBindingProps<M>): React.JSX.Element;

package/dist/components/RebaseLayout.d.ts

@@ -7,7 +7,7 @@ export interface RebaseLayoutProps {
     appBar?: React.ReactNode;
     /** Custom Drawer to override the default. */
     drawer?: React.ReactNode;
-    /** Expand the drawer while the pointer is over it. Not a load-time default — that is `defaultDrawerOpen`. */
+    /** Expand the drawer while the pointer is over it. On by default; pass `false` to opt out. Not a load-time default — that is `defaultDrawerOpen`. */
     autoOpenDrawer?: boolean;
     /** Start with the drawer expanded instead of collapsed to icons. Ignored on small layouts. */
     defaultDrawerOpen?: boolean;

package/dist/components/RebaseShell.d.ts

@@ -4,7 +4,7 @@ export interface RebaseShellProps {
     /** Top bar. Only rendered if provided — pass `<AppBar/>` for the default one. */
     appBar?: React.ReactNode;
     drawer?: React.ReactNode;
-    /** Expand the drawer while the pointer is over it. Not a load-time default — that is `defaultDrawerOpen`. */
+    /** Expand the drawer while the pointer is over it. On by default; pass `false` to opt out. Not a load-time default — that is `defaultDrawerOpen`. */
     autoOpenDrawer?: boolean;
     /** Start with the drawer expanded instead of collapsed to icons. Ignored on small layouts. */
     defaultDrawerOpen?: boolean;

package/dist/components/RelationSelector.d.ts

@@ -15,7 +15,14 @@ export interface RelationSelectorProps {
     /** Callback returning selected EntityRelation(s) */
     onValueChange?: (updatedValue: EntityRelation | EntityRelation[] | undefined) => void;
     placeholder?: React.ReactNode;
-    size?: "small" | "medium";
+    /**
+     * `large` is the form's size and is on the shared 28/32/40/48 control
+     * scale, so a relation picker lines up with the text field beside it.
+     *
+     * `small` and `medium` predate that scale (42 and 56) and are kept as they
+     * are because the table cells and the filter row are built around them.
+     */
+    size?: "small" | "medium" | "large";
     useChips?: boolean;
     disabled?: boolean;
     error?: boolean;

package/dist/components/UserSelector.d.ts

@@ -6,7 +6,14 @@ export interface UserSelectorProps {
     value?: string | null;
     onValueChange?: (userId: string | null) => void;
     placeholder?: React.ReactNode;
-    size?: "small" | "medium";
+    /**
+     * `large` is the form's size and is on the shared 28/32/40/48 control
+     * scale, so a user picker lines up with the text field beside it.
+     *
+     * `small` and `medium` predate that scale (42 and 56) and are kept as they
+     * are because the table cells and the filter row are built around them.
+     */
+    size?: "small" | "medium" | "large";
     disabled?: boolean;
     invisible?: boolean;
     clearable?: boolean;

package/dist/components/app/Scaffold.d.ts

@@ -1,19 +1,25 @@
 import React from "react";
 export declare const DRAWER_WIDTH = 280;
+/**
+ * Namespaced by base path: two admins served from one origin are two different
+ * navigations, and a single key would have them overwrite each other's drawer.
+ */
+export declare function drawerOpenStorageKey(basePath: string | undefined): string;
 /**
  * @group Core
  */
 export interface ScaffoldProps {
     /**
-     * Open the drawer on hover
+     * Expand the collapsed drawer while the pointer is over it. On by default —
+     * pass `false` to keep the rail a rail until the user clicks the toggle.
      */
     autoOpenDrawer?: boolean;
     /**
      * Start with the drawer expanded rather than collapsed to icons.
      *
      * Distinct from {@link autoOpenDrawer}, which is a hover behaviour: this one
-     * only seeds the initial state, so the user's own toggle still wins for the
-     * rest of the session.
+     * only seeds the very first visit. Once the user toggles the drawer, that
+     * choice is stored in `localStorage` and wins over this prop on every load.
      *
      * Ignored on small layouts, where an expanded drawer covers the content it is
      * meant to navigate.

package/dist/components/index.d.ts

@@ -1,5 +1,7 @@
 export type { EntityViewBindingProps } from "./EntityViewBinding";
 export { EntityViewBinding } from "./EntityViewBinding";
+export type { EntityDisplayHeaderProps } from "./EntityDisplayHeader";
+export { EntityDisplayHeader, HEADER_DISPLAY_ROLES } from "./EntityDisplayHeader";
 export * from "./DetailViewBinding";
 export type { SelectionProps } from "./ReferenceTable/SelectionTableBinding";
 export { SelectionTableBinding } from "./ReferenceTable/SelectionTableBinding";

package/dist/data_export/export/export.d.ts

@@ -17,6 +17,13 @@ export interface DownloadEntitiesExportParams<M extends Record<string, unknown>>
 export declare function downloadEntitiesExport<M extends Record<string, unknown>>({ data, additionalData, properties, propertiesOrder, name, flattenArrays, additionalHeaders, exportType, dateExportType }: DownloadEntitiesExportParams<M>): void;
 export declare function getEntityCSVExportableData(data: Entity<Record<string, unknown>>[], additionalData: Record<string, unknown>[] | undefined, properties: Properties, headers: Header[], dateExportType: "timestamp" | "string"): unknown[][];
 export declare function getEntityJsonExportableData(data: Entity<Record<string, unknown>>[], additionalData: Record<string, unknown>[] | undefined, properties: Properties, dateExportType: "timestamp" | "string"): Record<string, unknown>[];
+/**
+ * Neutralise a cell that a spreadsheet would otherwise evaluate, by prefixing a
+ * single quote — the standard OWASP mitigation. The apostrophe is consumed by
+ * the spreadsheet as "treat the rest as text", so the value reads back intact.
+ */
+export declare function escapeCsvFormula(value: string): string;
+export declare function entryToCSVRow(entry: unknown[]): string;
 export declare function downloadBlob(content: BlobPart[], filename: string, contentType: string): void;
 export declare function downloadDataAsCsv(data: object[], name: string): void;
 export {};

package/dist/data_export/export/fetch_export_data.d.ts

@@ -0,0 +1,48 @@
+import { Entity, FindParams, FindResponse } from "@rebasepro/types";
+/**
+ * Rows asked for per request.
+ *
+ * Kept at or below the server's `MAX_LIST_LIMIT`, which is now the largest page
+ * a read will serve *and refuses* anything larger — it used to clamp silently,
+ * and asking for 100 000 while receiving 1 000 looked exactly like a collection
+ * with 1 000 rows in it. The walk still never trusts the page size it asked for:
+ * it advances by the rows it was actually handed.
+ */
+export declare const EXPORT_PAGE_SIZE = 500;
+/**
+ * Most rows one browser-side export will materialise.
+ *
+ * Everything here is built in memory and handed to a Blob, so there is a
+ * ceiling whether or not it is named. Naming it means going over it **throws**
+ * instead of writing a short file that reads like the whole collection.
+ */
+export declare const MAX_EXPORT_ROWS = 100000;
+export interface FetchAllForExportParams<M extends Record<string, unknown>> {
+    /** The collection accessor to read through — `dataClient.collection(path)`. */
+    accessor: {
+        find(params?: FindParams<M>): Promise<FindResponse<M>>;
+    };
+    /** Query to export. The window (`limit` / `offset` / `page`) is owned by the walk. */
+    params?: Omit<FindParams<M>, "limit" | "offset" | "page">;
+    pageSize?: number;
+    maxRows?: number;
+    /** Called after every page with the rows so far, and the total when the server reports one. */
+    onProgress?: (loaded: number, total: number | undefined) => void;
+}
+/**
+ * Read **every** row matching a query, one page at a time.
+ *
+ * `find({})` sends no `limit`, and an absent limit is resolved server-side to
+ * `DEFAULT_LIST_LIMIT` — 50 rows. The export used to hand those 50 rows back as
+ * `<collection>.csv` with nothing saying it was a sample, next to a dialog
+ * warning that the collection had 100 000 documents.
+ *
+ * Termination is driven by the server's `meta.hasMore` where it is reported and
+ * by an empty page otherwise — never by comparing a page's length against the
+ * requested limit, since a final page that happens to be exactly full is
+ * indistinguishable that way and a walk that stops there drops rows.
+ *
+ * @throws When more than `maxRows` rows match. A truncated export is worse than
+ * no export: it is indistinguishable from a complete one.
+ */
+export declare function fetchAllEntitiesForExport<M extends Record<string, unknown>>({ accessor, params, pageSize, maxRows, onProgress }: FetchAllForExportParams<M>): Promise<Entity<M>[]>;

package/dist/data_export/export/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./export";
+export * from "./fetch_export_data";
 export * from "./BasicExportAction";
 export * from "./ExportCollectionAction";

package/dist/data_import/utils/csv.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Split CSV text into rows of raw cells, RFC 4180 style.
+ *
+ * Quoted fields may contain the delimiter, newlines and doubled quotes; this is
+ * the exact inverse of what the export's `entryToCSVRow` writes, so a file this
+ * admin produced reads back into the cells it was built from.
+ */
+export declare function parseCsvRows(text: string, delimiter?: string): string[][];
+/**
+ * Pick the delimiter that splits the header row into the most cells. A
+ * single-column file matches nothing and stays on the comma.
+ */
+export declare function detectCsvDelimiter(text: string): string;
+export interface ParsedCsv {
+    headers: string[];
+    data: Record<string, string>[];
+}
+/**
+ * Parse CSV text into one object per row, keyed by the header row.
+ *
+ * The picker accepts `.csv` and the dialog promises "Upload a CSV, Excel or JSON
+ * file", but every non-JSON file used to be handed to ExcelJS'
+ * `workbook.xlsx.load`, which is a zip reader — so every CSV failed with
+ * "Can't find end of central directory : is this a zip file ?". The export
+ * writes CSV by default, so the round trip could not close.
+ *
+ * A blank header keeps its column rather than collapsing it, so the cells to its
+ * right stay under their own names.
+ */
+export declare function parseCsvToObjects(text: string): ParsedCsv;

package/dist/data_import/utils/index.d.ts

@@ -1,3 +1,5 @@
 export * from "./file_to_json";
+export * from "./csv";
+export * from "./save_entities";
 export * from "./data";
 export * from "./get_import_inference_type";

package/dist/data_import/utils/save_entities.d.ts

@@ -0,0 +1,38 @@
+import { Entity, RebaseData } from "@rebasepro/types";
+/** Rows written per request, and per transaction where the data source has one. */
+export declare const IMPORT_BATCH_SIZE = 25;
+/**
+ * An import failure that says where it stopped.
+ *
+ * "Error saving data / null value in column "sku" violates not-null constraint"
+ * on a ten-thousand-row import named no row, and the Retry button restarted at
+ * zero — where the rows already written now conflicted, so it could never
+ * succeed. Both halves of that are what this carries.
+ */
+export interface ImportSaveError extends Error {
+    /** Rows written and confirmed before the failure. Where a retry resumes. */
+    committed: number;
+    /** Index of the first row that was not written, 0-based. */
+    failedFrom: number;
+    /** Index after the last row of the batch that was not written. */
+    failedTo: number;
+}
+/**
+ * Write imported entities in batches, reporting what was committed.
+ *
+ * Resumable on purpose: a failure at row 4 000 leaves rows 1–3 999 in the table
+ * whatever this does, so the only useful thing to report is where to carry on
+ * from. `offset` is that point — the Retry button passes back the `committed`
+ * count of the error it is retrying, instead of starting from zero and
+ * conflicting on every row that already exists.
+ *
+ * @throws {ImportSaveError} naming the rows that were not written.
+ */
+export declare function saveImportedEntities(dataClient: RebaseData, path: string, data: Partial<Entity<any>>[], { offset, batchSize, onBatchCommitted, bulkUnsupported }?: {
+    offset?: number;
+    batchSize?: number;
+    onBatchCommitted?: (rowsWritten: number) => void;
+    bulkUnsupported?: {
+        current: boolean;
+    };
+}): Promise<void>;

package/dist/data_import/utils/transforms.d.ts

@@ -1,6 +1,15 @@
 /**
  * Take an object with keys of type `address.street`, `address.city` and
  * convert it to an object with nested objects like `{ address: { street: ..., city: ... } }`
+ *
+ * Keys here are the **header row of an uploaded file**, so they are attacker
+ * data. `res["__proto__"] = …` is the prototype setter rather than an own
+ * property, so a column named `__proto__.polluted` walked out of the accumulator
+ * and wrote onto `Object.prototype` for the life of the tab — and
+ * `constructor.prototype.x` threw a `TypeError` that surfaced as an unreadable
+ * file. Such a column is refused, not sanitised, the way `setIn` settled it
+ * (`docs/bug-classes.md` class 22).
+ *
  * @param flatObj
  */
 export declare function unflattenObject(flatObj: {