@standardbeagle/edit-db 0.4.494 → 0.4.583

package/dist/hooks/useColumnNav.d.ts

@@ -1,7 +1,7 @@
 import { ReactNode } from 'react';
-import { ColumnPanel } from '../data-panel';
+import { DrillFrame } from '../lib/drill-stack';
 interface ColumnNavEntry {
-    panel: ColumnPanel;
+    panel: DrillFrame;
     element: HTMLElement | null;
 }
 interface ColumnNavState {
@@ -13,7 +13,7 @@ interface ColumnNavState {
 }
 interface ColumnNavRegistration {
     mainTable: string | null;
-    columns: ColumnPanel[];
+    columns: DrillFrame[];
     columnRefs: Map<number, HTMLElement | null>;
     onClose: (index: number) => void;
 }

package/dist/hooks/useColumnSizingPersistence.d.ts

@@ -0,0 +1,19 @@
+import { ColumnSizingState } from '@tanstack/react-table';
+export declare const COL_MIN_WIDTH = 60;
+export declare const COL_MAX_AUTO_WIDTH = 450;
+export declare const COL_DEFAULT_WIDTH = 150;
+export interface UseColumnSizingPersistenceResult {
+    columnSizing: ColumnSizingState;
+    setColumnSizing: React.Dispatch<React.SetStateAction<ColumnSizingState>>;
+}
+/**
+ * Owns per-table column sizing, persisted to localStorage.
+ *
+ * Writes are debounced so a live ('onChange') resize drag doesn't write on every
+ * mousemove. `skipPersistRef` suppresses the first run after mount/table-switch,
+ * which would only write back the sizing just loaded from storage.
+ * `pendingSizingRef` carries the latest unsaved state so a table switch or
+ * unmount flushes it instead of dropping a resize made less than the debounce
+ * window ago.
+ */
+export declare function useColumnSizingPersistence(tableName?: string): UseColumnSizingPersistenceResult;

package/dist/hooks/useColumnVisibilityPersistence.d.ts

@@ -0,0 +1,34 @@
+import { VisibilityState } from '@tanstack/react-table';
+/**
+ * Read a stored selection. Returns null — not `{}` — when there is nothing
+ * stored, because "no stored preference" (fall back to the host defaults) and
+ * "stored: everything visible" are different states.
+ */
+export declare function loadColumnVisibility(tableName: string): VisibilityState | null;
+export declare function saveColumnVisibility(tableName: string, visibility: VisibilityState): void;
+export declare function clearColumnVisibility(tableName: string): void;
+/**
+ * Turn a host's list of columns to show into table state: everything named is
+ * visible, everything else in `allColumnIds` is hidden. Columns the host names
+ * that this table doesn't have are ignored, so one config can cover a schema
+ * that varies between deployments.
+ */
+export declare function visibilityFromDefaults(allColumnIds: string[], defaultVisible?: string[]): VisibilityState;
+export interface UseColumnVisibilityPersistenceResult {
+    columnVisibility: VisibilityState;
+    setColumnVisibility: React.Dispatch<React.SetStateAction<VisibilityState>>;
+    /** Drop the stored selection and go back to the host defaults for this table. */
+    resetColumnVisibility: () => void;
+}
+/**
+ * Owns which columns a table shows, persisted per table to localStorage.
+ *
+ * A viewer picking columns is a durable preference, not a per-visit one: the
+ * selection survives reload and return visits. Host defaults apply until the
+ * viewer makes a choice, and `resetColumnVisibility` puts them back.
+ *
+ * Only a change through the returned setter is written. Merely opening a table
+ * must not store its defaults — that would freeze today's defaults into every
+ * viewer's storage and make a later change to them invisible.
+ */
+export declare function useColumnVisibilityPersistence(tableName: string | undefined, defaultVisibility: VisibilityState): UseColumnVisibilityPersistenceResult;

package/dist/hooks/useColumnVisibilityPersistence.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/useCompositeTableRef.d.ts

@@ -1,4 +1,4 @@
-import { Schema } from '../types/schema';
+import { SchemaContextValue } from '../types/schema';
 export interface CompositeTableRefValue {
     /** Route-encoded composite key (`v1::v2`) suitable as a Select value. */
     route: string;
@@ -34,4 +34,4 @@ export interface CompositeTableRefOptions {
  * and the currently-selected row is resolved via a single-row lookup when it lies
  * outside the fetched window so it stays selectable instead of showing blank.
  */
-export declare function useCompositeTableRef(schema: Schema, destTableName: string, destColumnNames: string[], options?: CompositeTableRefOptions): CompositeTableRef;
+export declare function useCompositeTableRef(schema: SchemaContextValue, destTableName: string, destColumnNames: string[], options?: CompositeTableRefOptions): CompositeTableRef;

package/dist/hooks/useDataTable.d.ts

@@ -1,6 +1,8 @@
-import { Table, Join } from '../types/schema';
+import { Table, Column, Join } from '../types/schema';
 import { ColumnDef, ColumnFiltersState, SortingState } from '@tanstack/react-table';
-import { ColumnPanel } from '../data-panel';
+import { DrillFrame } from '../lib/drill-stack';
+import { ExportRunner } from '../lib/export';
+import { GridGroupMemberRequest, GroupingRow, GroupingSort } from '../lib/grid-grouping';
 export { getFilterOperators } from '../lib/query-builder';
 export type { ColumnFilterValue } from '../lib/query-builder';
 interface RowData {
@@ -25,6 +27,17 @@ export declare function clampPageIndex(pageIndex: number, pageCount: number): nu
  */
 export declare function reconcileColumnFiltersFromUrl(prev: ColumnFiltersState, cfParam: string): ColumnFiltersState;
 export declare function getMultiJoinRows(row: RowData, join: Join): RowData[];
+/**
+ * Reads the joined parent object a single-link column renders.
+ *
+ * Keyed on the join's FIELD name, not its destination table: a table that
+ * references the same target through several foreign keys has one field per key
+ * (billing_address, shipping_address) and no field named for the table, so a
+ * lookup by table name finds nothing and the cell renders as null. Mirrors
+ * getMultiJoinRows, which has always had to do this for aliased child
+ * collections.
+ */
+export declare function getSingleJoinRow(row: RowData, join: Join): RowData | undefined;
 export declare function getMultiJoinTotal(row: RowData, join: Join): number;
 /**
  * Return type for the useDataTable hook.
@@ -47,8 +60,33 @@ interface UseDataTableResult {
     pageCount: number;
     /** Current page data rows */
     rows: RowData[];
+    /** Total matching rows for the active filter/sort (across all pages). */
+    totalRows: number;
+    /** Server aggregate rows for URL-selected grouping; never derived from the page. */
+    grouping: {
+        column: Column;
+        sumColumn: Column | null;
+        rows: GroupingRow[];
+        loading: boolean;
+        error: Error | null;
+        sort: GroupingSort;
+        onSortChange: (sort: GroupingSort) => void;
+        memberRequest: (value: unknown) => GridGroupMemberRequest;
+    } | null;
+    /**
+     * Export the FULL result set for the current filters + sort, paging through
+     * the same fetcher/query — not just the visible page. Null when there is no
+     * active query/table to export.
+     */
+    exportRows: ExportRunner;
     /** Whether data is currently loading (no rows to show yet) */
     loading: boolean;
+    /**
+     * A refresh is in flight while previous rows remain on screen as
+     * placeholder data (page turn, sort, filter change). Drives the grid's
+     * in-flight indicator; `loading` alone blanks the rows.
+     */
+    fetching: boolean;
     /** Error object if the query failed */
     error: Error | null;
     /** Update sorting state */
@@ -59,6 +97,9 @@ interface UseDataTableResult {
     onPageIndexChange: (pageIndex: number) => void;
     /** Update page size */
     onPageSizeChange: (pageSize: number) => void;
+    /** Rewrites only the URL-owned grouping parameter. */
+    onGroupingChange: (columnName: string | null) => void;
+    onGroupingSumChange: (columnName: string | null) => void;
 }
 /**
  * Hook for managing data table state including sorting, filtering, and pagination.
@@ -77,15 +118,15 @@ interface UseDataTableResult {
  *   pageCount,
  *   onSortingChange,
  *   onPageIndexChange,
- * } = useDataTable(table, recordId, parentTable);
+ * } = useDataTable(table, id, filterTable);
  * ```
  *
  * @param table - Table schema definition
- * @param id - Optional record ID for filtering to a specific row
+ * @param id - Optional row ID for filtering to a specific row
  * @param filterTable - Optional parent table name for relationship filtering
  * @param filterColumn - Optional column name for explicit FK filtering
  * @param onExpandContent - Callback when content expansion is requested
  * @param onOpenColumn - Callback when opening a side panel column
  * @returns Data table state and control functions
  */
-export declare function useDataTable(table: Table | null, id?: string, filterTable?: string, filterColumn?: string, onExpandContent?: (rowIndex: number, columnName: string) => void, onOpenColumn?: (panel: ColumnPanel) => void): UseDataTableResult;
+export declare function useDataTable(table: Table | null, id?: string, filterTable?: string, filterColumn?: string, onExpandContent?: (rowIndex: number, columnName: string) => void, onOpenColumn?: (panel: DrillFrame) => void): UseDataTableResult;

package/dist/hooks/useDebouncedCommit.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/useDeltaMutation.d.ts

@@ -0,0 +1,20 @@
+import { Table } from '../types/schema';
+/**
+ * The server's collection-diff save shape (`<t>_delta`): three optional lists
+ * that apply in inserted → updated → deleted order inside ONE transaction — a
+ * failure anywhere applies nothing — and ride the server's set-based bulk fast
+ * path at batch scale. Payloads must already be wire-ready (coerceDetail /
+ * delete key payloads); this hook only carries the document.
+ */
+export interface DeltaDocument {
+    inserted?: Record<string, unknown>[];
+    updated?: Record<string, unknown>[];
+    deleted?: Record<string, unknown>[];
+}
+export interface UseDeltaMutationResult {
+    saveDelta: (delta: DeltaDocument) => Promise<unknown>;
+    isPending: boolean;
+    error: Error | null;
+}
+export declare function deltaChangeCount(delta: DeltaDocument): number;
+export declare function useDeltaMutation(table: Table): UseDeltaMutationResult;

package/dist/hooks/useEditorConfig.d.ts

@@ -1,4 +1,5 @@
 import { ReactNode } from 'react';
+import { TableAction } from '../lib/table-action';
 /**
  * Optional, opt-in editor features. Kept tiny and separate from the data/schema
  * contexts so feature flags don't force those providers to re-render and so
@@ -11,6 +12,32 @@ export interface EditorConfig {
      * may not want on every connect. Hosts opt in via `<Editor showStats />`.
      */
     showStats: boolean;
+    /**
+     * Restrict the editor to these tables, by GraphQL name or db name. Undefined
+     * exposes everything the server returns — which on a managed host also means
+     * its own bookkeeping tables (Azure SQL surfaces firewall rules this way).
+     * Filtering here rather than in the sidebar keeps excluded tables out of
+     * routing and FK lookups too, not just out of the list.
+     */
+    tables?: string[];
+    /**
+     * Columns visible by default per table, keyed by table name; every other
+     * column starts hidden. Only the starting point — a viewer's own choices are
+     * stored per table and win from then on.
+     */
+    defaultColumns?: Record<string, string[]>;
+    /**
+     * Columns to move to the right end of every grid, in this order. For audit
+     * stamps (created/modified) that are read far less often than the data they
+     * annotate but sit in the middle of the natural column order.
+     */
+    trailingColumns?: string[];
+    /**
+     * Host-contributed actions on each table in the navigation list, rendered in
+     * the table's kebab menu AFTER the built-in Download actions. The host owns
+     * what an action does; edit-db just invokes it with the schema table.
+     */
+    tableActions?: TableAction[];
 }
 export declare function EditorConfigProvider({ config, children }: {
     config: EditorConfig;

package/dist/hooks/useFitMode.d.ts

@@ -0,0 +1,23 @@
+import { RefObject } from 'react';
+/** Sentinel page-size value meaning "fit as many rows as the viewport allows". */
+export declare const FIT_SENTINEL = -1;
+/**
+ * Rows that fit a container of `containerHeight` px: header subtracted, floor
+ * to whole rows, never below 5. The single source of the fit formula — the
+ * hook and its tests both use this.
+ */
+export declare function computeFitRowCount(containerHeight: number): number;
+export interface UseFitModeResult {
+    fitMode: boolean;
+    setFitMode: React.Dispatch<React.SetStateAction<boolean>>;
+    /** Rows that fit the current scroll container height. */
+    computeFitSize: () => number;
+}
+/**
+ * "Fit" page-sizing: derive the page size from the scroll container's height so
+ * the grid shows exactly as many rows as fit, re-fitting when the container
+ * resizes. The resize path is debounced so dragging a splitter/window doesn't
+ * fire a burst of queries (each distinct page size is a new query key) — only
+ * the settled size runs.
+ */
+export declare function useFitMode(scrollRef: RefObject<HTMLDivElement>, onPageSizeChange: (pageSize: number) => void): UseFitModeResult;

package/dist/hooks/useFitMode.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/usePanelSize.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Persistent, drag-resizable panel dimension.
+ *
+ * Returns the current size plus a pointerdown handler to put on a separator
+ * element. Dragging follows the pointer along the given axis; the size is
+ * clamped to [min, max] and persisted per `key` so a layout survives reload.
+ * `invert` flips the drag direction for separators that sit BEFORE the panel
+ * they size (e.g. a bottom panel resized by the handle above it: dragging the
+ * handle UP must grow the panel).
+ *
+ * The separator also supports keyboard resizing (arrow keys, 16px steps) via
+ * the returned onKeyDown — a drag-only separator is unreachable to keyboard
+ * users. Callers should render the handle with role="separator" and an
+ * aria-orientation matching the axis.
+ */
+export interface PanelSizeOptions {
+    key: string;
+    initial: number;
+    min: number;
+    max: number;
+    axis: 'x' | 'y';
+    invert?: boolean;
+}
+export declare function usePanelSize({ key, initial, min, max, axis, invert }: PanelSizeOptions): {
+    size: number;
+    onPointerDown: (e: React.PointerEvent<HTMLElement>) => void;
+    onKeyDown: (e: React.KeyboardEvent<HTMLElement>) => void;
+};

package/dist/hooks/usePanelSize.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/usePath.d.ts

@@ -63,5 +63,6 @@ export declare function Route({ path, element }: {
     path: string;
     element: ReactElement;
 }): ReactElement;
+export declare const combinePaths: (current: string, newPath: string) => string;
 export declare const matchPath: (route: string, path: string) => PathMatch;
 export {};

package/dist/hooks/useRowHoverActions.d.ts

@@ -0,0 +1,26 @@
+import { PointerEvent, MutableRefObject } from 'react';
+export interface HoveredRow {
+    rowId: string;
+    el: HTMLElement;
+}
+export interface UseRowHoverActionsResult {
+    hoveredRow: HoveredRow | null;
+    hoverRow: (rowId: string, el: HTMLElement) => void;
+    scheduleDismiss: () => void;
+    cancelDismiss: () => void;
+    /** Suppresses the click that follows a long-press so it doesn't also select the row. */
+    suppressClick: MutableRefObject<boolean>;
+    startPress: (rowId: string, el: HTMLElement, e: PointerEvent) => void;
+    onPressMove: () => void;
+    cancelPress: () => void;
+}
+/**
+ * Row hover/long-press action tracking for the data grid.
+ *
+ * Mouse: hovering a row opens its action toolbar (with a small dismiss delay so
+ * moving onto the toolbar doesn't close it). Touch: a long-press (hold) opens
+ * the same actions since hover doesn't exist on touch; a finger move (scroll)
+ * cancels the press, and a fired press suppresses the click that follows the
+ * lift so it doesn't also select.
+ */
+export declare function useRowHoverActions(): UseRowHoverActionsResult;

package/dist/hooks/useSchema.d.ts

@@ -1,5 +1,5 @@
 import { ReactNode } from 'react';
-import { Schema } from '../types/schema';
+import { SchemaContextValue, Table } from '../types/schema';
 /**
  * Provider component for database schema context.
  * Fetches schema via GraphQL and makes it available to child components.
@@ -28,4 +28,10 @@ export declare const SchemaProvider: ({ children }: {
  *
  * @returns Schema context value with tables and metadata
  */
-export declare function useSchema(): Schema;
+export declare function useSchema(): SchemaContextValue;
+/**
+ * Keep only the tables a host allow-listed, matching on either name and ignoring
+ * case so a host can list them the way they read in its own docs. An empty or
+ * absent list means no restriction.
+ */
+export declare function filterAllowedTables(tables: Table[], allowed?: string[]): Table[];

package/dist/hooks/useSchemaFilter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/useTableExport.d.ts

@@ -0,0 +1,13 @@
+import { Table } from '../types/schema';
+import { ExportFormat, ExportResult } from '../lib/export';
+/**
+ * Downloads a whole table WITHOUT opening it: the navigation-level counterpart
+ * of the grid toolbar's export. Reuses the grid's export projection
+ * (`buildQuery` with `fields: 'export'` — long text included, non-PK binary
+ * excluded, no join blocks), the shared page-draining serializer, and the same
+ * browser download path, so the two exports cannot drift. Unfiltered by design:
+ * a filtered export belongs to the grid, where the filters live.
+ * <see cref="DEFAULT_ROW_CAP"/> bounds the drain; the result reports
+ * `truncated` so the caller can warn instead of silently shipping a partial file.
+ */
+export declare function useTableExport(): (table: Table, format: ExportFormat) => Promise<ExportResult>;

package/dist/hooks/useTableMutation.d.ts

@@ -1,7 +1,5 @@
 import { Table, Column } from '../types/schema';
-interface ColumnJoin {
-    column: Column;
-}
+import { ColumnJoin } from '../lib/mutation-payload';
 export interface UseTableMutationResult {
     update: (detail: Record<string, unknown>) => Promise<unknown>;
     insert: (detail: Record<string, unknown>) => Promise<unknown>;
@@ -9,4 +7,3 @@ export interface UseTableMutationResult {
     error: Error | null;
 }
 export declare function useTableMutation(table: Table, editColumns: ColumnJoin[], idColumns: Column[], editId?: string): UseTableMutationResult;
-export {};

package/dist/hooks/useTableRef.d.ts

@@ -1,4 +1,4 @@
-import { Schema } from '../types/schema';
+import { SchemaContextValue } from '../types/schema';
 export interface TableRefValue {
     key: string;
     label: string;
@@ -17,7 +17,7 @@ export interface TableRef {
  * list is narrowed server-side, so parents beyond the fetch window stay
  * findable; otherwise one window is fetched and the caller filters it.
  */
-export declare function useTableRef(schema: Schema, tableName: string, columnName: string, search?: string, enabled?: boolean): TableRef;
+export declare function useTableRef(schema: SchemaContextValue, tableName: string, columnName: string, search?: string, enabled?: boolean): TableRef;
 export interface TableRefLookup {
     loading: boolean;
     error: unknown;
@@ -29,4 +29,4 @@ export interface TableRefLookup {
  * Select can still display the stored value instead of a misleading
  * placeholder. Pass `key` as null/'' to disable the lookup.
  */
-export declare function useTableRefValue(schema: Schema, tableName: string, columnName: string, key: unknown): TableRefLookup;
+export declare function useTableRefValue(schema: SchemaContextValue, tableName: string, columnName: string, key: unknown): TableRefLookup;

package/dist/hooks/useTableStats.d.ts

@@ -57,27 +57,3 @@ export declare function buildRowCountQuery(tableNames: string[]): string | null;
  * @returns Table statistics map and loading state
  */
 export declare function useTableStats(enabled?: boolean): UseTableStatsResult;
-/**
- * Formats a number into an abbreviated string representation.
- *
- * @example
- * ```typescript
- * abbreviateNumber(12)      // "12"
- * abbreviateNumber(1200)    // "1.2k"
- * abbreviateNumber(45000)   // "45k"
- * abbreviateNumber(1200000) // "1.2M"
- * ```
- *
- * @param num - Number to abbreviate
- * @returns Abbreviated string representation
- */
-export declare function abbreviateNumber(num: number | null): string;
-/**
- * Calculates a visual bar width (1-10) based on row count.
- * Used for sparkline visualization.
- *
- * @param count - Row count
- * @param maxCount - Maximum row count across all tables for scaling
- * @returns Width value from 1-10
- */
-export declare function calculateBarWidth(count: number | null, maxCount: number): number;

package/dist/index.d.ts

@@ -2,6 +2,18 @@ import { Editor } from './editor';
 export default Editor;
 export { Editor };
 export type { GraphQLFetcher } from './common/fetcher';
-export { HttpGraphQLFetcher } from './common/fetcher';
+export { HttpGraphQLFetcher, GraphQLRequestError } from './common/fetcher';
 export { useTableMutation } from './hooks/useTableMutation';
 export type { UseTableMutationResult } from './hooks/useTableMutation';
+export { createSavedObjectsClient, parseSavedObject, SavedObjectConflictError, SAVED_OBJECTS_PATH, } from './common/saved-objects';
+export type { SavedObject, SavedObjectType, SavedObjectsClient, } from './common/saved-objects';
+export { FormRunner, FormRunnerView, resolveDefinitionTable } from './components/form-runner';
+export { FormRunnerHost } from './components/form-runner-host';
+export { parseFormDefinition, visibleFields } from './lib/form-definition';
+export type { FormDefinition, FormField, FormControlType } from './lib/form-definition';
+export type { FieldWidgetHint } from './lib/form-widget';
+export { buildCsv, buildJson, formatCsvCell, exportAllRows, downloadTextFile, filenameFor, mimeFor, UTF8_BOM, DEFAULT_ROW_CAP, } from './lib/export';
+export type { ExportFormat, JsonMode, CsvOptions, JsonOptions, ExportPage, ExportResult, ExportRunner, RunExportOptions, } from './lib/export';
+export { serializeColumnFilters, deserializeColumnFilters } from './lib/query-builder';
+export type { TableAction } from './lib/table-action';
+export type { Table, Column } from './types/schema';

package/dist/lib/column-order.d.ts

@@ -0,0 +1,17 @@
+import { ColumnDef } from '@tanstack/react-table';
+export interface ColumnOrderConfig {
+    /** Columns to place first, in this order. */
+    leading?: string[];
+    /** Columns to place last, in this order. */
+    trailing?: string[];
+}
+/**
+ * Reorder columns around a host's preferences: named leading columns first in the
+ * order named, named trailing columns last in the order named, everything else
+ * keeping its schema order in between. Names the table doesn't have are skipped,
+ * so one host config can cover tables that don't all carry the same columns.
+ *
+ * Order is independent of visibility: a column the viewer switches back on lands
+ * in its configured place rather than at the end.
+ */
+export declare function orderColumns<TData>(columns: ColumnDef<TData, unknown>[], { leading, trailing }: ColumnOrderConfig): ColumnDef<TData, unknown>[];

package/dist/lib/column-order.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/content-detect.d.ts

@@ -11,6 +11,18 @@ export declare function isJsonColumn(col: {
 }): boolean;
 /** Check if a dbType is a long text type (text, ntext, varchar(max), xml) */
 export declare function isLongTextDbType(dbType: string): boolean;
+/**
+ * Column-level "large value" check for fetch-on-demand decisions (grid SELECT
+ * exclusion, sortability, content-viewer cells). Prefers the server's
+ * dialect-decided `dbColumnSchema.isLargeValue` flag; the dbType-name fallback
+ * exists only for servers that predate the flag. The name heuristic is WRONG on
+ * PostgreSQL and SQLite — `text` is their ordinary string type, not a LOB — which
+ * is exactly why the server flag is authoritative when present.
+ */
+export declare function isLargeValueColumn(col: {
+    dbType: string;
+    isLargeValue?: boolean;
+}): boolean;
 /** Detect content kind from a string value and optional dbType hint */
 export declare function detectContentKind(value: string, dbType?: string): ContentKind;
 /** Max characters to show in a table cell before truncating */
@@ -19,3 +31,25 @@ export declare const CELL_TRUNCATE = 80;
 export declare function truncateForCell(value: string): string;
 /** Format binary data (base64 string) for display */
 export declare function formatBinaryPreview(value: string): string;
+/** What a binary (base64) value actually IS, sniffed from its magic bytes. */
+export type SniffedBinary = {
+    kind: 'image';
+    mime: string;
+    extension: string;
+} | {
+    kind: 'pdf';
+    mime: 'application/pdf';
+    extension: '.pdf';
+} | {
+    kind: 'unknown';
+    mime: 'application/octet-stream';
+    extension: '.bin';
+};
+/**
+ * Sniffs an image/document type from the FIRST BYTES of a base64 value — never
+ * from a column name or a user-supplied mime string, so a mislabeled blob can
+ * only ever downgrade to the generic binary rendering, not upgrade to <img>.
+ */
+export declare function sniffBinaryContent(base64: string): SniffedBinary;
+/** A data: URL for an inline binary preview (only call for sniffed images). */
+export declare function binaryDataUrl(base64: string, mime: string): string;

package/dist/lib/content-detect.sniff.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/drill-stack.d.ts

@@ -1,8 +1,25 @@
-import { ColumnPanel } from '../data-panel';
+/**
+ * @module lib/drill-stack
+ *
+ * Pure-logic helpers for the stackable parent/child drill-down used by the
+ * edit-db data panel. Each entry in the stack describes a side column: a
+ * target table plus an optional filter (FK column + parent row id) that
+ * scopes the child rows to those related to a row in the previous level.
+ *
+ * Kept dependency-free so it can be unit-tested without React or the DOM.
+ */
 /**
  * A single frame in the drill navigation chain, visible as one side column.
+ * `filterTable` + `filterId` + `filterColumn` describe the FK scoping applied
+ * to `tableName`'s rows — they're optional so the same shape can also
+ * represent a simple "open table X" panel.
  */
-export type DrillFrame = ColumnPanel;
+export interface DrillFrame {
+    tableName: string;
+    filterTable?: string;
+    filterId?: string;
+    filterColumn?: string;
+}
 /**
  * Is `frame` the same drill target as `other` (same table + same filter)?
  *