@k2b/ui 0.34.0 → 0.36.0

package/dist/types/actions/Dropdown.d.ts

@@ -102,6 +102,8 @@ export type DropdownProps = {
      * Defaults to `menu`. A controlled menu (`open`) always stays a menu.
      */
     phone?: "menu" | "sheet";
+    /** Content above the phone sheet's menu. `close` dismisses it with normal history and focus restoration. */
+    sheetTop?: (close: () => void) => JSX.Element;
     /**
      * Renders the entries only once the menu first opens, for a menu repeated on every row of a long list: the page
      * then carries each row's trigger, not each row's entries. Fixed for the menu's lifetime.

package/dist/types/content/MapViewFrame.d.ts

@@ -27,5 +27,5 @@ export declare function MapFootRow(props: {
     scale?: MapScale;
     children?: JSX.Element;
 }): JSX.Element;
-/** Geometry without a browser, a canvas, or a network dependency; suitable for server rendering and PDF output. */
+/** Geometry fallback without a browser, canvas, or network. Does not contain a geographic basemap image. */
 export declare function MapViewFrame(props: MapViewFrameProps): JSX.Element;

package/dist/types/content/MatchText.d.ts

@@ -0,0 +1,21 @@
+import { type JSX } from "solid-js";
+/** A half-open `[start, end)` range of Unicode code points. */
+export type MatchRange = readonly [number, number];
+export type MatchTextProps = {
+    text: string;
+    /** Code point ranges to mark, as search engines such as Filegate return them; not UTF-16 offsets. */
+    ranges?: readonly MatchRange[];
+};
+/** Splits text into marked and plain parts. Ranges are clipped to the text, sorted, and merged when they touch. */
+export declare function matchParts(text: string, ranges?: readonly MatchRange[]): {
+    text: string;
+    hit: boolean;
+}[];
+/**
+ * Text with its search matches marked, for result names and paths. It renders inline text and `mark` elements
+ * only, so the host's element keeps truncating and styling the whole text. The marks change only the fill, never
+ * the text's width, and screen readers read the text unchanged.
+ * @example <span class="name"><MatchText text="Rechnung Oktober.pdf" ranges={[[0, 8]]} /></span>
+ */
+export declare function MatchText(props: MatchTextProps): JSX.Element;
+export default MatchText;

package/dist/types/content/index.d.ts

@@ -40,11 +40,13 @@ export { MapAttribution } from "./MapAttribution";
 export { MapView } from "./MapView";
 export { MapViewFrame } from "./MapViewFrame";
 export { default as MarkdownView, type MarkdownRenderOptions, type MarkdownViewProps, renderSafeMarkdown } from "./MarkdownView";
+export { type MatchRange, MatchText, type MatchTextProps, matchParts } from "./MatchText";
 export type { MessageEventGroupProps, MessageEventRowProps, MessageGroupEntry, MessageRowAction, MessageRowAttachment, MessageRowAuthor, MessageRowFile, MessageRowMedia, MessageRowOrigin, MessageRowProgress, MessageRowProps, MessageRowQuote, MessageRowReaction, MessageRowStatus, MessageRowThread, MessageSystemRowProps, } from "./MessageRow";
 export { MessageEventGroup, MessageEventRow, MessageRow, MessageSystemRow, startsMessageGroup } from "./MessageRow";
 export { type MapPaletteColors, type MapTheme, mapPalette } from "./map-palette";
 export { type MapStyleOptions, mapAttribution, mapStyle } from "./map-style";
-export type { MapViewArea, MapViewFit, MapViewFrameProps, MapViewLine, MapViewLineTone, MapViewMarker, MapViewOwnLocation, MapViewPoint, MapViewProps, MapViewStyle, MapViewStyleSource, MapViewTone, } from "./map-view-types";
+export { MAP_SNAPSHOT_MAX_PIXELS, MapSnapshotError, type MapSnapshotErrorCode } from "./map-view-snapshot";
+export type { MapViewArea, MapViewFit, MapViewFrameProps, MapViewHandle, MapViewLine, MapViewLineTone, MapViewMarker, MapViewOwnLocation, MapViewPoint, MapViewProps, MapViewSnapshot, MapViewSnapshotOptions, MapViewStyle, MapViewStyleSource, MapViewTone, } from "./map-view-types";
 export { MARKDOWN_CALLOUT_CLASSES, MARKDOWN_CALLOUT_ICON_ATTRIBUTES, type MarkdownInfoBlock, type MarkdownInfoBlockRenderInput, type MarkdownInfoBlockType, markdownInfoBlocks, renderMarkdownInfoBlock, scanMarkdownInfoBlock, } from "./markdown-info-blocks";
 export { type MarkdownLinkInput, type MarkdownReference, type MarkdownReferenceKind, type MarkdownReferenceType, markdownLinkReference, markdownReferenceIcon, markdownReferenceType, markdownReferenceTypeLabel, markStandaloneLinks, renderMarkdownLink, } from "./markdown-links";
 export { Pagination, type PaginationProps } from "./Pagination";

package/dist/types/content/map-view-glyphs.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Validate the glyphs MapLibre will decode before it can silently substitute local fonts.
+ * Uses the same PBF reader and 3px bitmap border as MapLibre 6, without allocating glyph images.
+ */
+export declare function validateMapGlyphs(data: ArrayBuffer): void;

package/dist/types/content/map-view-live.d.ts

@@ -1,2 +1,2 @@
 import { Map, type MapOptions } from "maplibre-gl";
-export declare function createMap(options: MapOptions, onResourceError: () => void): Map;
+export declare function createMap(options: MapOptions, resourceFailed: () => void): Map;

package/dist/types/content/map-view-snapshot.d.ts

@@ -0,0 +1,13 @@
+import type { MapViewSnapshot } from "./map-view-types";
+/** Same decoded RGBA budget as Cloud's isolated print-image worker (64 MiB). */
+export declare const MAP_SNAPSHOT_MAX_PIXELS: number;
+export type MapSnapshotErrorCode = "not_ready" | "resource_failed" | "changed" | "disposed" | "busy" | "too_large" | "timed_out" | "aborted" | "capture_failed";
+export declare class MapSnapshotError extends Error {
+    readonly code: MapSnapshotErrorCode;
+    constructor(code: MapSnapshotErrorCode);
+}
+export declare function snapshotAborted(signal: AbortSignal): MapSnapshotError;
+/** Also observes late rejection; a cancelled image/font/encoding operation never becomes unhandled. */
+export declare function snapshotWait<T>(promise: Promise<T>, signal: AbortSignal): Promise<T>;
+/** Called synchronously in MapLibre's render event, before WebGL clears its drawing buffer. */
+export declare function rasterizeMapView(root: HTMLElement, base: HTMLCanvasElement, signal: AbortSignal): Promise<MapViewSnapshot>;

package/dist/types/content/map-view-types.d.ts

@@ -50,8 +50,23 @@ export type MapViewFrameProps = {
     attribution?: JSX.Element;
     class?: string;
 };
+export type MapViewSnapshot = {
+    data: Blob;
+    width: number;
+    height: number;
+};
+export type MapViewSnapshotOptions = {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+};
+export type MapViewHandle = {
+    /** Capture the current complete view; never loads, pans, refits, or retries provider resources. */
+    snapshot: (options?: MapViewSnapshotOptions) => Promise<MapViewSnapshot>;
+};
 export type MapViewProps = Omit<MapViewFrameProps, "attribution"> & {
     style: MapViewStyleSource;
+    /** Browser-only handle; remains safely callable after disposal (rejects disposed). */
+    ref?: (handle: MapViewHandle) => void;
     attribution: JSX.Element;
     onSelect?: (id: string) => void;
     infoTile?: (marker: MapViewMarker) => JSX.Element;

package/dist/types/inputs/Combobox.d.ts

@@ -14,6 +14,18 @@ export type ComboboxProps = FieldProps & {
     fetchData: (query: string, signal: AbortSignal) => Promise<ComboboxOption[]>;
     onSelect: (option: ComboboxOption) => void;
     debounceMs?: number;
+    /** The query is the field's own value: picking or closing keeps the typed text, and Enter without an active option only closes the list. */
+    freeText?: boolean;
+    /** Below this many characters nothing loads and the list stays closed. */
+    minQueryLength?: number;
+    /** This result (by position) is active as soon as results arrive, so Enter takes it. */
+    autoHighlight?: number;
+    /** Replaces the results with a host-owned notice, such as an exhausted quota; nothing loads while it is set. */
+    status?: JSX.Element;
+    /** Shown instead of the default text when a search finds nothing. */
+    empty?: JSX.Element;
+    /** One line under the results, such as their source. */
+    footer?: JSX.Element;
 };
 export declare function Combobox(props: ComboboxProps): JSX.Element;
 export default Combobox;

package/dist/types/inputs/TextInput.d.ts

@@ -1,7 +1,7 @@
 import { type JSX } from "solid-js";
 import type { Completion } from "./completion";
 import type { ValueFieldProps } from "./field-contract";
-export type TextInputProps = Omit<JSX.InputHTMLAttributes<HTMLInputElement>, "onChange" | "onInput" | "prefix" | "suffix" | "type" | "value" | keyof ValueFieldProps<string>> & ValueFieldProps<string> & {
+export type TextInputProps = Omit<JSX.InputHTMLAttributes<HTMLInputElement>, "onChange" | "onInput" | "onKeyDown" | "prefix" | "suffix" | "type" | "value" | keyof ValueFieldProps<string>> & ValueFieldProps<string> & {
     minLength?: number;
     maxLength?: number;
     type?: "text" | "search" | "email" | "url" | "tel";
@@ -21,6 +21,7 @@ export type TextInputProps = Omit<JSX.InputHTMLAttributes<HTMLInputElement>, "on
     password?: boolean;
     markdown?: boolean;
     onSubmit?: () => void;
+    onKeyDown?: JSX.EventHandlerUnion<HTMLInputElement | HTMLTextAreaElement, KeyboardEvent>;
     lines?: number;
     abbreviations?: Record<string, string>;
     completions?: readonly Completion[];

package/dist/types/layout/AppWorkspace.d.ts

@@ -335,7 +335,10 @@ export type AppWorkspaceSidebarItemStatusProps = {
     unread?: number | boolean;
     /** Marks unread items that mention the person with "@". */
     mention?: boolean;
-    /** Shows a muted bell. */
+    /**
+     * Shows a muted bell, and the item reads as set aside: its label in the muted ink without unread weight, and a
+     * mention count without its fill.
+     */
     muted?: boolean;
     /**
      * Items that wait for the person, such as requests to approve, in the unread slot instead of `unread`. `label` is

package/dist/types/layout/ScrollArea.d.ts

@@ -6,6 +6,8 @@ export type ScrollAreaProps = Omit<JSX.HTMLAttributes<HTMLDivElement>, "children
     viewportSize?: "compact";
     orientation?: "vertical" | "horizontal";
     scrollPreserveKey?: string | false;
+    /** Keep 0.5 rem inside both side edges, like a workspace column; with a mouse the end one is a fixed scroll track. */
+    inset?: boolean;
     class?: string;
 };
 export declare function ScrollArea(props: ScrollAreaProps): JSX.Element;

package/dist/types/text-editor/TextEditor.d.ts

@@ -0,0 +1,69 @@
+import type { Extension } from "@codemirror/state";
+import { type JSX } from "solid-js";
+import { type DropdownPosition } from "../actions/Dropdown";
+import { type TextEditorController, type TextEditorMode, type TextEditorOptions } from "./engine";
+import { type InlineFormat } from "./format";
+import { type TableHost } from "./table";
+export type TextEditorProps = {
+    label: string;
+    initialValue?: string;
+    mode?: TextEditorMode;
+    onModeChange?: (mode: TextEditorMode) => void;
+    readOnly?: boolean;
+    loading?: boolean;
+    placeholder?: string;
+    extensions?: Extension;
+    /** Host-owned Markdown presentation; see `createTextEditor`. The host then also styles the editor surface. */
+    presentation?: TextEditorOptions["presentation"];
+    /** `false` when the host renders its own formatting toolbar and mode control; place `controls.TableMenu` in it. */
+    toolbar?: boolean;
+    /** Collaboration supplies history and server-owned structure here. */
+    host?: Pick<TableHost, "structure" | "renderCell" | "onCellSelection" | "tabMovesFocus"> & Partial<Pick<TableHost, "undo" | "redo" | "boundary">>;
+    maxLength: number;
+    maxPasteCells?: number;
+    onChange?: (text: string) => void;
+    onReady?: (editor: TextEditorController, controls: TextEditorControls) => void;
+    /** Return `true` when the host attached the images itself; otherwise the editor shows its attachment hint. */
+    onDroppedImages?: (count: number, files: File[]) => boolean | void;
+    /** Opens the host's attachment picker when clipboard images cannot be inserted. */
+    onAttachImages?: () => void;
+    onTableCheck?: (needsCheck: boolean) => void;
+    /** Host-owned sync status; its place is reserved across transitions. */
+    status?: JSX.Element;
+    class?: string;
+};
+export type TableSizePickerProps = {
+    maxRows: number;
+    maxColumns: number;
+    onPick: (size: {
+        rows: number;
+        columns: number;
+    }) => void;
+    /** Share this picker with slash commands or secondary menus. */
+    onReady?: (open: () => void) => void;
+    disabled?: boolean;
+    class?: string;
+    size?: "xs" | "sm";
+};
+/** Shared table-size control: pointer grid on desktop, large fields in a phone sheet. */
+export declare function TableSizePicker(props: TableSizePickerProps): JSX.Element;
+type TableMenuTrigger = {
+    text?: string;
+    class?: string;
+    size?: "xs" | "sm";
+    position?: DropdownPosition;
+};
+/** Shared table controls for a host-owned toolbar (`toolbar={false}`). */
+export type TextEditorControls = {
+    /** A table cell has focus in the formatted view. */
+    tableActive: () => boolean;
+    /** The shared cell menu behind a host-styled trigger; on phones it opens as a sheet. */
+    TableMenu: (props: TableMenuTrigger) => JSX.Element;
+    /** Formats the focused cell's selection; `false` when no cell has focus. */
+    formatCell: (format: InlineFormat) => boolean;
+    /** Shows a host message, such as a server's reason for a rejected table action, in the editor's notice. */
+    notify: (message: string) => void;
+};
+/** A Markdown text field with app-injected collaboration and a directly editable table view. */
+export declare function TextEditor(props: TextEditorProps): JSX.Element;
+export {};

package/dist/types/text-editor/clipboard-html.d.ts

@@ -0,0 +1,9 @@
+/** Parse only the HTML vocabulary that the Markdown converter consumes.
+ * Resource attributes and active elements never reach a clipboard consumer.
+ * The returned detached body is read as data and never mounted in the editor.
+ */
+export declare const parseClipboardHtml: (html: string) => HTMLElement;
+export declare const convertHtml: (html: string, code: boolean) => {
+    markdown: string;
+    droppedImages: number;
+} | null;

package/dist/types/text-editor/clipboard-loading.d.ts

@@ -0,0 +1,8 @@
+import { type EditorView, ViewPlugin } from "@codemirror/view";
+import type { TableHost } from "./table";
+/** Load the HTML sanitizer only when needed, before either paste consumer runs.
+ * A delayed paste never overwrites edits made while its parser was loading.
+ */
+export declare const clipboardLoading: (getHost: (view: EditorView) => TableHost | null, syncSelection?: (view: EditorView) => void) => ViewPlugin<{
+    destroy(): void;
+}, undefined>;

package/dist/types/text-editor/clipboard.d.ts

@@ -0,0 +1,20 @@
+export declare const htmlClipboardReady: () => boolean;
+export declare const loadHtmlClipboard: () => Promise<void>;
+export declare const parseClipboardHtml: (html: string) => HTMLElement;
+export declare const convertClipboardHtml: (html: string, code: boolean) => {
+    markdown: string;
+    droppedImages: number;
+} | null;
+/** All clipboard entry paths share one preflight, before insertion or conversion. */
+export declare function inspectClipboard(data: DataTransfer, limits: {
+    maxLength: number;
+    maxPasteCells: number;
+}): {
+    error: "textTooLarge" | "pasteTooLarge";
+} | {
+    text: string;
+    html: string;
+    images: number;
+    files: File[];
+    tsv: string[][] | null;
+};

package/dist/types/text-editor/engine.d.ts

@@ -0,0 +1,34 @@
+import { type Extension } from "@codemirror/state";
+import { EditorView } from "@codemirror/view";
+import { type TableHost } from "./table";
+export type TextEditorMode = "formatted" | "source" | "plain";
+export type TextEditorOptions = {
+    parent: HTMLElement;
+    /** Initial Markdown. Subsequent collaborative changes arrive through extensions. */
+    doc?: string;
+    mode?: TextEditorMode;
+    readOnly?: boolean;
+    placeholder?: string;
+    label: string;
+    extensions?: Extension;
+    /**
+     * Replaces the built-in Markdown language, highlighting, formatted markers and
+     * formatting keys of the formatted and source modes. The engine keeps the
+     * table grid, clean paste, limits and history routing in every mode.
+     */
+    presentation?: (mode: Exclude<TextEditorMode, "plain">) => Extension;
+    /** The host owns history; collaboration bindings supply theirs. */
+    host: TableHost;
+    onChange?: (text: string) => void;
+    onDroppedImages?: (count: number, files: File[]) => void;
+};
+/** Shared engine; application extensions own transport, awareness and domain features. */
+export declare function createTextEditor(options: TextEditorOptions): {
+    view: EditorView;
+    /** Also re-reads `presentation`, so a host can refresh it, e.g. after a theme change. */
+    setMode: (mode: TextEditorMode) => void;
+    setLabel: (label: string) => void;
+    setReadOnly: (readOnly: boolean) => void;
+    destroy: () => void;
+};
+export type TextEditorController = ReturnType<typeof createTextEditor>;

package/dist/types/text-editor/format.d.ts

@@ -0,0 +1,34 @@
+/** Toolbar and keyboard commands. Each one is a plain Markdown edit of the selection. */
+import { type EditorState, Facet, type TransactionSpec } from "@codemirror/state";
+import type { EditorView } from "@codemirror/view";
+/** Insertion text follows the editor's inherited locale, including keyboard commands. */
+export declare const formatLabels: Facet<{
+    link: string;
+    column: (column: number) => string;
+}, {
+    link: string;
+    column: (column: number) => string;
+}>;
+/** Named Markdown marks or an app's single-line paired delimiter (for example Notebook's `==`). */
+export type InlineFormat = "bold" | "italic" | "code" | "strike" | "link" | {
+    marker: string;
+};
+/** Pure transaction spec, also used when a missing table cell must be materialized atomically. */
+export declare const inlineFormat: (state: EditorState, name: InlineFormat) => TransactionSpec;
+export declare const commands: {
+    bold: (view: EditorView) => boolean;
+    italic: (view: EditorView) => boolean;
+    code: (view: EditorView) => boolean;
+    strike: (view: EditorView) => boolean;
+    heading: (view: EditorView) => boolean;
+    heading1: (view: EditorView) => boolean;
+    heading2: (view: EditorView) => boolean;
+    heading3: (view: EditorView) => boolean;
+    codeBlock: (view: EditorView) => boolean;
+    bulletList: (view: EditorView) => boolean;
+    orderedList: (view: EditorView) => boolean;
+    quote: (view: EditorView) => boolean;
+    link: (view: EditorView) => boolean;
+    table: (view: EditorView) => boolean;
+    rule: (view: EditorView) => boolean;
+};

package/dist/types/text-editor/formatted.d.ts

@@ -0,0 +1 @@
+export declare const formattedView: import("@codemirror/state").Extension[];

package/dist/types/text-editor/language.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Markdown language without `@codemirror/lang-markdown`: that package pulls in
+ * `@codemirror/lang-html` (and with it CSS and JavaScript) for HTML blocks.
+ * The shared editor needs only the GFM tree, so it wraps `@lezer/markdown`.
+ */
+import { Language, LanguageSupport } from "@codemirror/language";
+export declare const markdownLanguage: Language;
+export declare const markdown: () => LanguageSupport;

package/dist/types/text-editor/markdown-table.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Pure GFM table edits in original Markdown coordinates. Markdown is the only
+ * model; callers reparse after applying a transaction. No repair of damaged
+ * tables or prose is attempted. Extra and missing body cells remain inspectable.
+ */
+import type { ChangeDesc } from "@codemirror/state";
+export type Align = "left" | "center" | "right" | null;
+export type Change = {
+    from: number;
+    to: number;
+    insert: string;
+};
+/** Trimmed raw content, with absolute UTF-16 source offsets. */
+export type Cell = {
+    from: number;
+    to: number;
+    text: string;
+};
+export type Line = {
+    from: number;
+    to: number;
+    pipes: number[];
+    leadingPipe: boolean;
+    trailingPipe: boolean;
+    cells: Cell[];
+    /** Original terminator, used when inserting rows. */
+    lineBreak?: string;
+};
+export type Table = {
+    from: number;
+    to: number;
+    /** Header, delimiter, then body rows. */
+    lines: Line[];
+    align: Align[];
+    columns: number;
+};
+/** Only top-level Lezer GFM tables: never code, block quotes, or list items. */
+export declare const findTables: (doc: string) => Table[];
+export declare const tableAt: (doc: string, pos: number) => Table | null;
+/**
+ * Problems that must stay visible before formatted output is sent. A damaged
+ * separator makes GFM fall back to a paragraph: two adjacent pipe-framed rows
+ * there still need review. This only inspects top-level paragraph nodes, never
+ * code, quotations or lists, and does not repair or rewrite any text.
+ */
+export declare const inspectTableStructure: (doc: string) => {
+    extraCells: boolean;
+    missingSeparator: boolean;
+};
+export declare const gridLine: (table: Table, row: number) => Line | undefined;
+export declare const rowCount: (table: Table) => number;
+/** Literal displayed text → safe raw content. Call once, never on existing raw Markdown. */
+export declare const escapeCell: (value: string) => string;
+/** Display text and a raw offset for every displayed UTF-16 boundary. */
+export declare const cellDisplayMap: (raw: string) => {
+    text: string;
+    offsets: number[];
+};
+/** Decode only table pipes and backslashes; leave inline Markdown source editable. */
+export declare const displayCell: (raw: string) => string;
+/**
+ * One minimal contiguous source edit from literal displayed input. Unchanged
+ * escapes keep their exact bytes, including noncanonical lone backslashes.
+ * `from` is the old cell's absolute start; input must NOT be pre-escaped.
+ */
+export declare const cellChanges: (raw: string, nextDisplayed: string, from: number) => Change[];
+/**
+ * Map an edit based on an old cell through intervening document changes.
+ * Deletes only surviving old-source spans (iterGaps), preserving remote inserts
+ * and excluding replaced/deleted identities. Returns current-document offsets.
+ * The caller must first verify that the mapped range is still the same cell;
+ * concurrent structural/escape edits require resyncing its displayed snapshot.
+ */
+export declare const mappedCellChanges: (raw: string, nextDisplayed: string, from: number, changes: ChangeDesc) => Change[];
+/** Spike-compatible escaped RAW input; fills ragged cells within the existing grid width. */
+export declare const setCellText: (table: Table, row: number, col: number, next: string) => Change[];
+export declare const insertRow: (table: Table, after: number) => Change[];
+export declare const deleteRow: (table: Table, row: number) => Change[];
+/** Move a body row, retaining every untouched row's original source and identities. */
+export declare const moveRow: (source: string, table: Table, row: number, to: number) => Change[];
+/** Swap adjacent columns, including their alignment, without rewriting other cells. */
+export declare const moveColumn: (table: Table, column: number, to: number) => Change[];
+/** A hidden header is an empty GFM header; its former values become the first body row. */
+export declare const toggleHeader: (source: string, table: Table) => Change[];
+/** Delete only the selected table; surrounding prose remains byte-for-byte intact. */
+export declare const deleteTable: (table: Table) => Change[];
+/** Insert before `at`, including at the widest row's end; pad ragged rows without dropping cells. */
+export declare const insertColumn: (table: Table, at: number) => Change[];
+/** Complete a ragged grid without changing or removing any existing cell. */
+export declare const completeColumns: (table: Table) => Change[];
+export declare const deleteColumn: (table: Table, col: number) => Change[];
+export declare const setAlign: (table: Table, col: number, align: Align) => Change[];
+/** First grid row is the header; pad short rows, preserve every extra cell. */
+export declare const tableFromGrid: (grid: string[][]) => string;
+/** Quoted TSV (including doubled quotes and embedded newlines). Invalid quotes stay raw. */
+export declare const parseTsv: (text: string) => string[][] | null;
+/** Apply sorted or unsorted, non-overlapping edits in old-document coordinates. */
+export declare const applyChanges: (doc: string, changes: Change[]) => string;
+/**
+ * Settle recognized ragged GFM tables without deleting or rewriting source.
+ * Extra cells become named-grid positions with empty headers, never discarded.
+ * Unrecognizable tables remain raw text for the application's check state;
+ * code, quotes and lists are not repair candidates.
+ */
+export declare const repairTables: (doc: string, maxLength: number) => Change[];

package/dist/types/text-editor/messages.d.ts

@@ -0,0 +1,113 @@
+export declare const textEditorMessages: import("@k2b/stdlib").Catalog<{
+    formatting: string;
+    formatted: string;
+    source: string;
+    view: string;
+    loading: string;
+    bold: string;
+    italic: string;
+    heading: string;
+    heading1: string;
+    heading2: string;
+    heading3: string;
+    strike: string;
+    codeBlock: string;
+    inlineCode: string;
+    column: (column: number) => string;
+    menuRow: (row: number) => string;
+    menuColumn: (name: string) => string;
+    menuAbove: string;
+    menuBelow: string;
+    menuUp: string;
+    menuDown: string;
+    menuInsertLeft: string;
+    menuInsertRight: string;
+    menuMoveLeft: string;
+    menuMoveRight: string;
+    menuDelete: string;
+    menuCopy: string;
+    menuMarkdown: string;
+    columnAlignment: (column: number) => string;
+    discardRecovery: string;
+    bulletList: string;
+    orderedList: string;
+    quote: string;
+    link: string;
+    code: string;
+    table: string;
+    insertTable: string;
+    rows: string;
+    columns: string;
+    insertSize: ({ rows, columns }: {
+        rows: number;
+        columns: number;
+    }) => string;
+    rule: string;
+    rowAbove: string;
+    rowBelow: string;
+    colLeft: string;
+    colRight: string;
+    deleteRow: string;
+    deleteCol: string;
+    moveRowUp: string;
+    moveRowDown: string;
+    moveColLeft: string;
+    moveColRight: string;
+    toggleHeader: string;
+    deleteTable: string;
+    alignment: string;
+    copyTable: string;
+    copyMarkdown: string;
+    copyingTable: string;
+    copiedTable: string;
+    copiedMarkdown: string;
+    copyFailed: string;
+    alignLeft: string;
+    alignCenter: string;
+    alignRight: string;
+    cellLabel: ({ row, column, name }: {
+        row: number;
+        column: number;
+        name?: string;
+    }) => string;
+    structureUnavailable: string;
+    recoveredInput: string;
+    cellRemoved: string;
+    structureFailed: string;
+    pasteTooLarge: string;
+    textTooLarge: string;
+    checkTable: string;
+    checkTableDetail: string;
+    checkSeparatorDetail: string;
+    reviewMarkdown: string;
+    imageHint: string;
+    dismiss: string;
+    tableMenu: string;
+    tableChanged: ({ rows, columns }: {
+        rows: number;
+        columns: number;
+    }) => string;
+    rowMenu: string;
+    columnMenu: string;
+    addRow: string;
+    emptyCell: string;
+    editMarkdown: string;
+    showTable: string;
+    done: string;
+    markdownValid: string;
+    markdownInvalid: string;
+    markdownLine: (line: number) => string;
+    markdownSeparator: ({ header, separator }: {
+        header: number;
+        separator: number;
+    }) => string;
+    markdownExtra: (line: number) => string;
+    applyingTable: string;
+    markdownApplyFailed: string;
+    markdownStructural: string;
+    markdownChanged: string;
+    discardMarkdown: string;
+    continueMarkdown: string;
+    addColumn: string;
+    completeColumns: string;
+}>;

package/dist/types/text-editor/paste.d.ts

@@ -0,0 +1,6 @@
+/** HTML clipboard content as Markdown; `null` when it is better pasted as plain text. */
+export declare const htmlToMarkdown: (html: string) => {
+    markdown: string;
+    droppedImages: number;
+} | null;
+export declare const cleanPaste: (onDroppedImages?: (count: number, files: File[]) => void, plain?: boolean) => import("@codemirror/state").Extension;