@50arms/ui 0.0.0-stage → 35.2.0

package/dist/types/lib/sim/settings.d.ts

@@ -0,0 +1,11 @@
+import type { DataSource, NetworkSpeed } from "./types";
+export interface SimSettings {
+    networkSpeed: NetworkSpeed;
+    dataSource: DataSource;
+}
+export declare function useSimSettings(): SimSettings;
+export declare function setSimSettings(patch: Partial<SimSettings>): void;
+/** Read outside React — `latency.ts` needs the current speed synchronously,
+    inside a plain async function with no hook rules to follow. */
+export declare function getNetworkSpeed(): NetworkSpeed;
+export declare function getDataSource(): DataSource;

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

@@ -0,0 +1,3 @@
+export type NetworkSpeed = "instant" | "fast" | "typical" | "flaky";
+export type DataSource = "simulated" | "live";
+export type SimNamespace = "demo" | "ledger";

package/dist/types/lib/submit-shortcut.d.ts

@@ -0,0 +1,24 @@
+import { type KeyboardEvent } from "react";
+/**
+ * DX-5596: the one submit contract every multi-line input shares (`MarkdownEditor`, `Textarea`).
+ * Ctrl+Enter (Cmd+Enter on a Mac) calls `onSubmit`; `label` is the verb the hint names ("post",
+ * translated by the caller); `disabled` is the caller's own can't-submit rule, the same one its
+ * button follows. While disabled the chord calls nothing but is still swallowed, so it does not
+ * insert a line break. Plain Enter keeps its meaning.
+ */
+export interface SubmitAction {
+    onSubmit: () => void;
+    label: string;
+    disabled?: boolean;
+}
+type Chord = "ctrl+enter" | "cmd+enter";
+/** Ctrl+Enter everywhere; Cmd+Enter in the hint on a Mac or iPad. Read after mount so SSR and hydration agree. */
+export declare function useSubmitChord(): Chord;
+/** Runs `submit` on Ctrl/Cmd+Enter (either modifier on every platform, as `InlineMarkdownEdit` does). True when it took the key. */
+export declare function handleSubmitChord(event: KeyboardEvent<HTMLElement>, submit: SubmitAction | undefined): void;
+/** The permanent hint line naming the chord and its action: "Ctrl+Enter to post". */
+export declare function SubmitHint({ submit, className }: {
+    submit: SubmitAction;
+    className?: string;
+}): import("react").JSX.Element;
+export {};

package/dist/types/lib/syntax/index.d.ts

@@ -0,0 +1,16 @@
+import type { Grammar, Token } from "./types";
+export declare function tokenize(source: string, language: string | null | undefined): Token[];
+export declare function listLanguages(): string[];
+export declare function resolveLanguage(alias: string | null | undefined): string | null;
+export declare function getGrammar(name: string | null | undefined): Grammar | undefined;
+/**
+ * Register a custom grammar.
+ *
+ * Seeds first, so a consumer registering `json` deliberately overrides the
+ * built-in rather than being silently overwritten by it on the next call that
+ * happens to seed.
+ */
+export declare function registerGrammar(grammar: Grammar): void;
+export { checkCoverage } from "./tokenize";
+export { defineGrammar } from "./registry";
+export type { Token, TokenType, Grammar, Rule, TokenizeContext } from "./types";

package/dist/types/lib/syntax/languages/bash.d.ts

@@ -0,0 +1 @@
+export declare const bash: import("..").Grammar;

package/dist/types/lib/syntax/languages/css.d.ts

@@ -0,0 +1 @@
+export declare const css: import("..").Grammar;

package/dist/types/lib/syntax/languages/html.d.ts

@@ -0,0 +1,17 @@
+import type { Rule } from "../types";
+/** Reads one attribute out of the raw attribute run of an opening tag. */
+export declare function attrValue(attrs: string, name: string): string | null;
+/** The language a `<script>` block's attributes ask for. */
+export declare function scriptLang(attrs: string): string;
+/** The language a `<style>` block's attributes ask for. */
+export declare function styleLang(attrs: string): string;
+/**
+ * The tag-interior states, shared with the Vue grammar so a directive like
+ * `@click` or `:prop` is understood identically in both. Returned fresh per
+ * grammar — `defineGrammar` rewrites every pattern, so sharing rule OBJECTS
+ * between two grammars would work only by luck.
+ */
+export declare function markupStates(): Record<string, Rule[]>;
+/** The `<script>` / `<style>` embed rules, shared with Vue's own root. */
+export declare function embedRules(scriptUntil: RegExp, styleUntil: RegExp): Rule[];
+export declare const html: import("..").Grammar;

package/dist/types/lib/syntax/languages/index.d.ts

@@ -0,0 +1,33 @@
+import type { Grammar } from "../types";
+import { bash } from "./bash";
+import { css } from "./css";
+import { html } from "./html";
+import { javascript, jsx, tsx, typescript } from "./javascript";
+import { markdown } from "../markdown/grammar";
+import { json } from "./json";
+import { mongodb } from "./mongodb";
+import { plain } from "./plain";
+import { mysql, postgresql, sql } from "./sql";
+import { vue } from "./vue";
+import { yaml } from "./yaml";
+/**
+ * Every grammar, as a VALUE. `src/lib/syntax/index.ts` iterates this list to
+ * seed the registry at module load.
+ *
+ * It is a list rather than each module registering itself on import, because
+ * `package.json` declares `sideEffects: ["*.css"]` — which tells every bundler
+ * that a bare `import "./javascript"` is safe to delete, and esbuild does. That
+ * is exactly how this project once shipped an empty icon registry (CAV-11).
+ *
+ * Order is not significant: an embedded language is resolved through
+ * `getGrammar` when the region is scanned, not when the grammar is defined, so
+ * `vue` may reference `css` regardless of which was registered first.
+ *
+ * Markdown is imported from its own module rather than its barrel: the barrel
+ * also exports the React renderer, and the tokenizer must stay usable without
+ * React in the graph.
+ *
+ * Adding a language: write the grammar, add it here. Nothing else.
+ */
+export declare const LANGUAGES: Grammar[];
+export { plain, json, yaml, markdown, javascript, typescript, jsx, tsx, html, css, sql, mysql, postgresql, mongodb, bash, vue };

package/dist/types/lib/syntax/languages/javascript.d.ts

@@ -0,0 +1,22 @@
+import type { Rule } from "../types";
+export interface JsFlavour {
+    /** TypeScript keywords and primitive type names. */
+    ts: boolean;
+    /** JSX element rules. See the JSX-IS-OPT-IN note above. */
+    jsx: boolean;
+}
+/**
+ * The complete state machine, rebuilt per grammar.
+ *
+ * A FUNCTION, NOT A SHARED CONSTANT: `defineGrammar` rewrites every pattern
+ * (sticky + hasIndices), and two grammars handing it the same rule objects
+ * would work only by accident. Fresh objects make that impossible to get wrong.
+ *
+ * `prefix` rules are spliced in ahead of everything else in the shared rule
+ * body, which is how MongoDB adds `$gte` without re-deriving JavaScript.
+ */
+export declare function jsStates(flavour: JsFlavour, prefix?: Rule[]): Record<string, Rule[]>;
+export declare const javascript: import("..").Grammar;
+export declare const typescript: import("..").Grammar;
+export declare const jsx: import("..").Grammar;
+export declare const tsx: import("..").Grammar;

package/dist/types/lib/syntax/languages/json.d.ts

@@ -0,0 +1 @@
+export declare const json: import("..").Grammar;

package/dist/types/lib/syntax/languages/mongodb.d.ts

@@ -0,0 +1 @@
+export declare const mongodb: import("..").Grammar;

package/dist/types/lib/syntax/languages/plain.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The identity grammar: everything is text.
+ *
+ * It exists so "no highlighting" is a REGISTERED language rather than a missing
+ * one. A picker can offer it, a fence can name it, and the editor behaves
+ * identically — only the colours are absent. Without it, "plain" and "the
+ * language you asked for does not exist" would be indistinguishable states.
+ */
+export declare const plain: import("..").Grammar;

package/dist/types/lib/syntax/languages/sql.d.ts

@@ -0,0 +1,4 @@
+import type { Grammar } from "../types";
+export declare const sql: Grammar;
+export declare const mysql: Grammar;
+export declare const postgresql: Grammar;

package/dist/types/lib/syntax/languages/vue.d.ts

@@ -0,0 +1 @@
+export declare const vue: import("..").Grammar;

package/dist/types/lib/syntax/languages/yaml.d.ts

@@ -0,0 +1 @@
+export declare const yaml: import("..").Grammar;

package/dist/types/lib/syntax/markdown/frames.d.ts

@@ -0,0 +1,145 @@
+import type { MdAlign } from "./types";
+/** An absolute source range. Half-open, like everything else here. */
+export interface Range {
+    start: number;
+    end: number;
+}
+/**
+ * What a frame IS — everything the projector needs to build its element, and
+ * nothing about where it is. Position lives on the frame record, not here, so
+ * a frame description can be compared and tested without coordinates.
+ *
+ * These are deliberately FINER than `MdNode`. A table is one node and six frame
+ * kinds, because the pipes and the delimiter row have to land somewhere legal
+ * in a DOM table, and "somewhere legal" is a structural question the renderer's
+ * tree does not answer.
+ */
+export type Frame = {
+    kind: "paragraph";
+} | {
+    kind: "heading";
+    level: 1 | 2 | 3 | 4 | 5 | 6;
+} | {
+    kind: "code";
+    language: string | null;
+    fenced: boolean;
+    open: boolean;
+}
+/**
+ * The code INSIDE a fence or an indent — the lines a reader would copy, and
+ * nothing else.
+ *
+ * EXISTS FOR THE SAME REASON THE QUOTE'S BAR MOVED OFF THE QUOTE. A block
+ * owns the newline that ends it (see `endBlock`), so the outer `code` frame
+ * necessarily extends one line past its last character. Anything drawn on
+ * that outer frame — a background, a padding box — therefore paints an empty
+ * fragment underneath the code, which reads as a stray tinted stub. The body
+ * frame stops at the last code character, so the block's decoration has
+ * somewhere to live that the terminator is not inside.
+ *
+ * It is also what finally makes `<pre><code>` honest here: the fence lines
+ * stay in the `<pre>` where they belong, and the `<code>` holds only code.
+ *
+ * It carries the LANGUAGE because it, not its parent, is the frame whose
+ * content is the code — so it is the one the projector hands to a syntax
+ * highlighter. Keying that off the outer frame was the first version, and it
+ * tokenized the block's terminating newline and nothing else.
+ */
+ | {
+    kind: "codeBody";
+    language: string | null;
+} | {
+    kind: "quote";
+} | {
+    kind: "list";
+    ordered: boolean;
+    start: number;
+    tight: boolean;
+}
+/**
+ * `marker` is the item's OWN marker text — `-`, `*`, `3.`, `7)`.
+ *
+ * Carried because the marker is collapsed markup, so the view has to draw
+ * something in its place, and a CSS counter would draw the wrong thing: a
+ * list that starts at 3 renumbers to 1, and a list the author numbered
+ * `1. 1. 1.` (which markdown allows, and which many people write) renumbers
+ * to 1, 2, 3. The rendered marker should be what the document says.
+ */
+ | {
+    kind: "listItem";
+    checked: boolean | null;
+    marker: string;
+} | {
+    kind: "rule";
+} | {
+    kind: "frontmatter";
+    language: string;
+} | {
+    kind: "footnoteDef";
+    label: string;
+} | {
+    kind: "linkDef";
+} | {
+    kind: "table";
+} | {
+    kind: "tableRow";
+    header: boolean;
+} | {
+    kind: "tableCell";
+    header: boolean;
+    align: MdAlign | null;
+}
+/**
+ * A row's pipes and padding, and the whole delimiter row.
+ *
+ * EXISTS BECAUSE OF THE CARET CONTRACT, not for tidiness. Rule 1 says every
+ * source offset is a caret position, and a DOM table cannot hold text outside
+ * a cell — text placed directly in a `<tr>` gets an anonymous cell box the
+ * browser will not step into, which the arrow-key torture test caught as
+ * Right moving from offset 2 to offset 2. So the pipes get a cell of their
+ * own. It is hidden, not absent, which is the difference between a character
+ * the caret can reach and one it cannot.
+ */
+ | {
+    kind: "tableGutter";
+} | {
+    kind: "tableDelimiter";
+} | {
+    kind: "inline";
+} | {
+    kind: "emphasis";
+} | {
+    kind: "strong";
+} | {
+    kind: "strike";
+} | {
+    kind: "codeSpan";
+} | {
+    kind: "link";
+    href: string;
+    title?: string;
+} | {
+    kind: "image";
+    src: string;
+    alt: string;
+    title?: string;
+} | {
+    kind: "autolink";
+    href: string;
+} | {
+    kind: "footnoteRef";
+    label: string;
+} | {
+    kind: "hardBreak";
+};
+export type FrameKind = Frame["kind"];
+/** A frame as the projector receives it: what, where, and what it owns. */
+export interface FrameRecord {
+    frame: Frame;
+    start: number;
+    end: number;
+    /** Absolute source ranges holding this frame's own text. Empty = opaque. */
+    content: readonly Range[];
+    /** Emission order, which breaks ties between two frames at the same offset. */
+    seq: number;
+}

package/dist/types/lib/syntax/markdown/grammar.d.ts

@@ -0,0 +1 @@
+export declare const markdown: import("..").Grammar;

package/dist/types/lib/syntax/markdown/index.d.ts

@@ -0,0 +1,5 @@
+export { parseMarkdown, RE_FENCE } from "./parse";
+export { markdown } from "./grammar";
+export { MarkdownNodes, sanitizeHref } from "./render";
+export type { MdNode, MdInline, MdListItem, MdCell, MdAlign, MdCodeRenderer } from "./types";
+export { MarkdownRefProvider, RefText, type MarkdownRefProviderProps } from "./refs";

package/dist/types/lib/syntax/markdown/inline.d.ts

@@ -0,0 +1,21 @@
+import type { TokenType } from "../types";
+import { type Segments, type Sink } from "./spans";
+import type { MdInline } from "./types";
+export interface LinkRef {
+    href: string;
+    title?: string;
+}
+export type RefMap = ReadonlyMap<string, LinkRef>;
+/**
+ * Parses the joined text of `seg` between `from` and `to`, reporting spans to
+ * `sink` and returning the tree.
+ *
+ * `ambient` is the token type unclaimed text takes — `text` in a paragraph,
+ * `heading` inside a heading, `quote` inside a blockquote. Constructs override
+ * it, so `` `code` `` in a heading still reads as code.
+ */
+export declare function parseInline(seg: Segments, refs: RefMap, sink: Sink | undefined, ambient?: TokenType, from?: number, to?: number): MdInline[];
+/** Reference labels are case-insensitive and whitespace-collapsed. */
+export declare function normalizeRef(label: string): string;
+/** Flattens a subtree to its text — an image's alt attribute takes no markup. */
+export declare function plainText(nodes: MdInline[]): string;

package/dist/types/lib/syntax/markdown/parse.d.ts

@@ -0,0 +1,15 @@
+import { type Sink } from "./spans";
+import type { MdNode } from "./types";
+/** Exported so any other layer that needs to find the SAME fence boundaries
+    the parser itself will — e.g. `StreamingMarkdown`'s pre-parse balancing
+    pass — imports this instead of keeping a second copy of the pattern. */
+export declare const RE_FENCE: RegExp;
+/** The renderer's entry point: tree only, no token bookkeeping. */
+export declare function parseMarkdown(source: string): MdNode[];
+/**
+ * The shared entry point. `sink` is supplied only by the grammar; without it
+ * the span reporting compiles down to a handful of `undefined` checks.
+ */
+export declare function parseDocument(source: string, sink?: Sink): MdNode[];
+/** Heading anchors: lowercase, non-word runs to hyphens, trimmed. */
+export declare function slug(text: string): string;

package/dist/types/lib/syntax/markdown/refs.d.ts

@@ -0,0 +1,47 @@
+import { type ReactNode } from "react";
+import type { MdNode } from "./types";
+/**
+ * Pass stable references: a module-level `pattern` and a memoised (or module-level) `resolve` and
+ * `renderRef`. The provider's context value memoises on all three, so an inline arrow or a regex
+ * literal written in render makes every document beneath it re-collect its refs on each render.
+ */
+export interface MarkdownRefProviderProps<T> {
+    /**
+     * Matches ONE ref per match; the whole match is the ref. It must carry the
+     * `g` flag and should anchor its edges (`\b`) so `ADX-1` is not a `DX-1`.
+     */
+    pattern: RegExp;
+    /**
+     * Resolves a batch of distinct refs to the ones that exist. A ref missing
+     * from the answer renders as text. It should honour `signal`, which aborts
+     * when the text that asked unmounts. A rejection is not swallowed.
+     */
+    resolve: (refs: string[], signal: AbortSignal) => Promise<ReadonlyMap<string, T>>;
+    /** Draws one resolved ref — the app's router link. */
+    renderRef: (ref: string, resolved: T) => ReactNode;
+    children?: ReactNode;
+}
+/** What a document that holds refs draws them with. */
+export interface RefLinks {
+    pattern: RegExp;
+    resolved: ReadonlyMap<string, unknown>;
+    renderRef: (ref: string, resolved: unknown) => ReactNode;
+}
+/** Provided by a rendered document to its inlines: the resolved refs, or none. */
+export declare const RefLinksContext: import("react").Context<RefLinks | null>;
+/** Makes ref linking available to every `Markdown`, `MarkdownNodes` and `RefText` beneath it. */
+export declare function MarkdownRefProvider<T>({ pattern, resolve, renderRef, children }: MarkdownRefProviderProps<T>): import("react").JSX.Element;
+/**
+ * The refs of one document, resolved. `null` with no provider above, which is
+ * how "no provider: nothing changes" holds.
+ */
+export declare function useRefLinks(source: string | readonly MdNode[]): RefLinks | null;
+/** `text` with each resolved ref drawn by the app; the text itself when there is nothing to draw. */
+export declare function linkRefs(text: string, links: RefLinks | null): ReactNode;
+/**
+ * Plain (non-markdown) card text with its refs linked: a one-line statement, a
+ * for/against note. With no provider it is the string.
+ */
+export declare function RefText({ children }: {
+    children: string;
+}): import("react").JSX.Element;

package/dist/types/lib/syntax/markdown/render.d.ts

@@ -0,0 +1,25 @@
+import { type ReactNode } from "react";
+import type { MdCodeRenderer, MdNode } from "./types";
+export interface MarkdownNodesProps {
+    nodes: MdNode[];
+    /** How a fenced block renders. Supplied by the consumer to avoid a cycle. */
+    renderCode: MdCodeRenderer;
+}
+/**
+ * The document. It owns the resource-ref scope (DXUI-32): the refs of the whole
+ * tree are collected and resolved once here, and every inline beneath reads the
+ * answer from context. Nested block lists (quote, list item, footnote) use
+ * `Blocks`, so a document is one scope however deeply it nests.
+ */
+export declare function MarkdownNodes({ nodes, renderCode }: MarkdownNodesProps): ReactNode;
+/**
+ * RULE TWO, the implementation: a link's scheme is checked before it is
+ * rendered.
+ *
+ * `[click](javascript:fetch('/api/keys').then(…))` is a working attack against
+ * every renderer that passes href through untouched, and `data:text/html` is
+ * the same hole wearing a different scheme. Anything not on the allowed list
+ * returns null, and the caller renders the label as plain text rather than
+ * dropping it — silently swallowing it would hide the attempt.
+ */
+export declare function sanitizeHref(href: string): string | null;

package/dist/types/lib/syntax/markdown/spans.d.ts

@@ -0,0 +1,84 @@
+import type { TokenType } from "../types";
+import type { Frame, Range } from "./frames";
+/** A run of source text with the absolute offset of its first character. */
+export interface Piece {
+    text: string;
+    start: number;
+}
+/**
+ * Pieces joined into one string for the inline scanner, plus the map back.
+ *
+ * The `"\n"` inserted BETWEEN pieces is synthetic — in the source those two
+ * lines may be separated by a newline plus a `> ` prefix, or by nothing at all.
+ * It is deliberately covered by no part, so a span crossing it maps to two
+ * source ranges and the prefix in between is left for the caller to have
+ * already claimed.
+ */
+export interface Segments {
+    text: string;
+    parts: ReadonlyArray<{
+        ja: number;
+        jb: number;
+        sa: number;
+    }>;
+}
+export declare function makeSegments(pieces: Piece[]): Segments;
+/** One line of prose is the common case; spelled out so callers do not build a
+    single-element array by hand at forty call sites. */
+export declare function segmentOf(piece: Piece): Segments;
+/**
+ * Maps a joined-text range to the absolute source ranges it covers.
+ *
+ * Returns several ranges when the span crosses a piece boundary, and none when
+ * it falls entirely on a synthetic separator.
+ */
+export declare function mapRange(seg: Segments, a: number, b: number): Array<{
+    start: number;
+    end: number;
+}>;
+/**
+ * Where the parser reports what it consumed.
+ *
+ * `span` takes ABSOLUTE source offsets — never joined-text ones — because a
+ * token that is right relative to some intermediate string is a token the
+ * editor cannot use. `embed` is the entire nesting feature for markdown: the
+ * grammar forwards it to `ctx.sub`, and a fenced block gets highlighted in its
+ * own language with no code anywhere that knows which language that is.
+ */
+export interface Sink {
+    span(start: number, end: number, type: TokenType): void;
+    embed(code: string, language: string | null, at: number): void;
+    /**
+     * Opens a structural frame. `content` names the absolute source ranges this
+     * frame holds as its own TEXT; omitting it means the frame is opaque and its
+     * children claim what they need. See ./frames.ts for why that default.
+     *
+     * Required rather than optional so a new consumer cannot silently receive
+     * spans without structure — the grammar, which genuinely wants only spans,
+     * says so with an explicit no-op rather than by omission.
+     */
+    open(frame: Frame, start: number, content?: readonly Range[]): void;
+    /**
+     * Closes the innermost frame. `content` adds ranges the frame could not know
+     * at open time — in practice its own trailing line terminator, which is not
+     * known until the reader has found where the block ends.
+     */
+    close(end: number, content?: readonly Range[]): void;
+}
+/**
+ * The source ranges a `Segments` covers — its parts, in absolute coordinates.
+ *
+ * This is the whole reason frames could reuse the existing bookkeeping: a
+ * block's content ranges are ALREADY computed, as the pieces it cut its
+ * prefixes off to build. Deriving them a second time is how the two would drift.
+ */
+export declare function contentOf(seg: Segments): Range[];
+/** The absolute range spanned by a joined-text range, prefixes included.
+ *
+ *  Deliberately the OUTER hull rather than the list `mapRange` returns: a
+ *  frame's interval must contain the `> ` prefixes sitting between its pieces,
+ *  or the frames those prefixes belong to would not nest inside it. The pieces
+ *  themselves are what `contentOf`/`mapRange` report; this is the envelope. */
+export declare function hullOf(seg: Segments, a: number, b: number): Range | null;
+/** Reports a joined-text range, split across pieces, at one token type. */
+export declare function markRange(seg: Segments, sink: Sink | undefined, a: number, b: number, type: TokenType): void;

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

@@ -0,0 +1,108 @@
+import type { ReactNode } from "react";
+/**
+ * The markdown tree.
+ *
+ * WHY MARKDOWN GETS A PARSER AND EVERY OTHER LANGUAGE GETS A RULE STACK. The
+ * scanner decides what a character means from the rules in force AT THAT
+ * POSITION. Markdown decides from block structure that is only knowable later:
+ * whether a line is a paragraph or a lazy continuation of the list item above
+ * it depends on its indentation relative to a marker several lines back, and
+ * whether `---` is a thematic break or the underline of a setext heading
+ * depends on what follows. No positional rule stack can see either.
+ *
+ * So markdown parses properly into this tree — and then emits the same flat
+ * `Token[]` as everything else, so the editor highlights it with no special
+ * case anywhere. One parse, two consumers: the renderer reads the tree, the
+ * highlighter reads the tokens.
+ */
+export type MdNode = {
+    kind: "paragraph";
+    children: MdInline[];
+} | {
+    kind: "heading";
+    level: 1 | 2 | 3 | 4 | 5 | 6;
+    id: string;
+    children: MdInline[];
+} | {
+    kind: "code";
+    language: string | null;
+    code: string; /** unclosed fence, still typing */
+    open: boolean;
+} | {
+    kind: "quote";
+    children: MdNode[];
+} | {
+    kind: "list";
+    ordered: boolean;
+    start: number;
+    tight: boolean;
+    items: MdListItem[];
+} | {
+    kind: "table";
+    head: MdCell[];
+    rows: MdCell[][];
+    align: (MdAlign | null)[];
+} | {
+    kind: "rule";
+} | {
+    kind: "frontmatter";
+    language: string;
+    body: string;
+} | {
+    kind: "footnotes";
+    items: Array<{
+        label: string;
+        children: MdNode[];
+    }>;
+};
+export type MdAlign = "left" | "center" | "right";
+export interface MdListItem {
+    /** null for a plain bullet; true/false for a task list checkbox. */
+    checked: boolean | null;
+    children: MdNode[];
+}
+export interface MdCell {
+    children: MdInline[];
+}
+export type MdInline = {
+    kind: "text";
+    value: string;
+} | {
+    kind: "code";
+    value: string;
+} | {
+    kind: "emphasis";
+    children: MdInline[];
+} | {
+    kind: "strong";
+    children: MdInline[];
+} | {
+    kind: "strike";
+    children: MdInline[];
+} | {
+    kind: "link";
+    href: string;
+    title?: string;
+    children: MdInline[];
+} | {
+    kind: "image";
+    src: string;
+    alt: string;
+    title?: string;
+} | {
+    kind: "footnoteRef";
+    label: string;
+} | {
+    kind: "break";
+};
+/**
+ * How a fenced block is rendered. The markdown renderer must NOT import the
+ * `Code` component — `Code` renders markdown, so that import is a cycle. The
+ * consumer supplies the renderer instead, which also means a chat message and
+ * a docs page can present the same fence differently.
+ */
+export type MdCodeRenderer = (block: {
+    language: string | null;
+    code: string;
+    open: boolean;
+}) => ReactNode;