@intentface/chat 0.1.0

package/dist/composer/editor-dom.js

@@ -0,0 +1,431 @@
+// Editor DOM — the adapters between the contenteditable element and the flat
+// segment model. The reader and position mapping are pure (they walk a
+// minimal structural node view, so tests need no DOM); the materializers at
+// the bottom are thin real-DOM wrappers over the pure spec builder.
+//
+// Writer/reader pact for line breaks: every "\n" renders as <br>, plus one
+// padding <br> when the document is empty or ends with "\n" (an unpadded
+// trailing line is unreachable/zero-height). The reader inverts this by
+// dropping exactly one trailing "\n" when the last rendered node was a <br>.
+// Round-trips: "" ↔ <br>, "a\n" ↔ a<br><br>, "a\n\n" ↔ a<br><br><br>.
+import { nextChipId } from "./segments.js";
+const TEXT_NODE = 3;
+const ELEMENT_NODE = 1;
+// Elements whose appearance inside the editable means something rewrote our
+// flat structure (paste leftovers, extensions) — content still reads, but the
+// document gets renormalized from the model afterwards.
+const BLOCK_NODE_NAMES = new Set([
+    "DIV",
+    "P",
+    "PRE",
+    "BLOCKQUOTE",
+    "UL",
+    "OL",
+    "LI",
+    "H1",
+    "H2",
+    "H3",
+    "H4",
+    "H5",
+    "H6",
+    "TABLE",
+]);
+export const toReadable = (node) => node;
+const chipIdOf = (node) => node.nodeType === ELEMENT_NODE ? (node.getAttribute?.("data-chip-id") ?? null) : null;
+// Non-editable elements without a chip identity are pure presentation (the
+// badge's hint span) — invisible to the model: the reader skips them and the
+// position mappers give them zero width.
+const isPresentationOnly = (node) => node.nodeType === ELEMENT_NODE &&
+    node.getAttribute?.("contenteditable") === "false" &&
+    chipIdOf(node) === null;
+// ---------------------------------------------------------------------------
+// Reader — DOM → segments. Adjacent text concatenates (fragmentation is
+// normalized logically, never via root.normalize() — WebKit collapses the
+// caret when the selection's text node gets merged), NBSP reads as a plain
+// space, badge spans and unknown inline elements are transparent wrappers,
+// chip spans resolve through the registry.
+// ---------------------------------------------------------------------------
+export const readDocumentFromDom = (root, resolveChip, makeId = nextChipId) => {
+    const doc = [];
+    let dirty = false;
+    let pendingText = "";
+    let lastWasBreak = false;
+    const seenChipIds = new Set();
+    const flushText = () => {
+        if (pendingText.length === 0)
+            return;
+        const previous = doc.at(-1);
+        if (previous?.type === "text") {
+            doc[doc.length - 1] = { type: "text", text: previous.text + pendingText };
+        }
+        else {
+            doc.push({ type: "text", text: pendingText });
+        }
+        pendingText = "";
+    };
+    const visit = (node) => {
+        if (node.nodeType === TEXT_NODE) {
+            const content = (node.data ?? "").replace(/\u00A0/g, " ");
+            if (content.length > 0) {
+                pendingText += content;
+                lastWasBreak = false;
+            }
+            return;
+        }
+        if (node.nodeType !== ELEMENT_NODE)
+            return;
+        if (node.nodeName === "BR") {
+            pendingText += "\n";
+            lastWasBreak = true;
+            return;
+        }
+        const chipId = chipIdOf(node);
+        if (chipId !== null) {
+            // Chip span content is presentation — never read. Unknown ids are
+            // leftovers from DOM the model doesn't know (mark dirty, skip);
+            // duplicated ids (clone paths) get a fresh identity.
+            const chip = resolveChip(chipId);
+            if (!chip) {
+                dirty = true;
+                return;
+            }
+            flushText();
+            const id = seenChipIds.has(chipId) ? makeId() : chipId;
+            seenChipIds.add(chipId);
+            doc.push({ type: "chip", id, chip });
+            lastWasBreak = false;
+            return;
+        }
+        // Presentation-only elements (the badge's hint span) never reach the model.
+        if (isPresentationOnly(node))
+            return;
+        // Badge span / unknown inline: transparent wrapper. Block elements also
+        // read through, but flag the document for renormalization.
+        if (BLOCK_NODE_NAMES.has(node.nodeName))
+            dirty = true;
+        for (const child of Array.from(node.childNodes))
+            visit(child);
+    };
+    for (const child of Array.from(root.childNodes))
+        visit(child);
+    // Invert the writer's padding <br>: one trailing "\n" is the padding, not
+    // content — but only when a <br> was actually the last rendered node.
+    if (lastWasBreak && pendingText.endsWith("\n")) {
+        pendingText = pendingText.slice(0, -1);
+    }
+    flushText();
+    return { doc, dirty };
+};
+// ---------------------------------------------------------------------------
+// Position mapping — DOM points ↔ logical positions. Chips count 1, <br>
+// counts 1 (it renders a "\n"), badge/unknown wrappers are transparent.
+// ---------------------------------------------------------------------------
+/** Logical position of (node, offset), or null when the point isn't inside root. */
+export const logicalRangeFromDom = (root, targetNode, targetOffset) => {
+    let position = 0;
+    let found = null;
+    const visit = (node) => {
+        if (node === targetNode && node.nodeType !== TEXT_NODE && chipIdOf(node) === null) {
+            // Element point: offset is a child index — resolve by walking children
+            // until the index, then record.
+            const children = Array.from(node.childNodes).slice(0, targetOffset);
+            for (const child of children) {
+                if (measure(child))
+                    return true;
+            }
+            found = position;
+            return true;
+        }
+        if (node.nodeType === TEXT_NODE) {
+            if (node === targetNode) {
+                found = position + Math.min(targetOffset, (node.data ?? "").length);
+                return true;
+            }
+            position += (node.data ?? "").length;
+            return false;
+        }
+        if (node.nodeType !== ELEMENT_NODE)
+            return false;
+        if (node.nodeName === "BR") {
+            position += 1;
+            return false;
+        }
+        if (chipIdOf(node) !== null) {
+            // A point inside a chip clamps to the chip's start.
+            if (node === targetNode || contains(node, targetNode)) {
+                found = position;
+                return true;
+            }
+            position += 1;
+            return false;
+        }
+        // Presentation-only elements are zero-width; a point inside one clamps to
+        // its boundary.
+        if (isPresentationOnly(node)) {
+            if (node === targetNode || contains(node, targetNode)) {
+                found = position;
+                return true;
+            }
+            return false;
+        }
+        for (const child of Array.from(node.childNodes)) {
+            if (visit(child))
+                return true;
+        }
+        return false;
+    };
+    // Advance `position` past a whole subtree (used for element-point offsets).
+    const measure = (node) => visit(node);
+    const contains = (parent, target) => {
+        for (const child of Array.from(parent.childNodes)) {
+            if (child === target || contains(child, target))
+                return true;
+        }
+        return false;
+    };
+    if (root === targetNode) {
+        const children = Array.from(root.childNodes).slice(0, targetOffset);
+        for (const child of children) {
+            if (measure(child))
+                return found;
+        }
+        return position;
+    }
+    for (const child of Array.from(root.childNodes)) {
+        if (visit(child))
+            return found;
+    }
+    return found;
+};
+export const documentToDomSpec = (doc) => {
+    const specs = [];
+    for (const segment of doc) {
+        if (segment.type === "chip") {
+            specs.push({ kind: "chip", id: segment.id });
+            continue;
+        }
+        const lines = segment.text.split("\n");
+        lines.forEach((line, lineIndex) => {
+            if (lineIndex > 0)
+                specs.push({ kind: "br", padding: false });
+            if (line.length > 0)
+                specs.push({ kind: "text", text: line });
+        });
+    }
+    // Padding <br>: an empty document or one ending in a line break needs a
+    // trailing <br> for the last line to be reachable and have height.
+    const last = specs.at(-1);
+    if (!last || last.kind === "br")
+        specs.push({ kind: "br", padding: true });
+    return specs;
+};
+// ---------------------------------------------------------------------------
+// Real-DOM materializers — thin, untested by design; all decisions live in
+// the pure layers above.
+// ---------------------------------------------------------------------------
+const createChipSpan = (id) => {
+    const span = document.createElement("span");
+    span.contentEditable = "false";
+    span.setAttribute("data-mention-chip", "");
+    span.setAttribute("data-chip-id", id);
+    // A chip is atomic inline content: it must sit on the text baseline and must
+    // not inherit the editor's break-spaces whitespace mode, or its label wraps
+    // mid-chip.
+    span.style.display = "inline";
+    span.style.verticalAlign = "baseline";
+    span.style.whiteSpace = "normal";
+    return span;
+};
+/**
+ * Render the canonical child list. Existing chip spans are reused by id —
+ * moving a node preserves its React portal; recreating it would remount the
+ * chip content. Returns the live id → element map for the portal layer.
+ */
+export const renderDocumentToDom = (root, doc) => {
+    const existingSpans = new Map();
+    for (const span of root.querySelectorAll("[data-chip-id]")) {
+        const id = span.getAttribute("data-chip-id");
+        if (id && !existingSpans.has(id))
+            existingSpans.set(id, span);
+    }
+    const chipsById = new Map(doc.flatMap((segment) => segment.type === "chip" ? [[segment.id, segment.chip]] : []));
+    const chipElements = new Map();
+    const children = documentToDomSpec(doc).map((spec) => {
+        if (spec.kind === "text")
+            return document.createTextNode(spec.text);
+        if (spec.kind === "br")
+            return document.createElement("br");
+        const span = existingSpans.get(spec.id) ?? createChipSpan(spec.id);
+        // Without an accessible boundary the chip reads as bare prose inside the
+        // textbox — label + type gives AT an atomic token ("Rasmus, @ mention").
+        const chip = chipsById.get(spec.id);
+        if (chip)
+            span.setAttribute("aria-label", `${chip.label}, ${chip.prefix} mention`);
+        chipElements.set(spec.id, span);
+        return span;
+    });
+    root.replaceChildren(...children);
+    return chipElements;
+};
+/** DOM point for a logical position, preferring text-node points. */
+export const domPointFromLogical = (root, position) => {
+    let remaining = position;
+    const walk = (parent) => {
+        for (let index = 0; index < parent.childNodes.length; index++) {
+            const child = parent.childNodes[index];
+            if (!child)
+                continue;
+            if (child.nodeType === TEXT_NODE) {
+                const length = child.data.length;
+                if (remaining <= length)
+                    return { node: child, offset: remaining };
+                remaining -= length;
+                continue;
+            }
+            if (child.nodeType !== ELEMENT_NODE)
+                continue;
+            const element = child;
+            if (element.nodeName === "BR" || element.hasAttribute("data-chip-id")) {
+                if (remaining === 0)
+                    return { node: parent, offset: index };
+                remaining -= 1;
+                continue;
+            }
+            // Presentation-only (the badge's hint span): zero width, never a target.
+            if (isPresentationOnly(toReadable(element)))
+                continue;
+            // Transparent wrapper (badge span): descend.
+            const inner = walk(element);
+            if (inner)
+                return inner;
+        }
+        return remaining === 0 ? { node: parent, offset: parent.childNodes.length } : null;
+    };
+    return walk(root) ?? { node: root, offset: root.childNodes.length };
+};
+export const readSelectionRange = (root) => {
+    const selection = root.ownerDocument.getSelection();
+    if (!selection || selection.rangeCount === 0)
+        return null;
+    const range = selection.getRangeAt(0);
+    if (!root.contains(range.startContainer) || !root.contains(range.endContainer))
+        return null;
+    const start = logicalRangeFromDom(toReadable(root), toReadable(range.startContainer), range.startOffset);
+    const end = logicalRangeFromDom(toReadable(root), toReadable(range.endContainer), range.endOffset);
+    if (start === null || end === null)
+        return null;
+    return start <= end ? { start, end } : { start: end, end: start };
+};
+export const writeCaretToDom = (root, start, end = start) => {
+    const selection = root.ownerDocument.getSelection();
+    if (!selection)
+        return;
+    const anchor = domPointFromLogical(root, start);
+    const focus = end === start ? anchor : domPointFromLogical(root, end);
+    selection.setBaseAndExtent(anchor.node, anchor.offset, focus.node, focus.offset);
+};
+const badgeSpansOf = (root) => [
+    ...root.querySelectorAll("[data-command-badge]"),
+];
+const unwrapBadgeSpan = (span) => {
+    const parent = span.parentNode;
+    if (!parent)
+        return;
+    // Presentation children (the hint span) are the badge's own chrome — they
+    // die with it rather than spilling into content.
+    for (const child of [...span.children]) {
+        if (isPresentationOnly(toReadable(child)))
+            child.remove();
+    }
+    while (span.firstChild)
+        parent.insertBefore(span.firstChild, span);
+    parent.removeChild(span);
+    // No parent.normalize() — the reader concatenates fragmented text nodes,
+    // and merging the selection's node collapses the caret in WebKit.
+};
+// The badge's logical text length: direct text nodes only — the hint span is
+// zero-width presentation and must not count toward the token range.
+const badgeTextLength = (span) => {
+    let length = 0;
+    for (const child of [...span.childNodes]) {
+        if (child.nodeType === TEXT_NODE)
+            length += child.data.length;
+    }
+    return length;
+};
+/**
+ * Make the DOM match the token (or its absence). Returns true when the DOM
+ * changed — the caller must restore the caret afterwards.
+ */
+export const syncBadge = (root, token) => {
+    const spans = badgeSpansOf(root);
+    if (!token) {
+        if (spans.length === 0)
+            return false;
+        for (const span of spans)
+            unwrapBadgeSpan(span);
+        return true;
+    }
+    // Fast path: one span already covering exactly [start, end] with the right
+    // placeholder marker.
+    const [onlySpan] = spans;
+    if (spans.length === 1 && onlySpan) {
+        const span = onlySpan;
+        const parent = span.parentNode;
+        if (parent) {
+            const index = [...parent.childNodes].indexOf(span);
+            const spanStart = logicalRangeFromDom(toReadable(root), toReadable(parent), index);
+            const spanLength = badgeTextLength(span);
+            const hasPlaceholder = span.hasAttribute("data-command-placeholder");
+            if (spanStart === token.start &&
+                spanStart + spanLength === token.end &&
+                hasPlaceholder === token.showPlaceholder) {
+                return false;
+            }
+        }
+    }
+    for (const span of spans)
+        unwrapBadgeSpan(span);
+    // Wrap [start, end]: a Range handles boundary text-node splitting for us.
+    // The token is text-only by construction (chips scan as whitespace), so the
+    // extracted fragment never partially covers a non-text node.
+    const startPoint = domPointFromLogical(root, token.start);
+    const endPoint = domPointFromLogical(root, token.end);
+    const range = root.ownerDocument.createRange();
+    range.setStart(startPoint.node, startPoint.offset);
+    range.setEnd(endPoint.node, endPoint.offset);
+    const span = root.ownerDocument.createElement("span");
+    span.setAttribute("data-command-badge", "");
+    if (token.showPlaceholder)
+        span.setAttribute("data-command-placeholder", "");
+    span.appendChild(range.extractContents());
+    range.insertNode(span);
+    return true;
+};
+// ---------------------------------------------------------------------------
+// Caret visibility — native typing auto-scrolls; programmatic writes don't.
+// Nudge only the nearest scrollable ancestor (never scrollIntoView — it
+// yanks the whole page).
+// ---------------------------------------------------------------------------
+export const scrollCaretIntoView = (root) => {
+    const selection = root.ownerDocument.getSelection();
+    if (!selection || selection.rangeCount === 0)
+        return;
+    const rect = selection.getRangeAt(0).getBoundingClientRect();
+    let scroller = root;
+    while (scroller && scroller !== root.ownerDocument.body) {
+        const { overflowY } = getComputedStyle(scroller);
+        if ((overflowY === "auto" || overflowY === "scroll") &&
+            scroller.scrollHeight > scroller.clientHeight) {
+            break;
+        }
+        scroller = scroller.parentElement;
+    }
+    if (!scroller || scroller === root.ownerDocument.body)
+        return;
+    const view = scroller.getBoundingClientRect();
+    if (rect.top < view.top)
+        scroller.scrollTop -= view.top - rect.top;
+    else if (rect.bottom > view.bottom)
+        scroller.scrollTop += rect.bottom - view.bottom;
+};

package/dist/composer/fuzzy.d.ts

@@ -0,0 +1,4 @@
+import type { CommandItemData } from "./types.js";
+export declare const fuzzyScore: (query: string, target: string) => number;
+export declare const filterArrayItems: (items: CommandItemData[], query: string) => CommandItemData[];
+export declare const suggestionRemainder: (query: string, label: string) => string | null;

package/dist/composer/fuzzy.js

@@ -0,0 +1,49 @@
+// Command list — fuzzy filtering. A prefix match wins outright (2); otherwise
+// every matched character scores, with bonuses for adjacency and word-boundary
+// hits, normalized by query length. Returns 0 when the query can't be matched.
+export const fuzzyScore = (query, target) => {
+    if (!query)
+        return 1;
+    const lowerQuery = query.toLowerCase();
+    const lowerTarget = target.toLowerCase();
+    if (lowerTarget.startsWith(lowerQuery))
+        return 2;
+    let queryIndex = 0;
+    let score = 0;
+    let previousMatchIndex = -1;
+    for (let targetIndex = 0; targetIndex < lowerTarget.length && queryIndex < lowerQuery.length; targetIndex++) {
+        if (lowerTarget[targetIndex] === lowerQuery[queryIndex]) {
+            score += 1;
+            if (previousMatchIndex === targetIndex - 1)
+                score += 2;
+            if (targetIndex === 0 || lowerTarget[targetIndex - 1] === " ")
+                score += 1;
+            previousMatchIndex = targetIndex;
+            queryIndex++;
+        }
+    }
+    return queryIndex === lowerQuery.length ? score / lowerQuery.length : 0;
+};
+export const filterArrayItems = (items, query) => {
+    if (!query)
+        return items;
+    // Score and filter in a single pass, then sort by score.
+    const scored = [];
+    for (const item of items) {
+        const target = `${item.label ?? item.value ?? ""} ${item.keywords ?? ""}`.trim();
+        const score = fuzzyScore(query, target);
+        if (score > 0)
+            scored.push({ item, score });
+    }
+    scored.sort((a, b) => b.score - a.score);
+    return scored.map(({ item }) => item);
+};
+// Ghost-text completion: the part of the highlighted item's label that would
+// complete the query — only for a case-insensitive prefix match (a fuzzy hit
+// completed inline would read as broken), with the label's own casing.
+export const suggestionRemainder = (query, label) => {
+    if (!label.toLowerCase().startsWith(query.toLowerCase()))
+        return null;
+    const remainder = label.slice(query.length);
+    return remainder.length > 0 ? remainder : null;
+};

package/dist/composer/index.d.ts

@@ -0,0 +1,25 @@
+export type { ComposerSubmitState, UseComposerSubmitOptions } from "./actions.js";
+export { useComposerSubmit } from "./actions.js";
+export type { ComposerAttachmentsProps, ComposerAttachmentTriggerProps } from "./attachments.js";
+export type { CommandListState, ComposerCommandProps } from "./command-list.js";
+export { useCommandListItems } from "./command-list.js";
+export type { ComposerContainerProps } from "./container.js";
+export { useComposerController } from "./controller.js";
+export { filterArrayItems, fuzzyScore, suggestionRemainder } from "./fuzzy.js";
+export * as Composer from "./index.parts.js";
+export type { ComposerSubmitOn, EditorKeyAction, EditorKeyContext } from "./keyboard.js";
+export { interpretAskUserKey, interpretEditorKey } from "./keyboard.js";
+export type { ComposerPanelProps } from "./panel.js";
+export type { ComposerPlaceholderProps } from "./placeholder.js";
+export type { ComposerPopoverProps } from "./popover.js";
+export type { ActiveTokenState, RegisteredPrefix } from "./prefix-detection.js";
+export { CLOSED_COMMAND_STATE, detectActivePrefix } from "./prefix-detection.js";
+export type { ComposerRootProps } from "./root.js";
+export type { Segment, SegmentDoc, TextChange } from "./segments.js";
+export { documentLength, getPlainText, serializeSegments, sliceSegments, spliceSegments, } from "./segments.js";
+export type { ComposerAskUserState, ComposerAttachmentsState, ComposerCommandsState, ComposerEditorState, ComposerPanelSlice, ComposerState, ComposerStore, } from "./store.js";
+export { useComposer, useComposerStore } from "./store.js";
+export type { ComposerTextareaProps, ComposerTextareaState } from "./textarea.js";
+export type { AskUserOption, AskUserQuestion, AttachmentsApi, ChipData, CommandItemData, CommandItemKind, ComposerAnswerEntry, ComposerAnswersSubmit, ComposerCommandsConfig, ComposerCommandsItems, ComposerCommandsMap, ComposerEditorHandle, ComposerMessageSubmit, ComposerSnapshot, ComposerSubmitData, PrefixOnSelectContext, RegisteredEditor, TriggerRule, } from "./types.js";
+export type { ComposerEditableProps, UseComposerEditorOptions, UseComposerEditorResult, } from "./use-composer-editor.js";
+export { useComposerEditor } from "./use-composer-editor.js";

package/dist/composer/index.js

@@ -0,0 +1,13 @@
+// Public surface of @intentface/chat/composer: the `Composer` namespace plus
+// the store/controller/hook building blocks. No "use client" directive here —
+// see index.parts.ts.
+export { useComposerSubmit } from "./actions.js";
+export { useCommandListItems } from "./command-list.js";
+export { useComposerController } from "./controller.js";
+export { filterArrayItems, fuzzyScore, suggestionRemainder } from "./fuzzy.js";
+export * as Composer from "./index.parts.js";
+export { interpretAskUserKey, interpretEditorKey } from "./keyboard.js";
+export { CLOSED_COMMAND_STATE, detectActivePrefix } from "./prefix-detection.js";
+export { documentLength, getPlainText, serializeSegments, sliceSegments, spliceSegments, } from "./segments.js";
+export { useComposer, useComposerStore } from "./store.js";
+export { useComposerEditor } from "./use-composer-editor.js";

package/dist/composer/index.parts.d.ts

@@ -0,0 +1,11 @@
+export { ComposerActions as Actions, ComposerContextWindow as ContextWindow, ComposerSubmit as Submit, } from "./actions.js";
+export { ComposerAttachments as Attachments, ComposerAttachmentTrigger as AttachmentTrigger, } from "./attachments.js";
+export { ComposerCommand as Command, ComposerCommandDismiss as CommandDismiss, ComposerCommandEmpty as CommandEmpty, ComposerCommandGroup as CommandGroup, ComposerCommandGroupLabel as CommandGroupLabel, ComposerCommandItem as CommandItem, ComposerCommandItemDescription as CommandItemDescription, ComposerCommandItemIcon as CommandItemIcon, ComposerCommandItemLabel as CommandItemLabel, ComposerCommandList as CommandList, ComposerCommandLoading as CommandLoading, } from "./command-list.js";
+export { ComposerContainer as Container } from "./container.js";
+export { ComposerPanel as Panel } from "./panel.js";
+export { ComposerPlaceholder as Placeholder } from "./placeholder.js";
+export { ComposerPopover as Popover } from "./popover.js";
+export { ComposerRoot as Root } from "./root.js";
+/** Create a standalone store handle: `<Composer.Root store={…}>` + `useComposerStore(store, selector)` + `store.controller` for imperative access. */
+export { createComposerStore as createStore } from "./store.js";
+export { ComposerTextarea as Textarea } from "./textarea.js";

package/dist/composer/index.parts.js

@@ -0,0 +1,15 @@
+// Part names for the `Composer` namespace. Deliberately carries no
+// "use client" directive: this module and index.ts must stay server-resolvable
+// so a React Server Component can reach Composer.Root and its siblings through
+// them. Each part module carries the directive itself.
+export { ComposerActions as Actions, ComposerContextWindow as ContextWindow, ComposerSubmit as Submit, } from "./actions.js";
+export { ComposerAttachments as Attachments, ComposerAttachmentTrigger as AttachmentTrigger, } from "./attachments.js";
+export { ComposerCommand as Command, ComposerCommandDismiss as CommandDismiss, ComposerCommandEmpty as CommandEmpty, ComposerCommandGroup as CommandGroup, ComposerCommandGroupLabel as CommandGroupLabel, ComposerCommandItem as CommandItem, ComposerCommandItemDescription as CommandItemDescription, ComposerCommandItemIcon as CommandItemIcon, ComposerCommandItemLabel as CommandItemLabel, ComposerCommandList as CommandList, ComposerCommandLoading as CommandLoading, } from "./command-list.js";
+export { ComposerContainer as Container } from "./container.js";
+export { ComposerPanel as Panel } from "./panel.js";
+export { ComposerPlaceholder as Placeholder } from "./placeholder.js";
+export { ComposerPopover as Popover } from "./popover.js";
+export { ComposerRoot as Root } from "./root.js";
+/** Create a standalone store handle: `<Composer.Root store={…}>` + `useComposerStore(store, selector)` + `store.controller` for imperative access. */
+export { createComposerStore as createStore } from "./store.js";
+export { ComposerTextarea as Textarea } from "./textarea.js";

package/dist/composer/internals.d.ts

@@ -0,0 +1,29 @@
+import { type RefObject, useEffect } from "react";
+import type { RegisteredPrefix } from "./prefix-detection.js";
+import type { ComposerCommandsMap, ComposerSnapshot, RegisteredEditor } from "./types.js";
+export declare const useIsomorphicLayoutEffect: typeof useEffect;
+export declare const useAsRef: <T>(value: T) => RefObject<T>;
+export type ComposerInternalsValue = {
+    commands: ComposerCommandsMap;
+    getRegisteredPrefixes: () => RegisteredPrefix[];
+    reportEditorUpdate: () => void;
+};
+export declare const ComposerInternalsContext: import("react").Context<ComposerInternalsValue | null>;
+export declare const useComposerInternals: () => ComposerInternalsValue;
+export declare const useCommandRegistry: (commands: ComposerCommandsMap) => {
+    getRegisteredPrefixes: () => RegisteredPrefix[];
+};
+export declare const useDragDropFiles: ({ rootRef, globalDropRef, onFiles, setDragging, }: {
+    rootRef: RefObject<HTMLElement | null>;
+    globalDropRef: RefObject<boolean>;
+    onFiles: (files: FileList) => void;
+    setDragging: (active: boolean) => void;
+}) => void;
+export declare const useComposerSnapshot: ({ editorRef, defaultValue, value, onValueChange, }: {
+    editorRef: RefObject<RegisteredEditor | null>;
+    defaultValue?: ComposerSnapshot;
+    value?: ComposerSnapshot;
+    onValueChange?: (snapshot: ComposerSnapshot) => void;
+}) => {
+    reportEditorUpdate: () => void;
+};