docblocks-react-ui 0.0.0-stage → 0.1.1

package/dist/index-YJcgf8Hh.d.mts

@@ -0,0 +1,39 @@
+import { ComponentType, ReactNode } from "react";
+import { Block, BlockId, BlockType, Doc, TextRun } from "docblocks-core";
+//#region src/blocks/renderers.d.ts
+/** The props a block renderer receives: the block id and its plain snapshot. */
+interface BlockRendererProps {
+  id: BlockId;
+  block: Block;
+}
+/**
+ * A consumer renderer for a block type; resolved in place of the built-in
+ * renderer. Replacing a text-editable type swaps the whole block view,
+ * including the wrapper, the contenteditable element, and its editing
+ * affordance — a renderer that needs editing drives the core commands
+ * through the hooks (the consumer builds its own UI on top of them).
+ *
+ * The built-in text renderers read the per-block context (the page
+ * context — the root, a table cell, or a frame — and the flat page
+ * sequence) for the keyboard gestures; a consumer renderer does not read
+ * it — the context is part of the built-in rendering, not of the renderer
+ * contract. Nesting is a derived notion (the flat page model: a block's
+ * `indent` attr relative to its preceding block, not a data field), so a
+ * replaced block does not receive its derived nested content — the
+ * sequence rendering stands a block's deeper followers as a nested slot
+ * AFTER the replaced view (the content is never dropped); a renderer that
+ * wants to render them itself drives the doc through the hooks.
+ *
+ * A renderer is a plain render function, not a component: it is invoked
+ * during the block view's render, so it must not call hooks itself —
+ * return a component's output from a wrapper component if needed.
+ */
+type BlockRenderer = (props: BlockRendererProps) => ReactNode;
+/**
+ * Per-instance consumer renderers, keyed by block type. A type without an
+ * entry keeps its built-in renderer; a type with neither renders the
+ * placeholder (future block types keep working).
+ */
+type BlockRendererMap = Partial<Record<BlockType, BlockRenderer>>;
+//#endregion
+export { BlockRendererMap as n, BlockRendererProps as r, BlockRenderer as t };

package/dist/index.d.mts

@@ -0,0 +1,388 @@
+import { n as BlockRendererMap, r as BlockRendererProps, t as BlockRenderer } from "./index-YJcgf8Hh.mjs";
+import { n as EditorView, t as Editor } from "./Editor-DT7RkRXf.mjs";
+import { $ as TableEnvelopeBase, A as DomainEvent, B as ProtocolCapability, C as BridgeColumnAnnotation, D as CellValueParse, E as CellMap, F as MutationContext, G as Revision, H as ProtocolLimits, I as MutationReceipt, J as SortInput, K as RowPage, L as OperationStatus, M as FilterInput, N as Id, O as Column, P as IsoInstant, Q as TableDescription, R as PageQuery, S as BridgeColumn, T as BridgeValueInput, U as QueryOperator, V as ProtocolDescriptor, W as QuerySemantics, X as SubscriptionObserver, Y as SubscriptionHandle, Z as SubscriptionStatus, _ as UseDatabaseTable, a as EditorContextValue, at as BridgeErrorCode, b as FilterBuilder, c as EmbedSandboxPolicy, ct as toBridgeError, d as PdfPreview, dt as BlobStore, et as TableEvent, f as PdfPreviewProps, ft as BlobSubtype, g as DatabaseTableRow, h as DatabaseTablePhase, i as AccessLevel, it as BridgeError, j as FilterConditionInput, k as DatabaseBridge, l as MentionEntry, lt as BlobMeta, m as useDatabaseTable, mt as createMemoryBlobStore, n as DEFAULT_EMBED_SANDBOX, nt as TableSnapshot, o as EditorMode, ot as isBridgeError, p as SyncEmbedResolver, pt as blobSubtypeOf, q as RowWire, r as EditorProvider, rt as BRIDGE_ERROR_CODES, s as EditorProviderProps, st as isBridgeErrorCode, t as useEditorContext, tt as TableRef, u as MentionProvider, ut as BlobRef, v as emptyFilter, w as BridgeTableDescription, x as BatchOp, y as filterIsComplete, z as PageSnapshot } from "./index-D6_ysSmQ.mjs";
+import * as React from "react";
+import { ComponentType, ReactNode } from "react";
+import { Block, BlockId, BlockType, Doc, DocMeta, PresenceState, Selection, SelectionView, SyncEmbedRef, TextRun } from "docblocks-core";
+import { VariantProps } from "class-variance-authority";
+import { ClassValue } from "clsx";
+import { DayPicker } from "react-day-picker";
+import * as CheckboxPrimitive from "@radix-ui/react-checkbox";
+import * as PopoverPrimitive from "@radix-ui/react-popover";
+import * as SeparatorPrimitive from "@radix-ui/react-separator";
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+import * as SelectPrimitive from "@radix-ui/react-select";
+import * as TabsPrimitive from "@radix-ui/react-tabs";
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+//#region src/database/bridge/annotation.d.ts
+/** The standard PostgreSQL type names per operator / input group. The contract
+ *  is type-agnostic — this is the package's DEFAULT catalog; a non-standard
+ *  type name falls back to the minimal `is` / `is not` + the text input, and
+ *  the consumer's `operators` override always wins. */
+declare const TEXT_TYPES: Set<string>;
+/**
+ * Builds the column annotation from the `BridgeColumn`: the operator
+ * catalog (the consumer's `operators` override, else the option-based
+ * catalog for the option columns, else the package default for the
+ * Postgres type, else the minimal `is` / `is not`) + the value input
+ * kind. The filter builder renders from this; `snapshotTable` / `queryNextPage` must apply
+ * exactly the declared operators.
+ */
+declare function columnAnnotation(column: BridgeColumn): BridgeColumnAnnotation;
+//#endregion
+//#region src/database/bridge/filter.d.ts
+/**
+ * Validates a raw (string) value against the value input kind before it is
+ * written to the row (the number must parse, the date / datetime must be a
+ * real date). The empty string is a valid "clear" (null). text / enum /
+ * row-link / boolean pass through (the browser input / the picker
+ * already constrains them).
+ */
+declare function parseCellValue(kind: BridgeValueInput, raw: string): CellValueParse;
+/** Evaluates one filter condition against a cell value. */
+declare function conditionMatches(op: string, value: unknown, expected: unknown): boolean;
+//#endregion
+//#region src/database/bridge/protocol.d.ts
+/** The protocol's version. */
+declare const PROTOCOL_VERSION = 2;
+/** The capabilities every conformant bridge declares (the baseline:
+ *  the ordered rows, the snapshot → replay bootstrap, the idempotent
+ *  writes, the structured errors, and the view invalidation). */
+declare const BASELINE_CAPABILITIES: readonly ["orderedRows", "snapshotReplay", "idempotentWrites", "structuredErrors", "viewInvalidation"];
+/** The bridge's guard (a pre-contract bridge object stands none of the discriminators). */
+declare function isDatabaseBridge(candidate: unknown): candidate is DatabaseBridge;
+/**
+ * Validates the negotiated descriptor: the protocol version 2 + every
+ * baseline capability. Returns the capability set the UI gates its
+ * optional paths on (the `rowRestore` / `columnRestore` / `mixedBatch` /
+ * `cas` / `serverSort` stands). A mismatched version or a missing baseline
+ * capability rejects with `protocol_mismatch`.
+ */
+declare function validateProtocolDescriptor(descriptor: ProtocolDescriptor): Set<ProtocolCapability>;
+//#endregion
+//#region src/database/use-database-table/utils.d.ts
+/** The cell-value equality (null / undefined stand as the empty cell). */
+declare function cellValueEqual(current: unknown, next: unknown): boolean;
+/** The write's context: the fresh client-issued operation id (a UUID,
+ *  unique within the retention) + the issue time. Every user action stands
+ *  a fresh `operationId` — the id is never reused across logical
+ *  operations, and a failed write is reconciled by the SAME id (the
+ *  bridge's idempotency), never a silent new one. */
+declare function newMutationContext(): MutationContext;
+//#endregion
+//#region src/canvas/text-fonts.d.ts
+/**
+ * The shape text's font options: the
+ * self-hosted set (the package ships the woff2 in fonts/ + the
+ * @font-face in the assembled stylesheet's section 5) — each with a
+ * Cyrillic-capable fallback in the stack (a file / family missing on
+ * the consumer's side degrades to the fallback, not to invisible).
+ *
+ * The weight coverage per family follows the family's available weights
+ * (PT Sans stands 700 over the 600, Lora / PT Serif stand 400 over the
+ * 300 — the browser's font matching picks the nearest stand).
+ */
+declare const SHAPE_FONT_OPTIONS: readonly [{
+  readonly id: "Inter";
+  readonly label: "Inter";
+  readonly stack: "'Inter', 'Open Sans', Arial, sans-serif";
+}, {
+  readonly id: "Open Sans";
+  readonly label: "Open Sans";
+  readonly stack: "'Open Sans', Arial, sans-serif";
+}, {
+  readonly id: "PT Sans";
+  readonly label: "PT Sans";
+  readonly stack: "'PT Sans', 'Open Sans', Arial, sans-serif";
+}, {
+  readonly id: "Lora";
+  readonly label: "Lora";
+  readonly stack: "'Lora', Georgia, 'Times New Roman', serif";
+}, {
+  readonly id: "PT Serif";
+  readonly label: "PT Serif";
+  readonly stack: "'PT Serif', Georgia, 'Times New Roman', serif";
+}, {
+  readonly id: "JetBrains Mono";
+  readonly label: "JetBrains Mono";
+  readonly stack: "'JetBrains Mono', 'Courier New', monospace";
+}];
+/** The name → the stack map (the absent / an unrecognized name falls to
+ * the raw name — a consumer's own loaded font is addressable by name). */
+declare const SHAPE_FONT_STACKS: Record<string, string>;
+//#endregion
+//#region src/DocHeader.d.ts
+declare function DocHeader({ doc, view, onViewChange, accessLevel, mode, onModeChange, publishedDoc }: {
+  /** The headless document (the consumer's own stand: the live doc over the editor's stand, the published snapshot over the viewer's stand — the reader's browser never holds the live document). */
+  doc?: Doc;
+  view: EditorView;
+  onViewChange: (view: EditorView) => void;
+  /** The consumer's user access level (the switcher's gate): a "viewer" stands the published's mode forced (the switcher stands no stand); an "editor" (the default) may switch the modes. */
+  accessLevel?: AccessLevel;
+  /** The current document mode (consumer-controlled, like `view`): the switcher's value over the "editor"'s level. */
+  mode?: EditorMode;
+  /** The mode's change (the consumer owns the state, like `onViewChange`): the switcher's entry stands only over the callback's presence. */
+  onModeChange?: (mode: EditorMode) => void;
+  /** The published snapshot (the meta's source over the published's stand; the "Published"'s option stands disabled over its absence). */
+  publishedDoc?: Doc | null;
+}): import("react").JSX.Element;
+//#endregion
+//#region src/hooks.d.ts
+/** The headless document owned by the nearest EditorProvider. */
+declare function useDoc(): Doc;
+/**
+ * The block snapshot at id; undefined when the block is missing (e.g.
+ * removed by a peer). Selecting the reference itself keeps consumers
+ * re-rendering only when the block actually changed.
+ */
+declare function useBlock(id: BlockId): Block | undefined;
+/**
+ * The flattened text of the block's runs. Read from the store (not via
+ * `doc.getText`) so the read participates in the store's reference
+ * stability: the selector re-runs on store changes, but consumers
+ * re-render only when the flattened text actually changes.
+ */
+declare function useText(id: BlockId): string;
+/** The local view selection; a separate slice so caret moves do not re-render block consumers. */
+declare function useSelection(): Selection;
+/** Remote peers' ephemeral state; a separate slice for the same reason. */
+declare function usePresence(): PresenceState[];
+/** The document meta; the reference is replaced only when the title changed. */
+declare function useMeta(): DocMeta;
+/**
+ * The per-instance selection view for setting selections and reading the
+ * local state; null before the mount effect ran and after unmount (the
+ * view is destroyed on unmount). Read it at event time (the render value
+ * only updates when the component re-renders), not in effects keyed on
+ * unrelated state.
+ */
+declare function useSelectionView(): SelectionView | null;
+//#endregion
+//#region src/editing/keyboard/models.d.ts
+/** The marks the format shortcuts and the mark toolbar toggle. */
+type FormatMark = "bold" | "italic" | "strike" | "underline" | "code";
+//#endregion
+//#region src/editing/keyboard/utils.d.ts
+/**
+ * The toggle decision for one mark over [from, to): "unset" when every run
+ * overlapping the range already carries the mark, "set" otherwise. A
+ * partially covered run counts only if it carries the mark. Reads the block
+ * snapshot via `getBlock`; the caller issues the command.
+ */
+declare function markToggleAction(doc: Doc, blockId: BlockId, from: number, to: number, mark: FormatMark): "set" | "unset";
+//#endregion
+//#region src/editing/format-toolbar/constants.d.ts
+/** The default format palette: the shared palette's seven pastel theme
+ * tokens + the theme's own background token (a consumer can pass its own
+ * through the editor's `formatPalette` prop — a `string[]` of hex or var). */
+declare const FORMAT_PALETTE: readonly string[];
+//#endregion
+//#region src/text/runs.d.ts
+/**
+ * Render inline text runs with their marks (lenient reader contract:
+ * unknown marks are ignored and the text is kept). The link's href is
+ * gated over the public contract (the remote input is not validated —
+ * an unsafe scheme stands the plain text, never the raw <a>).
+ */
+declare function renderRuns(runs: TextRun[]): ReactNode;
+//#endregion
+//#region src/fonts.d.ts
+/**
+ * The package's font subsystem — the single place for the package's fonts.
+ *
+ * One self-hosted set (the woff2 in `fonts/`; the @font-face declarations in
+ * the assembled stylesheet's last section, `fonts/shape-fonts.css`) — a file
+ * is fetched only for the used family / weight / subset via `unicode-range`.
+ *
+ * Three roles share the set:
+ * - The UI default font (the editor's chrome + the page text) — `Inter`,
+ *   the `--docblocks-font-family` token's default (the consumer's
+ *   `--font-sans` override takes priority — the token contract is unchanged).
+ * - The shape text's font options (`SHAPE_FONT_OPTIONS` — the shape
+ *   `fontFamily` attr's catalog; a consumer's own loaded font is addressable
+ *   by its raw name — the absent / an unrecognized name falls to the raw name).
+ * - The mono font (the code block) — the `--docblocks-mono-
+ *   font-family` token's default (the consumer's `--font-mono` override takes
+ *   priority).
+ *
+ * Adding a font:
+ * 1. Drop the woff2 in `fonts/` under the `<family>-<weight><i?>-<l|c>.woff2`
+ *    naming (l = latin, c = cyrillic).
+ * 2. Add the @font-face declarations to `fonts/shape-fonts.css` (a
+ *    unicode-range per subset, so a subset is fetched only when used).
+ * 3. If the font is a shape option, add it to `SHAPE_FONT_OPTIONS` — the
+ *    `SHAPE_FONT_STACKS` map derives from it.
+ * The build (`scripts/assemble-styles.mjs`) copies `fonts/` to `dist/fonts/`
+ * and appends the @font-face section to the shipped stylesheet.
+ */
+/** The UI default font's name (self-hosted — the shape set's own Inter). */
+declare const UI_FONT_ID = "Inter";
+/**
+ * The UI default font's stack: the self-hosted Inter first, then the system
+ * fallbacks (a consumer without the package's stylesheet degrades to the
+ * system font, not to nothing). Stands the `--docblocks-font-family` token's
+ * default.
+ */
+declare const UI_FONT_STACK = "'Inter', system-ui, -apple-system, 'Segoe UI', sans-serif";
+/**
+ * The mono default's stack (the code block). Stands the
+ * `--docblocks-mono-font-family` token's default.
+ */
+declare const MONO_FONT_STACK = "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace";
+//#endregion
+//#region src/shared/ui/Alert.d.ts
+declare const alertVariants: (props?: ({
+  variant?: "default" | "destructive" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function Alert({ className, variant, ...props }: React.ComponentProps<"div"> & VariantProps<typeof alertVariants>): React.JSX.Element;
+declare function AlertTitle({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function AlertDescription({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+//#endregion
+//#region src/shared/ui/Badge.d.ts
+declare const badgeVariants: (props?: ({
+  variant?: "default" | "destructive" | "outline" | "secondary" | "custom" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function Badge({ className, variant, asChild, ...props }: React.ComponentProps<"span"> & VariantProps<typeof badgeVariants> & {
+  asChild?: boolean;
+}): React.JSX.Element;
+//#endregion
+//#region src/shared/ui/BareSelect.d.ts
+declare function BareSelect({ className, children, ...props }: React.ComponentProps<"select">): React.JSX.Element;
+//#endregion
+//#region src/shared/ui/Button.d.ts
+declare const buttonVariants: (props?: ({
+  variant?: "link" | "default" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
+  size?: "default" | "icon" | "sm" | "lg" | "xl" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function Button({ className, variant, size, asChild, type, ...props }: React.ComponentProps<"button"> & VariantProps<typeof buttonVariants> & {
+  asChild?: boolean;
+}): React.JSX.Element;
+//#endregion
+//#region src/shared/ui/Card.d.ts
+declare function Card({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardHeader({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardTitle({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardDescription({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardAction({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardContent({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardFooter({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+//#endregion
+//#region src/shared/ui/Checkbox.d.ts
+declare function Checkbox({ className, ...props }: React.ComponentProps<typeof CheckboxPrimitive.Root>): React.JSX.Element;
+//#endregion
+//#region src/shared/ui/DropdownMenu.d.ts
+declare function DropdownMenu({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Root>): React.JSX.Element;
+declare function DropdownMenuPortal({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Portal>): React.JSX.Element;
+declare function DropdownMenuTrigger({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Trigger>): React.JSX.Element;
+declare function DropdownMenuContent({ className, sideOffset, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Content>): React.JSX.Element;
+declare function DropdownMenuGroup({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Group>): React.JSX.Element;
+declare function DropdownMenuItem({ className, inset, variant, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Item> & {
+  inset?: boolean;
+  variant?: "default" | "destructive";
+}): React.JSX.Element;
+declare function DropdownMenuCheckboxItem({ className, children, checked, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.CheckboxItem>): React.JSX.Element;
+declare function DropdownMenuRadioGroup({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.RadioGroup>): React.JSX.Element;
+declare function DropdownMenuRadioItem({ className, children, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.RadioItem>): React.JSX.Element;
+declare function DropdownMenuLabel({ className, inset, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Label> & {
+  inset?: boolean;
+}): React.JSX.Element;
+declare function DropdownMenuSeparator({ className, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Separator>): React.JSX.Element;
+declare function DropdownMenuShortcut({ className, ...props }: React.ComponentProps<"span">): React.JSX.Element;
+declare function DropdownMenuSub({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Sub>): React.JSX.Element;
+declare function DropdownMenuSubTrigger({ className, inset, children, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.SubTrigger> & {
+  inset?: boolean;
+}): React.JSX.Element;
+declare function DropdownMenuSubContent({ className, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.SubContent>): React.JSX.Element;
+//#endregion
+//#region src/shared/ui/Input.d.ts
+declare const inputVariants: (props?: ({
+  size?: "default" | "sm" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+/**
+ * The input's props: the native input props minus the native `size`
+ * attribute (the number) — it would collide with the size variant
+ * (`number & "sm" | "default"` collapses to `undefined`); the variant
+ * takes the name.
+ */
+type InputProps = Omit<React.ComponentProps<"input">, "size"> & VariantProps<typeof inputVariants>;
+declare function Input({ className, size, type, ...props }: InputProps): React.JSX.Element;
+//#endregion
+//#region src/shared/ui/Label.d.ts
+declare function Label({ className, ...props }: React.ComponentProps<"label">): React.JSX.Element;
+//#endregion
+//#region src/shared/ui/Popover.d.ts
+declare function Popover({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Root>): React.JSX.Element;
+declare function PopoverTrigger({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Trigger>): React.JSX.Element;
+declare function PopoverContent({ className, align, sideOffset, ...props }: React.ComponentProps<typeof PopoverPrimitive.Content>): React.JSX.Element;
+declare function PopoverAnchor({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Anchor>): React.JSX.Element;
+declare function PopoverHeader({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function PopoverTitle({ className, ...props }: React.ComponentProps<"h2">): React.JSX.Element;
+declare function PopoverDescription({ className, ...props }: React.ComponentProps<"p">): React.JSX.Element;
+//#endregion
+//#region src/shared/ui/Separator.d.ts
+declare function Separator({ className, orientation, decorative, ...props }: React.ComponentProps<typeof SeparatorPrimitive.Root>): React.JSX.Element;
+//#endregion
+//#region src/shared/ui/Select.d.ts
+declare function Select({ ...props }: React.ComponentProps<typeof SelectPrimitive.Root>): React.JSX.Element;
+declare function SelectGroup({ ...props }: React.ComponentProps<typeof SelectPrimitive.Group>): React.JSX.Element;
+declare function SelectValue({ ...props }: React.ComponentProps<typeof SelectPrimitive.Value>): React.JSX.Element;
+declare function SelectTrigger({ className, size, bare, children, ...props }: React.ComponentProps<typeof SelectPrimitive.Trigger> & {
+  size?: "sm" | "default";
+  /** The iconless trigger (the flat cell stand — the chevron is
+   *  hidden; the value / the placeholder stand alone). */
+  bare?: boolean;
+}): React.JSX.Element;
+declare function SelectContent({ className, children, position, ...props }: React.ComponentProps<typeof SelectPrimitive.Content>): React.JSX.Element;
+declare function SelectLabel({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.Label>): React.JSX.Element;
+declare function SelectItem({ className, children, ...props }: React.ComponentProps<typeof SelectPrimitive.Item>): React.JSX.Element;
+declare function SelectSeparator({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.Separator>): React.JSX.Element;
+declare function SelectScrollUpButton({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.ScrollUpButton>): React.JSX.Element;
+declare function SelectScrollDownButton({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.ScrollDownButton>): React.JSX.Element;
+//#endregion
+//#region src/shared/ui/ScrollArea.d.ts
+/**
+ * The thin-scrollbar scroll container: the native scrollbar styled to the
+ * theme's border color (`scrollbar-width: thin` + `scrollbar-color`), so a
+ * scrollable region never shows the browser's default bar. The focus ring
+ * stands for the keyboard scroll (the container takes the focus while a
+ * user scrolls it with the keys).
+ *
+ * React 19: the `ref` stands as a regular prop (ref-as-prop) — the consumer
+ * holds a DOM handle of the scroll element (the slash menu's active-item
+ * auto-scroll queries through it).
+ */
+declare function ScrollArea({ className, ref, ...props }: React.ComponentProps<"div"> & {
+  ref?: React.Ref<HTMLDivElement>;
+}): React.JSX.Element;
+//#endregion
+//#region src/shared/ui/Skeleton.d.ts
+declare function Skeleton({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+//#endregion
+//#region src/shared/ui/Tabs.d.ts
+/**
+ * The tabs primitive (Radix): a root with a list of triggers and the
+ * optional content panels. The root is controlled through `value` /
+ * `onValueChange` (or uncontrolled through `defaultValue`); the list
+ * carries the `default` (a muted pill) or the `line` variant (an
+ * underline under the active tab). The trigger's active state is the
+ * Radix `data-state="active"` attribute, styled through the
+ * `data-[state=active]:` classes.
+ */
+declare function Tabs({ className, orientation, ...props }: React.ComponentProps<typeof TabsPrimitive.Root>): React.JSX.Element;
+declare const tabsListVariants: (props?: ({
+  variant?: "line" | "default" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function TabsList({ className, variant, ...props }: React.ComponentProps<typeof TabsPrimitive.List> & VariantProps<typeof tabsListVariants>): React.JSX.Element;
+declare function TabsTrigger({ className, ...props }: React.ComponentProps<typeof TabsPrimitive.Trigger>): React.JSX.Element;
+declare function TabsContent({ className, ...props }: React.ComponentProps<typeof TabsPrimitive.Content>): React.JSX.Element;
+//#endregion
+//#region src/shared/ui/Tooltip.d.ts
+declare function TooltipProvider({ delayDuration, ...props }: React.ComponentProps<typeof TooltipPrimitive.Provider>): React.JSX.Element;
+declare function Tooltip({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Root>): React.JSX.Element;
+declare function TooltipTrigger({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Trigger>): React.JSX.Element;
+declare function TooltipContent({ className, sideOffset, children, ...props }: React.ComponentProps<typeof TooltipPrimitive.Content>): React.JSX.Element;
+//#endregion
+//#region src/shared/ui/cn.d.ts
+declare function cn(...inputs: ClassValue[]): string;
+//#endregion
+export { type AccessLevel, Alert, AlertDescription, AlertTitle, BASELINE_CAPABILITIES, BRIDGE_ERROR_CODES, Badge, BareSelect, type BatchOp, type BlobMeta, type BlobRef, type BlobStore, type BlobSubtype, type BlockRenderer, type BlockRendererMap, type BlockRendererProps, type BridgeColumn, type BridgeColumnAnnotation, BridgeError, type BridgeErrorCode, type BridgeTableDescription, type BridgeValueInput, Button, Card, CardAction, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, type CellMap, type CellValueParse, Checkbox, type Column, DEFAULT_EMBED_SANDBOX, type DatabaseBridge, type DatabaseTablePhase, type DatabaseTableRow, DocHeader, type DomainEvent, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, Editor, type EditorContextValue, type EditorMode, EditorProvider, type EditorProviderProps, type EditorView, type EmbedSandboxPolicy, FORMAT_PALETTE, FilterBuilder, type FilterConditionInput, type FilterInput, type FormatMark, type Id, Input, type IsoInstant, Label, MONO_FONT_STACK, type MentionEntry, type MentionProvider, type MutationContext, type MutationReceipt, type OperationStatus, PROTOCOL_VERSION, type PageQuery, type PageSnapshot, type PdfPreview, type PdfPreviewProps, Popover, PopoverAnchor, PopoverContent, PopoverDescription, PopoverHeader, PopoverTitle, PopoverTrigger, type ProtocolCapability, type ProtocolDescriptor, type ProtocolLimits, type QueryOperator, type QuerySemantics, type Revision, type RowPage, type RowWire, SHAPE_FONT_OPTIONS, SHAPE_FONT_STACKS, ScrollArea, Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, Separator, Skeleton, type SortInput, type SubscriptionHandle, type SubscriptionObserver, type SubscriptionStatus, type SyncEmbedRef, type SyncEmbedResolver, TEXT_TYPES, type TableDescription, type TableEnvelopeBase, type TableEvent, type TableRef, type TableSnapshot, Tabs, TabsContent, TabsList, TabsTrigger, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, UI_FONT_ID, UI_FONT_STACK, type UseDatabaseTable, badgeVariants, blobSubtypeOf, buttonVariants, cellValueEqual, cn, columnAnnotation, conditionMatches, createMemoryBlobStore, emptyFilter, filterIsComplete, isBridgeError, isBridgeErrorCode, isDatabaseBridge, markToggleAction, newMutationContext, parseCellValue, renderRuns, toBridgeError, useBlock, useDatabaseTable, useDoc, useEditorContext, useMeta, usePresence, useSelection, useSelectionView, useText, validateProtocolDescriptor };