@50arms/ui 0.0.0-stage → 35.1.0

package/dist/types/lib/i18n/strings.d.ts

@@ -0,0 +1,18 @@
+import { type AuthProvenanceFlowsStrings } from "./areas/auth-provenance-flows";
+import { type BoardStrings } from "./areas/board";
+import { type CardFaceStrings } from "./areas/card-face";
+import { type ChatChartStrings } from "./areas/chat-chart";
+import { type CodeEditorStrings } from "./areas/code-editor";
+import { type DateTimelineStrings } from "./areas/date-timeline";
+import { type DatesStrings } from "./areas/dates";
+import { type DocsViewsStrings } from "./areas/docs-views";
+import { type FeedbackStrings } from "./areas/feedback";
+import { type FormsStrings } from "./areas/forms";
+import { type FormatsStrings } from "./areas/formats";
+import { type KeysStrings } from "./areas/keys";
+import { type MarkdownStrings } from "./areas/markdown";
+import { type MoveRejectedStrings } from "./areas/move-rejected";
+import { type NavigationStrings } from "./areas/navigation";
+import { type RbacStrings } from "./areas/rbac";
+export type UiStrings = AuthProvenanceFlowsStrings & BoardStrings & CardFaceStrings & ChatChartStrings & CodeEditorStrings & DateTimelineStrings & DatesStrings & DocsViewsStrings & FeedbackStrings & FormsStrings & FormatsStrings & KeysStrings & MarkdownStrings & MoveRejectedStrings & NavigationStrings & RbacStrings;
+export declare const ENGLISH_UI_STRINGS: UiStrings;

package/dist/types/lib/icons.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Icon lookup.
+ *
+ * Icons are DATA here, not components. A `[tag, attrs]` tuple list is ~100
+ * bytes and carries no React overhead — components reference icons BY NAME
+ * (`<Icon name="check" />`) and resolve the geometry from `coreIcons` at
+ * render. The map below is seeded once from `coreIcons` at module load and
+ * never mutated afterward.
+ *
+ * The core set's geometry is Lucide's (ISC licensed — see src/icons/data.ts),
+ * extracted to data at build time so nothing ships at runtime.
+ */
+/** A single SVG child: an element name and its attributes. */
+export type IconNodeChild = readonly [tag: string, attrs: Record<string, string | number>];
+/** An icon's full geometry — the children of a 24x24 `<svg>`. */
+export type IconNode = readonly IconNodeChild[];
+/** Look up an icon, or `undefined` when the name is not in the core set. */
+export declare function getIcon(name: string): IconNode | undefined;
+/** Every name in the core set, sorted — powers icon galleries and docs pages. */
+export declare function iconNames(): string[];
+/** True when `name` resolves — for a consumer validating config-driven icons. */
+export declare function hasIcon(name: string): boolean;

package/dist/types/lib/interactive-target.d.ts

@@ -0,0 +1,3 @@
+export declare const INTERACTIVE_SELECTOR = "button, a, input, textarea, select, [role='button']";
+/** True when `target` is, or is inside, a control. */
+export declare function isInteractiveTarget(target: EventTarget | null): boolean;

package/dist/types/lib/intl-cache.d.ts

@@ -0,0 +1,31 @@
+export declare function numberFormat(locale: string, options: Intl.NumberFormatOptions): Intl.NumberFormat;
+export declare function dateFormat(locale: string, options: Intl.DateTimeFormatOptions): Intl.DateTimeFormat;
+export declare function listFormat(locale: string, options?: Intl.ListFormatOptions): Intl.ListFormat;
+/** A cached `Intl.Collator`: sort names the way `locale` orders them (DX-4740), never by code point. */
+export declare function collator(locale: string, options?: Intl.CollatorOptions): Intl.Collator;
+/** A cached `Intl.PluralRules` (DX-4740): which plural category (`one`, `other`, ...) a count takes in `locale`. */
+export declare function pluralRules(locale: string, options?: Intl.PluralRulesOptions): Intl.PluralRules;
+/** The locale's digit-group and decimal separators ("," and "." in en-US, "." and "," in es-AR). */
+export declare function numberSeparators(locale: string): {
+    group: string;
+    decimal: string;
+};
+/**
+ * Text a person typed in `locale`'s number convention → a finite `number`, or `null`.
+ * `strip` removes locale-specific decoration first (a currency symbol). Group
+ * separators are dropped and the decimal separator becomes ".", then the result
+ * must be a plain signed decimal — `"12abc"` is a typo, not twelve.
+ */
+export declare function parseLocalizedNumber(text: string, locale: string, strip?: readonly string[]): number | null;
+/**
+ * Create a Date from year/month/day values, treating them as UTC (not local time).
+ * Used by date formatting and parsing to work in UTC consistently.
+ */
+export declare function asUtcDate(year: number, month: number, day: number): Date;
+/**
+ * The locale's digit set as an array [0, 1, 2, ..., 9], for normalizing user input
+ * or parsing output of locale-specific formatters.
+ */
+export declare function localeDigits(locale: string): string[];
+/** A percentage as the locale writes it. `percent` is on the 0-100 scale; it is rounded to `digits` decimals. */
+export declare function formatPercent(percent: number, locale: string, digits?: number): string;

package/dist/types/lib/legal-document.d.ts

@@ -0,0 +1,82 @@
+/**
+ * A legal document as DATA, plus the four pure decisions the `LegalDocument`
+ * component makes about it. DX-4022.
+ *
+ * No React in this file on purpose: the `LegalDocumentValue` shape is what a
+ * server holds and serves, so the `./pure` entry re-exports the types and a
+ * back end can type its content module without importing the design system's
+ * component graph.
+ *
+ * The shape mirrors a legal text and adds nothing to it: a title block,
+ * numbered sections, and in each section the paragraphs and bullet lists in
+ * document order. A paragraph that opens a numbered clause ("4.2 Beta
+ * confidentiality. ...") carries that opening as `clause`, split off only so
+ * a renderer can set it as a run-in heading and give it an anchor;
+ * `${number} ${heading} ${text}` is the paragraph as written. Nothing in the
+ * component writes a word of the document, which is what lets a verbatim check
+ * compare the page against its source and expect an exact match.
+ */
+export interface LegalDocumentValue {
+    /** The document's own title line, e.g. "TERMS OF USE". */
+    title: string;
+    /** The company line under the title. */
+    issuer: string;
+    /** As written in the document, so it may still be an unfilled `[DATE]`. */
+    effectiveDate: string;
+    /** Which version of the text this is, as an acceptance would record it. */
+    version: string;
+    sections: readonly LegalSection[];
+}
+export interface LegalSection {
+    /** "1", "2", ... the number the document gives the section, and what "Section N" cites. */
+    number: string;
+    title: string;
+    blocks: readonly LegalBlock[];
+}
+export type LegalBlock = {
+    kind: "paragraph";
+    /** A numbered clause's opening words, when the paragraph starts one. */
+    clause?: {
+        number: string;
+        heading: string;
+    };
+    text: string;
+} | {
+    kind: "list";
+    items: readonly string[];
+};
+/**
+ * The fragment a section or clause is linked by: "7" is `section-7`, "7.2" is
+ * `section-7-2`.
+ *
+ * Keyed on the NUMBER, never the title: "Section 7" is how a document cites
+ * itself (and how a lawyer cites it in an email), so a link survives a heading
+ * being reworded in a later version.
+ */
+export declare function legalSectionAnchor(number: string): string;
+/** One run of a paragraph: plain text, or a value the document left unfilled. */
+export interface LegalTextRun {
+    text: string;
+    unconfirmed: boolean;
+}
+/**
+ * Split text into plain runs and square-bracketed placeholder runs.
+ *
+ * A draft marks every value it has not settled (a date, a notice period, a
+ * dollar cap) by writing it in square brackets. Those spans are kept verbatim,
+ * brackets included; this only finds them so they can be SHOWN as unconfirmed
+ * rather than read as agreed terms. Concatenating the runs' text always gives
+ * back the input unchanged.
+ */
+export declare function splitUnconfirmed(text: string): LegalTextRun[];
+/** How many placeholder values a document still carries. */
+export declare function countUnconfirmed(document: LegalDocumentValue): number;
+/**
+ * Whether a run of text is written in capitals throughout.
+ *
+ * Disclaimers and liability limits are set in capitals on purpose (that is what
+ * makes them conspicuous in the legal sense), so the renderer keeps every
+ * letter as written and makes the block easier to read instead: a rule beside
+ * it, looser tracking. A short all-caps fragment is not a paragraph of it.
+ */
+export declare function isAllCaps(text: string): boolean;

package/dist/types/lib/line-diff-model.d.ts

@@ -0,0 +1,39 @@
+export type DiffKind = "unchanged" | "added" | "removed";
+export interface DiffLine {
+    kind: DiffKind;
+    text: string;
+}
+/** Unchanged lines shown either side of a change when the caller names none. */
+export declare const DEFAULT_CONTEXT = 2;
+/** Lines one press of an expand-up / expand-down control reveals. */
+export declare const EXPAND_STEP = 8;
+/** `"".split("\n")` is `[""]`: an empty string has no lines at all. */
+export declare const splitLines: (text: string) => string[];
+/** The line diff of `after` against `before` (LCS): a line in both once, one only in `before` removed, one only in `after` added; an edited line is its removal then its addition. */
+export declare function diffLines(before: string[], after: string[]): DiffLine[];
+/** A folded run of unchanged lines: rows `[start, end)` of the diff. */
+export interface Gap {
+    start: number;
+    end: number;
+    /** No change above it: only the lines just above the change below can be revealed. */
+    atStart: boolean;
+    /** No change below it: only the lines just below the change above can be revealed. */
+    atEnd: boolean;
+}
+/** The unchanged runs further than `context` lines from every change. A diff with no change at all is one gap. */
+export declare function foldGaps(lines: readonly DiffLine[], context: number): Gap[];
+/** What a person has opened of one gap: lines revealed just below the change above (`down`) and just above the change below (`up`). */
+export interface Reveal {
+    down: number;
+    up: number;
+}
+export declare const NOTHING: Reveal;
+/** How the gap reads now: rows revealed under the change above, rows revealed over the change below, and how many stay folded between them. */
+export declare function gapState(g: Gap, r?: Reveal): {
+    top: number;
+    bottom: number;
+    hidden: number;
+};
+export type Expand = "down" | "up" | "all";
+/** The reveal after one press. "down" and "up" open `step` more lines (never past the gap); "all" opens the rest. */
+export declare function expand(g: Gap, r: Reveal, how: Expand, step?: number): Reveal;

package/dist/types/lib/markdown/attachments.d.ts

@@ -0,0 +1,50 @@
+import { type Projection } from "./project";
+/** One file the document references: a tile in the strip. */
+export interface AttachmentRow {
+    /** The file's identity: the destination exactly as the parser reads it. */
+    url: string;
+    /** The reference name of its first reference in the text. */
+    name: string;
+    /** Whether the first reference is an image construct. */
+    image: boolean;
+}
+export interface AttachmentOptions {
+    /** Whether a LINK's destination is a file the app stores. An image construct always counts; a typed link only through this. */
+    isFileUrl: (url: string) => boolean;
+}
+/**
+ * Whether a construct is an attachment reference: an image with a destination, or a link `isFileUrl` accepts. The ONE
+ * definition: the strip, the numbering and the construct bar (which never opens over a reference) all use it.
+ */
+export declare function isAttachmentReference(kind: "image" | "link", url: string, options: AttachmentOptions): boolean;
+/**
+ * One row per distinct URL the text references as a file, in the order it first appears. It reads the parse the
+ * editor's surface already holds, so a keystroke never parses the text a second time.
+ */
+export declare function attachmentsOf(projection: Projection, options: AttachmentOptions): AttachmentRow[];
+/**
+ * The number the next file referenced takes: one more than the highest number any ATTACHMENT in the text already
+ * ends in, whatever its kind. Numbers are never renumbered when a file is removed, because the person may have
+ * written "see Image 2" in the text; a renamed reference that no longer ends in a number takes no part, and a typed
+ * ordinary link ("[RFC 2119](...)") never does.
+ */
+export declare function nextReferenceNumber(source: string, options: AttachmentOptions): number;
+/** The name for the next file referenced: `kindWord` and `nextReferenceNumber`. */
+export declare function nextReferenceName(source: string, kindWord: string, options: AttachmentOptions): string;
+/** Rewrites the bracket text of EVERY construct that points at `url`; the destination and everything else stay byte for byte. */
+export declare function renameAttachment(source: string, url: string, name: string): string;
+/**
+ * Deletes EVERY construct that points at `url`, and one separating space beside each (the one before it, else
+ * the one after), so `a ![x](u) b` becomes `a b`. A space two constructs share is taken once, so two references
+ * side by side never reach into the text after them.
+ */
+export declare function removeAttachment(source: string, url: string): string;
+/**
+ * The one splice that turns `before` into `after`: the span between their common prefix and common suffix.
+ * Several constructs changing at once (a rename, a remove) is still ONE edit, and so one undo step.
+ */
+export declare function coveringSplice(before: string, after: string): {
+    start: number;
+    end: number;
+    text: string;
+} | null;

package/dist/types/lib/markdown/caret-map.d.ts

@@ -0,0 +1,69 @@
+import type { Projection } from "./project";
+/** A half-open source range. */
+export interface Span {
+    start: number;
+    end: number;
+}
+export interface CaretMap {
+    source: string;
+    /** Every offset the caret may occupy, ascending and unique. */
+    stops: readonly number[];
+    /** The source range of every VISIBLE grapheme, in document order. */
+    graphemes: readonly Span[];
+    /**
+     * The stop that stands for each source offset, indexed by offset.
+     *
+     * NEEDED BECAUSE "NEAREST" IS THE WRONG QUESTION. Deleting the "d" from
+     * `**bold**` leaves the caret at offset 5, which is the same PLACE as offset
+     * 7 but two characters closer to 4 — so a nearest-by-distance snap puts the
+     * caret before the "l" instead of after the construct, and the next keystroke
+     * lands in the wrong word. An offset belongs to the coincident group it falls
+     * in, and only this table knows which that is.
+     */
+    representative: readonly number[];
+}
+/**
+ * Builds the map for a projection.
+ *
+ * Pure, and rebuilt with every projection rather than maintained across edits —
+ * the same reasoning the projection itself gives. Nothing is kept in step, so
+ * nothing can drift.
+ */
+export declare function caretMap(projection: Projection): CaretMap;
+/**
+ * The legal offset standing for `offset` — the caret's real place.
+ *
+ * Not "the closest number in `stops`": see `representative`. Out-of-range
+ * offsets clamp, because a caret that cannot be placed is worse than one placed
+ * at the edge.
+ */
+export declare function nearestStop(map: CaretMap, offset: number): number;
+/** The next legal offset in `direction`, or the same one at a document edge. */
+export declare function stepStop(map: CaretMap, offset: number, direction: 1 | -1): number;
+/** The visible grapheme immediately before `offset`, if there is one. */
+export declare function graphemeBefore(map: CaretMap, offset: number): Span | null;
+/** The visible grapheme immediately after `offset`, if there is one. */
+export declare function graphemeAfter(map: CaretMap, offset: number): Span | null;
+/** The first legal offset on the line holding `offset` — where Home goes. */
+export declare function lineStartStop(map: CaretMap, offset: number): number;
+/**
+ * The last legal offset on the line holding `offset` — where End goes.
+ *
+ * SG-799 — NOT SAFE TO LEAVE TO THE BROWSER, the way `input.ts` leaves
+ * vertical movement and word-wise movement to it. A block's own leading
+ * markup (`# `, `- `, `> `) renders as `display: inline-block; width: 0`
+ * (`styles/markdown.css`'s "markup is collapsed at all times" rule) so it can
+ * be reached at all without ever having visible geometry — but a zero-size
+ * `inline-block` is an ATOMIC box for Chromium's own line-navigation, and a
+ * real Chromium probe caught it landing End's selection INSIDE that leading
+ * box (`("# ", offset 2)`, the same on-screen point as where the caret
+ * already stood) instead of at the true end of the visible text — every time,
+ * on every block with a leading marker, regardless of heading level and
+ * regardless of whether the line was the document's last one. Home already
+ * had the model-side half of this fix (`lineStartStop`, above) sitting
+ * unused — nothing in `input.ts` ever called it, so Home had the identical
+ * exposure and simply hadn't been caught yet. Both are now computed here and
+ * written directly, the same way `moveCaret` already computes ArrowLeft/Right
+ * instead of trusting the browser.
+ */
+export declare function lineEndStop(map: CaretMap, offset: number): number;

package/dist/types/lib/markdown/caret.d.ts

@@ -0,0 +1,6 @@
+export declare function stepOffset(source: string, offset: number, direction: 1 | -1): number;
+/** The source range of the line containing `offset`, terminator excluded. */
+export declare function lineAt(source: string, offset: number): {
+    start: number;
+    end: number;
+};

package/dist/types/lib/markdown/commands.d.ts

@@ -0,0 +1,186 @@
+import type { SourceSelection } from "./position";
+import type { Splice } from "./surface";
+export interface Edit {
+    splice: Splice;
+    select: SourceSelection;
+}
+/** A command returns null when it does not apply, so the key falls through. */
+export type Command = (source: string, selection: SourceSelection) => Edit | null;
+interface LineSpan {
+    start: number;
+    end: number;
+    text: string;
+}
+/**
+ * Toggles a symmetric inline marker around the selection.
+ *
+ * WRAPPING AND UNWRAPPING ARE THE SAME COMMAND, and which one happens is
+ * decided by looking at the source on both sides — not by asking the rendered
+ * tree whether the selection "is bold". The tree answer is ambiguous the moment
+ * a selection spans a boundary; the source answer never is.
+ */
+export declare function toggleInline(marker: string): Command;
+export declare const toggleBold: Command;
+export declare const toggleItalic: Command;
+export declare const toggleCode: Command;
+export declare const toggleStrike: Command;
+/** The heading level of a line, 0 for a paragraph. */
+export declare function headingLevel(text: string): number;
+/**
+ * Sets a line's heading level. Level 0 removes the heading.
+ *
+ * Applied to the FIRST line of the selection only. A multi-line selection means
+ * "make this a heading", and a heading is one line — turning six selected lines
+ * into six headings is a destructive reading of an ambiguous gesture.
+ */
+export declare function setHeading(level: number): Command;
+export declare function adjustHeading(delta: number): Command;
+/**
+ * Toggles a list over every line the selection touches.
+ *
+ * Removes only when EVERY line already has that kind of marker — the same
+ * convention every editor uses, and the one that makes a mixed selection do
+ * something predictable rather than alternating line by line.
+ */
+export declare function toggleList(asOrdered: boolean): Command;
+export declare const indentLines: Command;
+export declare const outdentLines: Command;
+/** Toggles a task checkbox, adding one if the item has none. */
+export declare const toggleTask: Command;
+export declare const toggleQuote: Command;
+/**
+ * Wraps the selected lines in a fence, or unwraps the fence they are inside.
+ *
+ * The fence is built from the lines OUTSIDE the selection when unwrapping, so
+ * putting the caret anywhere in a code block and pressing the key removes the
+ * block — rather than requiring the user to select the fence lines they cannot
+ * see.
+ */
+export declare function toggleCodeBlock(language?: string): Command;
+/** The fenced block containing `offset`, if any. */
+export declare function fenceAround(source: string, offset: number): {
+    start: number;
+    end: number;
+    bodyStart: number;
+    bodyEnd: number;
+} | null;
+export declare const insertRule: Command;
+/**
+ * Wraps the selection as a link, leaving the caret in the destination.
+ *
+ * With no href the destination is empty and the caret sits inside the
+ * parentheses, which is where a popover would put it too — the command is the
+ * same whether a popover drove it or a hotkey did.
+ */
+export declare function insertLink(href?: string, title?: string): Command;
+/**
+ * Inserts an image of `src`, using the selection as its alt text.
+ *
+ * ALT TEXT IS NOT OPTIONAL AND NOT AN AFTERTHOUGHT, which is why the selection
+ * becomes it rather than the source: an image whose alt is the filename is
+ * exactly as useless to a screen reader as one with none, and the person
+ * inserting it is the only one who knows what it shows.
+ *
+ * `src` IS REQUIRED AND MAY NOT BE EMPTY (DX-3134). The old default of `""`
+ * inserted `![]()`: an image with nothing to show, which the surface drew as
+ * nothing and the caret could not find — the toolbar's Image button appeared
+ * to do nothing at all. Choosing a picture is the editor's job (its file
+ * picker), so a command is only ever asked to write one that exists. The caret
+ * lands after the image, where the next keystroke belongs.
+ *
+ * NEVER LANDS INSIDE CODE (DX-3140). This is public API (`src/index.ts`), a
+ * separate path from `ImagePipeline.insert` that a consumer can call directly
+ * against a selection with no idea what it currently contains — so it is
+ * exactly as able to write a dead `![](…)` into a fence or a span as a paste
+ * ever was. `enclosingCode` + `reshapeForCodeBoundary` (`images.ts`) are the
+ * SAME functions the pipeline uses for the same reason there, redirecting
+ * the insertion to land just past the code instead of inside it.
+ */
+export declare function insertImage(src: string, alt?: string): Command;
+export interface TableSpan {
+    start: number;
+    end: number;
+    /** Whole lines: header, delimiter, then body rows. */
+    rows: LineSpan[];
+}
+/** The GFM table containing `offset`, if any. */
+export declare function tableAround(source: string, offset: number): TableSpan | null;
+/** A row's cells, by their text, with the outer pipes removed. */
+export declare function cellsOf(text: string): string[];
+/** Which row and column an offset falls in, within a table. */
+export declare function cellAt(source: string, table: TableSpan, offset: number): {
+    row: number;
+    column: number;
+} | null;
+/** `columnHeader(n)` names the n-th (1-based) header cell; the editor passes its provider string. */
+export declare function insertTable(columnHeader: (position: number) => string, columns?: number, bodyRows?: number): Command;
+export declare function insertRow(below: boolean): Command;
+/** `header` is the new column's header cell text. */
+export declare function insertColumn(after: boolean, header: string): Command;
+export declare const deleteRow: Command;
+export declare const deleteColumn: Command;
+export declare const deleteTable: Command;
+export declare function alignColumn(align: "left" | "center" | "right"): Command;
+/**
+ * Moves the caret to the next or previous CELL of the table it is in.
+ *
+ * Tab between cells is the one table affordance people notice the absence of
+ * immediately, because every spreadsheet and every other table editor has it.
+ * It is a MOVEMENT, not an edit, so it returns a zero-width splice — the same
+ * shape every other command uses, which keeps one code path in the caller.
+ *
+ * Wraps to the next ROW at the end of one, and stops at the table's ends rather
+ * than escaping into the document: a Tab that leaves the table by surprise is
+ * how a user loses their place in it.
+ */
+export declare function tableTab(forward: boolean): Command;
+/**
+ * Enter, with the block structure carried onto the next line.
+ *
+ * The one place a command looks at what the line IS rather than what the user
+ * selected — because pressing Enter in a list and getting a bare line is the
+ * single most-noticed omission in a markdown editor.
+ *
+ * An EMPTY list item exits the list instead of making another one, which is
+ * what every editor does and what stops a stray marker being left behind.
+ */
+/**
+ * Backspace at the start of a block's own text, which removes that block's
+ * markup instead of the character before it.
+ *
+ * THIS IS THE ONLY WAY TO REMOVE MARKUP YOU CANNOT SEE. Under the old contract
+ * the marker was reachable text, so deleting a list item's dash was just
+ * backspacing over a dash. Now the caret cannot enter a marker at all, and the
+ * character before an item's first letter is the newline that ends the line
+ * above — so a plain backspace would MERGE THE ITEM INTO THE PREVIOUS LINE and
+ * leave `previous- item` behind, printing a marker as prose. Every rich editor
+ * uses this rule for the same reason; here it is load-bearing rather than
+ * conventional.
+ *
+ * It is a LADDER, one rung per press, so holding backspace unwinds a nested
+ * item cleanly instead of jumping to plain text: checkbox, then one indent
+ * level per press, then the marker itself.
+ *
+ * Returns null unless the caret is collapsed AT OR BEFORE the block's content
+ * start — anywhere past it, backspace means what it always meant.
+ *
+ * AT OR BEFORE, not exactly at, because with the markup collapsed every offset
+ * from the line's start to its content start is the SAME PLACE on screen, and
+ * which of them the caret map picks depends on what else is on the line. An
+ * empty task item holding a table turned out to put it at offset 0 rather than
+ * at 6, and an exact test then declined — leaving a document that rendered as a
+ * checkbox and an empty table with no key that could remove either.
+ */
+export declare const backspaceBlockPrefix: Command;
+export declare const smartEnter: Command;
+/**
+ * Tab: indent inside a list, otherwise decline so focus can leave.
+ *
+ * WCAG 2.1.2 permits an editor to own Tab, but the advisement clause is
+ * normative — an undocumented escape is a failure even when the escape exists.
+ * Declining outside a list means Tab does the ordinary thing almost everywhere,
+ * which is the cheapest possible way to satisfy it.
+ */
+export declare const smartTab: Command;
+export declare const smartShiftTab: Command;
+export {};

package/dist/types/lib/markdown/convert.d.ts

@@ -0,0 +1,99 @@
+import { type Command, type Edit } from "./commands";
+import type { Projection } from "./project";
+/** The block kinds a line-type control can offer. */
+export type BlockKind = "paragraph" | "heading" | "quote" | "code" | "bullet" | "ordered" | "task" | "table" | "rule";
+export interface BlockInfo {
+    kind: BlockKind;
+    /** 1–6 for a heading, otherwise undefined. */
+    level?: number;
+    /** The info string of a fence, "" when it has none. */
+    language?: string;
+    /** Whether a task item is ticked. */
+    checked?: boolean;
+    /** The source span this control operates on. */
+    start: number;
+    end: number;
+}
+/**
+ * What the block at `offset` is, and the span a conversion would replace.
+ *
+ * The span is the whole construct for a fence or a table and the caret's own
+ * line otherwise — see the header. A caller with a real selection widens it
+ * itself; this answers for a point.
+ */
+export declare function blockAt(source: string, offset: number): BlockInfo;
+export interface ConvertOptions {
+    /** 1–6, for `heading`. Ignored otherwise. */
+    level?: number;
+    /** Info string, for `code`. Ignored otherwise. */
+    language?: string;
+}
+/**
+ * Converts the block at the selection to `kind`, whatever it is now.
+ *
+ * SET, NOT TOGGLE: converting a quote to a quote is a no-op rather than an
+ * un-quote, because a menu item that undoes itself when the current type is
+ * picked is a menu item that punishes confirming what you already have.
+ */
+export declare function convertBlock(kind: BlockKind, options?: ConvertOptions): Command;
+/**
+ * Rewrites a fenced block's info string.
+ *
+ * Its own command rather than `convertBlock("code", {language})`, because that
+ * would rebuild the whole block to change one word — losing nothing, but
+ * replacing every line and therefore every DOM node the reconciler had kept.
+ */
+export declare function setFenceLanguage(language: string): Command;
+/** The inline mark kinds a toolbar can show as active. */
+export type InlineMark = "strong" | "emphasis" | "codeSpan" | "strike";
+/**
+ * Every inline mark frame containing `offset`, read from the projection.
+ *
+ * SAME METHOD AS `constructAt`, for the same reason: the parser has already
+ * decided where a `**bold**` run starts and ends, including cases a regex
+ * would get wrong — a marker inside a code span, one split across an escaped
+ * character. A toolbar asking "is the caret inside bold" gets the parser's
+ * answer instead of re-deriving it from the source text a second time.
+ *
+ * Boundaries are INCLUSIVE on both ends, matching `constructAt` — a caret at
+ * either edge of `**bold**` still reads as inside it. This is a display
+ * nicety (which toolbar buttons light up), not a decision about where
+ * `toggleInline` wraps or unwraps, which reasons about the source directly.
+ */
+export declare function marksAt(projection: Projection, offset: number): Set<InlineMark>;
+export interface ConstructInfo {
+    kind: "link" | "image";
+    /** Destination — `href` for a link, `src` for an image. */
+    target: string;
+    /** Label for a link, alt text for an image. */
+    label: string;
+    title?: string;
+    start: number;
+    end: number;
+}
+/**
+ * The innermost link or image containing `offset`.
+ *
+ * Read from the PROJECTION rather than by matching brackets, for the reason
+ * every other reader in this codebase gives: the parser has already decided
+ * what is a link, including the cases a regex gets wrong — a bracket inside a
+ * code span, an unbalanced one, a reference definition elsewhere in the file.
+ */
+export declare function constructAt(projection: Projection, offset: number): ConstructInfo | null;
+export interface ConstructPatch {
+    target?: string;
+    label?: string;
+    title?: string;
+    /** Rewrites a link as an image or the other way round. */
+    kind?: "link" | "image";
+}
+/** Rewrites the link or image at `offset` from its parts. */
+export declare function editConstruct(projection: Projection, offset: number, patch: ConstructPatch): Edit | null;
+/**
+ * Replaces a link or image with its own text.
+ *
+ * The one conversion that removes a construct rather than changing it, and the
+ * only way to get rid of a link now that its brackets are markup the caret
+ * cannot reach.
+ */
+export declare function unwrapConstruct(projection: Projection, offset: number): Edit | null;

package/dist/types/lib/markdown/dom.d.ts

@@ -0,0 +1,30 @@
+import type { Frame } from "../syntax/markdown/frames";
+/** Marks the wrapper around a run of markup, for the collapse rule. */
+export declare const SYNTAX_ATTR = "data-md-syntax";
+/** Names the frame an element came from, for styling and for the reconciler. */
+export declare const FRAME_ATTR = "data-md";
+export interface TagSpec {
+    tag: string;
+    /** Attributes the element carries, beyond `data-md`. */
+    attrs?: Record<string, string>;
+}
+/**
+ * The element a frame becomes.
+ *
+ * `a` deliberately renders as a `<span>`, NOT an anchor. An anchor inside a
+ * contenteditable is a trap: the browser gives it its own selection behaviour,
+ * some engines make it draggable, and a click navigates away from the document
+ * being edited. The link's appearance is a class; its behaviour belongs to the
+ * editor, which knows whether a modifier key was held.
+ */
+export declare function tagFor(frame: Frame): TagSpec;
+/**
+ * Whether two frames describe the same element, for reuse during a patch.
+ *
+ * Compared by TAG and by the attributes that would have to change, not by deep
+ * equality of the frame: a heading whose text changed is the same `<h2>` and
+ * must keep its identity, while a heading that became an `<h3>` is a different
+ * element. Getting this wrong in the permissive direction replaces nodes the
+ * caret is inside; getting it wrong in the strict direction is merely slower.
+ */
+export declare function sameElement(a: Frame, b: Frame): boolean;