@octanejs/lexical 0.1.2

package/src/LexicalPlainTextPlugin.tsrx

@@ -0,0 +1,33 @@
+// Ported from @lexical/react/src/LexicalPlainTextPlugin.tsx — the plain-text twin
+// of RichTextPlugin (registerPlainText instead of registerRichText).
+import { useLexicalComposerContext } from './LexicalComposerContext';
+import { useLexicalEditable } from './useLexicalEditable';
+import { useCanShowPlaceholder } from './shared/useCanShowPlaceholder';
+import { usePlainTextSetup } from './shared/usePlainTextSetup';
+import { Decorators } from './shared/LexicalDecorators.tsrx';
+
+function Placeholder(props) {
+	const [editor] = useLexicalComposerContext();
+	const showPlaceholder = useCanShowPlaceholder(editor);
+	const editable = useLexicalEditable();
+
+	if (!showPlaceholder) {
+		return null;
+	}
+	const content = props.content;
+	if (typeof content === 'function') {
+		return content(editable);
+	}
+	return content != null ? content : null;
+}
+
+export function PlainTextPlugin(props) @{
+	const [editor] = useLexicalComposerContext();
+	usePlainTextSetup(editor);
+
+	<>
+		{props.contentEditable}
+		<Placeholder content={props.placeholder} />
+		<Decorators editor={editor} ErrorBoundary={props.ErrorBoundary} />
+	</>
+}

package/src/LexicalRichTextPlugin.tsrx

@@ -0,0 +1,35 @@
+// Ported from @lexical/react/src/LexicalRichTextPlugin.tsx. Wires the core
+// rich-text commands and renders the provided contentEditable, an optional
+// placeholder, and decorator nodes. (The legacy `isUsingReactExtension` branch is
+// omitted — that's the @lexical/extension path handled in a later phase.)
+import { useLexicalComposerContext } from './LexicalComposerContext';
+import { useLexicalEditable } from './useLexicalEditable';
+import { useCanShowPlaceholder } from './shared/useCanShowPlaceholder';
+import { useRichTextSetup } from './shared/useRichTextSetup';
+import { Decorators } from './shared/LexicalDecorators.tsrx';
+
+function Placeholder(props) {
+	const [editor] = useLexicalComposerContext();
+	const showPlaceholder = useCanShowPlaceholder(editor);
+	const editable = useLexicalEditable();
+
+	if (!showPlaceholder) {
+		return null;
+	}
+	const content = props.content;
+	if (typeof content === 'function') {
+		return content(editable);
+	}
+	return content != null ? content : null;
+}
+
+export function RichTextPlugin(props) @{
+	const [editor] = useLexicalComposerContext();
+	useRichTextSetup(editor);
+
+	<>
+		{props.contentEditable}
+		<Placeholder content={props.placeholder} />
+		<Decorators editor={editor} ErrorBoundary={props.ErrorBoundary} />
+	</>
+}

package/src/LexicalSelectionAlwaysOnDisplay.tsrx

@@ -0,0 +1,11 @@
+// Ported from @lexical/react/src/LexicalSelectionAlwaysOnDisplay.tsx.
+import { selectionAlwaysOnDisplay } from '@lexical/utils';
+import { useLexicalComposerContext } from './LexicalComposerContext';
+import { useEffect } from 'octane';
+
+export function SelectionAlwaysOnDisplay(props) {
+	const [editor] = useLexicalComposerContext();
+	const onReposition = props.onReposition;
+	useEffect(() => selectionAlwaysOnDisplay(editor, onReposition), [editor, onReposition]);
+	return null;
+}

package/src/LexicalTabIndentationPlugin.tsrx

@@ -0,0 +1,21 @@
+// Ported from @lexical/react/src/LexicalTabIndentationPlugin.tsx.
+// registerTabIndentation is from @lexical/extension's framework-agnostic core.
+import { registerTabIndentation } from '@lexical/extension';
+import { useLexicalComposerContext } from './LexicalComposerContext';
+import { useEffect } from 'octane';
+
+export { registerTabIndentation } from '@lexical/extension';
+
+export function TabIndentationPlugin(props) {
+	const [editor] = useLexicalComposerContext();
+	const maxIndent = props.maxIndent;
+	const canIndent = props.$canIndent;
+
+	useEffect(() => registerTabIndentation(editor, maxIndent, canIndent), [
+		editor,
+		maxIndent,
+		canIndent,
+	]);
+
+	return null;
+}

package/src/LexicalTableOfContentsPlugin.tsrx

@@ -0,0 +1,213 @@
+// Ported from @lexical/react/src/LexicalTableOfContentsPlugin.tsx. Keeps an ordered
+// list of [key, text, tag] entries in sync with every HeadingNode. Render-prop
+// component: `children(entries, editor)` returns the element to render.
+import { useLexicalComposerContext } from './LexicalComposerContext';
+import { $isHeadingNode, HeadingNode } from '@lexical/rich-text';
+import { $getNextRightPreorderNode } from '@lexical/utils';
+import { $getNodeByKey, $getRoot, $isElementNode, TextNode } from 'lexical';
+import { useEffect, useState } from 'octane';
+
+function toEntry(heading) {
+	return [heading.getKey(), heading.getTextContent(), heading.getTag()];
+}
+
+function $insertHeadingIntoTableOfContents(prevHeading, newHeading, currentTableOfContents) {
+	if (newHeading === null) {
+		return currentTableOfContents;
+	}
+	const newEntry = toEntry(newHeading);
+	let newTableOfContents = [];
+	if (prevHeading === null) {
+		if (currentTableOfContents.length > 0 && currentTableOfContents[0][0] === newHeading.__key) {
+			return currentTableOfContents;
+		}
+		newTableOfContents = [newEntry, ...currentTableOfContents];
+	} else {
+		for (let i = 0; i < currentTableOfContents.length; i++) {
+			const key = currentTableOfContents[i][0];
+			newTableOfContents.push(currentTableOfContents[i]);
+			if (key === prevHeading.getKey() && key !== newHeading.getKey()) {
+				if (
+					i + 1 < currentTableOfContents.length &&
+						currentTableOfContents[i + 1][0] === newHeading.__key
+				) {
+					return currentTableOfContents;
+				}
+				newTableOfContents.push(newEntry);
+			}
+		}
+	}
+	return newTableOfContents;
+}
+
+function $deleteHeadingFromTableOfContents(key, currentTableOfContents) {
+	const newTableOfContents = [];
+	for (const heading of currentTableOfContents) {
+		if (heading[0] !== key) {
+			newTableOfContents.push(heading);
+		}
+	}
+	return newTableOfContents;
+}
+
+function $updateHeadingInTableOfContents(heading, currentTableOfContents) {
+	const newTableOfContents = [];
+	for (const oldHeading of currentTableOfContents) {
+		if (oldHeading[0] === heading.getKey()) {
+			newTableOfContents.push(toEntry(heading));
+		} else {
+			newTableOfContents.push(oldHeading);
+		}
+	}
+	return newTableOfContents;
+}
+
+function $updateHeadingPosition(prevHeading, heading, currentTableOfContents) {
+	const newTableOfContents = [];
+	const newEntry = toEntry(heading);
+
+	if (!prevHeading) {
+		newTableOfContents.push(newEntry);
+	}
+	for (const oldHeading of currentTableOfContents) {
+		if (oldHeading[0] === heading.getKey()) {
+			continue;
+		}
+		newTableOfContents.push(oldHeading);
+		if (prevHeading && oldHeading[0] === prevHeading.getKey()) {
+			newTableOfContents.push(newEntry);
+		}
+	}
+
+	return newTableOfContents;
+}
+
+function $getPreviousHeading(node) {
+	let prevHeading = $getNextRightPreorderNode(node);
+	while (prevHeading !== null && !$isHeadingNode(prevHeading)) {
+		prevHeading = $getNextRightPreorderNode(prevHeading);
+	}
+	return prevHeading;
+}
+
+export function TableOfContentsPlugin(props) {
+	const [tableOfContents, setTableOfContents] = useState([]);
+	const [editor] = useLexicalComposerContext();
+
+	useEffect(() => {
+		let currentTableOfContents = [];
+		editor.read('latest', () => {
+			const updateCurrentTableOfContents = (node) => {
+				for (const child of node.getChildren()) {
+					if ($isHeadingNode(child)) {
+						currentTableOfContents.push([
+							child.getKey(),
+							child.getTextContent(),
+							child.getTag(),
+						]);
+					} else if ($isElementNode(child)) {
+						updateCurrentTableOfContents(child);
+					}
+				}
+			};
+
+			updateCurrentTableOfContents($getRoot());
+			setTableOfContents(currentTableOfContents);
+		});
+
+		const removeRootUpdateListener = editor.registerUpdateListener(({
+			editorState,
+			dirtyElements,
+		}) => {
+			editorState.read(() => {
+				const updateChildHeadings = (node) => {
+					for (const child of node.getChildren()) {
+						if ($isHeadingNode(child)) {
+							const prevHeading = $getPreviousHeading(child);
+							currentTableOfContents = $updateHeadingPosition(
+								prevHeading,
+								child,
+								currentTableOfContents,
+							);
+							setTableOfContents(currentTableOfContents);
+						} else if ($isElementNode(child)) {
+							updateChildHeadings(child);
+						}
+					}
+				};
+
+				$getRoot().getChildren().forEach((node) => {
+					if ($isElementNode(node) && dirtyElements.get(node.__key)) {
+						updateChildHeadings(node);
+					}
+				});
+			});
+		});
+
+		const removeHeaderMutationListener = editor.registerMutationListener(HeadingNode, (
+			mutatedNodes,
+		) => {
+			editor.read('latest', () => {
+				for (const [nodeKey, mutation] of mutatedNodes) {
+					if (mutation === 'created') {
+						const newHeading = $getNodeByKey(nodeKey);
+						if ($isHeadingNode(newHeading)) {
+							const prevHeading = $getPreviousHeading(newHeading);
+							currentTableOfContents = $insertHeadingIntoTableOfContents(
+								prevHeading,
+								newHeading,
+								currentTableOfContents,
+							);
+						}
+					} else if (mutation === 'destroyed') {
+						currentTableOfContents = $deleteHeadingFromTableOfContents(
+							nodeKey,
+							currentTableOfContents,
+						);
+					} else if (mutation === 'updated') {
+						const newHeading = $getNodeByKey(nodeKey);
+						if ($isHeadingNode(newHeading)) {
+							const prevHeading = $getPreviousHeading(newHeading);
+							currentTableOfContents = $updateHeadingPosition(
+								prevHeading,
+								newHeading,
+								currentTableOfContents,
+							);
+						}
+					}
+				}
+				setTableOfContents(currentTableOfContents);
+			});
+		}, { skipInitialization: true });
+
+		const removeTextNodeMutationListener = editor.registerMutationListener(TextNode, (
+			mutatedNodes,
+		) => {
+			editor.read('latest', () => {
+				for (const [nodeKey, mutation] of mutatedNodes) {
+					if (mutation === 'updated') {
+						const currNode = $getNodeByKey(nodeKey);
+						if (currNode !== null) {
+							const parentNode = currNode.getParentOrThrow();
+							if ($isHeadingNode(parentNode)) {
+								currentTableOfContents = $updateHeadingInTableOfContents(
+									parentNode,
+									currentTableOfContents,
+								);
+								setTableOfContents(currentTableOfContents);
+							}
+						}
+					}
+				}
+			});
+		}, { skipInitialization: true });
+
+		return () => {
+			removeHeaderMutationListener();
+			removeTextNodeMutationListener();
+			removeRootUpdateListener();
+		};
+	}, [editor]);
+
+	return props.children(tableOfContents, editor);
+}

package/src/LexicalTablePlugin.tsrx

@@ -0,0 +1,67 @@
+// Ported from @lexical/react/src/LexicalTablePlugin.ts (usePropSignal inlined).
+import { signal } from '@lexical/extension';
+import {
+	$isScrollableTablesActive,
+	registerTableCellUnmergeTransform,
+	registerTablePlugin,
+	registerTableSelectionObserver,
+	setScrollableTablesActive,
+	TableCellNode,
+} from '@lexical/table';
+import { $fullReconcile } from 'lexical';
+import { useLexicalComposerContext } from './LexicalComposerContext';
+import { useEffect, useState } from 'octane';
+
+export function TablePlugin(props) {
+	const [editor] = useLexicalComposerContext();
+	const hasCellMerge =
+		props.hasCellMerge === undefined ? true : props.hasCellMerge;
+	const hasCellBackgroundColor =
+		props.hasCellBackgroundColor === undefined ? true : props.hasCellBackgroundColor;
+	const hasTabHandler =
+		props.hasTabHandler === undefined ? true : props.hasTabHandler;
+	const hasHorizontalScroll =
+		props.hasHorizontalScroll === undefined ? false : props.hasHorizontalScroll;
+	const hasNestedTables =
+		props.hasNestedTables === undefined ? false : props.hasNestedTables;
+
+	useEffect(() => {
+		const hadHorizontalScroll = $isScrollableTablesActive(editor);
+		if (hadHorizontalScroll !== hasHorizontalScroll) {
+			setScrollableTablesActive(editor, hasHorizontalScroll);
+			editor.update($fullReconcile);
+		}
+	}, [editor, hasHorizontalScroll]);
+
+	// usePropSignal — inlined.
+	const [hasNestedTablesSignal] = useState(() => signal(hasNestedTables));
+	if (hasNestedTablesSignal.peek() !== hasNestedTables) {
+		hasNestedTablesSignal.value = hasNestedTables;
+	}
+
+	useEffect(() => registerTablePlugin(editor, { hasNestedTables: hasNestedTablesSignal }), [
+		editor,
+		hasNestedTablesSignal,
+	]);
+
+	useEffect(() => registerTableSelectionObserver(editor, hasTabHandler), [editor, hasTabHandler]);
+
+	useEffect(() => {
+		if (!hasCellMerge) {
+			return registerTableCellUnmergeTransform(editor);
+		}
+	}, [editor, hasCellMerge]);
+
+	useEffect(() => {
+		if (hasCellBackgroundColor) {
+			return;
+		}
+		return editor.registerNodeTransform(TableCellNode, (node) => {
+			if (node.getBackgroundColor() !== null) {
+				node.setBackgroundColor(null);
+			}
+		});
+	}, [editor, hasCellBackgroundColor, hasCellMerge]);
+
+	return null;
+}

package/src/LexicalTypeaheadMenuPlugin.tsrx

@@ -0,0 +1,141 @@
+// Ported from @lexical/react/src/LexicalTypeaheadMenuPlugin.tsx — renders a
+// floating menu (mentions / slash-command) while the text before the cursor
+// matches `triggerFn`. `.tsrx` component (auto-slotted hooks); uses octane's
+// startTransition (the React version used a reactPatches shim).
+import { useLexicalComposerContext } from './LexicalComposerContext';
+import { LexicalMenu } from './shared/LexicalMenu.tsrx';
+import { useMenuAnchorRef } from './shared/useMenuAnchorRef';
+import {
+	getQueryTextForSearch,
+	isSelectionOnEntityBoundary,
+	tryToPositionRange,
+} from './typeaheadShared';
+import { $getSelection, $isRangeSelection, COMMAND_PRIORITY_LOW } from 'lexical';
+import { startTransition, useCallback, useEffect, useState } from 'octane';
+
+export { useBasicTypeaheadTriggerMatch, PUNCTUATION } from './typeaheadShared';
+export { MenuOption, SCROLL_TYPEAHEAD_OPTION_INTO_VIEW_COMMAND } from './shared/menuShared';
+export { useDynamicPositioning } from './shared/useDynamicPositioning';
+
+export function LexicalTypeaheadMenuPlugin(props) {
+	const options = props.options;
+	const onQueryChange = props.onQueryChange;
+	const onSelectOption = props.onSelectOption;
+	const onOpen = props.onOpen;
+	const onClose = props.onClose;
+	const menuRenderFn = props.menuRenderFn;
+	const triggerFn = props.triggerFn;
+	const anchorClassName = props.anchorClassName;
+	const commandPriority =
+		props.commandPriority != null ? props.commandPriority : COMMAND_PRIORITY_LOW;
+	const parent = props.parent;
+	const preselectFirstItem = props.preselectFirstItem !== false;
+	const ignoreEntityBoundary = props.ignoreEntityBoundary === true;
+
+	const [editor] = useLexicalComposerContext();
+	const [resolution, setResolution] = useState(null);
+	const anchorElementRef = useMenuAnchorRef(resolution, setResolution, anchorClassName, parent);
+
+	const closeTypeahead = useCallback(() => {
+		if (resolution === null) {
+			return;
+		}
+		const finish = () => setResolution(null);
+		let result;
+		try {
+			result = onClose && onClose();
+		} finally {
+			if (result) {
+				result.then(finish, finish);
+			} else {
+				finish();
+			}
+		}
+	}, [onClose, resolution]);
+
+	const openTypeahead = useCallback((res) => {
+		setResolution(res);
+		if (onOpen != null && resolution === null) {
+			onOpen(res);
+		}
+	}, [onOpen, resolution]);
+
+	useEffect(() => {
+		const updateListener = () => {
+			editor.read('latest', () => {
+				if (!editor.isEditable()) {
+					closeTypeahead();
+					return;
+				}
+				if (editor.isComposing()) {
+					return;
+				}
+				const editorWindow = editor._window || window;
+				const range = editorWindow.document.createRange();
+				const selection = $getSelection();
+				const text = getQueryTextForSearch(editor);
+				if (
+					!$isRangeSelection(selection) || !selection.isCollapsed() || text === null ||
+						range === null
+				) {
+					closeTypeahead();
+					return;
+				}
+				const match = triggerFn(text, editor);
+				onQueryChange(match ? match.matchingString : null);
+				if (
+					match !== null &&
+						(ignoreEntityBoundary || !isSelectionOnEntityBoundary(editor, match.leadOffset))
+				) {
+					const isRangePositioned = tryToPositionRange(
+						match.leadOffset,
+						range,
+						editorWindow,
+						editor.getRootElement(),
+					);
+					if (isRangePositioned !== null) {
+						startTransition(
+							() => openTypeahead({ getRect: () => range.getBoundingClientRect(), match }),
+						);
+						return;
+					}
+				}
+				closeTypeahead();
+			});
+		};
+		return editor.registerUpdateListener(updateListener);
+	}, [
+		editor,
+		triggerFn,
+		onQueryChange,
+		resolution,
+		closeTypeahead,
+		openTypeahead,
+		ignoreEntityBoundary,
+	]);
+
+	useEffect(
+		() => editor.registerEditableListener((isEditable) => {
+			if (!isEditable) {
+				closeTypeahead();
+			}
+		}),
+		[editor, closeTypeahead],
+	);
+
+	if (resolution === null || editor === null || anchorElementRef.current === null) {
+		return null;
+	}
+	return <LexicalMenu
+		close={closeTypeahead}
+		resolution={resolution}
+		editor={editor}
+		anchorElementRef={anchorElementRef}
+		options={options}
+		menuRenderFn={menuRenderFn}
+		shouldSplitNodeWithQuery={true}
+		onSelectOption={onSelectOption}
+		commandPriority={commandPriority}
+		preselectFirstItem={preselectFirstItem}
+	/>;
+}

package/src/autoEmbedShared.ts

@@ -0,0 +1,43 @@
+// Typed / agnostic surface of @lexical/react/src/LexicalAutoEmbedPlugin.tsx — the
+// types, the URL matcher, the INSERT_EMBED_COMMAND, and the AutoEmbedOption class.
+// The component lives in LexicalAutoEmbedPlugin.tsrx.
+import type { LexicalCommand, LexicalEditor, LexicalNode } from 'lexical';
+
+import { createCommand } from 'lexical';
+import { MenuOption } from './shared/menuShared';
+
+export type EmbedMatchResult<TEmbedMatchResult = unknown> = {
+	url: string;
+	id: string;
+	data?: TEmbedMatchResult;
+};
+
+export interface EmbedConfig<
+	TEmbedMatchResultData = unknown,
+	TEmbedMatchResult = EmbedMatchResult<TEmbedMatchResultData>,
+> {
+	type: string;
+	parseUrl: (text: string) => Promise<TEmbedMatchResult | null> | TEmbedMatchResult | null;
+	insertNode: (editor: LexicalEditor, result: TEmbedMatchResult) => void;
+}
+
+export const URL_MATCHER =
+	/((https?:\/\/(www\.)?)|(www\.))[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_+.~#?&//=]*)/;
+
+export const INSERT_EMBED_COMMAND: LexicalCommand<EmbedConfig['type']> =
+	createCommand('INSERT_EMBED_COMMAND');
+
+export class AutoEmbedOption extends MenuOption {
+	title: string;
+	onSelect: (targetNode: LexicalNode | null) => void;
+	constructor(
+		title: string,
+		options: {
+			onSelect: (targetNode: LexicalNode | null) => void;
+		},
+	) {
+		super(title);
+		this.title = title;
+		this.onSelect = options.onSelect.bind(this);
+	}
+}

package/src/index.ts

@@ -0,0 +1,99 @@
+// @octanejs/lexical — Octane bindings for Lexical, a port of @lexical/react.
+//
+// @lexical/react has NO root barrel — it ships per-subpath modules. This package
+// mirrors that layout (import from `@octanejs/lexical/LexicalComposer`, etc.), and
+// ALSO provides this convenience barrel that re-exports everything.
+//
+// Components/nodes live in `.tsrx` files (the octane compiler handles them; tsgo
+// treats them as `any` via the `*.tsrx` ambient module). Genuinely-typed surface —
+// config types and the framework-agnostic helpers — is re-exported from real `.ts`
+// sources / the `@lexical/*` packages so consumers keep those types.
+
+// --- Core editor ---
+export {
+	LexicalComposerContext,
+	createLexicalComposerContext,
+	useLexicalComposerContext,
+} from './LexicalComposerContext';
+export type {
+	LexicalComposerContextType,
+	LexicalComposerContextWithEditor,
+} from './LexicalComposerContext';
+export type { InitialConfigType, InitialEditorStateType } from './types';
+
+export { LexicalComposer } from './LexicalComposer.tsrx';
+export { ContentEditable, ContentEditableElement } from './LexicalContentEditable.tsrx';
+export { RichTextPlugin } from './LexicalRichTextPlugin.tsrx';
+export { PlainTextPlugin } from './LexicalPlainTextPlugin.tsrx';
+export { LexicalErrorBoundary } from './LexicalErrorBoundary.tsrx';
+
+export { useLexicalEditable } from './useLexicalEditable';
+export { useLexicalSubscription, type LexicalSubscription } from './useLexicalSubscription';
+
+// --- Phase 2 plugins ---
+export { HistoryPlugin } from './LexicalHistoryPlugin.tsrx';
+export { createEmptyHistoryState } from '@lexical/history';
+export type { HistoryState } from '@lexical/history';
+export { OnChangePlugin } from './LexicalOnChangePlugin.tsrx';
+export { AutoFocusPlugin } from './LexicalAutoFocusPlugin.tsrx';
+export { ClearEditorPlugin } from './LexicalClearEditorPlugin.tsrx';
+
+// --- Phase 3 plugins ---
+export { ListPlugin } from './LexicalListPlugin.tsrx';
+export { CheckListPlugin } from './LexicalCheckListPlugin.tsrx';
+export { LinkPlugin } from './LexicalLinkPlugin.tsrx';
+export { AutoLinkPlugin } from './LexicalAutoLinkPlugin.tsrx';
+export { createLinkMatcherWithRegExp } from '@lexical/link';
+export { HashtagPlugin } from './LexicalHashtagPlugin.tsrx';
+export { TabIndentationPlugin } from './LexicalTabIndentationPlugin.tsrx';
+export { registerTabIndentation } from '@lexical/extension';
+export { MarkdownShortcutPlugin, DEFAULT_TRANSFORMERS } from './LexicalMarkdownShortcutPlugin.tsrx';
+export { TablePlugin } from './LexicalTablePlugin.tsrx';
+export { NodeEventPlugin } from './LexicalNodeEventPlugin.tsrx';
+export { EditorRefPlugin } from './LexicalEditorRefPlugin.tsrx';
+export { HorizontalRulePlugin } from './LexicalHorizontalRulePlugin.tsrx';
+export { HorizontalRuleNode, $createHorizontalRuleNode } from './LexicalHorizontalRuleNode.tsrx';
+export { $isHorizontalRuleNode, INSERT_HORIZONTAL_RULE_COMMAND } from '@lexical/extension';
+
+// --- Phase 3 hooks ---
+export { useLexicalNodeSelection } from './useLexicalNodeSelection';
+export { useLexicalTextEntity } from './useLexicalTextEntity';
+export { useLexicalIsTextContentEmpty } from './useLexicalIsTextContentEmpty';
+
+// --- Phase 4: menus + utilities ---
+export { LexicalTypeaheadMenuPlugin } from './LexicalTypeaheadMenuPlugin.tsrx';
+export { LexicalNodeMenuPlugin } from './LexicalNodeMenuPlugin.tsrx';
+export { useBasicTypeaheadTriggerMatch, PUNCTUATION } from './typeaheadShared';
+export { MenuOption, SCROLL_TYPEAHEAD_OPTION_INTO_VIEW_COMMAND } from './shared/menuShared';
+export type {
+	MenuRef,
+	MenuRenderFn,
+	MenuResolution,
+	MenuTextMatch,
+	TriggerFn,
+} from './shared/menuShared';
+export { useDynamicPositioning } from './shared/useDynamicPositioning';
+export { useMenuAnchorRef } from './shared/useMenuAnchorRef';
+export { ClickableLinkPlugin } from './LexicalClickableLinkPlugin.tsrx';
+export { SelectionAlwaysOnDisplay } from './LexicalSelectionAlwaysOnDisplay.tsrx';
+export { useLexicalSlotRef } from './useLexicalSlotRef';
+
+// --- Phase 4: nested editor + decorator-block building blocks ---
+export { LexicalNestedComposer } from './LexicalNestedComposer.tsrx';
+export { DecoratorBlockNode, $isDecoratorBlockNode } from './LexicalDecoratorBlockNode';
+export type { SerializedDecoratorBlockNode } from './LexicalDecoratorBlockNode';
+export { BlockWithAlignableContents } from './LexicalBlockWithAlignableContents.tsrx';
+export { CollaborationContext, useCollaborationContext } from './LexicalCollaborationContext';
+export type { CollaborationContextType } from './LexicalCollaborationContext';
+export { CharacterLimitPlugin } from './LexicalCharacterLimitPlugin.tsrx';
+export { useCharacterLimit } from './shared/useCharacterLimit';
+export { TableOfContentsPlugin } from './LexicalTableOfContentsPlugin.tsrx';
+export { LexicalAutoEmbedPlugin } from './LexicalAutoEmbedPlugin.tsrx';
+export { URL_MATCHER, INSERT_EMBED_COMMAND, AutoEmbedOption } from './autoEmbedShared';
+export type { EmbedConfig, EmbedMatchResult } from './autoEmbedShared';
+export { DraggableBlockPlugin_EXPERIMENTAL } from './LexicalDraggableBlockPlugin.tsrx';
+export {
+	NodeContextMenuPlugin,
+	NodeContextMenuOption,
+	NodeContextMenuSeparator,
+} from './LexicalNodeContextMenuPlugin.tsrx';