@mrakomor/core 0.0.11 → 0.0.12

package/dist/types/plugin/list/List.d.mts

@@ -0,0 +1,61 @@
+/**
+ * Unwrap the selected list item as a text block (list → text namespace).
+ * Runs before default `transformBlockElement`; calls `preventDefault` so
+ * list `items` are not dropped. Text → list is now handled generically by
+ * default's `onTransformBlockElement` via `List.fromExchangeState`.
+ * @param {import('#src/types.mjs').EmitterEvent} event
+ */
+export function onTransformListItem(event: import("#src/types.mjs").EmitterEvent): void;
+/**
+ * Shared list plugin wiring for {@link List} and TTS subclasses.
+ * @param {typeof List} Block
+ * @returns {import('#src/types.mjs').Plugin}
+ */
+export function createListPlugin(Block: typeof List): import("#src/types.mjs").Plugin;
+/**
+ * Registers the list block (UL/OL insert-menu variants).
+ * @returns {import('#src/types.mjs').Plugin}
+ */
+export function listPlugin(): import("#src/types.mjs").Plugin;
+export class List extends BlockComponent {
+    static get LABEL(): string;
+    static getStateSchema(node: any): import("@esmj/schema").SchemaInterface<{
+        component: string;
+        componentId: string;
+        properties: {
+            items: import("#src/types.mjs").ListItem[];
+        };
+        settings: {
+            style: "ORDERED" | "UNORDERED";
+        };
+    }, {
+        component: string;
+        componentId: string;
+        properties: {
+            items: import("#src/types.mjs").ListItem[];
+        };
+        settings: {
+            style: "ORDERED" | "UNORDERED";
+        };
+    }>;
+    getInlineStyleComponents(): any;
+    getEntityRangeComponents(): any;
+    /**
+     * Splice `newState` in at this list's block index and write it via the
+     * shared `updateBlockAt()` (normalizes only this entry, writes through the
+     * internal `_setContentState()`) instead of the public `setContent()` —
+     * avoids re-normalizing every other block's possibly-stale live state.
+     * @param {import('#src/types.mjs').BlockState} newState
+     */
+    _commitState(newState: import("#src/types.mjs").BlockState): void;
+    _buildItemContent(item: any): DocumentFragment;
+    /**
+     * Each’s `tagName` is the list root (`ul`/`ol`), not a span inside it.
+     * `@esmj/dom` ≥0.3.3 applies `display:contents` only to the default span.
+     * @returns {HTMLElement}
+     */
+    render(): HTMLElement;
+    onKeydown(event: any): void;
+    #private;
+}
+import { BlockComponent } from '#src/component/block/BlockComponent.mjs';

package/dist/types/plugin/list/index.d.mts

@@ -0,0 +1 @@
+export { List, listPlugin } from "./List.mjs";

package/dist/types/plugin/list/listHelpers.d.mts

@@ -0,0 +1,166 @@
+/**
+ * @typedef {import('#src/types.mjs').BlockState} BlockState
+ * @typedef {import('#src/types.mjs').ListItem} ListItem
+ * @typedef {import('#src/types.mjs').ListBlockState} ListBlockState
+ * @typedef {import('#src/types.mjs').RichTextComponents} RichTextComponents
+ * @typedef {import('#src/types.mjs').UnwrapListResult} UnwrapListResult
+ */
+/**
+ * Map a list root tag to ORDERED / UNORDERED settings.style.
+ * @param {Element | null | undefined} node
+ * @returns {'ORDERED' | 'UNORDERED' | undefined}
+ */
+export function listStyleFromNode(node: Element | null | undefined): "ORDERED" | "UNORDERED" | undefined;
+/**
+ * Ensure Each keys stay unique even if CMS/DOM already duplicated ids.
+ * @param {ListItem[]} [items]
+ * @returns {ListItem[]}
+ */
+export function ensureUniqueListItemIds(items?: ListItem[]): ListItem[];
+/**
+ * Collect `<li>` nodes that are items of `listRoot`.
+ * List `Each` uses `{ tagName: 'ul' | 'ol' }`, so live items are direct
+ * `ul/ol > li`. Nested `<li>` inside an item (native-drag debris) is ignored.
+ * @param {Element | null | undefined} listRoot
+ * @returns {Element[]}
+ */
+export function directListItemElements(listRoot: Element | null | undefined): Element[];
+/**
+ * Character offset of the caret within a single list item.
+ * @param {Element} li
+ * @param {Range | null} range
+ * @returns {number}
+ */
+export function getCursorInListItem(li: Element, range: Range | null): number;
+/**
+ * Split a list item state at cursor (item shape, not full block state).
+ * @param {ListItem} itemState
+ * @param {number} cursor
+ * @returns {{ before: ListItem, after: ListItem }}
+ */
+export function splitListItemByCursor(itemState: ListItem, cursor: number): {
+    before: ListItem;
+    after: ListItem;
+};
+/**
+ * Wrap a text-shaped or items-shaped exchange state as a list. Prefers
+ * `exchangeState.properties.items` (per-item `text`/`inlineStyleRanges`/
+ * `entityRanges`/`depth`) when present, so a List → exchangeState → List
+ * round trip (future transform/merge) preserves rich text and nesting
+ * losslessly. Falls back to wrapping `properties.text` /
+ * `inlineStyleRanges` / `entityRanges` as a single item — used for a plain
+ * text block (paragraph/headline) transformed into a list, which has no
+ * `items`.
+ * @param {BlockState | import('#src/types.mjs').ExchangeBlockState | null | undefined} exchangeState
+ * @param {{ style?: 'ORDERED' | 'UNORDERED' }} [options]
+ * @returns {ListBlockState}
+ */
+export function wrapTextBlockAsList(exchangeState: BlockState | import("#src/types.mjs").ExchangeBlockState | null | undefined, { style }?: {
+    style?: "ORDERED" | "UNORDERED";
+}): ListBlockState;
+/**
+ * Lift one list item to a text block, splitting the list around it. When
+ * `Constructor` is given, the lifted item's exchange state is passed through
+ * `Constructor.fromExchangeState()` (same contract slash's
+ * `buildTargetBlockState` uses) so a target block type's own reshaping is
+ * honored; omit it (or when the caller has no registry access, e.g. these
+ * unit tests) to fall back to the plain text-block shape.
+ * @param {ListBlockState} listState
+ * @param {number} itemIndex
+ * @param {{ namespace?: string, Constructor?: import('#src/types.mjs').BlockConstructor }} [options] target text-block namespace (default paragraph) and its resolved constructor
+ * @returns {UnwrapListResult}
+ */
+export function unwrapListItem(listState: ListBlockState, itemIndex: number, { namespace, Constructor }?: {
+    namespace?: string;
+    Constructor?: import("#src/types.mjs").BlockConstructor;
+}): UnwrapListResult;
+/**
+ * @typedef {object} MergeListBlocksResult
+ * @property {BlockState[]} content
+ * @property {number} listIndex index of the merged list
+ * @property {number} cursor caret offset in the last merged item at the join
+ */
+/**
+ * List marker style used for merge compatibility (UL vs OL).
+ * @param {BlockState | null | undefined} state
+ * @returns {'ORDERED' | 'UNORDERED' | null}
+ */
+export function listBlockStyle(state: BlockState | null | undefined): "ORDERED" | "UNORDERED" | null;
+/**
+ * Whether two adjacent list blocks can merge (same list type).
+ * @param {BlockState | null | undefined} left
+ * @param {BlockState | null | undefined} right
+ * @returns {boolean}
+ */
+export function canMergeListBlocks(left: BlockState | null | undefined, right: BlockState | null | undefined): boolean;
+/**
+ * Append a list block onto the previous list: merge the first item into the
+ * last item of the previous list, then append the rest (Notion join).
+ * @param {BlockState[]} content
+ * @param {number} previousListIndex
+ * @param {number} currentListIndex
+ * @returns {MergeListBlocksResult | null}
+ */
+export function mergeListBlockIntoPreviousList(content: BlockState[], previousListIndex: number, currentListIndex: number): MergeListBlocksResult | null;
+/**
+ * Append an incoming exchange state onto a list's last item (Backspace merge
+ * join). Handles two shapes generically via `exchangeState.properties.items`:
+ * a flat text block (Paragraph/Headline) produces a single-item exchange
+ * state, so only the join happens; a same-style List/TtsList's own
+ * `toExchangeState()` produces a multi-item exchange state, so `items[0]`
+ * joins the last item and `items.slice(1)` are appended as new list items
+ * instead of being flattened away (Notion: re-merging a split list restores
+ * every item, not one concatenated line). Does NOT gate on list style —
+ * that compatibility check is scenario-specific (only the "empty separator
+ * between two lists" Backspace re-merge cares whether mixing ORDERED/
+ * UNORDERED is acceptable) and lives in the caller that owns that scenario
+ * (`onBackspaceMergeAdjacentLists` in `List.mjs`, via `canMergeListBlocks`),
+ * not in this generic append primitive — a future caller (e.g. a
+ * user-triggered "merge into" action) may legitimately want to merge across
+ * styles. Pure state transform — no content-array indexing/splicing; the
+ * caller (`List.appendExchangeState`, itself called generically by
+ * default's `onMergeBlockElement` and the empty-block-removal Backspace
+ * path) owns array mutation. Returns `null` when the list has no items to
+ * append onto. The result's `itemIndex` names the joined item — needed
+ * because when extra items are appended, the joined item is no longer the
+ * list's last item, and `List.setCursor({ cursor })` alone can only target
+ * the last one.
+ * @param {ListBlockState} listState
+ * @param {import('#src/types.mjs').ExchangeBlockState} exchangeState
+ * @returns {{ state: ListBlockState, cursor: number, itemIndex: number } | null}
+ */
+export function mergeTextBlockIntoLastListItem(listState: ListBlockState, exchangeState: import("#src/types.mjs").ExchangeBlockState): {
+    state: ListBlockState;
+    cursor: number;
+    itemIndex: number;
+} | null;
+/**
+ * Build rich-text DOM fragment for one list item.
+ * @param {ListItem} item
+ * @param {RichTextComponents} components
+ * @returns {DocumentFragment}
+ */
+export function buildListItemContent(item: ListItem, components: RichTextComponents): DocumentFragment;
+/**
+ * Parse one <li> into a list item state object.
+ * @param {Element} li
+ * @param {RichTextComponents} components
+ * @returns {ListItem}
+ */
+export function parseListItemFromHTML(li: Element, components: RichTextComponents): ListItem;
+export type BlockState = import("#src/types.mjs").BlockState;
+export type ListItem = import("#src/types.mjs").ListItem;
+export type ListBlockState = import("#src/types.mjs").ListBlockState;
+export type RichTextComponents = import("#src/types.mjs").RichTextComponents;
+export type UnwrapListResult = import("#src/types.mjs").UnwrapListResult;
+export type MergeListBlocksResult = {
+    content: BlockState[];
+    /**
+     * index of the merged list
+     */
+    listIndex: number;
+    /**
+     * caret offset in the last merged item at the join
+     */
+    cursor: number;
+};

package/dist/types/plugin/menu/Menu.d.mts

@@ -0,0 +1,22 @@
+/**
+ * Floating shared menu overlay (insert + slash).
+ * @param {{
+ *   open: import('#src/types.mjs').Signal<boolean>,
+ *   positionX: import('#src/types.mjs').Signal<number>,
+ *   positionY: import('#src/types.mjs').Signal<number>,
+ *   entries: import('#src/types.mjs').Signal<import('#src/types.mjs').BlockComponentRegistration[]>,
+ *   highlightIndex: import('#src/types.mjs').Signal<number>,
+ *   ariaLabel: import('#src/types.mjs').Signal<string>,
+ *   menuRef: import('#src/types.mjs').ElementRef,
+ * }} props
+ * @returns {*}
+ */
+export function Menu({ open, positionX, positionY, entries, highlightIndex, ariaLabel, menuRef, }: {
+    open: import("#src/types.mjs").Signal<boolean>;
+    positionX: import("#src/types.mjs").Signal<number>;
+    positionY: import("#src/types.mjs").Signal<number>;
+    entries: import("#src/types.mjs").Signal<import("#src/types.mjs").BlockComponentRegistration[]>;
+    highlightIndex: import("#src/types.mjs").Signal<number>;
+    ariaLabel: import("#src/types.mjs").Signal<string>;
+    menuRef: import("#src/types.mjs").ElementRef;
+}): any;

package/dist/types/plugin/menu/menuPlugin.d.mts

@@ -0,0 +1,6 @@
+/**
+ * Shared floating menu overlay (used by insert + slash plugins).
+ * @param {import('#src/types.mjs').PluginContext} options
+ * @returns {import('#src/types.mjs').Plugin}
+ */
+export function menuPlugin({ mrakomor }: import("#src/types.mjs").PluginContext): import("#src/types.mjs").Plugin;

package/dist/types/plugin/paragraph/Paragraph.d.mts

@@ -0,0 +1,16 @@
+/**
+ * Registers the paragraph block type.
+ * @returns {import('#src/types.mjs').Plugin}
+ */
+export function paragraphPlugin(): import("#src/types.mjs").Plugin;
+export class Paragraph extends BlockComponent {
+    static get LABEL(): string;
+    static getStateSchema(node: any): any;
+    getInlineStyleComponents(): any;
+    getEntityRangeComponents(): any;
+    parseFromHTML(node: any): import("#src/types.mjs").RichTextState;
+    _buildContent(state: any): DocumentFragment;
+    render(): any;
+    onKeydown(event: any): void;
+}
+import { BlockComponent } from '#src/component/block/BlockComponent.mjs';

package/dist/types/plugin/paragraph/index.d.mts

@@ -0,0 +1 @@
+export { Paragraph, paragraphPlugin } from "./Paragraph.mjs";

package/dist/types/plugin/slashCommand/SlashActionRegister.d.mts

@@ -0,0 +1,12 @@
+/**
+ * Non-block slash command register (`handler(ctx)` rows).
+ */
+export class SlashActionRegister extends Register {
+    /**
+     * @param {import('#src/types.mjs').SlashActionRegistration} raw
+     * @param {number} index
+     * @returns {import('#src/types.mjs').SlashActionRegistration | null}
+     */
+    normalize(raw: import("#src/types.mjs").SlashActionRegistration, index: number): import("#src/types.mjs").SlashActionRegistration | null;
+}
+import Register from '#src/register/Register.mjs';

package/dist/types/plugin/slashCommand/index.d.mts

@@ -0,0 +1 @@
+export { slashCommandPlugin } from "./slashCommandPlugin.mjs";

package/dist/types/plugin/slashCommand/slashActionSchema.d.mts

@@ -0,0 +1,29 @@
+/**
+ * Derive bare slash action register id from label or fallback.
+ * @param {string | undefined} label
+ * @param {string | number} fallback
+ * @returns {string}
+ */
+export function slashActionSlug(label: string | undefined, fallback: string | number): string;
+/**
+ * Derive stable slash action register id (bare slug).
+ * @param {object} input
+ * @param {string} [input.id]
+ * @param {string} [input.label]
+ * @param {string | number} [input.fallback]
+ * @returns {string}
+ */
+export function slashActionRegistrationId({ id, label, fallback }: {
+    id?: string | undefined;
+    label?: string | undefined;
+    fallback?: string | number | undefined;
+}): string;
+/**
+ * Parse one slash action register entry.
+ * @param {import('#src/types.mjs').SlashActionRegistration} entry
+ * @param {number} index
+ * @returns {import('#src/types.mjs').SlashActionRegistration}
+ */
+export function parseSlashActionRegistration(entry: import("#src/types.mjs").SlashActionRegistration, index?: number): import("#src/types.mjs").SlashActionRegistration;
+/** @type {import('@esmj/schema').SchemaType<import('#src/types.mjs').SlashActionRegistration>} */
+export const slashActionRegistrationRowSchema: import("@esmj/schema").SchemaType<import("#src/types.mjs").SlashActionRegistration>;

package/dist/types/plugin/slashCommand/slashCommandHelpers.d.mts

@@ -0,0 +1,77 @@
+/**
+ * Snapshot the block at `/` from live DOM (`_getBlockElementState` / stale `getState()`).
+ * Does not write `#content` — avoids re-render and caret loss while query chars stay DOM-only.
+ * @param {import('#src/types.mjs').Mrakomor} mrakomor
+ * @param {Element} blockElement
+ * @returns {import('#src/types.mjs').BlockState | null}
+ */
+export function storeSlashBaseline(mrakomor: import("#src/types.mjs").Mrakomor, blockElement: Element): import("#src/types.mjs").BlockState | null;
+/**
+ * Whether `/` may open a slash session after this character (start or whitespace).
+ * @param {string | null | undefined} prevChar
+ * @returns {boolean}
+ */
+export function canOpenSlashAt(prevChar: string | null | undefined): boolean;
+/**
+ * If the cursor sits inside a slash token, return its span and query.
+ * @param {string} text
+ * @param {number} cursorOffset
+ * @returns {{ slashStart: number, slashEnd: number, query: string } | null}
+ */
+export function parseSlashToken(text: string, cursorOffset: number): {
+    slashStart: number;
+    slashEnd: number;
+    query: string;
+} | null;
+/**
+ * Apply an input delta to an open slash session.
+ * @param {import('#src/types.mjs').SlashSession} session
+ * @param {{ inputType?: string, data?: string | null }} event
+ * @returns {import('#src/types.mjs').SlashSession | null}
+ */
+export function applyInputToSession(session: import("#src/types.mjs").SlashSession, event: {
+    inputType?: string;
+    data?: string | null;
+}): import("#src/types.mjs").SlashSession | null;
+/**
+ * Whether a slash menu entry is a non-block action (`handler`).
+ * @param {import('#src/types.mjs').SlashMenuEntry | null | undefined} entry
+ * @returns {boolean}
+ */
+export function isSlashAction(entry: import("#src/types.mjs").SlashMenuEntry | null | undefined): boolean;
+/**
+ * Filter registrations by case-insensitive substring on label and keywords.
+ * @param {import('#src/types.mjs').SlashMenuEntry[]} entries
+ * @param {string} query
+ * @returns {import('#src/types.mjs').SlashMenuEntry[]}
+ */
+export function filterEntries(entries: import("#src/types.mjs").SlashMenuEntry[], query: string): import("#src/types.mjs").SlashMenuEntry[];
+/**
+ * Build a normalized target block state for a slash registration. Converts
+ * the current text through `Constructor.fromExchangeState()` so block-type-
+ * specific shaping (e.g. List wrapping text into a one-item list) stays
+ * owned by the target component, not by slash.
+ * @param {import('#src/types.mjs').BlockComponentRegistration} registration
+ * @param {import('#src/types.mjs').BlockState | null} [afterState]
+ * @returns {import('#src/types.mjs').BlockState | null}
+ */
+export function buildTargetBlockState(registration: import("#src/types.mjs").BlockComponentRegistration, afterState?: import("#src/types.mjs").BlockState | null): import("#src/types.mjs").BlockState | null;
+/**
+ * Run a non-block slash action: strip `/query`, replace block, then handler.
+ * @param {import('#src/types.mjs').SlashCommandContext} ctx
+ * @param {import('#src/types.mjs').SlashActionRegistration} registration
+ */
+export function applySlashActionCommand(ctx: import("#src/types.mjs").SlashCommandContext, registration: import("#src/types.mjs").SlashActionRegistration): void;
+/**
+ * Restore baseline text, then replace or insert the target block.
+ * @param {import('#src/types.mjs').SlashCommandContext} ctx
+ * @param {import('#src/types.mjs').BlockComponentRegistration} registration
+ */
+export function applyBlockSlashCommand(ctx: import("#src/types.mjs").SlashCommandContext, registration: import("#src/types.mjs").BlockComponentRegistration): void;
+/**
+ * Build slash context from the active session.
+ * @param {import('#src/types.mjs').Mrakomor} mrakomor
+ * @param {import('#src/types.mjs').SlashSession} session
+ * @returns {import('#src/types.mjs').SlashCommandContext}
+ */
+export function buildSlashContext(mrakomor: import("#src/types.mjs").Mrakomor, session: import("#src/types.mjs").SlashSession): import("#src/types.mjs").SlashCommandContext;

package/dist/types/plugin/slashCommand/slashCommandPlugin.d.mts

@@ -0,0 +1,11 @@
+/**
+ * Notion-style `/` command palette — drives the shared menuPlugin.
+ *
+ * 1. `/` INPUT — store baseline (`_getBlockElementState` clone, no re-render), open menu.
+ * 2. Query chars — session offsets only; query stays DOM-only.
+ * 3. Enter — strip `/query` from baseline, apply block or action.
+ *
+ * @param {import('#src/types.mjs').PluginContext} options
+ * @returns {import('#src/types.mjs').Plugin}
+ */
+export function slashCommandPlugin({ mrakomor }: import("#src/types.mjs").PluginContext): import("#src/types.mjs").Plugin;

package/dist/types/plugin/slashCommand/slashHelp.d.mts

@@ -0,0 +1,12 @@
+/**
+ * Slash command token shown in help for an action (`/help`, …).
+ * @param {import('#src/types.mjs').SlashActionRegistration} action
+ * @returns {string}
+ */
+export function slashActionHelpCommand(action: import("#src/types.mjs").SlashActionRegistration): string;
+/**
+ * Map a normalized slash action to a help register row.
+ * @param {import('#src/types.mjs').SlashActionRegistration} action
+ * @returns {import('#src/types.mjs').HelpEntry}
+ */
+export function helpEntryFromSlashAction(action: import("#src/types.mjs").SlashActionRegistration): import("#src/types.mjs").HelpEntry;

package/dist/types/plugin/tooltip/Tooltip.d.mts

@@ -0,0 +1,16 @@
+/**
+ * Floating selection tooltip.
+ * @param {{ mrakomor: import('#src/types.mjs').Mrakomor, open: import('#src/types.mjs').Signal<boolean>, tooltipElement: import('#src/types.mjs').ElementRef }} props
+ * @returns {*}
+ */
+export function Tooltip({ mrakomor, open, tooltipElement }: {
+    mrakomor: import("#src/types.mjs").Mrakomor;
+    open: import("#src/types.mjs").Signal<boolean>;
+    tooltipElement: import("#src/types.mjs").ElementRef;
+}): any;
+/**
+ * Selection-driven formatting tooltip.
+ * @param {import('#src/types.mjs').PluginContext} options
+ * @returns {import('#src/types.mjs').Plugin}
+ */
+export function tooltipPlugin({ mrakomor }: import("#src/types.mjs").PluginContext): import("#src/types.mjs").Plugin;

package/dist/types/plugin/tooltip/index.d.mts

@@ -0,0 +1 @@
+export { Tooltip, tooltipPlugin } from "./Tooltip.mjs";

package/dist/types/plugin/tts/TtsHeadline.d.mts

@@ -0,0 +1,27 @@
+/**
+ * Registers TTS headline blocks (voice entity ranges on H1–H5).
+ * @returns {import('#src/types.mjs').Plugin}
+ */
+export function ttsHeadlinePlugin(): import("#src/types.mjs").Plugin;
+export class TtsHeadlineComponent extends HeadlineComponent {
+    getInlineStyleComponents(): never[];
+    getEntityRangeComponents(): any;
+    parseFromHTML(node: any): import("#src/types.mjs").RichTextState;
+    _buildContent(state: any): DocumentFragment;
+}
+export class TtsHeadline1 extends TtsHeadlineComponent {
+    static get LABEL(): string;
+}
+export class TtsHeadline2 extends TtsHeadlineComponent {
+    static get LABEL(): string;
+}
+export class TtsHeadline3 extends TtsHeadlineComponent {
+    static get LABEL(): string;
+}
+export class TtsHeadline4 extends TtsHeadlineComponent {
+    static get LABEL(): string;
+}
+export class TtsHeadline5 extends TtsHeadlineComponent {
+    static get LABEL(): string;
+}
+import { HeadlineComponent } from '#src/plugin/headline/Headline.mjs';

package/dist/types/plugin/tts/TtsList.d.mts

@@ -0,0 +1,19 @@
+/**
+ * Registers the TTS list block (voice ranges on items, no inline styles).
+ * Use instead of `listPlugin` for TTS editor presets.
+ * @returns {import('#src/types.mjs').Plugin}
+ */
+export function ttsListPlugin(): import("#src/types.mjs").Plugin;
+/**
+ * List block for TTS: same namespace/behavior as {@link List}, but items keep
+ * only `atom.tts.Voice` entity ranges and drop inline styles.
+ */
+export class TtsList extends List {
+    getInlineStyleComponents(): never[];
+    /**
+     * @param {Element | null | undefined} node
+     * @returns {import('#src/types.mjs').ListBlockState}
+     */
+    parseFromHTML(node: Element | null | undefined): import("#src/types.mjs").ListBlockState;
+}
+import { List } from '#src/plugin/list/List.mjs';

package/dist/types/plugin/tts/TtsParagraph.d.mts

@@ -0,0 +1,9 @@
+/**
+ * Registers the TTS paragraph (voice ranges only, no inline styles).
+ * @returns {import('#src/types.mjs').Plugin}
+ */
+export function ttsParagraphPlugin(): import("#src/types.mjs").Plugin;
+export class TtsParagraph extends Paragraph {
+    getInlineStyleComponents(): never[];
+}
+import { Paragraph } from '#src/plugin/paragraph/Paragraph.mjs';

package/dist/types/plugin/tts/TtsVoice.d.mts

@@ -0,0 +1,52 @@
+/**
+ * Voice metadata for a TTS id, or the first voice if unknown.
+ * @param {string} voiceId
+ * @returns {{ id: string, label: string, gender: string, color: string }}
+ */
+export function getVoice(voiceId: string): {
+    id: string;
+    label: string;
+    gender: string;
+    color: string;
+};
+/**
+ * Distinct accent color for a TTS voice id. Falls back to a hash-derived
+ * hue for ids not present in {@link VOICES} so future/unknown voices still
+ * get a stable, distinct color instead of sharing one default.
+ * @param {string} voiceId
+ * @returns {string} CSS color value
+ */
+export function getVoiceColor(voiceId: string): string;
+/**
+ * Registers the TTS voice entity range.
+ * @returns {import('#src/types.mjs').Plugin}
+ */
+export function ttsVoicePlugin(): import("#src/types.mjs").Plugin;
+export const VOICES: {
+    id: string;
+    label: string;
+    gender: string;
+    color: string;
+}[];
+export class TtsVoice extends EntityRangeElement {
+    static get LABEL(): string;
+    static getStateSchema(node: any): import("@esmj/schema").SchemaInterface<{
+        entity: {
+            type: string;
+            data: unknown;
+        };
+        length: number;
+        offset: number;
+    }, {
+        entity: {
+            type: string;
+            data: unknown;
+        };
+        length: number;
+        offset: number;
+    }>;
+    onMount(): void;
+    onUnmount(): void;
+    #private;
+}
+import { EntityRangeElement } from '../../component/entityRange/EntityRangeElement.mjs';

package/dist/types/plugin/tts/index.d.mts

@@ -0,0 +1,4 @@
+export { TtsHeadlineComponent, ttsHeadlinePlugin } from "./TtsHeadline.mjs";
+export { TtsList, ttsListPlugin } from "./TtsList.mjs";
+export { TtsParagraph, ttsParagraphPlugin } from "./TtsParagraph.mjs";
+export { getVoice, TtsVoice, ttsVoicePlugin, VOICES } from "./TtsVoice.mjs";

package/dist/types/register/Register.d.mts

@@ -0,0 +1,50 @@
+/**
+ * Map-backed register: normalize on `add`, sorted `list()`, {@link Observable} on change.
+ * Subclasses implement {@link Register.normalize}.
+ */
+export class Register {
+    /**
+     * @param {import('#src/types.mjs').Mrakomor} mrakomor
+     * @param {object} [options]
+     * @param {function(*[]): *[]} [options.sort]
+     */
+    constructor(mrakomor: import("#src/types.mjs").Mrakomor, options?: {
+        sort?: ((arg0: any[]) => any[]) | undefined;
+    });
+    /** @type {import('#src/types.mjs').Mrakomor} */
+    mrakomor: import("#src/types.mjs").Mrakomor;
+    /**
+     * Parse one raw row for storage. Return `null` to skip invalid input.
+     * @param {*} _raw
+     * @param {number} _index
+     * @returns {*|null}
+     */
+    normalize(_raw: any, _index: number): any | null;
+    /**
+     * Normalize and upsert one or many entries by id.
+     * @param {*|*[]} raw
+     * @returns {*|null|*[]}
+     */
+    add(raw: any | any[]): any | null | any[];
+    /**
+     * @param {string} id
+     * @returns {*|undefined}
+     */
+    get(id: string): any | undefined;
+    /**
+     * @param {string} id
+     * @returns {boolean}
+     */
+    has(id: string): boolean;
+    /**
+     * @param {string} id
+     * @returns {boolean}
+     */
+    remove(id: string): boolean;
+    /**
+     * @returns {*[]}
+     */
+    list(): any[];
+    #private;
+}
+export { Register as default };

package/dist/types/register/sortRegisterEntries.d.mts

@@ -0,0 +1,7 @@
+/**
+ * Sort register rows by `order`, preserving registration index as tie-breaker.
+ * @template T
+ * @param {T[]} entries
+ * @returns {T[]}
+ */
+export function sortRegisterEntries<T>(entries: T[]): T[];