From e1a5da89b7f97f4337449f0867c0f50d21aa7bf7 Mon Sep 17 00:00:00 2001
From: Amp <amp@ampcode.com>
Date: Sat, 14 Nov 2026 17:29:02 +0000
Subject: [PATCH] feat(rust): the extension API (buildEditorFromExtensions),
 with a JS-recorded scripts/extensions vector

## Description

The Rust port had `register_*` functions for each package but no
extension API, so nothing could build an editor from extensions the way
`buildEditorFromExtensions` does, and the extension-shaped parts of
upstream (`InitialStateExtension`, `ClearEditorExtension`, signals) had no
counterpart.

This ports it behind the existing `extension` feature:

- `lexical`'s `extension-core`: `defineExtension`, `configExtension`,
  `declarePeerDependency`, `safeCast`, `shallowMergeConfig` and the
  `LexicalExtension` types, plus `mergeRegister`.
- `@lexical/extension`'s builder: `buildEditorFromExtensions` and
  `LexicalBuilder` (dependency and peer resolution, the duplicate-name and
  conflict invariants, config merging, the init/build/register phases in
  JS's order, disposal), `ExtensionRep`, and the dependency lookups
  (`getExtensionDependencyFromEditor`, `getPeerDependencyFromEditor` and
  their `OrThrow` forms).
- A port of `@preact/signals-core` 1.14.4 (`signal`, `computed`, `effect`,
  `batch`, `untracked`), with `namedSignals` and `watchedSignal`.
- `InitialStateExtension`, `ClearEditorExtension`, `EditorStateExtension`
  and `DecoratorTextExtension`'s extension.

`packages/lexical-conformance` gains JSON-described test extensions
(`ExtensionSpec`) that log each phase with their merged config, and a
`scripts/extensions` vector with 26 cases: a dependency diamond, duplicate
and conflicting extensions, peers present and absent, peers read before
they are configured or built, every form of `$initialEditorState`, node
registration, `ClearEditorExtension`, `EditorStateExtension` as a signal,
`namedSignals` toggling a registration, and disposal. Builder errors are
recorded in JS's wording, and both Rust and Swift reproduce it. Swift
matched every case, so no Swift source changes.

Not ported, each listed in PARITY.md: the editor options a headless Rust
editor lacks (`namespace`, `theme`, `html`, `editable`, `onError`,
`parentEditor`, `dom`...), node replacements, `HMRExtension`,
`HorizontalRuleExtension` and the other DOM- or keyboard-bound extensions,
and the packages' own extensions (`RichTextExtension`, `HistoryExtension`,
...), whose `register_*` functions are already ported.

## Test plan

### Before

```
$ cargo run -q --locked --release -p lexical-conformance
| **Total** | 631 | 631 | 0 | 0 | 0 | |
```

(No `scripts/extensions` row.)

### After

```
$ cargo run -q --locked --release -p lexical-conformance
| `property/sequences` | 81 | 81 | 0 | 0 | 0 | pass |
| `scripts/extensions` | 26 | 26 | 0 | 0 | 0 | pass |
| `scripts/text` | 13 | 13 | 0 | 0 | 0 | pass |
| **Total** | 657 | 657 | 0 | 0 | 0 | |
```

Mutation checks (each reverted): `merge_register` cleaning up in forward
order fails 4 cases; root `configExtension` overrides not merged fails 4;
batch snapshots never reconciled fails 1; an extension recorded before its
dependencies fails 2; in Swift, no array concatenation in the test
`mergeConfig` fails 7.

`cargo fmt --all --check`, `cargo clippy --workspace --all-targets
--all-features --locked -- -D warnings`, `cargo test --workspace
--all-features --locked`, `cargo doc` with `-D warnings`, `cargo +1.88
check -p lexical-editor --all-features`, `--no-default-features` alone and
with `extension`, and the Rune app's clippy all pass.
`UPDATE_VECTORS=1 pnpm exec vitest run src/scripts.test.ts`: 20 passed,
and no vector changed (md5). Swift: `swift build --build-tests` and
`swift test --skip-build --filter ConformanceTests`, 33 tests in 13 suites
passed.

Amp-Thread-ID: https://ampcode.com/threads/T-16d45229-bfa8-417a-a091-d3e3888d830d
---
 packages/lexical-conformance/src/ops.ts       | 567 ++++++++++++-
 .../lexical-conformance/src/scripts.test.ts   | 277 +++++++
 .../vectors/scripts/extensions.json           |  28 +
 rust/DESIGN.md                                |   5 +-
 rust/PARITY.md                                |  64 +-
 rust/conformance/src/scripts.rs               | 134 +++-
 rust/conformance/src/scripts/extensions.rs    | 536 +++++++++++++
 rust/conformance/src/suites/mod.rs            |   5 +
 rust/lexical-editor/Cargo.toml                |   8 +-
 rust/lexical-editor/src/editor.rs             |   6 +
 .../src/extension/clear_editor_extension.rs   | 133 +++
 rust/lexical-editor/src/extension/config.rs   |  31 +
 .../src/extension/decorator_text_extension.rs |  13 +
 .../src/extension/editor_state_extension.rs   |  46 ++
 .../src/extension/extension_rep.rs            | 383 +++++++++
 .../src/extension/get_extension_dependency.rs |  42 +
 .../get_extension_dependency_from_editor.rs   |  26 +
 .../get_peer_dependency_from_editor.rs        |  41 +
 .../src/extension/initial_state_extension.rs  | 165 ++++
 .../src/extension/lexical_builder.rs          | 417 ++++++++++
 rust/lexical-editor/src/extension/mod.rs      |  65 +-
 .../src/extension/named_signals.rs            |  42 +
 rust/lexical-editor/src/extension/signals.rs  | 758 ++++++++++++++++++
 .../src/extension/watched_signal.rs           |  36 +
 .../src/extension_core/define_extension.rs    |  49 ++
 rust/lexical-editor/src/extension_core/mod.rs |  23 +
 .../src/extension_core/safe_cast.rs           |   8 +
 .../extension_core/shallow_merge_config.rs    |  16 +
 .../src/extension_core/types.rs               | 649 +++++++++++++++
 rust/lexical-editor/src/lib.rs                |  15 +
 rust/lexical-editor/src/merge_register.rs     |  14 +
 rust/lexical-editor/src/ordered.rs            |  18 +
 .../Tests/ConformanceTests/ExtensionOps.swift | 332 ++++++++
 swift/Tests/ConformanceTests/Ops.swift        |  89 +-
 .../Tests/ConformanceTests/ScriptTests.swift  |  18 +-
 35 files changed, 4962 insertions(+), 97 deletions(-)
 create mode 100644 packages/lexical-conformance/vectors/scripts/extensions.json
 create mode 100644 rust/conformance/src/scripts/extensions.rs
 create mode 100644 rust/lexical-editor/src/extension/clear_editor_extension.rs
 create mode 100644 rust/lexical-editor/src/extension/config.rs
 create mode 100644 rust/lexical-editor/src/extension/editor_state_extension.rs
 create mode 100644 rust/lexical-editor/src/extension/extension_rep.rs
 create mode 100644 rust/lexical-editor/src/extension/get_extension_dependency.rs
 create mode 100644 rust/lexical-editor/src/extension/get_extension_dependency_from_editor.rs
 create mode 100644 rust/lexical-editor/src/extension/get_peer_dependency_from_editor.rs
 create mode 100644 rust/lexical-editor/src/extension/initial_state_extension.rs
 create mode 100644 rust/lexical-editor/src/extension/lexical_builder.rs
 create mode 100644 rust/lexical-editor/src/extension/named_signals.rs
 create mode 100644 rust/lexical-editor/src/extension/signals.rs
 create mode 100644 rust/lexical-editor/src/extension/watched_signal.rs
 create mode 100644 rust/lexical-editor/src/extension_core/define_extension.rs
 create mode 100644 rust/lexical-editor/src/extension_core/mod.rs
 create mode 100644 rust/lexical-editor/src/extension_core/safe_cast.rs
 create mode 100644 rust/lexical-editor/src/extension_core/shallow_merge_config.rs
 create mode 100644 rust/lexical-editor/src/extension_core/types.rs
 create mode 100644 rust/lexical-editor/src/merge_register.rs
 create mode 100644 swift/Tests/ConformanceTests/ExtensionOps.swift

diff --git a/packages/lexical-conformance/src/ops.ts b/packages/lexical-conformance/src/ops.ts
index 170c8eea967..69687e8c451 100644
--- a/packages/lexical-conformance/src/ops.ts
+++ b/packages/lexical-conformance/src/ops.ts
@@ -13,9 +13,21 @@ import {
   registerCodeIndentation,
 } from '@lexical/code-core';
 import {
+  batch,
+  buildEditorFromExtensions,
+  ClearEditorExtension,
+  computed,
+  DecoratorTextExtension,
   DecoratorTextNode,
+  EditorStateExtension,
+  effect,
+  getExtensionDependencyFromEditor,
+  getKnownTypesAndNodes,
+  getPeerDependencyFromEditor,
   HorizontalRuleNode,
   namedSignals,
+  type NamedSignalsOutput,
+  untracked,
 } from '@lexical/extension';
 import {HashtagNode, registerLexicalHashtag} from '@lexical/hashtag';
 import {createEmptyHistoryState, registerHistory} from '@lexical/history';
@@ -65,6 +77,7 @@ import {
   $createNodeSelection,
   $createParagraphNode,
   $createRangeSelection,
+  $createTextNode,
   $getCaretRange,
   $getChildCaret,
   $getNodeByKey,
@@ -87,6 +100,8 @@ import {
   $setSelectionFromCaretRange,
   $setState,
   type AnyLexicalCommand,
+  type AnyLexicalExtension,
+  type AnyLexicalExtensionArgument,
   type AnyStateConfig,
   CAN_REDO_COMMAND,
   CAN_UNDO_COMMAND,
@@ -94,10 +109,12 @@ import {
   CLEAR_EDITOR_COMMAND,
   CLEAR_HISTORY_COMMAND,
   COMMAND_PRIORITY_EDITOR,
+  configExtension,
   CONTROLLED_TEXT_INSERTION_COMMAND,
   createCommand,
   createEditor,
   createState,
+  declarePeerDependency,
   DELETE_CHARACTER_COMMAND,
   DELETE_LINE_COMMAND,
   DELETE_WORD_COMMAND,
@@ -110,6 +127,8 @@ import {
   INSERT_TAB_COMMAND,
   type LexicalCommand,
   type LexicalEditor,
+  type LexicalEditorWithDispose,
+  type LexicalExtension,
   type LexicalNode,
   type NodeCaret,
   OUTDENT_CONTENT_COMMAND,
@@ -120,8 +139,10 @@ import {
   resetRandomKey,
   RootNode,
   SELECT_ALL_COMMAND,
+  type SerializedEditorState,
   type SerializedLexicalNode,
   SET_TEXT_FORMAT_COMMAND,
+  shallowMergeConfig,
   TextNode,
   UNDO_COMMAND,
 } from 'lexical';
@@ -241,8 +262,127 @@ export type HandlerSpec = {
 export type Step = (
   | {update: Action[]; tag?: string[]}
   | {dispatch: string; payload?: Json}
+  /** `editor.dispose()` of an editor built from `extensions`. */
+  | {dispose: true}
+  /**
+   * In one `batch`, `output[signal].value = value` for each
+   * `[extension, signal, value]`, where `output` is
+   * `getExtensionDependencyFromEditor(editor, extension).output` of an
+   * extension of `extensionDefs` with `signals` (its `namedSignals`).
+   */
+  | {setSignals: [string, string, Json][]}
+  /**
+   * Logs `['dependency', key, config]`:
+   * `getExtensionDependencyFromEditor(editor, extension).config` of an
+   * extension of `extensionDefs`.
+   */
+  | {logDependency: string}
+  /**
+   * Logs `['peer', name, config]`: the config of
+   * `getPeerDependencyFromEditor(editor, name)`, or `null` without one.
+   */
+  | {logPeer: string}
 ) & {now?: number};
 
+/** A config of an extension of `extensionDefs`, or overrides of one. */
+export type ExtensionConfig = {[key: string]: Json};
+
+/**
+ * An extension, by its key in `extensionDefs` or its name in
+ * REAL_EXTENSIONS, alone or with config overrides
+ * (`configExtension(extension, ...overrides)`).
+ */
+export type ExtensionArg = string | [string, ...ExtensionConfig[]];
+
+/** The phases an extension of `extensionDefs` defines. */
+export type ExtensionPhase =
+  | 'init'
+  | 'build'
+  | 'register'
+  | 'afterRegistration';
+
+/**
+ * A test extension, made by `testExtension` from JSON so that every runner
+ * can make the same one. Each phase it defines (all four by default) logs
+ * its name and merged config: `['init', name, config]`,
+ * `['build', name, config]`, `['register', name, config, text]` and
+ * `['afterRegistration', name, config, text]`, where `text` is the root
+ * text of `editor.getEditorState()`. `init` returns `{init: name}`. The
+ * clean-ups that `register` and `afterRegistration` return log
+ * `['unregister', name]` and `['afterUnregister', name]`. Unless it has
+ * `signals`, `register` also handles `EXTENSION_COMMAND` (a command the
+ * script makes), logging `['handled', name, payload]` and returning false.
+ */
+export type ExtensionSpec = {
+  name: string;
+  /** The default config; without it, the builder's default is `{}`. */
+  config?: ExtensionConfig;
+  dependencies?: ExtensionArg[];
+  /** `declarePeerDependency(name, config?)` each. */
+  peerDependencies?: [string, ExtensionConfig?][];
+  conflictsWith?: string[];
+  /** Node types, of `@lexical/extension`'s decorators (NODES). */
+  nodes?: string[];
+  /**
+   * `$initialEditorState`: `null`, an editor state serialized with
+   * `JSON.stringify` (`json`), or a function that appends a paragraph
+   * with `text` to the root.
+   */
+  initialEditorState?: null | {json: SerializedEditorState} | {text: string};
+  /**
+   * `mergeConfig` that merges with `shallowMergeConfig`, then concatenates
+   * every array of the overrides to the config's array of the same key.
+   */
+  mergeConfig?: 'concat';
+  phases?: ExtensionPhase[];
+  /**
+   * `init` logs `['initPeer', name, peer, config]` for `state.getPeer(peer)`
+   * of each, `null` when it is absent.
+   */
+  initPeers?: string[];
+  /** `build` logs `['buildPeer', name, peer, config]`, as `initPeers`. */
+  buildPeers?: string[];
+  /**
+   * `init` logs `['initDependency', name, key, config]` and `build`
+   * `['buildDependency', name, key, config]` for
+   * `state.getDependency(extension)` of each key of `extensionDefs`.
+   */
+  lookups?: string[];
+  /** `register` logs `['initResult', name, state.getInitResult()]`. */
+  initResult?: boolean;
+  /**
+   * `init` logs `['knownTypes', name, types]` of
+   * `getKnownTypesAndNodes(editorConfig)`, `['dependents', name, names]` of
+   * `state.getDirectDependentNames()` and `['peerNames', name, names]` of
+   * `state.getPeerNameSet()`.
+   */
+  inspect?: boolean;
+  /** `register` logs `['aborted', name]` when `state.getSignal()` aborts. */
+  abort?: boolean;
+  /**
+   * `register` registers an update listener that logs
+   * `['update', name, tags]` (sorted).
+   */
+  listen?: boolean;
+  /**
+   * `build` returns `namedSignals(config)`, of a config with a boolean
+   * `disabled` and a string `label`; `register` runs two effects. One logs
+   * `['summary', name, summary]`, where `summary` is a `computed` of
+   * `'off'` when disabled and `on:<label>` otherwise. The other, unless
+   * disabled, logs `['enable', name, label]` with the label read
+   * `untracked`, and handles `EXTENSION_COMMAND`, logging
+   * `['handled', name, label, payload]`; its clean-up logs
+   * `['disable', name]` and unregisters the handler.
+   */
+  signals?: boolean;
+  /**
+   * `register` runs an effect that logs `['editorState', name, text]`, the
+   * root text of the output of `EditorStateExtension`, which the extension
+   * has as a dependency.
+   */
+  editorState?: boolean;
+};
+
 export type Script = {
   name: string;
   /** Names from TRANSFORMS, registered in order. */
@@ -314,6 +454,16 @@ export type Script = {
    * registrations (inserting a rule by command, clicks) are left out.
    */
   extension?: boolean;
+  /**
+   * Build the editor with `buildEditorFromExtensions(...)` of these
+   * extensions instead of `createEditor`; the package flags above don't
+   * apply. The transforms, handlers and history are registered on the
+   * built editor. The build is recorded in `build`, and when it throws,
+   * the script has no steps.
+   */
+  extensions?: ExtensionArg[];
+  /** The test extensions `extensions` names, by key. */
+  extensionDefs?: {[key: string]: ExtensionSpec};
   steps: Step[];
   /** Record `state` after every step (default), or after the last only. */
   snapshot?: 'every' | 'final';
@@ -331,12 +481,32 @@ export type StepResult = {
   error?: true;
 };
 
-export type ScriptResult = Script & {results: StepResult[]};
+/**
+ * What `buildEditorFromExtensions` logged, then either the state, selection
+ * and text of the built editor, as a step records them, or the message it
+ * threw.
+ */
+export type BuildResult = {
+  log: Json[];
+  state?: string;
+  compact?: string;
+  selection?: Json;
+  text?: string;
+  error?: string;
+};
+
+export type ScriptResult = Script & {
+  build?: BuildResult;
+  results: StepResult[];
+};
 
 type Context = {
   editor: LexicalEditor;
   log: Json[];
   commands: Map<string, LexicalCommand<Json>>;
+  /** The test extensions made so far, by key. */
+  extensions: Map<string, AnyLexicalExtension>;
+  defs: {[key: string]: ExtensionSpec};
 };
 
 function $node(key: string): LexicalNode {
@@ -940,33 +1110,336 @@ const TRANSFORMS: Record<string, (ctx: Context) => () => void> = {
     }),
 };
 
+/**
+ * The extensions of `@lexical/extension` an `ExtensionArg` may name, as the
+ * package exports them, without config overrides (their configs aren't
+ * JSON).
+ */
+const REAL_EXTENSIONS = new Map<string, AnyLexicalExtension>([
+  ['ClearEditorExtension', ClearEditorExtension],
+  ['DecoratorTextExtension', DecoratorTextExtension],
+  ['EditorStateExtension', EditorStateExtension],
+]);
+
+/** The node classes an `ExtensionSpec`'s `nodes` names, by type. */
+const NODES = new Map<string, typeof LexicalNode>([
+  ['decorator-text', DecoratorTextNode],
+  ['horizontalrule', HorizontalRuleNode],
+]);
+
+const EXTENSION_PHASES: ExtensionPhase[] = [
+  'init',
+  'build',
+  'register',
+  'afterRegistration',
+];
+
+function extensionOf(ctx: Context, key: string): AnyLexicalExtension {
+  const real = REAL_EXTENSIONS.get(key);
+  if (real !== undefined) {
+    return real;
+  }
+  let made = ctx.extensions.get(key);
+  if (made === undefined) {
+    const spec = ctx.defs[key];
+    if (spec === undefined) {
+      throw new Error(`unknown extension ${key}`);
+    }
+    made = testExtension(ctx, spec);
+    ctx.extensions.set(key, made);
+  }
+  return made;
+}
+
+function extensionArg(
+  ctx: Context,
+  extensionArgument: ExtensionArg,
+): AnyLexicalExtensionArgument {
+  if (typeof extensionArgument === 'string') {
+    return extensionOf(ctx, extensionArgument);
+  }
+  const [key, ...configs] = extensionArgument;
+  return configExtension(extensionOf(ctx, key), ...configs);
+}
+
+/** The test extension `spec` describes (see `ExtensionSpec`). */
+function testExtension(ctx: Context, spec: ExtensionSpec): AnyLexicalExtension {
+  const {name} = spec;
+  const log = (...entry: Json[]) => {
+    ctx.log.push(entry);
+  };
+  const phases = new Set(spec.phases ?? EXTENSION_PHASES);
+  const rootText = (editor: LexicalEditor) =>
+    editor.getEditorState().read(() => $getRoot().getTextContent());
+  type Signals = NamedSignalsOutput<{disabled: boolean; label: string}>;
+  const extension: LexicalExtension<ExtensionConfig, string, unknown, unknown> =
+    {name};
+  if (spec.config !== undefined) {
+    extension.config = spec.config;
+  }
+  if (spec.conflictsWith !== undefined) {
+    extension.conflictsWith = spec.conflictsWith;
+  }
+  if (spec.dependencies !== undefined) {
+    extension.dependencies = spec.dependencies.map(d => extensionArg(ctx, d));
+  }
+  if (spec.peerDependencies !== undefined) {
+    extension.peerDependencies = spec.peerDependencies.map(([peer, config]) =>
+      config === undefined
+        ? declarePeerDependency(peer)
+        : declarePeerDependency(peer, config),
+    );
+  }
+  if (spec.nodes !== undefined) {
+    const nodes = spec.nodes;
+    extension.nodes = () =>
+      nodes.map(type => {
+        const klass = NODES.get(type);
+        if (klass === undefined) {
+          throw new Error(`unknown node type ${type}`);
+        }
+        return klass;
+      });
+  }
+  if (spec.initialEditorState !== undefined) {
+    const initial = spec.initialEditorState;
+    if (initial === null) {
+      extension.$initialEditorState = null;
+    } else if ('json' in initial) {
+      extension.$initialEditorState = JSON.stringify(initial.json);
+    } else {
+      extension.$initialEditorState = () => {
+        $getRoot().append(
+          $createParagraphNode().append($createTextNode(initial.text)),
+        );
+      };
+    }
+  }
+  if (spec.mergeConfig === 'concat') {
+    extension.mergeConfig = (config, overrides) => {
+      const merged = shallowMergeConfig(config, overrides);
+      for (const k in overrides) {
+        const [a, b] = [config[k], overrides[k]];
+        if (Array.isArray(a) && Array.isArray(b)) {
+          merged[k] = [...a, ...b];
+        }
+      }
+      return merged;
+    };
+  }
+  if (phases.has('init')) {
+    extension.init = (editorConfig, config, state) => {
+      log('init', name, config);
+      if (spec.inspect) {
+        log('knownTypes', name, [...getKnownTypesAndNodes(editorConfig).types]);
+        log('dependents', name, [...state.getDirectDependentNames()]);
+        log('peerNames', name, [...state.getPeerNameSet()]);
+      }
+      for (const peer of spec.initPeers ?? []) {
+        const dep = state.getPeer<AnyLexicalExtension>(peer);
+        log('initPeer', name, peer, dep === undefined ? null : dep.config);
+      }
+      for (const key of spec.lookups ?? []) {
+        const {config: depConfig} = state.getDependency(extensionOf(ctx, key));
+        log('initDependency', name, key, depConfig);
+      }
+      return {init: name};
+    };
+  }
+  if (phases.has('build')) {
+    extension.build = (editor, config, state) => {
+      log('build', name, config);
+      for (const peer of spec.buildPeers ?? []) {
+        const dep = state.getPeer<AnyLexicalExtension>(peer);
+        log('buildPeer', name, peer, dep === undefined ? null : dep.config);
+      }
+      for (const key of spec.lookups ?? []) {
+        const {config: depConfig} = state.getDependency(extensionOf(ctx, key));
+        log('buildDependency', name, key, depConfig);
+      }
+      return spec.signals ? namedSignals(config) : undefined;
+    };
+  }
+  if (phases.has('register')) {
+    extension.register = (editor, config, state) => {
+      log('register', name, config, rootText(editor));
+      if (spec.initResult) {
+        log('initResult', name, state.getInitResult() as Json);
+      }
+      const cleanups: (() => void)[] = [];
+      if (spec.abort) {
+        state.getSignal().addEventListener('abort', () => log('aborted', name));
+      }
+      if (spec.listen) {
+        cleanups.push(
+          editor.registerUpdateListener(({tags}) =>
+            log('update', name, [...tags].sort()),
+          ),
+        );
+      }
+      const extensionCommand = command(ctx, 'EXTENSION_COMMAND');
+      if (spec.signals) {
+        const {disabled, label} = state.getOutput() as Signals;
+        const summary = computed(() =>
+          disabled.value ? 'off' : `on:${label.value}`,
+        );
+        cleanups.push(
+          effect(() => {
+            log('summary', name, summary.value);
+          }),
+          effect(() => {
+            if (disabled.value) {
+              return;
+            }
+            const current = untracked(() => label.value);
+            log('enable', name, current);
+            const unregister = editor.registerCommand(
+              extensionCommand,
+              payload => {
+                log('handled', name, current, payload);
+                return false;
+              },
+              COMMAND_PRIORITY_EDITOR,
+            );
+            return () => {
+              log('disable', name);
+              unregister();
+            };
+          }),
+        );
+      } else {
+        cleanups.push(
+          editor.registerCommand(
+            extensionCommand,
+            payload => {
+              log('handled', name, payload);
+              return false;
+            },
+            COMMAND_PRIORITY_EDITOR,
+          ),
+        );
+      }
+      if (spec.editorState) {
+        const editorState = state.getDependency(EditorStateExtension).output;
+        cleanups.push(
+          effect(() => {
+            log(
+              'editorState',
+              name,
+              editorState.value.read(() => $getRoot().getTextContent()),
+            );
+          }),
+        );
+      }
+      return () => {
+        log('unregister', name);
+        for (const cleanup of cleanups.reverse()) {
+          cleanup();
+        }
+      };
+    };
+  }
+  if (phases.has('afterRegistration')) {
+    extension.afterRegistration = (editor, config) => {
+      log('afterRegistration', name, config, rootText(editor));
+      return () => log('afterUnregister', name);
+    };
+  }
+  return extension;
+}
+
 /** A script's editor, set up with its transforms, handlers and listeners,
  * that runs steps one at a time. */
 export type Session = {
   editor: LexicalEditor;
+  /** What building the editor from `extensions` recorded. */
+  build?: BuildResult;
   /** Runs `step` and records it; `snapshot` records the state too. */
   run(step: Step, snapshot: boolean): StepResult;
 };
 
+/** The editor's state, selection and text, as a step records them. */
+function snapshotOf(
+  editor: LexicalEditor,
+  log: Json[],
+  snapshot: boolean,
+): StepResult {
+  // A dispatch outside an update commits in a microtask; `editor.read`
+  // commits it first.
+  const result: StepResult = editor.read(() => ({
+    log,
+    selection: $selectionSnapshot(),
+    text: $getRoot().getTextContent(),
+  }));
+  if (snapshot) {
+    const state = editor.getEditorState();
+    result.state = JSON.stringify(state.toJSON());
+    result.compact = JSON.stringify(state.toJSON(true));
+  }
+  return result;
+}
+
 /** Starts `script` (without running its steps) on a new headless editor. */
 export function startSession(script: Omit<Script, 'steps'>): Session {
   resetRandomKey();
-  const editor = createEditor({
-    namespace: '',
-    nodes: [
-      ...(script.richText ? [HeadingNode, QuoteNode] : []),
-      ...(script.list ? [ListNode, ListItemNode] : []),
-      ...(script.link ? [LinkNode, AutoLinkNode] : []),
-      ...(script.code ? [CodeNode, CodeHighlightNode] : []),
-      ...(script.overflow ? [OverflowNode] : []),
-      ...(script.hashtag ? [HashtagNode] : []),
-      ...(script.extension ? [HorizontalRuleNode, DecoratorTextNode] : []),
-    ],
-    onError: e => {
-      throw e;
-    },
-  });
-  const ctx: Context = {commands: new Map(), editor, log: []};
+  const ctx: Context = {
+    commands: new Map(),
+    defs: script.extensionDefs ?? {},
+    editor: undefined as never,
+    extensions: new Map(),
+    log: [],
+  };
+  let build: BuildResult | undefined;
+  if (script.extensions !== undefined) {
+    for (const flag of [
+      'richText',
+      'plainText',
+      'list',
+      'link',
+      'code',
+      'overflow',
+      'hashtag',
+      'extension',
+    ] as const) {
+      if (script[flag]) {
+        throw new Error(`extensions and ${flag} don't mix`);
+      }
+    }
+    let built: LexicalEditorWithDispose;
+    try {
+      built = buildEditorFromExtensions(
+        ...script.extensions.map(e => extensionArg(ctx, e)),
+      );
+    } catch (e) {
+      build = {error: (e as Error).message, log: ctx.log};
+      return {
+        build,
+        editor: undefined as never,
+        run: () => {
+          throw new Error('the editor failed to build');
+        },
+      };
+    }
+    ctx.editor = built;
+    build = snapshotOf(built, ctx.log, true) as BuildResult;
+  } else {
+    ctx.editor = createEditor({
+      namespace: '',
+      nodes: [
+        ...(script.richText ? [HeadingNode, QuoteNode] : []),
+        ...(script.list ? [ListNode, ListItemNode] : []),
+        ...(script.link ? [LinkNode, AutoLinkNode] : []),
+        ...(script.code ? [CodeNode, CodeHighlightNode] : []),
+        ...(script.overflow ? [OverflowNode] : []),
+        ...(script.hashtag ? [HashtagNode] : []),
+        ...(script.extension ? [HorizontalRuleNode, DecoratorTextNode] : []),
+      ],
+      onError: e => {
+        throw e;
+      },
+    });
+  }
+  const {editor} = ctx;
   if (script.richText) {
     registerRichText(editor);
   }
@@ -1083,7 +1556,7 @@ export function startSession(script: Omit<Script, 'steps'>): Session {
           },
           {discrete: true, tag: step.tag},
         );
-      } else {
+      } else if ('dispatch' in step) {
         ctx.log.push([
           'dispatched',
           step.dispatch,
@@ -1092,28 +1565,19 @@ export function startSession(script: Omit<Script, 'steps'>): Session {
             step.payload ?? null,
           ),
         ]);
+      } else {
+        runExtensionStep(step, ctx);
       }
     } catch {
       error = true;
     }
-    // A dispatch outside an update commits in a microtask; `editor.read`
-    // commits it first.
-    const result: StepResult = editor.read(() => ({
-      log: ctx.log,
-      selection: $selectionSnapshot(),
-      text: $getRoot().getTextContent(),
-    }));
-    if (snapshot) {
-      const state = editor.getEditorState();
-      result.state = JSON.stringify(state.toJSON());
-      result.compact = JSON.stringify(state.toJSON(true));
-    }
+    const result = snapshotOf(editor, ctx.log, snapshot);
     if (error) {
       result.error = true;
     }
     return result;
   };
-  return {editor, run};
+  return build === undefined ? {editor, run} : {build, editor, run};
 }
 
 /** Runs `script` on a new headless editor and records every step. */
@@ -1125,5 +1589,44 @@ export function runScript(script: Script): ScriptResult {
       script.snapshot !== 'final' || i === script.steps.length - 1,
     ),
   );
-  return {...script, results};
+  return session.build === undefined
+    ? {...script, results}
+    : {...script, build: session.build, results};
+}
+
+/** A step of an editor built from extensions. */
+function runExtensionStep(
+  step: Exclude<Step, {update: Action[]} | {dispatch: string}>,
+  ctx: Context,
+): void {
+  const editor = ctx.editor;
+  if ('dispose' in step) {
+    (editor as LexicalEditorWithDispose).dispose();
+  } else if ('setSignals' in step) {
+    batch(() => {
+      for (const [key, name, value] of step.setSignals) {
+        const output = getExtensionDependencyFromEditor(
+          editor,
+          extensionOf(ctx, key),
+        ).output as NamedSignalsOutput<ExtensionConfig>;
+        output[name].value = value;
+      }
+    });
+  } else if ('logDependency' in step) {
+    const {config} = getExtensionDependencyFromEditor(
+      editor,
+      extensionOf(ctx, step.logDependency),
+    );
+    ctx.log.push(['dependency', step.logDependency, config]);
+  } else {
+    const dep = getPeerDependencyFromEditor<AnyLexicalExtension>(
+      editor,
+      step.logPeer,
+    );
+    ctx.log.push([
+      'peer',
+      step.logPeer,
+      dep === undefined ? null : (dep.config as Json),
+    ]);
+  }
 }
diff --git a/packages/lexical-conformance/src/scripts.test.ts b/packages/lexical-conformance/src/scripts.test.ts
index 12b80f5eb59..8730d7cac20 100644
--- a/packages/lexical-conformance/src/scripts.test.ts
+++ b/packages/lexical-conformance/src/scripts.test.ts
@@ -11,6 +11,8 @@ import {test} from 'vitest';
 
 import {
   type Action,
+  type ExtensionArg,
+  type ExtensionSpec,
   type HandlerSpec,
   type Json,
   runScript,
@@ -3521,3 +3523,278 @@ test('scripts/text', () => {
     ],
   );
 });
+
+test('scripts/extensions', () => {
+  // @lexical/extension's builder (buildEditorFromExtensions, LexicalBuilder.ts
+  // and ExtensionRep.ts) with test extensions made from JSON (ops.ts's
+  // ExtensionSpec), which log each phase they run with their merged config,
+  // and a few of the package's own extensions. The build log is the
+  // script's `build`; InitialStateExtension, which the builder always adds
+  // first, logs nothing itself.
+  const EXT: {[key: string]: ExtensionSpec} = {
+    base: {
+      config: {items: ['b'], label: 'base'},
+      inspect: true,
+      mergeConfig: 'concat',
+      name: 'test/base',
+    },
+    conflict: {conflictsWith: ['test/base'], name: 'test/conflict'},
+    dupA: {name: 'test/dup'},
+    dupB: {name: 'test/dup'},
+    early: {buildPeers: ['test/late'], name: 'test/early'},
+    earlyInit: {initPeers: ['test/late'], name: 'test/early-init'},
+    hr: {
+      initialEditorState: {
+        json: {
+          root: {
+            children: [
+              p(t('rule below')),
+              {type: 'horizontalrule', version: 1} as Node,
+            ],
+            direction: null,
+            format: '',
+            indent: 0,
+            type: 'root',
+            version: 1,
+          },
+        },
+      },
+      listen: true,
+      name: 'test/hr',
+      nodes: ['horizontalrule'],
+    },
+    hrUnregistered: {
+      initialEditorState: {
+        json: {
+          root: {
+            children: [{type: 'horizontalrule', version: 1} as Node],
+            direction: null,
+            format: '',
+            indent: 0,
+            type: 'root',
+            version: 1,
+          },
+        },
+      },
+      name: 'test/hr-unregistered',
+    },
+    late: {config: {label: 'late'}, name: 'test/late'},
+    left: {
+      config: {side: 'left'},
+      dependencies: [['base', {items: ['l'], label: 'from-left'}]],
+      name: 'test/left',
+    },
+    lookup: {lookups: ['base'], name: 'test/lookup'},
+    noInit: {initResult: true, name: 'test/no-init', phases: ['register']},
+    nullState: {initialEditorState: null, listen: true, name: 'test/null'},
+    peer: {config: {label: 'peer', other: 1}, name: 'test/peer'},
+    peerUser: {
+      buildPeers: ['test/peer', 'test/absent'],
+      initPeers: ['test/peer', 'test/absent'],
+      inspect: true,
+      name: 'test/peer-user',
+      peerDependencies: [['test/peer', {label: 'from-user'}], ['test/absent']],
+    },
+    quiet: {name: 'test/quiet', phases: []},
+    right: {
+      config: {side: 'right'},
+      dependencies: [['base', {items: ['r']}, {items: ['r2']}]],
+      lookups: ['base'],
+      name: 'test/right',
+    },
+    textState: {
+      initialEditorState: {text: 'from a function'},
+      listen: true,
+      name: 'test/text',
+    },
+    toClear: {
+      dependencies: ['ClearEditorExtension'],
+      initialEditorState: {text: 'clear me'},
+      name: 'test/to-clear',
+    },
+    toggle: {
+      config: {disabled: false, label: 'a'},
+      name: 'test/toggle',
+      signals: true,
+    },
+    top: {
+      abort: true,
+      dependencies: ['left', 'right'],
+      initResult: true,
+      inspect: true,
+      name: 'test/top',
+    },
+    watch: {
+      dependencies: ['EditorStateExtension'],
+      editorState: true,
+      name: 'test/watch',
+    },
+    withDecoratorText: {
+      dependencies: ['DecoratorTextExtension'],
+      initialEditorState: {
+        json: {
+          root: {
+            children: [
+              p(t('a'), {type: 'decorator-text', version: 1} as Node, t('b')),
+            ],
+            direction: null,
+            format: '',
+            indent: 0,
+            type: 'root',
+            version: 1,
+          },
+        },
+      },
+      name: 'test/with-decorator-text',
+    },
+  };
+  // The specs `extensions` names, with their dependencies.
+  const defs = (extensions: ExtensionArg[], ...more: string[]) => {
+    const out: {[key: string]: ExtensionSpec} = {};
+    const add = (arg: ExtensionArg) => {
+      const key = typeof arg === 'string' ? arg : arg[0];
+      const spec = EXT[key];
+      if (spec !== undefined && out[key] === undefined) {
+        out[key] = spec;
+        (spec.dependencies ?? []).forEach(add);
+      }
+    };
+    [...extensions, ...more].forEach(add);
+    return out;
+  };
+  const script = (
+    name: string,
+    extensions: ExtensionArg[],
+    steps: Step[] = [],
+    ...more: string[]
+  ): Script => ({
+    extensionDefs: defs(extensions, ...more),
+    extensions,
+    name,
+    steps,
+  });
+  const dispatch = (payload: Json): Step => ({
+    dispatch: 'EXTENSION_COMMAND',
+    payload,
+  });
+  const signals = (...entries: [string, Json][]): Step => ({
+    setSignals: entries.map(([name, value]) => ['toggle', name, value]),
+  });
+  emit(
+    'extensions',
+    'buildEditorFromExtensions: the order of the phases across a dependency graph, config merging, peer dependencies, errors, disposal, initial states, node registration and signals.',
+    [
+      script(
+        'a diamond: phase order, merge order and disposal',
+        ['top', ['base', {label: 'root'}]],
+        [
+          dispatch('x'),
+          {logDependency: 'base'},
+          {logDependency: 'left'},
+          {logDependency: 'top'},
+          {logPeer: 'test/right'},
+          {dispose: true},
+          dispatch('y'),
+          {dispose: true},
+        ],
+      ),
+      script('an extension listed twice is added once', [
+        'base',
+        ['base', {items: ['again']}],
+        'base',
+      ]),
+      script('an extension that defines no phase', ['quiet'], [dispatch(1)]),
+      script(
+        'a peer dependency that is present',
+        ['peerUser', 'peer'],
+        [{logPeer: 'test/peer'}, {logPeer: 'test/absent'}],
+      ),
+      script(
+        'a peer dependency that is absent',
+        ['peerUser'],
+        [{logPeer: 'test/peer'}, {logDependency: 'peerUser'}],
+      ),
+      script('a peer before it is configured', ['earlyInit', 'late']),
+      script('a peer before it is built', ['early', 'late']),
+      script('a peer that is built first', ['late', 'early']),
+      script('two extensions with one name', ['dupA', 'dupB']),
+      script('a conflict with an earlier extension', ['base', 'conflict']),
+      script('a conflict with a later extension', ['conflict', 'base']),
+      script('a dependency outside the editor', ['lookup'], [], 'base'),
+      script('getInitResult without init', ['noInit']),
+      script(
+        'an extension that is not in the editor',
+        ['base', 'dupA'],
+        [{logDependency: 'left'}, {logDependency: 'dupB'}, dispatch(1)],
+        'left',
+        'dupB',
+      ),
+      script('the default initial state', ['base']),
+      script('an initial state from JSON with a registered node', ['hr']),
+      script('an initial state with a node not registered', ['hrUnregistered']),
+      script(
+        'an initial state from a function',
+        ['textState'],
+        [update(node('2', 'setTextContent', 'x'))],
+      ),
+      script('a null initial state', ['nullState']),
+      script('the last initial state wins', ['hr', 'textState']),
+      script('DecoratorTextExtension registers its node', [
+        'withDecoratorText',
+      ]),
+      script(
+        'ClearEditorExtension',
+        ['toClear'],
+        [
+          update(select(['2', 3, 'text'])),
+          {dispatch: 'CLEAR_EDITOR_COMMAND'},
+          {dispose: true},
+          {dispatch: 'CLEAR_EDITOR_COMMAND'},
+        ],
+      ),
+      script(
+        'EditorStateExtension as a signal',
+        ['watch'],
+        [
+          update(node('1', 'append', [t('typed')])),
+          {dispose: true},
+          update(node('2', 'setTextContent', 'x')),
+        ],
+      ),
+      script(
+        'namedSignals toggle a registration',
+        [['toggle', {label: 'b'}]],
+        [
+          dispatch(1),
+          signals(['label', 'c']),
+          dispatch(2),
+          signals(['disabled', true]),
+          dispatch(3),
+          signals(['disabled', false], ['label', 'd']),
+          dispatch(4),
+          signals(['label', 'd']),
+          signals(['disabled', true], ['disabled', false]),
+          signals(['label', 'e'], ['disabled', true]),
+          {dispose: true},
+          signals(['disabled', false]),
+          dispatch(5),
+        ],
+      ),
+      script(
+        'a signal disabled by config',
+        [['toggle', {disabled: true}]],
+        [dispatch(1), signals(['disabled', false]), dispatch(2)],
+      ),
+      {
+        ...script(
+          'handlers registered after the build',
+          ['base', 'left'],
+          [dispatch('z')],
+        ),
+        handlers: [
+          {command: 'EXTENSION_COMMAND', id: 'h', priority: 1, result: false},
+        ],
+      },
+    ],
+  );
+});
diff --git a/packages/lexical-conformance/vectors/scripts/extensions.json b/packages/lexical-conformance/vectors/scripts/extensions.json
new file mode 100644
index 00000000000..a13b02d11fb
--- /dev/null
+++ b/packages/lexical-conformance/vectors/scripts/extensions.json
@@ -0,0 +1,28 @@
+{"description":"buildEditorFromExtensions: the order of the phases across a dependency graph, config merging, peer dependencies, errors, disposal, initial states, node registration and signals.","formatVersion":1,"kind":"script","cases":[
+{"extensionDefs":{"top":{"abort":true,"dependencies":["left","right"],"initResult":true,"inspect":true,"name":"test/top"},"left":{"config":{"side":"left"},"dependencies":[["base",{"items":["l"],"label":"from-left"}]],"name":"test/left"},"base":{"config":{"items":["b"],"label":"base"},"inspect":true,"mergeConfig":"concat","name":"test/base"},"right":{"config":{"side":"right"},"dependencies":[["base",{"items":["r"]},{"items":["r2"]}]],"lookups":["base"],"name":"test/right"}},"extensions":["top",["base",{"label":"root"}]],"name":"a diamond: phase order, merge order and disposal","steps":[{"dispatch":"EXTENSION_COMMAND","payload":"x"},{"logDependency":"base"},{"logDependency":"left"},{"logDependency":"top"},{"logPeer":"test/right"},{"dispose":true},{"dispatch":"EXTENSION_COMMAND","payload":"y"},{"dispose":true}],"build":{"log":[["init","test/base",{"items":["b","l","r","r2"],"label":"root"}],["knownTypes","test/base",["root","text","linebreak","tab","paragraph"]],["dependents","test/base",["test/left","test/right"]],["peerNames","test/base",[]],["init","test/left",{"side":"left"}],["init","test/right",{"side":"right"}],["initDependency","test/right","base",{"items":["b","l","r","r2"],"label":"root"}],["init","test/top",{}],["knownTypes","test/top",["root","text","linebreak","tab","paragraph"]],["dependents","test/top",[]],["peerNames","test/top",[]],["build","test/base",{"items":["b","l","r","r2"],"label":"root"}],["build","test/left",{"side":"left"}],["build","test/right",{"side":"right"}],["buildDependency","test/right","base",{"items":["b","l","r","r2"],"label":"root"}],["build","test/top",{}],["register","test/base",{"items":["b","l","r","r2"],"label":"root"},""],["register","test/left",{"side":"left"},""],["register","test/right",{"side":"right"},""],["register","test/top",{},""],["initResult","test/top",{"init":"test/top"}],["afterRegistration","test/base",{"items":["b","l","r","r2"],"label":"root"},""],["afterRegistration","test/left",{"side":"left"},""],["afterRegistration","test/right",{"side":"right"},""],["afterRegistration","test/top",{},""]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},"results":[{"log":[["handled","test/base","x"],["handled","test/left","x"],["handled","test/right","x"],["handled","test/top","x"],["dispatched","EXTENSION_COMMAND",false]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},{"log":[["dependency","base",{"items":["b","l","r","r2"],"label":"root"}]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},{"log":[["dependency","left",{"side":"left"}]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},{"log":[["dependency","top",{}]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},{"log":[["peer","test/right",{"side":"right"}]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},{"log":[["afterUnregister","test/top"],["afterUnregister","test/right"],["afterUnregister","test/left"],["afterUnregister","test/base"],["unregister","test/top"],["unregister","test/right"],["unregister","test/left"],["unregister","test/base"],["aborted","test/top"]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},{"log":[["dispatched","EXTENSION_COMMAND",false]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},{"log":[],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"}]},
+{"extensionDefs":{"base":{"config":{"items":["b"],"label":"base"},"inspect":true,"mergeConfig":"concat","name":"test/base"}},"extensions":["base",["base",{"items":["again"]}],"base"],"name":"an extension listed twice is added once","steps":[],"build":{"log":[["init","test/base",{"items":["b","again"],"label":"base"}],["knownTypes","test/base",["root","text","linebreak","tab","paragraph"]],["dependents","test/base",[]],["peerNames","test/base",[]],["build","test/base",{"items":["b","again"],"label":"base"}],["register","test/base",{"items":["b","again"],"label":"base"},""],["afterRegistration","test/base",{"items":["b","again"],"label":"base"},""]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},"results":[]},
+{"extensionDefs":{"quiet":{"name":"test/quiet","phases":[]}},"extensions":["quiet"],"name":"an extension that defines no phase","steps":[{"dispatch":"EXTENSION_COMMAND","payload":1}],"build":{"log":[],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},"results":[{"log":[["dispatched","EXTENSION_COMMAND",false]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"}]},
+{"extensionDefs":{"peerUser":{"buildPeers":["test/peer","test/absent"],"initPeers":["test/peer","test/absent"],"inspect":true,"name":"test/peer-user","peerDependencies":[["test/peer",{"label":"from-user"}],["test/absent"]]},"peer":{"config":{"label":"peer","other":1},"name":"test/peer"}},"extensions":["peerUser","peer"],"name":"a peer dependency that is present","steps":[{"logPeer":"test/peer"},{"logPeer":"test/absent"}],"build":{"log":[["init","test/peer",{"label":"from-user","other":1}],["init","test/peer-user",{}],["knownTypes","test/peer-user",["root","text","linebreak","tab","paragraph"]],["dependents","test/peer-user",[]],["peerNames","test/peer-user",["test/peer","test/absent"]],["initPeer","test/peer-user","test/peer",{"label":"from-user","other":1}],["initPeer","test/peer-user","test/absent",null],["build","test/peer",{"label":"from-user","other":1}],["build","test/peer-user",{}],["buildPeer","test/peer-user","test/peer",{"label":"from-user","other":1}],["buildPeer","test/peer-user","test/absent",null],["register","test/peer",{"label":"from-user","other":1},""],["register","test/peer-user",{},""],["afterRegistration","test/peer",{"label":"from-user","other":1},""],["afterRegistration","test/peer-user",{},""]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},"results":[{"log":[["peer","test/peer",{"label":"from-user","other":1}]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},{"log":[["peer","test/absent",null]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"}]},
+{"extensionDefs":{"peerUser":{"buildPeers":["test/peer","test/absent"],"initPeers":["test/peer","test/absent"],"inspect":true,"name":"test/peer-user","peerDependencies":[["test/peer",{"label":"from-user"}],["test/absent"]]}},"extensions":["peerUser"],"name":"a peer dependency that is absent","steps":[{"logPeer":"test/peer"},{"logDependency":"peerUser"}],"build":{"log":[["init","test/peer-user",{}],["knownTypes","test/peer-user",["root","text","linebreak","tab","paragraph"]],["dependents","test/peer-user",[]],["peerNames","test/peer-user",["test/peer","test/absent"]],["initPeer","test/peer-user","test/peer",null],["initPeer","test/peer-user","test/absent",null],["build","test/peer-user",{}],["buildPeer","test/peer-user","test/peer",null],["buildPeer","test/peer-user","test/absent",null],["register","test/peer-user",{},""],["afterRegistration","test/peer-user",{},""]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},"results":[{"log":[["peer","test/peer",null]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},{"log":[["dependency","peerUser",{}]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"}]},
+{"extensionDefs":{"earlyInit":{"initPeers":["test/late"],"name":"test/early-init"},"late":{"config":{"label":"late"},"name":"test/late"}},"extensions":["earlyInit","late"],"name":"a peer before it is configured","steps":[],"build":{"error":"ExtensionRep: getExtensionInitDependency called in state id 2 (expected >= 3 configured)","log":[["init","test/early-init",{}]]},"results":[]},
+{"extensionDefs":{"early":{"buildPeers":["test/late"],"name":"test/early"},"late":{"config":{"label":"late"},"name":"test/late"}},"extensions":["early","late"],"name":"a peer before it is built","steps":[],"build":{"error":"Extension test/late used as a dependency before build","log":[["init","test/early",{}],["init","test/late",{"label":"late"}],["build","test/early",{}]]},"results":[]},
+{"extensionDefs":{"late":{"config":{"label":"late"},"name":"test/late"},"early":{"buildPeers":["test/late"],"name":"test/early"}},"extensions":["late","early"],"name":"a peer that is built first","steps":[],"build":{"log":[["init","test/late",{"label":"late"}],["init","test/early",{}],["build","test/late",{"label":"late"}],["build","test/early",{}],["buildPeer","test/early","test/late",{"label":"late"}],["register","test/late",{"label":"late"},""],["register","test/early",{},""],["afterRegistration","test/late",{"label":"late"},""],["afterRegistration","test/early",{},""]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},"results":[]},
+{"extensionDefs":{"dupA":{"name":"test/dup"},"dupB":{"name":"test/dup"}},"extensions":["dupA","dupB"],"name":"two extensions with one name","steps":[],"build":{"error":"LexicalBuilder: Multiple extensions registered with name test/dup, names must be unique","log":[]},"results":[]},
+{"extensionDefs":{"base":{"config":{"items":["b"],"label":"base"},"inspect":true,"mergeConfig":"concat","name":"test/base"},"conflict":{"conflictsWith":["test/base"],"name":"test/conflict"}},"extensions":["base","conflict"],"name":"a conflict with an earlier extension","steps":[],"build":{"error":"LexicalBuilder: extension test/conflict conflicts with test/base","log":[]},"results":[]},
+{"extensionDefs":{"conflict":{"conflictsWith":["test/base"],"name":"test/conflict"},"base":{"config":{"items":["b"],"label":"base"},"inspect":true,"mergeConfig":"concat","name":"test/base"}},"extensions":["conflict","base"],"name":"a conflict with a later extension","steps":[],"build":{"error":"LexicalBuilder: extension test/base conflicts with test/conflict","log":[]},"results":[]},
+{"extensionDefs":{"lookup":{"lookups":["base"],"name":"test/lookup"},"base":{"config":{"items":["b"],"label":"base"},"inspect":true,"mergeConfig":"concat","name":"test/base"}},"extensions":["lookup"],"name":"a dependency outside the editor","steps":[],"build":{"error":"LexicalExtensionBuilder: Extension test/lookup missing dependency extension test/base to be in registry","log":[["init","test/lookup",{}]]},"results":[]},
+{"extensionDefs":{"noInit":{"initResult":true,"name":"test/no-init","phases":["register"]}},"extensions":["noInit"],"name":"getInitResult without init","steps":[],"build":{"error":"ExtensionRep: getInitResult() called for Extension test/no-init that does not define init","log":[["register","test/no-init",{},""]]},"results":[]},
+{"extensionDefs":{"base":{"config":{"items":["b"],"label":"base"},"inspect":true,"mergeConfig":"concat","name":"test/base"},"dupA":{"name":"test/dup"},"left":{"config":{"side":"left"},"dependencies":[["base",{"items":["l"],"label":"from-left"}]],"name":"test/left"},"dupB":{"name":"test/dup"}},"extensions":["base","dupA"],"name":"an extension that is not in the editor","steps":[{"logDependency":"left"},{"logDependency":"dupB"},{"dispatch":"EXTENSION_COMMAND","payload":1}],"build":{"log":[["init","test/base",{"items":["b"],"label":"base"}],["knownTypes","test/base",["root","text","linebreak","tab","paragraph"]],["dependents","test/base",[]],["peerNames","test/base",[]],["init","test/dup",{}],["build","test/base",{"items":["b"],"label":"base"}],["build","test/dup",{}],["register","test/base",{"items":["b"],"label":"base"},""],["register","test/dup",{},""],["afterRegistration","test/base",{"items":["b"],"label":"base"},""],["afterRegistration","test/dup",{},""]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},"results":[{"log":[],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}","error":true},{"log":[],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}","error":true},{"log":[["handled","test/base",1],["handled","test/dup",1],["dispatched","EXTENSION_COMMAND",false]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"}]},
+{"extensionDefs":{"base":{"config":{"items":["b"],"label":"base"},"inspect":true,"mergeConfig":"concat","name":"test/base"}},"extensions":["base"],"name":"the default initial state","steps":[],"build":{"log":[["init","test/base",{"items":["b"],"label":"base"}],["knownTypes","test/base",["root","text","linebreak","tab","paragraph"]],["dependents","test/base",[]],["peerNames","test/base",[]],["build","test/base",{"items":["b"],"label":"base"}],["register","test/base",{"items":["b"],"label":"base"},""],["afterRegistration","test/base",{"items":["b"],"label":"base"},""]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},"results":[]},
+{"extensionDefs":{"hr":{"initialEditorState":{"json":{"root":{"children":[{"children":[{"detail":0,"format":0,"mode":"normal","style":"","text":"rule below","type":"text","version":1}],"direction":null,"format":"","indent":0,"textFormat":0,"textStyle":"","type":"paragraph","version":1},{"type":"horizontalrule","version":1}],"direction":null,"format":"","indent":0,"type":"root","version":1}}},"listen":true,"name":"test/hr","nodes":["horizontalrule"]}},"extensions":["hr"],"name":"an initial state from JSON with a registered node","steps":[],"build":{"log":[["init","test/hr",{}],["build","test/hr",{}],["register","test/hr",{},""],["update","test/hr",["history-merge"]],["afterRegistration","test/hr",{},"rule below\n\n\n"]],"selection":null,"text":"rule below\n\n\n","state":"{\"root\":{\"children\":[{\"children\":[{\"detail\":0,\"format\":0,\"mode\":\"normal\",\"style\":\"\",\"text\":\"rule below\",\"type\":\"text\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1},{\"type\":\"horizontalrule\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[{\"type\":\"text\",\"text\":\"rule below\"}]},{\"type\":\"horizontalrule\"}]}}"},"results":[]},
+{"extensionDefs":{"hrUnregistered":{"initialEditorState":{"json":{"root":{"children":[{"type":"horizontalrule","version":1}],"direction":null,"format":"","indent":0,"type":"root","version":1}}},"name":"test/hr-unregistered"}},"extensions":["hrUnregistered"],"name":"an initial state with a node not registered","steps":[],"build":{"error":"parseEditorState: type \"horizontalrule\" + not found","log":[["init","test/hr-unregistered",{}],["build","test/hr-unregistered",{}],["register","test/hr-unregistered",{},""]]},"results":[]},
+{"extensionDefs":{"textState":{"initialEditorState":{"text":"from a function"},"listen":true,"name":"test/text"}},"extensions":["textState"],"name":"an initial state from a function","steps":[{"update":[{"args":["x"],"do":"node","key":"2","method":"setTextContent"}]}],"build":{"log":[["init","test/text",{}],["build","test/text",{}],["register","test/text",{},""],["afterRegistration","test/text",{},""],["update","test/text",["history-merge"]]],"selection":null,"text":"from a function","state":"{\"root\":{\"children\":[{\"children\":[{\"detail\":0,\"format\":0,\"mode\":\"normal\",\"style\":\"\",\"text\":\"from a function\",\"type\":\"text\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[{\"type\":\"text\",\"text\":\"from a function\"}]}]}}"},"results":[{"log":[["update","test/text",[]]],"selection":null,"text":"x","state":"{\"root\":{\"children\":[{\"children\":[{\"detail\":0,\"format\":0,\"mode\":\"normal\",\"style\":\"\",\"text\":\"x\",\"type\":\"text\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[{\"type\":\"text\",\"text\":\"x\"}]}]}}"}]},
+{"extensionDefs":{"nullState":{"initialEditorState":null,"listen":true,"name":"test/null"}},"extensions":["nullState"],"name":"a null initial state","steps":[],"build":{"log":[["init","test/null",{}],["build","test/null",{}],["register","test/null",{},""],["afterRegistration","test/null",{},""]],"selection":null,"text":"","state":"{\"root\":{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[]}}"},"results":[]},
+{"extensionDefs":{"hr":{"initialEditorState":{"json":{"root":{"children":[{"children":[{"detail":0,"format":0,"mode":"normal","style":"","text":"rule below","type":"text","version":1}],"direction":null,"format":"","indent":0,"textFormat":0,"textStyle":"","type":"paragraph","version":1},{"type":"horizontalrule","version":1}],"direction":null,"format":"","indent":0,"type":"root","version":1}}},"listen":true,"name":"test/hr","nodes":["horizontalrule"]},"textState":{"initialEditorState":{"text":"from a function"},"listen":true,"name":"test/text"}},"extensions":["hr","textState"],"name":"the last initial state wins","steps":[],"build":{"log":[["init","test/hr",{}],["init","test/text",{}],["build","test/hr",{}],["build","test/text",{}],["register","test/hr",{},""],["register","test/text",{},""],["afterRegistration","test/hr",{},""],["afterRegistration","test/text",{},""],["update","test/hr",["history-merge"]],["update","test/text",["history-merge"]]],"selection":null,"text":"from a function","state":"{\"root\":{\"children\":[{\"children\":[{\"detail\":0,\"format\":0,\"mode\":\"normal\",\"style\":\"\",\"text\":\"from a function\",\"type\":\"text\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[{\"type\":\"text\",\"text\":\"from a function\"}]}]}}"},"results":[]},
+{"extensionDefs":{"withDecoratorText":{"dependencies":["DecoratorTextExtension"],"initialEditorState":{"json":{"root":{"children":[{"children":[{"detail":0,"format":0,"mode":"normal","style":"","text":"a","type":"text","version":1},{"type":"decorator-text","version":1},{"detail":0,"format":0,"mode":"normal","style":"","text":"b","type":"text","version":1}],"direction":null,"format":"","indent":0,"textFormat":0,"textStyle":"","type":"paragraph","version":1}],"direction":null,"format":"","indent":0,"type":"root","version":1}}},"name":"test/with-decorator-text"}},"extensions":["withDecoratorText"],"name":"DecoratorTextExtension registers its node","steps":[],"build":{"log":[["init","test/with-decorator-text",{}],["build","test/with-decorator-text",{}],["register","test/with-decorator-text",{},""],["afterRegistration","test/with-decorator-text",{},"ab"]],"selection":null,"text":"ab","state":"{\"root\":{\"children\":[{\"children\":[{\"detail\":0,\"format\":0,\"mode\":\"normal\",\"style\":\"\",\"text\":\"a\",\"type\":\"text\",\"version\":1},{\"type\":\"decorator-text\",\"version\":1},{\"detail\":0,\"format\":0,\"mode\":\"normal\",\"style\":\"\",\"text\":\"b\",\"type\":\"text\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[{\"type\":\"text\",\"text\":\"a\"},{\"type\":\"decorator-text\"},{\"type\":\"text\",\"text\":\"b\"}]}]}}"},"results":[]},
+{"extensionDefs":{"toClear":{"dependencies":["ClearEditorExtension"],"initialEditorState":{"text":"clear me"},"name":"test/to-clear"}},"extensions":["toClear"],"name":"ClearEditorExtension","steps":[{"update":[{"anchor":["2",3,"text"],"do":"select"}]},{"dispatch":"CLEAR_EDITOR_COMMAND"},{"dispose":true},{"dispatch":"CLEAR_EDITOR_COMMAND"}],"build":{"log":[["init","test/to-clear",{}],["build","test/to-clear",{}],["register","test/to-clear",{},""],["afterRegistration","test/to-clear",{},""]],"selection":null,"text":"clear me","state":"{\"root\":{\"children\":[{\"children\":[{\"detail\":0,\"format\":0,\"mode\":\"normal\",\"style\":\"\",\"text\":\"clear me\",\"type\":\"text\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[{\"type\":\"text\",\"text\":\"clear me\"}]}]}}"},"results":[{"log":[],"selection":["range",["2",3,"text"],["2",3,"text"],0,""],"text":"clear me","state":"{\"root\":{\"children\":[{\"children\":[{\"detail\":0,\"format\":0,\"mode\":\"normal\",\"style\":\"\",\"text\":\"clear me\",\"type\":\"text\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[{\"type\":\"text\",\"text\":\"clear me\"}]}]}}"},{"log":[["dispatched","CLEAR_EDITOR_COMMAND",true]],"selection":["range",["3",0,"element"],["3",0,"element"],0,""],"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},{"log":[["afterUnregister","test/to-clear"],["unregister","test/to-clear"]],"selection":["range",["3",0,"element"],["3",0,"element"],0,""],"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},{"log":[["dispatched","CLEAR_EDITOR_COMMAND",false]],"selection":["range",["3",0,"element"],["3",0,"element"],0,""],"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"}]},
+{"extensionDefs":{"watch":{"dependencies":["EditorStateExtension"],"editorState":true,"name":"test/watch"}},"extensions":["watch"],"name":"EditorStateExtension as a signal","steps":[{"update":[{"args":[[{"detail":0,"format":0,"mode":"normal","style":"","text":"typed","type":"text","version":1}]],"do":"node","key":"1","method":"append"}]},{"dispose":true},{"update":[{"args":["x"],"do":"node","key":"2","method":"setTextContent"}]}],"build":{"log":[["init","test/watch",{}],["build","test/watch",{}],["register","test/watch",{},""],["editorState","test/watch",""],["afterRegistration","test/watch",{},""],["editorState","test/watch",""]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},"results":[{"log":[["editorState","test/watch","typed"]],"selection":null,"text":"typed","state":"{\"root\":{\"children\":[{\"children\":[{\"detail\":0,\"format\":0,\"mode\":\"normal\",\"style\":\"\",\"text\":\"typed\",\"type\":\"text\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[{\"type\":\"text\",\"text\":\"typed\"}]}]}}"},{"log":[["afterUnregister","test/watch"],["unregister","test/watch"]],"selection":null,"text":"typed","state":"{\"root\":{\"children\":[{\"children\":[{\"detail\":0,\"format\":0,\"mode\":\"normal\",\"style\":\"\",\"text\":\"typed\",\"type\":\"text\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[{\"type\":\"text\",\"text\":\"typed\"}]}]}}"},{"log":[],"selection":null,"text":"x","state":"{\"root\":{\"children\":[{\"children\":[{\"detail\":0,\"format\":0,\"mode\":\"normal\",\"style\":\"\",\"text\":\"x\",\"type\":\"text\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[{\"type\":\"text\",\"text\":\"x\"}]}]}}"}]},
+{"extensionDefs":{"toggle":{"config":{"disabled":false,"label":"a"},"name":"test/toggle","signals":true}},"extensions":[["toggle",{"label":"b"}]],"name":"namedSignals toggle a registration","steps":[{"dispatch":"EXTENSION_COMMAND","payload":1},{"setSignals":[["toggle","label","c"]]},{"dispatch":"EXTENSION_COMMAND","payload":2},{"setSignals":[["toggle","disabled",true]]},{"dispatch":"EXTENSION_COMMAND","payload":3},{"setSignals":[["toggle","disabled",false],["toggle","label","d"]]},{"dispatch":"EXTENSION_COMMAND","payload":4},{"setSignals":[["toggle","label","d"]]},{"setSignals":[["toggle","disabled",true],["toggle","disabled",false]]},{"setSignals":[["toggle","label","e"],["toggle","disabled",true]]},{"dispose":true},{"setSignals":[["toggle","disabled",false]]},{"dispatch":"EXTENSION_COMMAND","payload":5}],"build":{"log":[["init","test/toggle",{"disabled":false,"label":"b"}],["build","test/toggle",{"disabled":false,"label":"b"}],["register","test/toggle",{"disabled":false,"label":"b"},""],["summary","test/toggle","on:b"],["enable","test/toggle","b"],["afterRegistration","test/toggle",{"disabled":false,"label":"b"},""]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},"results":[{"log":[["handled","test/toggle","b",1],["dispatched","EXTENSION_COMMAND",false]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},{"log":[["summary","test/toggle","on:c"]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},{"log":[["handled","test/toggle","b",2],["dispatched","EXTENSION_COMMAND",false]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},{"log":[["summary","test/toggle","off"],["disable","test/toggle"]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},{"log":[["dispatched","EXTENSION_COMMAND",false]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},{"log":[["summary","test/toggle","on:d"],["enable","test/toggle","d"]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},{"log":[["handled","test/toggle","d",4],["dispatched","EXTENSION_COMMAND",false]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},{"log":[],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},{"log":[],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},{"log":[["disable","test/toggle"],["summary","test/toggle","off"]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},{"log":[["afterUnregister","test/toggle"],["unregister","test/toggle"]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},{"log":[],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},{"log":[["dispatched","EXTENSION_COMMAND",false]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"}]},
+{"extensionDefs":{"toggle":{"config":{"disabled":false,"label":"a"},"name":"test/toggle","signals":true}},"extensions":[["toggle",{"disabled":true}]],"name":"a signal disabled by config","steps":[{"dispatch":"EXTENSION_COMMAND","payload":1},{"setSignals":[["toggle","disabled",false]]},{"dispatch":"EXTENSION_COMMAND","payload":2}],"build":{"log":[["init","test/toggle",{"disabled":true,"label":"a"}],["build","test/toggle",{"disabled":true,"label":"a"}],["register","test/toggle",{"disabled":true,"label":"a"},""],["summary","test/toggle","off"],["afterRegistration","test/toggle",{"disabled":true,"label":"a"},""]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},"results":[{"log":[["dispatched","EXTENSION_COMMAND",false]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},{"log":[["summary","test/toggle","on:a"],["enable","test/toggle","a"]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},{"log":[["handled","test/toggle","a",2],["dispatched","EXTENSION_COMMAND",false]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"}]},
+{"extensionDefs":{"base":{"config":{"items":["b"],"label":"base"},"inspect":true,"mergeConfig":"concat","name":"test/base"},"left":{"config":{"side":"left"},"dependencies":[["base",{"items":["l"],"label":"from-left"}]],"name":"test/left"}},"extensions":["base","left"],"name":"handlers registered after the build","steps":[{"dispatch":"EXTENSION_COMMAND","payload":"z"}],"handlers":[{"command":"EXTENSION_COMMAND","id":"h","priority":1,"result":false}],"build":{"log":[["init","test/base",{"items":["b","l"],"label":"from-left"}],["knownTypes","test/base",["root","text","linebreak","tab","paragraph"]],["dependents","test/base",["test/left"]],["peerNames","test/base",[]],["init","test/left",{"side":"left"}],["build","test/base",{"items":["b","l"],"label":"from-left"}],["build","test/left",{"side":"left"}],["register","test/base",{"items":["b","l"],"label":"from-left"},""],["register","test/left",{"side":"left"},""],["afterRegistration","test/base",{"items":["b","l"],"label":"from-left"},""],["afterRegistration","test/left",{"side":"left"},""]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"},"results":[{"log":[["handler","h","z"],["handled","test/base","z"],["handled","test/left","z"],["dispatched","EXTENSION_COMMAND",false]],"selection":null,"text":"","state":"{\"root\":{\"children\":[{\"children\":[],\"direction\":null,\"format\":\"\",\"indent\":0,\"textFormat\":0,\"textStyle\":\"\",\"type\":\"paragraph\",\"version\":1}],\"direction\":null,\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}","compact":"{\"root\":{\"type\":\"root\",\"children\":[{\"type\":\"paragraph\",\"children\":[]}]}}"}]}
+]}
diff --git a/rust/DESIGN.md b/rust/DESIGN.md
index 4e777cf2860..854d6a60db5 100644
--- a/rust/DESIGN.md
+++ b/rust/DESIGN.md
@@ -56,7 +56,8 @@ depends on as the upstream package depends on them:
 
 | Feature     | Upstream package       | Needs                      |
 | ----------- | ---------------------- | -------------------------- |
-| (core)      | `lexical`, `@lexical/headless`, `@lexical/extension` | |
+| (core)      | `lexical`, `@lexical/headless` | |
+| `extension` | `@lexical/extension`, with `lexical`'s `extension-core` | |
 | `selection` | `@lexical/selection`   |                            |
 | `utils`     | `@lexical/utils`       | `selection`                |
 | `rich-text` | `@lexical/rich-text`   | `selection`, `utils`       |
@@ -194,7 +195,7 @@ thread.
 | Milestone | Scope | Vectors that pass when done | Status |
 | --- | --- | --- | --- |
 | M0 | The `rust/` workspace, JSON as JS writes it, the core nodes (root, paragraph, text, tab, line break), `parseEditorState` and `toJSON` in both forms, the conformance runner, CI | `meta`, `serialization/core`, the core-only cases of `property/documents` (JSON and text) | done |
-| M1 | The core model: `editor.update` and the commit (dirty nodes, normalization, transforms, listeners, commands, tags), node creation and methods (`splitText`, `mergeWithSibling`, `spliceText`, `insertAfter`, `remove`, `replace`...) with UTF-16 offsets, `RangeSelection` and `NodeSelection` editing, carets, NodeState, slots, the schema facility, `DecoratorNode`, the extension API (`buildEditorFromExtensions`), the parity ledger | `scripts/*`, `fuzz/core`, `file/*` | in progress: the update cycle, `setEditorState`, commands, transforms, listeners, the node methods, carets, selection reading and `RangeSelection`/`NodeSelection` editing are done (`scripts/*` and `fuzz/core` pass), and the platform's `Selection.modify` is an editor hook (`SelectionMovement`); NodeState is done (`createState`, `$getState`, `$setState`, `$getStateChange`, the `"$"` key and flat states in node JSON, unknown keys kept, clones, `$copyNode`, splits and merges, `scripts/node-state`), except its schema builders, which come with the schema facility; `DecoratorNode` is done (its hooks, block and inline decorators in `insertNodes`, deletion, `modify`, text content and formatting, `$setBlocksType` across one, `scripts/decorator`), except `editor._decorators` and the decorator listener, which the DOM reconciler fills; next, the extension API |
+| M1 | The core model: `editor.update` and the commit (dirty nodes, normalization, transforms, listeners, commands, tags), node creation and methods (`splitText`, `mergeWithSibling`, `spliceText`, `insertAfter`, `remove`, `replace`...) with UTF-16 offsets, `RangeSelection` and `NodeSelection` editing, carets, NodeState, slots, the schema facility, `DecoratorNode`, the extension API (`buildEditorFromExtensions`), the parity ledger | `scripts/*`, `fuzz/core`, `file/*` | in progress: the update cycle, `setEditorState`, commands, transforms, listeners, the node methods, carets, selection reading and `RangeSelection`/`NodeSelection` editing are done (`scripts/*` and `fuzz/core` pass), and the platform's `Selection.modify` is an editor hook (`SelectionMovement`); NodeState is done (`createState`, `$getState`, `$setState`, `$getStateChange`, the `"$"` key and flat states in node JSON, unknown keys kept, clones, `$copyNode`, splits and merges, `scripts/node-state`), except its schema builders, which come with the schema facility; `DecoratorNode` is done (its hooks, block and inline decorators in `insertNodes`, deletion, `modify`, text content and formatting, `$setBlocksType` across one, `scripts/decorator`), except `editor._decorators` and the decorator listener, which the DOM reconciler fills; the extension API is done (`buildEditorFromExtensions`, the extension-core types, dependency and peer resolution, config merging, the four phases, disposal, the dependency lookups, a port of `@preact/signals-core` with `namedSignals` and `watchedSignal`, and `InitialStateExtension`, `ClearEditorExtension`, `EditorStateExtension` and `DecoratorTextExtension`; `scripts/extensions` passes), except the packages' own extensions (`RichTextExtension`, `HistoryExtension`...), whose `register_*` functions are ported; next, slots, the schema facility and the parity ledger |
 | P | Desktop playgrounds (`apps/`): `lexical-playground-rune` on Rune, then `lexical-playground-gpui` on GPUI, sharing `lexical-playground-core`; they grow with each milestone below | the vectors, replayed in the app; a session exported from the app replays in JS (`replay.test.ts`); in CI, a GPUI session typed in a real window replays in JS | both apps run on macOS with typing, Return, deletion, formatting, input methods and the Parity panel; they grow with each milestone |
 | M2 | `rich-text` (headings, quotes, and the command handlers a text surface dispatches: typing, Enter, Backspace, formatting) and `history` (undo), which the playgrounds need first; then the node packages `list`, `link`, `code`, `overflow`, `hashtag`, with `selection` and `utils` | `serialization/*`, `property/documents` (JSON and text), `entities/hashtag-*`, `scripts/history` | done (every vector it names passes): `history` is done (`scripts/history` passes); `rich-text`'s nodes and `registerRichText`'s model command handlers are done (`scripts/rich-text` and `scripts/rich-text-commands` pass, with the heading and quote cases of `property/documents`); `plain-text`'s model command handlers are done (`scripts/plain-text` passes); `list`'s nodes, `registerList` and the model part of `registerCheckList` are done (`scripts/list` and `serialization/list` pass, with the list cases of `property/documents`); `link`'s nodes, `$toggleLink` and `registerLink`'s model handlers are done (`scripts/link` and `serialization/link` pass, with the link cases of `property/documents` that need no other package), `registerAutoLink` and its matchers are done behind `autolink` (`scripts/autolink` and `entities/autolink-match` pass); `selection`'s `$setBlocksType` is done (`scripts/set-blocks-type` passes); `code`'s nodes, `FlatStructureUtils.ts`, `CodeExtension`'s transform and `registerCodeIndentation`'s model handlers are done (`scripts/code` and `serialization/code` pass, with the code cases of `property/documents` that need no other package); `overflow`'s `OverflowNode` is done (`scripts/overflow` and `serialization/overflow` pass, with the overflow cases of `property/documents` that need no other package); `hashtag`'s `HashtagNode`, its matcher (generated character tables, no `regex`) and `registerLexicalHashtag`, with `text`'s `registerLexicalTextEntity`, are done (`entities/hashtag-match`, `entities/hashtag-documents` and `entities/hashtag-typing` pass, with the last waiting cases of `property/documents`), so M2's node packages are done |
 | M3 | The commands `property/sequences` dispatches | `property/sequences` | done (all 81 cases match JS): the suite builds `sequenceEditor`'s editor without `buildEditorFromExtensions`, from what each of its extensions registers, in the builder's order, with `InitialStateExtension`'s paragraph; the commands M2 ported needed two fixes, `NormalizeInlineElementsExtension`'s transform (`register_normalize_inline_elements`, removing empty links) and `$extendSelectionForDeletion` and `modify` stopping where the window gives no DOM selection (`SelectionMovement::has_dom_selection`) |
diff --git a/rust/PARITY.md b/rust/PARITY.md
index bc2b7d176c1..d2a1a791235 100644
--- a/rust/PARITY.md
+++ b/rust/PARITY.md
@@ -44,6 +44,10 @@ updated with each milestone.
 | Overflow node (the `overflow` feature) | `packages/lexical-overflow/src/index.ts` (`OverflowNode`: `insertNewAfter` (its parent's), `excludeFromCopy`, the `$transform` of its `$config` that removes it once empty; `$createOverflowNode`, `$isOverflowNode`), with `ElementNode`'s generated JSON; `ElementNode.excludeFromCopy` as a node hook | `overflow`, `node` | `serialization/overflow`, the overflow cases of `property/documents`, `scripts/overflow` |
 | Hashtag node and matcher (the `hashtag` feature) | `packages/lexical-hashtag/src/LexicalHashtagNode.ts` (`HashtagNode`: `canInsertTextBefore`, `isTextEntity`; `$createHashtagNode`, `$isHashtagNode`), with `TextNode`'s generated JSON; `LexicalHashtagExtension.ts` (`getHashtagRegexStringChars`, `getHashtagRegexString` and `getHashtagMatch` as the default matcher, `HashtagConfig`, `registerLexicalHashtag`), the character classes as range tables generated from the JS source by `rust/scripts/generate-hashtag-tables.mjs`; `TextNode.isTextEntity` as a node hook | `hashtag`, `node` | `entities/hashtag-match`, `entities/hashtag-documents`, `entities/hashtag-typing`, the hashtag cases of `property/documents` |
 | `@lexical/extension`'s decorators (the `extension` feature) | `packages/lexical-extension/src/HorizontalRuleExtension.ts` (`HorizontalRuleNode`: a block decorator whose text is `\n`; `$createHorizontalRuleNode`, `$isHorizontalRuleNode`), `DecoratorTextExtension.ts` (`DecoratorTextNode`: inline, `__isInlineFormattable`, `getFormat`, `hasFormat`, `setFormat`, `toggleFormat`, its `format` as a flat NodeState; `$isDecoratorTextNode`), with `LexicalNode`'s generated JSON | `extension` | `scripts/decorator` |
+| Extension core (the `extension` feature) | `packages/lexical/src/extension-core/`: `defineExtension.ts` (`defineExtension`, `configExtension`, `declarePeerDependency`), `safeCast.ts`, `shallowMergeConfig.ts`, `types.ts` (`LexicalExtension` with `name`, `conflictsWith`, `dependencies`, `peerDependencies`, `config`, `mergeConfig`, `nodes`, `$initialEditorState`, `init`, `build`, `register`, `afterRegistration`; `AnyLexicalExtension`, `AnyLexicalExtensionArgument`, `NormalizedPeerDependency`, `ExtensionConfigBase`, `ExtensionInitState`, `ExtensionBuildState`, `ExtensionRegisterState`, `LexicalExtensionDependency`, `InitialEditorConfig`, `InitialEditorStateType`, `LexicalEditorWithDispose`); `AbortController`/`AbortSignal` as `getSignal` uses them; `utils/mergeRegister.ts` | `extension_core` (re-exported at the crate root), `merge_register` | `scripts/extensions` |
+| Extension builder (the `extension` feature) | `packages/lexical-extension/src/LexicalBuilder.ts` (`buildEditorFromExtensions`, `LexicalBuilder`: `fromExtensions`, `maybeFromEditor`, `fromEditor`, `constructEditor`, `buildEditor` with `dispose`, `hasExtensionByName`, `getExtensionRep`, `addEdge`, `addExtension` with the duplicate-name and conflict invariants, `sortedExtensionReps`' depth-first sort, cycle invariant and config order, `registerEditor`, `buildCreateEditorArgs` for nodes and `$initialEditorState`), `internal/ExtensionRep.ts` (the state ids, `mergeConfigs`, `init`, `build`, `register` with its rollback, `afterRegistration`, `getSignal`, `getInitResult`, `getInitPeer`, `getExtensionInitDependency`, `getPeer`, `getInitDependency`, `getDependency`, `getDirectDependentNames`, `getPeerNameSet`, `getExtensionDependency`), `config.ts` (`getKnownTypesAndNodes`, `getNodeConfig`), `getExtensionDependencyFromEditor.ts`, `getPeerDependencyFromEditor.ts` (with `OrThrow`), `getExtensionDependency.ts` (`$getExtensionDependency`, `$getExtensionOutput`, `$getPeerDependency`) | `extension::lexical_builder`, `extension::extension_rep`, `extension::config`, `extension::get_*` | `scripts/extensions` |
+| Signals (the `extension` feature) | `signals.ts`, a port of `@preact/signals-core` 1.14.4 (`signal` with `watched`/`unwatched`, `computed`, `effect` with clean-ups, `batch` with its snapshots, `untracked`, `peek`, `subscribe`); `namedSignals.ts`; `watchedSignal.ts` | `extension::signals`, `extension::named_signals`, `extension::watched_signal` | `scripts/extensions` (`namedSignals toggle a registration`, `a signal disabled by config`, `EditorStateExtension as a signal`) |
+| Model-level extensions (the `extension` feature) | `InitialStateExtension.ts` (always first; its config and every form of `$initialEditorState`), `ClearEditorExtension.ts` (`registerClearEditor`, `$defaultOnClear`, `$onClear` as a signal), `EditorStateExtension.ts`, `DecoratorTextExtension.ts`'s extension | `extension::initial_state_extension`, `extension::clear_editor_extension`, `extension::editor_state_extension`, `extension::decorator_text_extension` | `scripts/extensions` |
 | `NormalizeInlineElementsExtension`'s register (the `extension` feature) | `packages/lexical-extension/src/NormalizeInlineElementsExtension.ts` (`deleteEmptyInline`, and the `register` that adds it to the transforms of every registered `ElementNode` class with an `isInline` of its own, without marking their nodes dirty), as `register_normalize_inline_elements`; `RichTextExtension` depends on it | `extension` | `property/sequences` |
 | `registerLexicalTextEntity` (the `text` feature) | `packages/lexical-text/src/registerLexicalTextEntity.ts`: `EntityMatch`, `registerLexicalTextEntity` (the `TextNode` transform and `$reverseNodeTransform`, `$replaceWithSimpleText`, `$wasTurnedIntoText`, `getFirstMatchAfter`, `isNextTextEntity`, `isTextAfterOutsideSource`, `isEntityAfter`, `$checkNextSibling`, `$moveSelectionIntoEntity`, `$wouldMerge`, `MAX_MATCHES_PASSED`, `MAX_TURNED_INTO_TEXT`, the per-update `markedInUpdate` and `turnedIntoTextInUpdate`); from the core `INTERNAL_getActiveEditorState` | `text`, `updates` | `entities/hashtag-documents`, `entities/hashtag-typing`, `property/sequences` |
 | `@lexical/text`'s root helpers (the `text` feature) | `packages/lexical-text/src/rootTextContent.ts` (`$rootTextContent`), `isRootTextContentEmpty.ts` (`$isRootTextContentEmpty`, with `String#trim`'s whitespace, and `$isRootTextContentEmptyCurry`), `canShowPlaceholder.ts` (`$canShowPlaceholder`, `$canShowPlaceholderCurry`), `findTextIntersectionFromCharacters.ts` (`$findTextIntersectionFromCharacters`, deprecated upstream, with UTF-16 counts), `index.ts`'s `TextNodeWithOffset` | `text` | `scripts/text` |
@@ -73,8 +77,35 @@ touches:
   the `devtools` feature), though no vector reaches that rule;
   `getTopLevelElement` is not, nor are slots on decorators (`__slotHost`, `__slots`). `@lexical/extension`'s
   `HorizontalRuleExtension` (`INSERT_HORIZONTAL_RULE_COMMAND`, clicks, the
-  selected class) and `DecoratorTextExtension` need the extension API, and
+  selected class) isn't ported (see the extension API below), and
   `applyFormatFromStyle` reads CSS.
+- Of the extension API (the `extension` feature): `InitialEditorConfig`'s
+  `namespace`, `theme` (and `deepThemeMergeInPlace`), `html`, `editable`,
+  `onError`, `onWarn`, `parentEditor`, `disableEvents` and `dom`, which a
+  headless Rust editor doesn't have; node replacements (`{replace, with}`)
+  and their conflict invariant, as `createEditor` takes classes only;
+  `buildEditor`'s `setRootElement(null)` and `Symbol.dispose` (dropping a
+  `LexicalEditorWithDispose` doesn't dispose it); `builderSymbol`'s version
+  and copy checks in `maybeFromEditor`, which one crate can't break; the
+  `nodes` thunk form (`nodes` is a list); `HMRExtension`. Configs are Rust
+  types that name their overrides' type (`ExtensionConfigBase::Partial`);
+  a JSON `Object` merges as JS does. Signal values compare with `==`
+  (`SignalValue`; an `EditorState` by identity) where JS's `!==` compares
+  objects by identity, and effect and computed bodies can't throw, so
+  preact's error paths have no counterpart and a cycle panics. `named_signals`
+  takes a JSON object; a typed config makes its signals field by field.
+  Every other extension of `@lexical/extension` (`AutoFocus`, `BlockId`,
+  `ClickAfterLastBlock`, `HorizontalRule`, `IME`, `KeyboardShortcuts`,
+  `NestedEditor`, `NodeSelection`, `NodeSelectionDataSelected`,
+  `NodeStructure`, `NormalizeInlineElements`, `NormalizeTripleClickSelection`,
+  `PreventSelectAll`, `RootElement`, `SelectBlock`,
+  `SelectionAlwaysOnDisplay`, `TabIndentation`, `WatchEditable`) reads the
+  DOM, a selection's DOM, keyboard events or slots, or waits on pieces that
+  aren't ported (`HorizontalRuleExtension` on `NodeSelectionExtension`), and
+  the extension forms of the other packages (`RichTextExtension`,
+  `PlainTextExtension`, `HistoryExtension`, `ListExtension`,
+  `LinkExtension`, `HashtagExtension`, `CodeExtension`, `OverflowExtension`)
+  aren't ported yet: their `register_*` functions are what they register.
 - Of NodeState: the `SerializationSchema` builders as `parse` functions
   (with them `canonicalValue`'s `arraySetValue` form and a config's
   `derived` and `schema`), which come with the schema facility;
@@ -107,8 +138,8 @@ touches:
 - `@lexical/list`'s DOM parts (`createDOM`, `updateDOM`, `exportDOM`,
   `importDOM`, the theme class names, `ListImportExtension`/`ListImportRules`
   and `WordListImportExtension`), which come with `html`; `ListExtension`
-  and `CheckListExtension`, which need the extension API (`ListExtension`'s
-  defaults are what `register_list` with `RegisterListOptions::default()`
+  and `CheckListExtension`, which aren't ported as extensions yet
+  (`ListExtension`'s defaults are what `register_list` with `RegisterListOptions::default()`
   does); `registerListStrictIndentTransform` (`hasStrictIndent`, off by
   default); `registerList`'s `KEY_BACKSPACE_COMMAND` handler and
   `registerCheckList`'s pointer, focus, arrow, Space and Escape handlers,
@@ -127,13 +158,12 @@ touches:
   `exportDOM`, `importDOM`, `$convertAnchorElement`, `LinkImportRules` and
   `LinkImportExtension`), which come with `html`, and `sanitizeUrl`, which
   only `updateLinkDOM` calls and which needs the WHATWG URL parser
-  (`new URL`); `LinkExtension`, which needs the extension API
+  (`new URL`); `LinkExtension`, which isn't ported yet
   (`register_link` with `LinkConfig::default()` is what its defaults do,
   and the config is a value where JS reads signals); `registerLink`'s
   `PASTE_COMMAND` handler (registered only with `validateUrl`), which reads
-  a `ClipboardEvent`'s data; `AutoLinkExtension`, which needs the extension
-  API (`register_auto_link` with `AutoLinkConfig::default()` and the
-  matchers is what it does with them; its `mergeConfig`, which concatenates
+  a `ClipboardEvent`'s data; `AutoLinkExtension`, which isn't ported yet
+  (`register_auto_link` with `AutoLinkConfig::default()` and the matchers is what it does with them; its `mergeConfig`, which concatenates
   configured arrays, is the caller's to do);
   `ClickableLinkExtension` and `AutoLinkAnnounceExtension`, which need a
   DOM. What `NodeStructureExtension` does for links where it enforces node
@@ -151,13 +181,13 @@ touches:
   `importDOM`, `$convertPreElement` and the other converters,
   `CodeImportRules`/`CodeImportExtension` and the VS Code paste overlay),
   which come with `html`, and `registerCodeGutter`, which writes to the
-  DOM; `CodeExtension` and `CodeIndentExtension`, which need the extension
-  API (`register_code` and `register_code_indentation(editor, None)` are
-  what their defaults register); `CodeExtension`'s `KEY_ENTER_COMMAND`
+  DOM; `CodeExtension` and `CodeIndentExtension`, which aren't ported as
+  extensions yet (`register_code` and `register_code_indentation(editor,
+  None)` are what their defaults register); `CodeExtension`'s `KEY_ENTER_COMMAND`
   handler and `registerCodeIndentation`'s handlers of `KEY_TAB_COMMAND`,
   the arrow keys (`$handleTab`, `$handleShiftLines`, `escapeWithArrows`),
   `MOVE_TO_START` and `MOVE_TO_END` (`$handleMoveTo`), which read a
-  `KeyboardEvent` and wait for an input layer. With no extension API,
+  `KeyboardEvent` and wait for an input layer. Without `CodeExtension`,
   `CodeNode.insertNewAfter` always takes the path JS takes for an editor
   without `CodeExtension` (exiting the block after two line breaks itself,
   as `scripts/code` records with `createEditor`), less the deprecation
@@ -172,7 +202,7 @@ touches:
   also hold hashtag or overflow nodes; they waited on those packages,
   which are now ported.
 - `@lexical/overflow`'s `createDOM` and `updateDOM`, which come with
-  `html`, and `OverflowExtension`, which needs the extension API
+  `html`, and `OverflowExtension`, which isn't ported yet
   (`overflow_nodes()` is its `nodes`). `excludeFromCopy` is a node hook
   that nothing calls yet: its callers are `@lexical/clipboard`'s and
   `@lexical/html`'s copies. `@lexical/react`'s character limit
@@ -187,7 +217,7 @@ touches:
   the transforms run, and `OverflowNode`'s removes the empty ones a random
   document holds.
 - `@lexical/hashtag`'s `createDOM`, which comes with `html`, and
-  `HashtagExtension`, which needs the extension API (`hashtag_nodes()` is
+  `HashtagExtension`, which isn't ported yet (`hashtag_nodes()` is
   its `nodes` and `register_lexical_hashtag(editor,
   HashtagConfig::default())` its `register`). Within `registerLexicalTextEntity`,
   `$carryNodeState`, `splitOffInUpdate`, `demotedInUpdate` and
@@ -234,8 +264,8 @@ touches:
   `$removeTextFromCaretRange` never meets a slot host and records no
   deletions.
 - `HistoryExtension` and `SharedHistoryExtension` (`@lexical/history`), which
-  need the extension API. Sharing one `HistoryState` between editors through
-  `register_history` works. `register_history` takes the delay and
+  aren't ported as extensions yet. Sharing one `HistoryState` between
+  editors through `register_history` works. `register_history` takes the delay and
   `maxDepth` as values, where JS also takes signals, and `maxDepth` as a
   `usize`.
 - `registerRichText`'s handlers of DOM events (click, the arrow keys,
@@ -251,8 +281,8 @@ touches:
   with its dependencies (`DragonExtension`,
   `NormalizeInlineElementsExtension`, whose transform
   `register_normalize_inline_elements` registers,
-  `NormalizeTripleClickSelectionExtension`), which need an input layer and
-  the extension API.
+  `NormalizeTripleClickSelectionExtension`), which need an input layer or
+  aren't ported as extensions yet.
   `quoteShadowRootState` is a flat NodeState, as in JS
   (`quote_shadow_root_state`; `scripts/node-state` sets and reads it). A
   shadow root quote's `collapseAtStart` (dissolving into
diff --git a/rust/conformance/src/scripts.rs b/rust/conformance/src/scripts.rs
index 79f8f6c1325..ee43cf4e1af 100644
--- a/rust/conformance/src/scripts.rs
+++ b/rust/conformance/src/scripts.rs
@@ -66,12 +66,18 @@ use std::cell::{Cell, RefCell};
 use std::collections::HashMap;
 use std::rc::Rc;
 
+mod extensions;
+
 /// What `ops.ts`'s `Context` holds besides the editor.
 #[derive(Default)]
 struct Ctx {
     log: RefCell<Vec<Value>>,
     commands: RefCell<HashMap<String, LexicalCommand<Value>>>,
     states: States,
+    /// The test extensions made so far, by key.
+    extensions: RefCell<HashMap<String, Rc<extensions::TestExtension>>>,
+    /// `script.extensionDefs`.
+    extension_defs: RefCell<Object>,
 }
 
 /// `ops.ts`'s `STATES`, one set per session (JS's are shared by every
@@ -1084,6 +1090,8 @@ fn transform_name(name: &str) -> Option<&'static str> {
 /// step by step alongside JS Lexical.
 pub struct Session {
     editor: Editor,
+    /// The editor built from `extensions`, when the script has them.
+    built: Option<lexical::extension::LexicalEditorWithDispose>,
     ctx: Rc<Ctx>,
     /// The session's clock, in milliseconds: what the history merges by.
     /// It starts at 0, and a step's `now` sets it.
@@ -1109,10 +1117,82 @@ pub struct StepResult {
     pub error: Option<LexicalError>,
 }
 
+/// `snapshotOf(editor, log, snapshot)`: the log, the selection and the
+/// text, and with `snapshot` the state in both forms, in that key order.
+fn snapshot_of(editor: &Editor, ctx: &Ctx, snapshot: bool) -> Result<Object, String> {
+    // A dispatch outside an update commits at the next read, whose
+    // listeners log too.
+    let (selection, text) = editor
+        .read(|| (selection_snapshot(), get_root().get_text_content()))
+        .map_err(|e| format!("committing: {e}"))?;
+    let mut json = Object::new();
+    json.insert("log", Value::Array(ctx.log.borrow().clone()));
+    json.insert("selection", selection);
+    json.insert("text", text.into());
+    if snapshot {
+        let state = editor.get_editor_state();
+        json.insert("state", state.to_json(false).to_string().into());
+        json.insert("compact", state.to_json(true).to_string().into());
+    }
+    Ok(json)
+}
+
+/// The package flags a script with `extensions` can't have.
+const PACKAGE_FLAGS: [&str; 8] = [
+    "richText",
+    "plainText",
+    "list",
+    "link",
+    "code",
+    "overflow",
+    "hashtag",
+    "extension",
+];
+
 impl Session {
     /// `startSession(script)`: a new headless editor, with keys restarted.
     pub fn start(script: &Value) -> Result<Session, String> {
+        Self::start_with_build(script)?
+            .0
+            .ok_or_else(|| "the editor failed to build".to_owned())
+    }
+
+    /// `startSession(script)`, with what building the editor from the
+    /// script's `extensions` recorded (`session.build`). When that build
+    /// fails there is no session.
+    pub fn start_with_build(script: &Value) -> Result<(Option<Session>, Option<Value>), String> {
         reset_random_key();
+        if let Some(extensions) = script.get("extensions").and_then(Value::as_array) {
+            if let Some(flag) = PACKAGE_FLAGS
+                .iter()
+                .find(|f| script.get(f).and_then(Value::as_bool) == Some(true))
+            {
+                return Err(format!("extensions and {flag} don't mix"));
+            }
+            let ctx = Rc::new(Ctx::default());
+            if let Some(defs) = script.get("extensionDefs").and_then(Value::as_object) {
+                *ctx.extension_defs.borrow_mut() = defs.clone();
+            }
+            return match extensions::build(&ctx, extensions) {
+                Err(e) => {
+                    let mut build = Object::new();
+                    build.insert("error", e.message().into());
+                    build.insert("log", Value::Array(ctx.log.borrow().clone()));
+                    Ok((None, Some(Value::Object(build))))
+                }
+                Ok(built) => {
+                    let build = snapshot_of(&built, &ctx, true)?;
+                    let mut session = Self::start_on(script, built.editor().clone(), ctx)?;
+                    session.built = Some(built);
+                    Ok((Some(session), Some(Value::Object(build))))
+                }
+            };
+        }
+        Ok((Some(Self::start_plain(script)?), None))
+    }
+
+    /// `startSession(script)` on `createEditor`.
+    fn start_plain(script: &Value) -> Result<Session, String> {
         let rich_text = script.get("richText").and_then(Value::as_bool) == Some(true);
         let with_list = script.get("list").and_then(Value::as_bool) == Some(true);
         let with_link = script.get("link").and_then(Value::as_bool) == Some(true);
@@ -1147,6 +1227,20 @@ impl Session {
             ..CreateEditorArgs::default()
         });
         let ctx = Rc::new(Ctx::default());
+        Self::start_on(script, editor, ctx)
+    }
+
+    /// Registers the script's packages, transforms, handlers, listeners and
+    /// history on `editor`.
+    fn start_on(script: &Value, editor: Editor, ctx: Rc<Ctx>) -> Result<Session, String> {
+        let flag = |key: &str| script.get(key).and_then(Value::as_bool) == Some(true);
+        let (rich_text, with_list, with_link, with_code, with_hashtag) = (
+            flag("richText"),
+            flag("list"),
+            flag("link"),
+            flag("code"),
+            flag("hashtag"),
+        );
         if rich_text {
             let _unregister = lexical::rich_text::register_rich_text(&editor);
         }
@@ -1284,6 +1378,7 @@ impl Session {
         };
         Ok(Session {
             editor,
+            built: None,
             ctx,
             clock,
             unregister_history,
@@ -1329,26 +1424,15 @@ impl Session {
                     ..UpdateOptions::default()
                 },
             )
-        } else {
-            let name = step.str("dispatch")?;
+        } else if let Some(name) = step.get("dispatch").and_then(Value::as_str) {
             let payload = step.get("payload").cloned().unwrap_or(Value::Null);
             ctx.command(name)
                 .dispatch(editor, payload)
                 .map(|handled| ctx.log(vec!["dispatched".into(), name.into(), handled.into()]))
+        } else {
+            extensions::run_step(step, ctx, self.built.as_ref())
         };
-        // A dispatch outside an update commits at the next read.
-        let (selection, text) = editor
-            .read(|| (selection_snapshot(), get_root().get_text_content()))
-            .map_err(|e| format!("committing: {e}"))?;
-        let mut json = Object::new();
-        json.insert("log", Value::Array(ctx.log.borrow().clone()));
-        json.insert("selection", selection);
-        json.insert("text", text.into());
-        if snapshot {
-            let state = editor.get_editor_state();
-            json.insert("state", state.to_json(false).to_string().into());
-            json.insert("compact", state.to_json(true).to_string().into());
-        }
+        let mut json = snapshot_of(editor, ctx, snapshot)?;
         let error = outcome.err();
         if error.is_some() {
             json.insert("error", true.into());
@@ -1365,8 +1449,26 @@ pub fn check(case: &Value, _file: &Value) -> Result<Outcome, String> {
     if let Some(part) = unported(case) {
         return Ok(Outcome::NotPorted(part));
     }
-    let session = Session::start(case)?;
+    let (session, build) = Session::start_with_build(case)?;
+    same(
+        "build recorded",
+        build.is_some(),
+        case.get("build").is_some(),
+    )?;
+    if let (Some(build), Some(expected)) = (&build, case.get("build")) {
+        for field in ["log", "selection", "text", "state", "compact", "error"] {
+            same(
+                format!("build {field}"),
+                build.get(field),
+                expected.get(field),
+            )?;
+        }
+    }
     let steps = case.arr("steps")?;
+    let Some(session) = session else {
+        same("steps after a failed build", steps.len(), 0)?;
+        return Ok(Outcome::Pass);
+    };
     let results = case.arr("results")?;
     same("steps recorded", results.len(), steps.len())?;
     for (i, (step, expected)) in steps.iter().zip(results).enumerate() {
diff --git a/rust/conformance/src/scripts/extensions.rs b/rust/conformance/src/scripts/extensions.rs
new file mode 100644
index 00000000000..59751609e47
--- /dev/null
+++ b/rust/conformance/src/scripts/extensions.rs
@@ -0,0 +1,536 @@
+//! Scripts with `extensions`: the editor is built with
+//! `buildEditorFromExtensions` from test extensions that `ops.ts`'s
+//! `testExtension` makes from JSON (`ExtensionSpec`), and a few of
+//! `@lexical/extension`'s own (`REAL_EXTENSIONS`). Each test extension logs
+//! every phase it runs, so the log is the order the builder ran them in.
+
+use super::{Ctx, err};
+use lexical::extension::{DecoratorTextNode, HorizontalRuleNode};
+use lexical::extension::{
+    LexicalEditorWithDispose, NamedSignalsOutput, batch, build_editor_from_extensions,
+    clear_editor_extension, computed, decorator_text_extension, editor_state_extension, effect,
+    get_extension_dependency_from_editor, get_known_types_and_nodes,
+    get_peer_dependency_from_editor, named_signals, untracked,
+};
+use lexical::json::{Object, Value};
+use lexical::{
+    AnyLexicalExtensionArgument, COMMAND_PRIORITY_EDITOR, Editor, ExtensionBuildState,
+    ExtensionInitState, ExtensionRegisterState, InitialEditorConfig, InitialEditorStateType,
+    LexicalError, LexicalExtension, NodeClass, Unregister, config_extension, create_paragraph_node,
+    create_text_node, declare_peer_dependency, define_extension, get_root, shallow_merge_config,
+};
+use std::rc::Rc;
+
+/// A test extension: its config is JSON, its output the `namedSignals` of
+/// its config (empty unless it has `signals`), its init result
+/// `{init: name}`.
+pub(super) type TestExtension = LexicalExtension<Object, NamedSignalsOutput, Value>;
+
+const PHASES: [&str; 4] = ["init", "build", "register", "afterRegistration"];
+
+/// `REAL_EXTENSIONS`.
+fn real_extension(key: &str) -> Option<AnyLexicalExtensionArgument> {
+    Some(match key {
+        "ClearEditorExtension" => clear_editor_extension().into(),
+        "DecoratorTextExtension" => decorator_text_extension().into(),
+        "EditorStateExtension" => editor_state_extension().into(),
+        _ => return None,
+    })
+}
+
+/// `extensionOf(ctx, key)` for a test extension: the one made for `key`,
+/// made on first use.
+pub(super) fn test_extension_of(
+    ctx: &Rc<Ctx>,
+    key: &str,
+) -> Result<Rc<TestExtension>, LexicalError> {
+    if let Some(made) = ctx.extensions.borrow().get(key) {
+        return Ok(made.clone());
+    }
+    let spec = ctx
+        .extension_defs
+        .borrow()
+        .get(key)
+        .and_then(Value::as_object)
+        .cloned()
+        .ok_or_else(|| err(format!("unknown extension {key}")))?;
+    let made = test_extension(ctx, &spec)?;
+    ctx.extensions
+        .borrow_mut()
+        .insert(key.to_owned(), made.clone());
+    Ok(made)
+}
+
+/// `extensionArg(ctx, arg)`.
+pub(super) fn extension_arg(
+    ctx: &Rc<Ctx>,
+    arg: &Value,
+) -> Result<AnyLexicalExtensionArgument, LexicalError> {
+    if let Some(key) = arg.as_str() {
+        if let Some(real) = real_extension(key) {
+            return Ok(real);
+        }
+        return Ok(test_extension_of(ctx, key)?.into());
+    }
+    let parts = arg
+        .as_array()
+        .filter(|a| !a.is_empty())
+        .ok_or_else(|| err(format!("bad extension argument {arg}")))?;
+    let key = parts[0].as_str().unwrap_or("");
+    let configs = parts[1..]
+        .iter()
+        .map(|c| c.as_object().cloned().ok_or_else(|| err("bad config")))
+        .collect::<Result<Vec<_>, _>>()?;
+    Ok(config_extension(&test_extension_of(ctx, key)?, configs))
+}
+
+fn strings(v: Option<&Value>) -> Vec<String> {
+    v.and_then(Value::as_array)
+        .into_iter()
+        .flatten()
+        .filter_map(|s| s.as_str().map(str::to_owned))
+        .collect()
+}
+
+fn flag(spec: &Object, key: &str) -> bool {
+    spec.get(key).and_then(Value::as_bool) == Some(true)
+}
+
+fn names(names: Vec<String>) -> Value {
+    Value::Array(names.into_iter().map(Value::from).collect())
+}
+
+fn root_text(editor: &Editor) -> Value {
+    editor
+        .get_editor_state()
+        .read(|| get_root().get_text_content())
+        .into()
+}
+
+/// JS's truthiness of a JSON value.
+fn truthy(v: &Value) -> bool {
+    match v {
+        Value::Undefined | Value::Null => false,
+        Value::Bool(b) => *b,
+        Value::Number(n) => *n != 0.0 && !n.is_nan(),
+        Value::String(s) => !s.is_empty(),
+        _ => true,
+    }
+}
+
+/// `${value}` of a JSON string.
+fn template(v: &Value) -> String {
+    v.as_str().map_or_else(|| v.to_string(), str::to_owned)
+}
+
+/// `testExtension(ctx, spec)`.
+fn test_extension(ctx: &Rc<Ctx>, spec: &Object) -> Result<Rc<TestExtension>, LexicalError> {
+    let name = spec
+        .get("name")
+        .and_then(Value::as_str)
+        .ok_or_else(|| err("an extension needs a name"))?
+        .to_owned();
+    let phases = match spec.get("phases") {
+        Some(_) => strings(spec.get("phases")),
+        None => PHASES.iter().map(|p| (*p).to_owned()).collect(),
+    };
+    let has = |phase: &str| phases.iter().any(|p| p == phase);
+    let config = spec
+        .get("config")
+        .and_then(Value::as_object)
+        .cloned()
+        .unwrap_or_default();
+    let mut extension = TestExtension::new(name.clone(), config);
+    extension.conflicts_with = strings(spec.get("conflictsWith"));
+    for dep in spec
+        .get("dependencies")
+        .and_then(Value::as_array)
+        .into_iter()
+        .flatten()
+    {
+        extension.dependencies.push(extension_arg(ctx, dep)?);
+    }
+    for peer in spec
+        .get("peerDependencies")
+        .and_then(Value::as_array)
+        .into_iter()
+        .flatten()
+    {
+        let peer = peer.as_array().ok_or_else(|| err("bad peer dependency"))?;
+        let peer_name = peer
+            .first()
+            .and_then(Value::as_str)
+            .ok_or_else(|| err("bad peer dependency"))?;
+        let config = peer.get(1).and_then(Value::as_object).cloned();
+        extension
+            .peer_dependencies
+            .push(declare_peer_dependency::<Object>(peer_name, config));
+    }
+    for node_type in strings(spec.get("nodes")) {
+        extension.nodes.push(match node_type.as_str() {
+            "decorator-text" => NodeClass::of::<DecoratorTextNode>(),
+            "horizontalrule" => NodeClass::of::<HorizontalRuleNode>(),
+            other => return Err(err(format!("unknown node type {other}"))),
+        });
+    }
+    match spec.get("initialEditorState") {
+        None => {}
+        Some(Value::Null) => extension.initial_editor_state = Some(InitialEditorStateType::Null),
+        Some(initial) => {
+            if let Some(json) = initial.get("json") {
+                extension.initial_editor_state =
+                    Some(InitialEditorStateType::Json(json.to_string()));
+            } else {
+                let text = initial
+                    .get("text")
+                    .and_then(Value::as_str)
+                    .ok_or_else(|| err("bad initialEditorState"))?
+                    .to_owned();
+                extension.initial_editor_state =
+                    Some(InitialEditorStateType::Update(Rc::new(move |_| {
+                        let paragraph = create_paragraph_node();
+                        paragraph.append(&[create_text_node(&text)])?;
+                        get_root().append(&[paragraph])
+                    })));
+            }
+        }
+    }
+    if spec.get("mergeConfig").and_then(Value::as_str) == Some("concat") {
+        extension.merge_config = Some(Rc::new(|config: &Object, overrides: &Object| {
+            let mut merged = shallow_merge_config(config, Some(overrides));
+            for (k, b) in overrides.iter() {
+                if let (Some(Value::Array(a)), Value::Array(b)) = (config.get(k), b) {
+                    merged.insert(k, Value::Array(a.iter().chain(b).cloned().collect()));
+                }
+            }
+            merged
+        }));
+    }
+    let inspect = flag(spec, "inspect");
+    let init_peers = strings(spec.get("initPeers"));
+    let build_peers = strings(spec.get("buildPeers"));
+    let lookups = strings(spec.get("lookups"));
+    if has("init") {
+        let (ctx, name, lookups) = (ctx.clone(), name.clone(), lookups.clone());
+        extension.init = Some(Rc::new(
+            move |editor_config: &mut InitialEditorConfig,
+                  config: &Object,
+                  state: &ExtensionInitState| {
+                let log = |entry: Vec<Value>| ctx.log(entry);
+                log(vec![
+                    "init".into(),
+                    name.as_str().into(),
+                    config.clone().into(),
+                ]);
+                if inspect {
+                    let types = get_known_types_and_nodes(editor_config).types;
+                    log(vec![
+                        "knownTypes".into(),
+                        name.as_str().into(),
+                        Value::Array(types.into_iter().map(Value::from).collect()),
+                    ]);
+                    log(vec![
+                        "dependents".into(),
+                        name.as_str().into(),
+                        names(state.get_direct_dependent_names()),
+                    ]);
+                    log(vec![
+                        "peerNames".into(),
+                        name.as_str().into(),
+                        names(state.get_peer_name_set()),
+                    ]);
+                }
+                for peer in &init_peers {
+                    let config = state.get_peer::<Object>(peer)?;
+                    log(vec![
+                        "initPeer".into(),
+                        name.as_str().into(),
+                        peer.as_str().into(),
+                        config.map_or(Value::Null, |c| (*c).clone().into()),
+                    ]);
+                }
+                for key in &lookups {
+                    let config = state.get_dependency(&test_extension_of(&ctx, key)?)?;
+                    log(vec![
+                        "initDependency".into(),
+                        name.as_str().into(),
+                        key.as_str().into(),
+                        (*config).clone().into(),
+                    ]);
+                }
+                let mut result = Object::new();
+                result.insert("init", name.as_str().into());
+                Ok(Value::Object(result))
+            },
+        ));
+    }
+    let signals = flag(spec, "signals");
+    if has("build") {
+        let (ctx, name) = (ctx.clone(), name.clone());
+        extension.build = Some(Rc::new(
+            move |_editor: &Editor, config: &Object, state: &ExtensionBuildState<Value>| {
+                let log = |entry: Vec<Value>| ctx.log(entry);
+                log(vec![
+                    "build".into(),
+                    name.as_str().into(),
+                    config.clone().into(),
+                ]);
+                for peer in &build_peers {
+                    let dep = state.get_peer::<Object, NamedSignalsOutput, Value>(peer)?;
+                    log(vec![
+                        "buildPeer".into(),
+                        name.as_str().into(),
+                        peer.as_str().into(),
+                        dep.map_or(Value::Null, |d| (*d.config).clone().into()),
+                    ]);
+                }
+                for key in &lookups {
+                    let dep = state.get_dependency(&test_extension_of(&ctx, key)?)?;
+                    log(vec![
+                        "buildDependency".into(),
+                        name.as_str().into(),
+                        key.as_str().into(),
+                        (*dep.config).clone().into(),
+                    ]);
+                }
+                Ok(if signals {
+                    named_signals(config, None)
+                } else {
+                    NamedSignalsOutput::default()
+                })
+            },
+        ));
+    }
+    let (init_result, abort, listen, editor_state) = (
+        flag(spec, "initResult"),
+        flag(spec, "abort"),
+        flag(spec, "listen"),
+        flag(spec, "editorState"),
+    );
+    if has("register") {
+        let (ctx, name) = (ctx.clone(), name.clone());
+        extension.register = Some(Rc::new(
+            move |editor: &Editor,
+                  config: &Object,
+                  state: &ExtensionRegisterState<Value, NamedSignalsOutput>| {
+                let log = {
+                    let ctx = ctx.clone();
+                    move |entry: Vec<Value>| ctx.log(entry)
+                };
+                log(vec![
+                    "register".into(),
+                    name.as_str().into(),
+                    config.clone().into(),
+                    root_text(editor),
+                ]);
+                if init_result {
+                    let result = state.get_init_result()?;
+                    log(vec![
+                        "initResult".into(),
+                        name.as_str().into(),
+                        (*result).clone(),
+                    ]);
+                }
+                let mut cleanups: Vec<Unregister> = Vec::new();
+                if abort {
+                    let (log, name) = (log.clone(), name.clone());
+                    state
+                        .get_signal()?
+                        .add_abort_listener(move || log(vec!["aborted".into(), name.into()]));
+                }
+                if listen {
+                    let (log, name) = (log.clone(), name.clone());
+                    cleanups.push(editor.register_update_listener(move |payload| {
+                        let mut tags = payload.tags.clone();
+                        tags.sort();
+                        log(vec![
+                            "update".into(),
+                            name.as_str().into(),
+                            Value::Array(tags.into_iter().map(Value::from).collect()),
+                        ]);
+                    }));
+                }
+                let command = Rc::new(ctx.command("EXTENSION_COMMAND"));
+                if signals {
+                    let output = state.get_output().ok_or_else(|| err("no output"))?;
+                    let disabled = output
+                        .get("disabled")
+                        .cloned()
+                        .ok_or_else(|| err("no disabled signal"))?;
+                    let label = output
+                        .get("label")
+                        .cloned()
+                        .ok_or_else(|| err("no label signal"))?;
+                    let summary = {
+                        let (disabled, label) = (disabled.clone(), label.clone());
+                        computed(move || {
+                            if truthy(&disabled.value()) {
+                                "off".to_owned()
+                            } else {
+                                format!("on:{}", template(&label.value()))
+                            }
+                        })
+                    };
+                    {
+                        let (log, name) = (log.clone(), name.clone());
+                        cleanups.push(effect(move || {
+                            log(vec![
+                                "summary".into(),
+                                name.as_str().into(),
+                                summary.value().into(),
+                            ]);
+                            None
+                        }));
+                    }
+                    let (log, name, editor) = (log.clone(), name.clone(), editor.clone());
+                    cleanups.push(effect(move || {
+                        if truthy(&disabled.value()) {
+                            return None;
+                        }
+                        let current = untracked(|| label.value());
+                        log(vec!["enable".into(), name.as_str().into(), current.clone()]);
+                        let unregister = {
+                            let (log, name) = (log.clone(), name.clone());
+                            command.register(
+                                &editor,
+                                move |payload, _| {
+                                    log(vec![
+                                        "handled".into(),
+                                        name.as_str().into(),
+                                        current.clone(),
+                                        payload.clone(),
+                                    ]);
+                                    Ok(false)
+                                },
+                                COMMAND_PRIORITY_EDITOR,
+                            )
+                        };
+                        let (log, name) = (log.clone(), name.clone());
+                        Some(Box::new(move || {
+                            log(vec!["disable".into(), name.into()]);
+                            unregister();
+                        }))
+                    }));
+                } else {
+                    let (log, name) = (log.clone(), name.clone());
+                    cleanups.push(command.register(
+                        editor,
+                        move |payload, _| {
+                            log(vec![
+                                "handled".into(),
+                                name.as_str().into(),
+                                payload.clone(),
+                            ]);
+                            Ok(false)
+                        },
+                        COMMAND_PRIORITY_EDITOR,
+                    ));
+                }
+                if editor_state {
+                    let dep = state.get_dependency(&editor_state_extension())?;
+                    let signal = dep.output.ok_or_else(|| err("no editor state signal"))?;
+                    let (log, name) = (log.clone(), name.clone());
+                    cleanups.push(effect(move || {
+                        let text = signal.value().read(|| get_root().get_text_content());
+                        log(vec![
+                            "editorState".into(),
+                            name.as_str().into(),
+                            text.into(),
+                        ]);
+                        None
+                    }));
+                }
+                let name = name.clone();
+                Ok(Box::new(move || {
+                    log(vec!["unregister".into(), name.into()]);
+                    for cleanup in cleanups.into_iter().rev() {
+                        cleanup();
+                    }
+                }) as Unregister)
+            },
+        ));
+    }
+    if has("afterRegistration") {
+        let (ctx, name) = (ctx.clone(), name.clone());
+        extension.after_registration = Some(Rc::new(
+            move |editor: &Editor,
+                  config: &Object,
+                  _state: &ExtensionRegisterState<Value, NamedSignalsOutput>| {
+                ctx.log(vec![
+                    "afterRegistration".into(),
+                    name.as_str().into(),
+                    config.clone().into(),
+                    root_text(editor),
+                ]);
+                let (ctx, name) = (ctx.clone(), name.clone());
+                Ok(
+                    Box::new(move || ctx.log(vec!["afterUnregister".into(), name.into()]))
+                        as Unregister,
+                )
+            },
+        ));
+    }
+    Ok(define_extension(extension))
+}
+
+/// `buildEditorFromExtensions(...script.extensions)`.
+pub(super) fn build(
+    ctx: &Rc<Ctx>,
+    extensions: &[Value],
+) -> Result<LexicalEditorWithDispose, LexicalError> {
+    let args = extensions
+        .iter()
+        .map(|arg| extension_arg(ctx, arg))
+        .collect::<Result<Vec<_>, _>>()?;
+    build_editor_from_extensions(args)
+}
+
+/// `runExtensionStep(step, ctx)`.
+pub(super) fn run_step(
+    step: &Value,
+    ctx: &Rc<Ctx>,
+    built: Option<&LexicalEditorWithDispose>,
+) -> Result<(), LexicalError> {
+    let built = built.ok_or_else(|| err("the editor was not built from extensions"))?;
+    let editor: &Editor = built;
+    if step.get("dispose").is_some() {
+        built.dispose();
+    } else if let Some(entries) = step.get("setSignals").and_then(Value::as_array) {
+        batch(|| {
+            for entry in entries {
+                let entry = entry.as_array().map(Vec::as_slice);
+                let Some([key, name, value]) = entry else {
+                    return Err(err("bad setSignals"));
+                };
+                let extension = test_extension_of(ctx, key.as_str().unwrap_or(""))?;
+                let output = get_extension_dependency_from_editor(editor, &extension)?
+                    .output
+                    .ok_or_else(|| err("no output"))?;
+                let signal = output
+                    .get(name.as_str().unwrap_or(""))
+                    .ok_or_else(|| err(format!("no signal {name}")))?;
+                signal.set_value(value.clone());
+            }
+            Ok(())
+        })?;
+    } else if let Some(key) = step.get("logDependency").and_then(Value::as_str) {
+        let extension = test_extension_of(ctx, key)?;
+        let dep = get_extension_dependency_from_editor(editor, &extension)?;
+        ctx.log(vec![
+            "dependency".into(),
+            key.into(),
+            (*dep.config).clone().into(),
+        ]);
+    } else if let Some(name) = step.get("logPeer").and_then(Value::as_str) {
+        let dep =
+            get_peer_dependency_from_editor::<Object, NamedSignalsOutput, Value>(editor, name)?;
+        ctx.log(vec![
+            "peer".into(),
+            name.into(),
+            dep.map_or(Value::Null, |d| (*d.config).clone().into()),
+        ]);
+    } else {
+        return Err(err(format!("unknown step {step}")));
+    }
+    Ok(())
+}
diff --git a/rust/conformance/src/suites/mod.rs b/rust/conformance/src/suites/mod.rs
index 66a96de582f..a92731d660a 100644
--- a/rust/conformance/src/suites/mod.rs
+++ b/rust/conformance/src/suites/mod.rs
@@ -142,6 +142,11 @@ pub fn all() -> Vec<Suite> {
             variant: None,
             check: crate::scripts::check,
         },
+        Suite {
+            file: "scripts/extensions",
+            variant: None,
+            check: crate::scripts::check,
+        },
         Suite {
             file: "scripts/plain-text",
             variant: None,
diff --git a/rust/lexical-editor/Cargo.toml b/rust/lexical-editor/Cargo.toml
index 150e197a4ed..08d82b9ac85 100644
--- a/rust/lexical-editor/Cargo.toml
+++ b/rust/lexical-editor/Cargo.toml
@@ -64,9 +64,11 @@ file = []
 # the link branch is built with `link` (without it no link node can exist),
 # and the HTML form, mark and table nodes aren't ported.
 devtools = []
-# @lexical/extension's decorators: HorizontalRuleNode (a block decorator) and
-# DecoratorTextNode (an inline one), and NormalizeInlineElementsExtension's
-# transform. The rest of the package, the extension API, isn't ported.
+# @lexical/extension: the extension API (buildEditorFromExtensions, with
+# lexical's extension-core types and a port of @preact/signals-core), its
+# model-level extensions with NormalizeInlineElementsExtension's transform,
+# and its decorators, HorizontalRuleNode (a block decorator) and
+# DecoratorTextNode (an inline one).
 extension = []
 
 [dependencies]
diff --git a/rust/lexical-editor/src/editor.rs b/rust/lexical-editor/src/editor.rs
index 922b37f9601..cbe300e3557 100644
--- a/rust/lexical-editor/src/editor.rs
+++ b/rust/lexical-editor/src/editor.rs
@@ -287,6 +287,10 @@ pub(crate) struct EditorInner {
     namespace: String,
     /// `_editable`.
     editable: Cell<bool>,
+    /// The `LexicalBuilder` that built the editor (JS's
+    /// `editor[builderSymbol]`).
+    #[cfg(feature = "extension")]
+    pub(crate) builder: RefCell<Option<Rc<dyn Any>>>,
 }
 
 /// `createEditor(config)`: registers the core nodes (root, text, line
@@ -336,6 +340,8 @@ pub fn create_editor(args: CreateEditorArgs) -> Editor {
         selection_movement: RefCell::new(None),
         namespace,
         editable: Cell::new(true),
+        #[cfg(feature = "extension")]
+        builder: RefCell::new(None),
     }))
 }
 
diff --git a/rust/lexical-editor/src/extension/clear_editor_extension.rs b/rust/lexical-editor/src/extension/clear_editor_extension.rs
new file mode 100644
index 00000000000..2d69b80c3ce
--- /dev/null
+++ b/rust/lexical-editor/src/extension/clear_editor_extension.rs
@@ -0,0 +1,133 @@
+//! `ClearEditorExtension.ts`: `CLEAR_EDITOR_COMMAND`'s implementation.
+
+use super::signals::{Signal, effect, signal};
+use crate::extension_core::{
+    ExtensionBuildState, ExtensionConfigBase, ExtensionRegisterState, LexicalExtension,
+    define_extension,
+};
+use crate::{
+    CLEAR_EDITOR_COMMAND, COMMAND_PRIORITY_EDITOR, Editor, LexicalError, Unregister,
+    create_paragraph_node, get_root, get_selection,
+};
+use std::rc::Rc;
+
+/// `ClearEditorConfig.$onClear`: what clearing does, compared by identity
+/// as JS compares functions.
+#[derive(Clone)]
+pub struct OnClear(pub Rc<dyn Fn() -> Result<(), LexicalError>>);
+
+impl PartialEq for OnClear {
+    fn eq(&self, other: &Self) -> bool {
+        Rc::ptr_eq(&self.0, &other.0)
+    }
+}
+
+/// `ClearEditorConfig`.
+#[derive(Clone)]
+pub struct ClearEditorConfig {
+    pub on_clear: OnClear,
+}
+
+/// `Partial<ClearEditorConfig>`.
+#[derive(Clone, Default)]
+pub struct ClearEditorConfigOverrides {
+    pub on_clear: Option<OnClear>,
+}
+
+impl ExtensionConfigBase for ClearEditorConfig {
+    type Partial = ClearEditorConfigOverrides;
+
+    fn shallow_merge(&self, overrides: &ClearEditorConfigOverrides) -> Self {
+        ClearEditorConfig {
+            on_clear: overrides
+                .on_clear
+                .clone()
+                .unwrap_or_else(|| self.on_clear.clone()),
+        }
+    }
+}
+
+/// `namedSignals(ClearEditorConfig)`: `ClearEditorExtension`'s output.
+#[derive(Clone)]
+pub struct ClearEditorOutput {
+    pub on_clear: Signal<OnClear>,
+}
+
+/// `ClearEditorExtension`.
+pub type ClearEditorExtensionType = LexicalExtension<ClearEditorConfig, ClearEditorOutput, ()>;
+
+/// `$defaultOnClear`: the root gets one empty paragraph, selected if
+/// anything was, with a range selection's format reset.
+fn default_on_clear() -> Result<(), LexicalError> {
+    let root = get_root();
+    let selection = get_selection();
+    let paragraph = create_paragraph_node();
+    root.clear()?;
+    root.append(std::slice::from_ref(&paragraph))?;
+    if selection.is_some() {
+        paragraph.select(None, None)?;
+    }
+    if let Some(selection) = selection.filter(|s| s.is_range()) {
+        selection.set_format(0.0);
+    }
+    Ok(())
+}
+
+/// `registerClearEditor(editor, $onClear)`: handles `CLEAR_EDITOR_COMMAND`
+/// by running `on_clear` (by default `$defaultOnClear`) in the command's
+/// update.
+pub fn register_clear_editor(editor: &Editor, on_clear: Option<OnClear>) -> Unregister {
+    let on_clear = on_clear.map_or_else(|| Rc::new(default_on_clear) as Rc<_>, |c| c.0);
+    editor.register_command(
+        &CLEAR_EDITOR_COMMAND,
+        move |_, _| {
+            on_clear()?;
+            Ok(true)
+        },
+        COMMAND_PRIORITY_EDITOR,
+    )
+}
+
+fn make() -> Rc<ClearEditorExtensionType> {
+    define_extension(LexicalExtension {
+        build: Some(Rc::new(
+            |_editor: &Editor, config: &ClearEditorConfig, _state: &ExtensionBuildState<()>| {
+                Ok(ClearEditorOutput {
+                    on_clear: signal(config.on_clear.clone()),
+                })
+            },
+        )),
+        register: Some(Rc::new(
+            |editor: &Editor,
+             _config: &ClearEditorConfig,
+             state: &ExtensionRegisterState<(), ClearEditorOutput>| {
+                let output = state
+                    .get_output()
+                    .expect("ClearEditorExtension has a build");
+                // Weakly, as the editor keeps the effect through the signal.
+                let editor = editor.weak();
+                Ok(effect(move || {
+                    let on_clear = output.on_clear.value();
+                    let editor = editor.upgrade().map(Editor)?;
+                    Some(register_clear_editor(&editor, Some(on_clear)))
+                }))
+            },
+        )),
+        ..LexicalExtension::new(
+            "@lexical/extension/ClearEditor",
+            ClearEditorConfig {
+                on_clear: OnClear(Rc::new(default_on_clear)),
+            },
+        )
+    })
+}
+
+thread_local! {
+    static CLEAR_EDITOR_EXTENSION: Rc<ClearEditorExtensionType> = make();
+}
+
+/// `ClearEditorExtension`: an implementation of `CLEAR_EDITOR_COMMAND`,
+/// whose `$onClear` is a signal of its output.
+pub fn clear_editor_extension() -> Rc<ClearEditorExtensionType> {
+    CLEAR_EDITOR_EXTENSION.with(Rc::clone)
+}
diff --git a/rust/lexical-editor/src/extension/config.rs b/rust/lexical-editor/src/extension/config.rs
new file mode 100644
index 00000000000..8ea565bdcd4
--- /dev/null
+++ b/rust/lexical-editor/src/extension/config.rs
@@ -0,0 +1,31 @@
+//! `config.ts`: the node types and classes of an editor configuration.
+
+use crate::NodeClass;
+use crate::extension_core::InitialEditorConfig;
+
+/// `KnownTypesAndNodes`: the node types and classes of a configuration, in
+/// the order they were added.
+#[derive(Clone, Default)]
+pub struct KnownTypesAndNodes {
+    pub types: Vec<&'static str>,
+    pub nodes: Vec<NodeClass>,
+}
+
+/// `getKnownTypesAndNodes(config)`: the node types and classes registered
+/// in an [`InitialEditorConfig`], for an extension's `init` to register
+/// optional behavior when some node is present.
+pub fn get_known_types_and_nodes(config: &InitialEditorConfig) -> KnownTypesAndNodes {
+    let mut known = KnownTypesAndNodes::default();
+    for klass in get_node_config(config) {
+        if !known.types.contains(&klass.node_type()) {
+            known.types.push(klass.node_type());
+            known.nodes.push(*klass);
+        }
+    }
+    known
+}
+
+/// `getNodeConfig(config)`: a configuration's node classes.
+pub fn get_node_config(config: &InitialEditorConfig) -> &[NodeClass] {
+    &config.nodes
+}
diff --git a/rust/lexical-editor/src/extension/decorator_text_extension.rs b/rust/lexical-editor/src/extension/decorator_text_extension.rs
index e7947a32e48..7282c4df111 100644
--- a/rust/lexical-editor/src/extension/decorator_text_extension.rs
+++ b/rust/lexical-editor/src/extension/decorator_text_extension.rs
@@ -114,3 +114,16 @@ impl LexicalNode for DecoratorTextNode {
     }
     fn update_from_json(&mut self, _json: &Object) {}
 }
+
+thread_local! {
+    static DECORATOR_TEXT_EXTENSION: std::rc::Rc<crate::extension_core::LexicalExtension> =
+        crate::extension_core::define_extension(crate::extension_core::LexicalExtension {
+            nodes: vec![crate::NodeClass::of::<DecoratorTextNode>()],
+            ..crate::extension_core::LexicalExtension::new("@lexical/extension/DecoratorText", ())
+        });
+}
+
+/// `DecoratorTextExtension`: registers `DecoratorTextNode`.
+pub fn decorator_text_extension() -> std::rc::Rc<crate::extension_core::LexicalExtension> {
+    DECORATOR_TEXT_EXTENSION.with(std::rc::Rc::clone)
+}
diff --git a/rust/lexical-editor/src/extension/editor_state_extension.rs b/rust/lexical-editor/src/extension/editor_state_extension.rs
new file mode 100644
index 00000000000..b0b6219f0ef
--- /dev/null
+++ b/rust/lexical-editor/src/extension/editor_state_extension.rs
@@ -0,0 +1,46 @@
+//! `EditorStateExtension.ts`.
+
+use super::signals::Signal;
+use super::watched_signal::watched_signal;
+use crate::extension_core::{ExtensionBuildState, LexicalExtension, define_extension};
+use crate::{Editor, EditorState};
+use std::rc::Rc;
+
+/// `EditorStateExtension`.
+pub type EditorStateExtensionType = LexicalExtension<(), Signal<EditorState>, ()>;
+
+fn make() -> Rc<EditorStateExtensionType> {
+    define_extension(LexicalExtension {
+        build: Some(Rc::new(
+            |editor: &Editor, _config: &(), _state: &ExtensionBuildState<()>| {
+                // Weakly, as the editor keeps the signal.
+                let (snapshot, listen) = (editor.weak(), editor.weak());
+                Ok(watched_signal(
+                    move || {
+                        Editor(snapshot.upgrade().expect("the editor is alive")).get_editor_state()
+                    },
+                    move |editor_state_signal| {
+                        let Some(editor) = listen.upgrade().map(Editor) else {
+                            return Box::new(|| {});
+                        };
+                        let editor_state_signal = editor_state_signal.clone();
+                        editor.register_update_listener(move |payload| {
+                            editor_state_signal.set_value(payload.editor_state.clone());
+                        })
+                    },
+                ))
+            },
+        )),
+        ..LexicalExtension::new("@lexical/extension/EditorState", ())
+    })
+}
+
+thread_local! {
+    static EDITOR_STATE_EXTENSION: Rc<EditorStateExtensionType> = make();
+}
+
+/// `EditorStateExtension`: the editor's current state as a signal, which
+/// follows the editor's updates while something watches it.
+pub fn editor_state_extension() -> Rc<EditorStateExtensionType> {
+    EDITOR_STATE_EXTENSION.with(Rc::clone)
+}
diff --git a/rust/lexical-editor/src/extension/extension_rep.rs b/rust/lexical-editor/src/extension/extension_rep.rs
new file mode 100644
index 00000000000..f907bd8e842
--- /dev/null
+++ b/rust/lexical-editor/src/extension/extension_rep.rs
@@ -0,0 +1,383 @@
+//! `internal/ExtensionRep.ts`: the builder's record of one extension, its
+//! state through the phases (configured, initialized, built, registered),
+//! and what it answers the phases about other extensions.
+
+use super::lexical_builder::BuilderInner;
+use crate::error::invariant;
+use crate::extension_core::{
+    AbortSignal, AnyExtensionDependency, AnyLexicalExtension, Erased, ExtensionBuildState,
+    ExtensionInitState, ExtensionRegisterState, ExtensionRepAccess, InitialEditorConfig,
+};
+use crate::{Editor, LexicalError, Unregister};
+use std::cell::RefCell;
+use std::marker::PhantomData;
+use std::rc::{Rc, Weak};
+
+/// `ExtensionRepStateIds`.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub(crate) enum StateId {
+    Unmarked = 0,
+    Temporary = 1,
+    Permanent = 2,
+    Configured = 3,
+    Initialized = 4,
+    Built = 5,
+    Registered = 6,
+    AfterRegistration = 7,
+}
+
+impl StateId {
+    fn n(self) -> u8 {
+        self as u8
+    }
+}
+
+/// `ExtensionRepState`: the state id and what the states from `configured`
+/// on add.
+pub(crate) struct RepState {
+    pub(crate) id: StateId,
+    config: Option<Erased>,
+    init_result: Option<Erased>,
+    output: Option<Erased>,
+}
+
+/// `ExtensionRep`.
+pub(crate) struct ExtensionRep {
+    builder: Weak<BuilderInner>,
+    this: Weak<ExtensionRep>,
+    /// `configs`: a `Set` of `Partial<Config>`, so the same overrides
+    /// object counts once.
+    pub(crate) configs: RefCell<Vec<Erased>>,
+    dependency: RefCell<Option<AnyExtensionDependency>>,
+    peer_name_set: RefCell<Option<Vec<String>>>,
+    pub(crate) extension: Rc<dyn AnyLexicalExtension>,
+    pub(crate) state: RefCell<RepState>,
+    signal: RefCell<Option<AbortSignal>>,
+}
+
+impl ExtensionRep {
+    pub(crate) fn new(
+        builder: Weak<BuilderInner>,
+        extension: Rc<dyn AnyLexicalExtension>,
+    ) -> Rc<Self> {
+        Rc::new_cyclic(|this| ExtensionRep {
+            builder,
+            this: this.clone(),
+            configs: RefCell::new(Vec::new()),
+            dependency: RefCell::new(None),
+            peer_name_set: RefCell::new(None),
+            extension,
+            state: RefCell::new(RepState {
+                id: StateId::Unmarked,
+                config: None,
+                init_result: None,
+                output: None,
+            }),
+            signal: RefCell::new(None),
+        })
+    }
+
+    fn builder(&self) -> Rc<BuilderInner> {
+        self.builder
+            .upgrade()
+            .expect("an extension's builder outlives it")
+    }
+
+    fn access(&self) -> Rc<dyn ExtensionRepAccess> {
+        self.this.upgrade().expect("an extension rep is alive")
+    }
+
+    fn name(&self) -> &str {
+        self.extension.name()
+    }
+
+    pub(crate) fn id(&self) -> StateId {
+        self.state.borrow().id
+    }
+
+    pub(crate) fn set_id(&self, id: StateId) {
+        self.state.borrow_mut().id = id;
+    }
+
+    /// `configs.add(config)`.
+    pub(crate) fn add_config(&self, config: &Erased) {
+        let mut configs = self.configs.borrow_mut();
+        if !configs.iter().any(|c| same_object(c, config)) {
+            configs.push(config.clone());
+        }
+    }
+
+    /// `mergeConfigs()`: the default config with each config of `configs`
+    /// merged in, with the extension's `mergeConfig` or `shallowMergeConfig`.
+    fn merge_configs(&self) -> Result<Erased, LexicalError> {
+        let configs = self.configs.borrow().clone();
+        self.extension.merge_configs_erased(&configs)
+    }
+
+    fn config(&self) -> Erased {
+        self.state
+            .borrow()
+            .config
+            .clone()
+            .expect("a configured extension has a config")
+    }
+
+    /// `init(editorConfig)`.
+    pub(crate) fn init(&self, editor_config: &mut InitialEditorConfig) -> Result<(), LexicalError> {
+        let id = self.id();
+        invariant!(
+            id == StateId::Permanent,
+            "ExtensionRep: Can not configure from state id {}",
+            id.n()
+        );
+        let config = self.merge_configs()?;
+        {
+            let mut state = self.state.borrow_mut();
+            state.config = Some(config.clone());
+            state.id = StateId::Configured;
+        }
+        let init_state = ExtensionInitState { rep: self.access() };
+        let init_result = self
+            .extension
+            .init_erased(editor_config, &config, &init_state)?;
+        let mut state = self.state.borrow_mut();
+        state.init_result = init_result;
+        state.id = StateId::Initialized;
+        Ok(())
+    }
+
+    /// `build(editor)`.
+    pub(crate) fn build(&self, editor: &Editor) -> Result<(), LexicalError> {
+        let id = self.id();
+        invariant!(
+            id == StateId::Initialized,
+            "ExtensionRep: register called in state id {} (expected {} initialized)",
+            id.n(),
+            StateId::Built.n()
+        );
+        let build_state = ExtensionBuildState {
+            rep: self.access(),
+            _init: PhantomData,
+        };
+        let output = self
+            .extension
+            .build_erased(editor, &self.config(), &build_state)?;
+        let mut state = self.state.borrow_mut();
+        state.output = output;
+        state.id = StateId::Built;
+        Ok(())
+    }
+
+    fn register_state(&self) -> ExtensionRegisterState<(), ()> {
+        ExtensionRegisterState {
+            build: ExtensionBuildState {
+                rep: self.access(),
+                _init: PhantomData,
+            },
+            _output: PhantomData,
+        }
+    }
+
+    /// `register(editor, signal)`: registers the extension and returns the
+    /// clean-up, which returns it to the built state and runs the clean-up
+    /// its `register` returned.
+    pub(crate) fn register(
+        &self,
+        editor: &Editor,
+        signal: AbortSignal,
+    ) -> Result<Unregister, LexicalError> {
+        *self.signal.borrow_mut() = Some(signal);
+        let id = self.id();
+        invariant!(
+            id == StateId::Built,
+            "ExtensionRep: register called in state id {} (expected {} built)",
+            id.n(),
+            StateId::Built.n()
+        );
+        let cleanup = self.extension.register_erased(
+            editor,
+            &self.config(),
+            &self.register_state(),
+            false,
+        )?;
+        self.set_id(StateId::Registered);
+        let this = self.access_rep();
+        Ok(Box::new(move || {
+            let after = this.id();
+            // An invariant in JS, which only a dispose before registration
+            // finished could break.
+            assert!(
+                after == StateId::AfterRegistration,
+                "ExtensionRep: rollbackToBuiltState called in state id {} (expected {} afterRegistration)",
+                id.n(),
+                StateId::AfterRegistration.n()
+            );
+            this.set_id(StateId::Built);
+            if let Some(cleanup) = cleanup {
+                cleanup();
+            }
+        }))
+    }
+
+    fn access_rep(&self) -> Rc<ExtensionRep> {
+        self.this.upgrade().expect("an extension rep is alive")
+    }
+
+    /// `afterRegistration(editor)`.
+    pub(crate) fn after_registration(
+        &self,
+        editor: &Editor,
+    ) -> Result<Option<Unregister>, LexicalError> {
+        let id = self.id();
+        invariant!(
+            id == StateId::Registered,
+            "ExtensionRep: afterRegistration called in state id {} (expected {} registered)",
+            id.n(),
+            StateId::Registered.n()
+        );
+        let result =
+            self.extension
+                .register_erased(editor, &self.config(), &self.register_state(), true)?;
+        self.set_id(StateId::AfterRegistration);
+        Ok(result)
+    }
+
+    /// `getExtensionInitDependency()`: the config, once configured.
+    fn get_extension_init_dependency(&self) -> Result<Erased, LexicalError> {
+        let id = self.id();
+        invariant!(
+            id >= StateId::Configured,
+            "ExtensionRep: getExtensionInitDependency called in state id {} (expected >= {} configured)",
+            id.n(),
+            StateId::Configured.n()
+        );
+        Ok(self.config())
+    }
+
+    /// `getExtensionDependency()`: the config, init result and output, once
+    /// built.
+    pub(crate) fn get_extension_dependency(&self) -> Result<AnyExtensionDependency, LexicalError> {
+        if let Some(dependency) = self.dependency.borrow().clone() {
+            return Ok(dependency);
+        }
+        let state = self.state.borrow();
+        invariant!(
+            state.id >= StateId::Built,
+            "Extension {} used as a dependency before build",
+            self.name()
+        );
+        let dependency = AnyExtensionDependency {
+            config: state
+                .config
+                .clone()
+                .expect("a built extension has a config"),
+            init: state.init_result.clone(),
+            output: state.output.clone(),
+        };
+        drop(state);
+        *self.dependency.borrow_mut() = Some(dependency.clone());
+        Ok(dependency)
+    }
+
+    fn missing_dependency(&self, dep: &dyn AnyLexicalExtension) -> LexicalError {
+        LexicalError::new(format!(
+            "LexicalExtensionBuilder: Extension {} missing dependency extension {} to be in registry",
+            self.name(),
+            dep.name()
+        ))
+    }
+}
+
+/// JS's `===` on two objects held as `Rc<dyn Any>`.
+fn same_object(a: &Erased, b: &Erased) -> bool {
+    std::ptr::addr_eq(Rc::as_ptr(a), Rc::as_ptr(b))
+}
+
+impl ExtensionRepAccess for ExtensionRep {
+    fn extension_name(&self) -> String {
+        self.name().to_owned()
+    }
+
+    /// `getInitDependency(dep).config`.
+    fn get_init_dependency(&self, dep: &dyn AnyLexicalExtension) -> Result<Erased, LexicalError> {
+        let rep = self.builder().get_extension_rep(dep)?;
+        let Some(rep) = rep else {
+            return Err(self.missing_dependency(dep));
+        };
+        rep.get_extension_init_dependency()
+    }
+
+    /// `getInitPeer(name)?.config`.
+    fn get_init_peer(&self, name: &str) -> Result<Option<Erased>, LexicalError> {
+        let rep = self.builder().extension_rep_by_name(name);
+        rep.map(|rep| rep.get_extension_init_dependency())
+            .transpose()
+    }
+
+    /// `getDependency(dep)`.
+    fn get_dependency(
+        &self,
+        dep: &dyn AnyLexicalExtension,
+    ) -> Result<AnyExtensionDependency, LexicalError> {
+        let rep = self.builder().get_extension_rep(dep)?;
+        let Some(rep) = rep else {
+            return Err(self.missing_dependency(dep));
+        };
+        rep.get_extension_dependency()
+    }
+
+    /// `getPeer(name)`.
+    fn get_peer(&self, name: &str) -> Result<Option<AnyExtensionDependency>, LexicalError> {
+        let rep = self.builder().extension_rep_by_name(name);
+        rep.map(|rep| rep.get_extension_dependency()).transpose()
+    }
+
+    /// `getInitResult()`.
+    fn get_init_result(&self) -> Result<Option<Erased>, LexicalError> {
+        invariant!(
+            self.extension.has_init(),
+            "ExtensionRep: getInitResult() called for Extension {} that does not define init",
+            self.name()
+        );
+        let state = self.state.borrow();
+        invariant!(
+            state.id >= StateId::Initialized,
+            "ExtensionRep: getInitResult() called for ExtensionRep in state id {} < {} (initialized)",
+            state.id.n(),
+            StateId::Initialized.n()
+        );
+        Ok(state.init_result.clone())
+    }
+
+    /// `getDirectDependentNames()`.
+    fn get_direct_dependent_names(&self) -> Vec<String> {
+        self.builder().incoming_edge_names(self.name())
+    }
+
+    /// `getPeerNameSet()`.
+    fn get_peer_name_set(&self) -> Vec<String> {
+        if let Some(names) = self.peer_name_set.borrow().clone() {
+            return names;
+        }
+        let mut names: Vec<String> = Vec::new();
+        for peer in self.extension.peer_dependencies() {
+            if !names.iter().any(|n| n == peer.name()) {
+                names.push(peer.name().to_owned());
+            }
+        }
+        *self.peer_name_set.borrow_mut() = Some(names.clone());
+        names
+    }
+
+    /// `getSignal()`.
+    fn get_signal(&self) -> Result<AbortSignal, LexicalError> {
+        self.signal
+            .borrow()
+            .clone()
+            .ok_or_else(|| LexicalError::new("ExtensionRep.getSignal() called before register"))
+    }
+
+    fn get_output(&self) -> Option<Erased> {
+        self.state.borrow().output.clone()
+    }
+}
diff --git a/rust/lexical-editor/src/extension/get_extension_dependency.rs b/rust/lexical-editor/src/extension/get_extension_dependency.rs
new file mode 100644
index 00000000000..8d37c325f9f
--- /dev/null
+++ b/rust/lexical-editor/src/extension/get_extension_dependency.rs
@@ -0,0 +1,42 @@
+//! `getExtensionDependency.ts`: the `$` forms of
+//! `getExtensionDependencyFromEditor` and `getPeerDependencyFromEditor`, for
+//! the editor whose update or read is running.
+
+use super::get_extension_dependency_from_editor::get_extension_dependency_from_editor;
+use super::get_peer_dependency_from_editor::get_peer_dependency_from_editor;
+use crate::extension_core::{ExtensionConfigBase, LexicalExtension, LexicalExtensionDependency};
+use crate::updates::get_active_editor;
+use crate::{Editor, LexicalError};
+use std::rc::Rc;
+
+/// `$getEditor()`.
+fn active_editor() -> Result<Editor, LexicalError> {
+    get_active_editor().ok_or_else(|| {
+        LexicalError::new(
+            "Unable to find an active editor. This method can only be used synchronously during the callback of editor.update(), editor.read(), or editor.getEditorState().read(..., {editor}).",
+        )
+    })
+}
+
+/// `$getExtensionDependency(extension)`:
+/// `getExtensionDependencyFromEditor($getEditor(), extension)`.
+pub fn get_extension_dependency<C: ExtensionConfigBase, O: 'static, I: 'static>(
+    extension: &Rc<LexicalExtension<C, O, I>>,
+) -> Result<LexicalExtensionDependency<C, O, I>, LexicalError> {
+    get_extension_dependency_from_editor(&active_editor()?, extension)
+}
+
+/// `$getExtensionOutput(extension)`: `$getExtensionDependency(extension).output`.
+pub fn get_extension_output<C: ExtensionConfigBase, O: 'static, I: 'static>(
+    extension: &Rc<LexicalExtension<C, O, I>>,
+) -> Result<Option<Rc<O>>, LexicalError> {
+    Ok(get_extension_dependency(extension)?.output)
+}
+
+/// `$getPeerDependency(name)`:
+/// `getPeerDependencyFromEditor($getEditor(), name)`.
+pub fn get_peer_dependency<C: 'static, O: 'static, I: 'static>(
+    extension_name: &str,
+) -> Result<Option<LexicalExtensionDependency<C, O, I>>, LexicalError> {
+    get_peer_dependency_from_editor(&active_editor()?, extension_name)
+}
diff --git a/rust/lexical-editor/src/extension/get_extension_dependency_from_editor.rs b/rust/lexical-editor/src/extension/get_extension_dependency_from_editor.rs
new file mode 100644
index 00000000000..149626d5466
--- /dev/null
+++ b/rust/lexical-editor/src/extension/get_extension_dependency_from_editor.rs
@@ -0,0 +1,26 @@
+//! `getExtensionDependencyFromEditor.ts`.
+
+use super::lexical_builder::LexicalBuilder;
+use crate::error::invariant;
+use crate::extension_core::{ExtensionConfigBase, LexicalExtension, LexicalExtensionDependency};
+use crate::{Editor, LexicalError};
+use std::rc::Rc;
+
+/// `getExtensionDependencyFromEditor(editor, extension)`: the merged config,
+/// init result and output of an extension the editor was built with. An
+/// error when the editor wasn't built from extensions, or without this
+/// one.
+pub fn get_extension_dependency_from_editor<C: ExtensionConfigBase, O: 'static, I: 'static>(
+    editor: &Editor,
+    extension: &Rc<LexicalExtension<C, O, I>>,
+) -> Result<LexicalExtensionDependency<C, O, I>, LexicalError> {
+    let builder = LexicalBuilder::from_editor(editor)?;
+    let rep = builder.0.get_extension_rep(extension.as_ref())?;
+    invariant!(
+        rep.is_some(),
+        "getExtensionDependencyFromEditor: Extension {} was not built when creating this editor",
+        extension.name
+    );
+    let rep = rep.expect("checked");
+    rep.get_extension_dependency()?.typed(&extension.name)
+}
diff --git a/rust/lexical-editor/src/extension/get_peer_dependency_from_editor.rs b/rust/lexical-editor/src/extension/get_peer_dependency_from_editor.rs
new file mode 100644
index 00000000000..844b5637806
--- /dev/null
+++ b/rust/lexical-editor/src/extension/get_peer_dependency_from_editor.rs
@@ -0,0 +1,41 @@
+//! `getPeerDependencyFromEditor.ts`.
+
+use super::lexical_builder::LexicalBuilder;
+use crate::extension_core::LexicalExtensionDependency;
+use crate::{Editor, LexicalError};
+
+/// `getPeerDependencyFromEditor(editor, name)`: the merged config, init
+/// result and output of the extension named `name`, as an extension of the
+/// given types, if the editor was built with it; `None` if it wasn't, or
+/// wasn't built from extensions. JS takes the extension's type as a type
+/// argument for the same reason: the caller has no reference to it.
+pub fn get_peer_dependency_from_editor<C: 'static, O: 'static, I: 'static>(
+    editor: &Editor,
+    extension_name: &str,
+) -> Result<Option<LexicalExtensionDependency<C, O, I>>, LexicalError> {
+    let Some(builder) = LexicalBuilder::maybe_from_editor(editor) else {
+        return Ok(None);
+    };
+    let peer = builder.0.extension_rep_by_name(extension_name);
+    match peer {
+        None => Ok(None),
+        Some(peer) => peer
+            .get_extension_dependency()?
+            .typed(extension_name)
+            .map(Some),
+    }
+}
+
+/// `getPeerDependencyFromEditorOrThrow(editor, name)`: as
+/// [`get_peer_dependency_from_editor`], an error when the editor wasn't
+/// built with the extension.
+pub fn get_peer_dependency_from_editor_or_throw<C: 'static, O: 'static, I: 'static>(
+    editor: &Editor,
+    extension_name: &str,
+) -> Result<LexicalExtensionDependency<C, O, I>, LexicalError> {
+    get_peer_dependency_from_editor(editor, extension_name)?.ok_or_else(|| {
+        LexicalError::new(format!(
+            "getPeerDependencyFromEditorOrThrow: Editor was not built with Extension {extension_name}"
+        ))
+    })
+}
diff --git a/rust/lexical-editor/src/extension/initial_state_extension.rs b/rust/lexical-editor/src/extension/initial_state_extension.rs
new file mode 100644
index 00000000000..07f5f15f106
--- /dev/null
+++ b/rust/lexical-editor/src/extension/initial_state_extension.rs
@@ -0,0 +1,165 @@
+//! `InitialStateExtension.ts`: the extension every editor built from
+//! extensions starts with, which sets the initial state once everything is
+//! registered.
+
+use crate::extension_core::{
+    ExtensionConfigBase, ExtensionInitState, ExtensionRegisterState, InitialEditorConfig,
+    InitialEditorStateType, LexicalExtension, define_extension,
+};
+use crate::nodes::{
+    line_break::LineBreakNode, paragraph::ParagraphNode, root::RootNode, tab::TabNode,
+    text::TextNode,
+};
+use crate::{
+    Editor, HISTORY_MERGE_TAG, LexicalError, NodeClass, Unregister, UpdateOptions,
+    create_paragraph_node, get_root,
+};
+use std::cell::Cell;
+use std::rc::Rc;
+
+/// `EditorSetOptions`: the options of `setEditorState`.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct EditorSetOptions {
+    pub tag: Option<String>,
+}
+
+/// `InitialStateConfig`: the options of the update or the
+/// `setEditorState` that sets the initial state.
+#[derive(Clone, Debug)]
+pub struct InitialStateConfig {
+    pub update_options: UpdateOptions,
+    pub set_options: EditorSetOptions,
+}
+
+/// `Partial<InitialStateConfig>`.
+#[derive(Clone, Debug, Default)]
+pub struct InitialStateConfigOverrides {
+    pub update_options: Option<UpdateOptions>,
+    pub set_options: Option<EditorSetOptions>,
+}
+
+impl ExtensionConfigBase for InitialStateConfig {
+    type Partial = InitialStateConfigOverrides;
+
+    fn shallow_merge(&self, overrides: &InitialStateConfigOverrides) -> Self {
+        InitialStateConfig {
+            update_options: overrides
+                .update_options
+                .clone()
+                .unwrap_or_else(|| self.update_options.clone()),
+            set_options: overrides
+                .set_options
+                .clone()
+                .unwrap_or_else(|| self.set_options.clone()),
+        }
+    }
+}
+
+/// What `InitialStateExtension`'s `init` returns: the initial state, and
+/// whether it was set.
+pub struct InitialStateInit {
+    pub initial_editor_state: InitialEditorStateType,
+    pub initialized: Cell<bool>,
+}
+
+/// `InitialStateExtension`.
+pub type InitialStateExtensionType = LexicalExtension<InitialStateConfig, (), InitialStateInit>;
+
+/// `$defaultInitializer`: an empty root gets a paragraph.
+fn default_initializer(_editor: &Editor) -> Result<(), LexicalError> {
+    let root = get_root();
+    if root.is_empty() {
+        root.append(&[create_paragraph_node()])?;
+    }
+    Ok(())
+}
+
+fn init(
+    editor_config: &mut InitialEditorConfig,
+    _config: &InitialStateConfig,
+    _state: &ExtensionInitState,
+) -> Result<InitialStateInit, LexicalError> {
+    let initial_editor_state = editor_config
+        .initial_editor_state
+        .clone()
+        .unwrap_or_else(|| InitialEditorStateType::Update(Rc::new(default_initializer)));
+    Ok(InitialStateInit {
+        initial_editor_state,
+        initialized: Cell::new(false),
+    })
+}
+
+fn after_registration(
+    editor: &Editor,
+    config: &InitialStateConfig,
+    state: &ExtensionRegisterState<InitialStateInit, ()>,
+) -> Result<Unregister, LexicalError> {
+    let init_result = state.get_init_result()?;
+    if !init_result.initialized.replace(true) {
+        let tag = config.set_options.tag.as_deref();
+        match &init_result.initial_editor_state {
+            InitialEditorStateType::EditorState(editor_state) => {
+                editor.set_editor_state(editor_state, tag)?;
+            }
+            InitialEditorStateType::Update(update) => {
+                let (update, target) = (update.clone(), editor.clone());
+                editor.update(move || update(&target), config.update_options.clone())?;
+            }
+            // `''` is falsy in JS, so it sets nothing.
+            InitialEditorStateType::Json(json) if !json.is_empty() => {
+                let parsed_editor_state = editor.parse_editor_state(json)?;
+                editor.set_editor_state(&parsed_editor_state, tag)?;
+            }
+            InitialEditorStateType::Serialized(json) => {
+                let parsed_editor_state = editor.parse_editor_state_json(json)?;
+                editor.set_editor_state(&parsed_editor_state, tag)?;
+            }
+            InitialEditorStateType::Json(_) | InitialEditorStateType::Null => {}
+        }
+    }
+    Ok(Box::new(|| {}))
+}
+
+fn make() -> Rc<InitialStateExtensionType> {
+    let history_merge = || vec![HISTORY_MERGE_TAG.to_owned()];
+    define_extension(LexicalExtension {
+        init: Some(Rc::new(init)),
+        after_registration: Some(Rc::new(after_registration)),
+        // These are what `createEditor` registers anyway; listing them
+        // lets every `init` see all the known types before the editor
+        // exists.
+        nodes: vec![
+            NodeClass::with_import_json("root", RootNode::import_json),
+            NodeClass::of::<TextNode>(),
+            NodeClass::of::<LineBreakNode>(),
+            NodeClass::of::<TabNode>(),
+            NodeClass::of::<ParagraphNode>(),
+        ],
+        ..LexicalExtension::new(
+            "@lexical/extension/InitialState",
+            InitialStateConfig {
+                update_options: UpdateOptions {
+                    tags: history_merge(),
+                    ..UpdateOptions::default()
+                },
+                set_options: EditorSetOptions {
+                    tag: Some(HISTORY_MERGE_TAG.to_owned()),
+                },
+            },
+        )
+    })
+}
+
+thread_local! {
+    static INITIAL_STATE_EXTENSION: Rc<InitialStateExtensionType> = make();
+}
+
+/// `InitialStateExtension`: sets the editor's initial state from
+/// `$initialEditorState` (the last extension that gives one wins; by
+/// default an empty root gets a paragraph), in `afterRegistration`, so the
+/// initial state may depend on registered commands. Every editor
+/// [`build_editor_from_extensions`](super::build_editor_from_extensions)
+/// builds has it, first.
+pub fn initial_state_extension() -> Rc<InitialStateExtensionType> {
+    INITIAL_STATE_EXTENSION.with(Rc::clone)
+}
diff --git a/rust/lexical-editor/src/extension/lexical_builder.rs b/rust/lexical-editor/src/extension/lexical_builder.rs
new file mode 100644
index 00000000000..33e99ebdfd2
--- /dev/null
+++ b/rust/lexical-editor/src/extension/lexical_builder.rs
@@ -0,0 +1,417 @@
+//! `LexicalBuilder.ts`: `buildEditorFromExtensions` and `LexicalBuilder`,
+//! which resolves the extensions' dependency graph, merges their configs
+//! in dependency order, and runs their phases: `init` (before the editor
+//! exists), `build`, `register` and `afterRegistration`.
+
+use super::extension_rep::{ExtensionRep, StateId};
+use super::initial_state_extension::initial_state_extension;
+use crate::error::invariant;
+use crate::extension_core::{
+    AbortController, AnyLexicalExtension, AnyLexicalExtensionArgument, Erased, InitialEditorConfig,
+};
+use crate::merge_register::merge_register;
+use crate::ordered::{OrderedMap, OrderedSet};
+use crate::{CreateEditorArgs, Editor, LexicalError, NodeClass, Unregister, create_editor};
+use std::cell::RefCell;
+use std::rc::Rc;
+
+/// `buildEditorFromExtensions(...extensions)`: an editor built from the
+/// extensions (with `InitialStateExtension` first) and their dependencies,
+/// each configured, built and registered, with its initial state set.
+pub fn build_editor_from_extensions(
+    extensions: impl IntoIterator<Item = AnyLexicalExtensionArgument>,
+) -> Result<LexicalEditorWithDispose, LexicalError> {
+    LexicalBuilder::from_extensions(extensions)?.build_editor()
+}
+
+/// `LexicalEditorWithDispose`: an editor built from extensions, with the
+/// `dispose` that undoes their registration. It dereferences to its
+/// [`Editor`]. Dropping it doesn't dispose it (JS's `using` does; call
+/// [`dispose`](Self::dispose)).
+#[derive(Clone)]
+pub struct LexicalEditorWithDispose {
+    editor: Editor,
+    dispose: Rc<RefCell<Option<Unregister>>>,
+}
+
+impl LexicalEditorWithDispose {
+    /// `dispose()`: runs every clean-up the extensions' `register` and
+    /// `afterRegistration` returned, in the reverse of the order they
+    /// registered, then aborts their signal. Only the first call does
+    /// anything.
+    pub fn dispose(&self) {
+        let dispose = self.dispose.borrow_mut().take();
+        if let Some(dispose) = dispose {
+            dispose();
+        }
+    }
+
+    /// The editor.
+    pub fn editor(&self) -> &Editor {
+        &self.editor
+    }
+}
+
+impl std::ops::Deref for LexicalEditorWithDispose {
+    type Target = Editor;
+
+    fn deref(&self) -> &Editor {
+        &self.editor
+    }
+}
+
+/// `LexicalBuilder`: the extensions an editor is built from, by name, with
+/// the edges between them. Cloning it shares it.
+#[derive(Clone)]
+pub struct LexicalBuilder(pub(crate) Rc<BuilderInner>);
+
+pub(crate) struct BuilderInner {
+    roots: Vec<AnyLexicalExtensionArgument>,
+    extension_name_map: RefCell<OrderedMap<Rc<ExtensionRep>>>,
+    /// Per extension, the configs it gives each dependency and peer.
+    outgoing_config_edges: RefCell<OrderedMap<OrderedMap<Vec<Erased>>>>,
+    incoming_edges: RefCell<OrderedMap<OrderedSet>>,
+    conflicts: RefCell<OrderedMap<String>>,
+    sorted_extension_reps: RefCell<Option<Vec<Rc<ExtensionRep>>>>,
+}
+
+impl BuilderInner {
+    /// `extensionNameMap.get(name)`.
+    pub(crate) fn extension_rep_by_name(&self, name: &str) -> Option<Rc<ExtensionRep>> {
+        self.extension_name_map.borrow().get(name).cloned()
+    }
+
+    /// `getExtensionRep(extension)`: the extension's record, an error when
+    /// another extension has its name.
+    pub(crate) fn get_extension_rep(
+        &self,
+        extension: &dyn AnyLexicalExtension,
+    ) -> Result<Option<Rc<ExtensionRep>>, LexicalError> {
+        let Some(rep) = self.extension_rep_by_name(extension.name()) else {
+            return Ok(None);
+        };
+        invariant!(
+            same_extension(rep.extension.as_ref(), extension),
+            "LexicalBuilder: A registered extension with name {} exists but does not match the given extension",
+            extension.name()
+        );
+        Ok(Some(rep))
+    }
+
+    /// `incomingEdges.get(name)`, in the order the edges were added.
+    pub(crate) fn incoming_edge_names(&self, name: &str) -> Vec<String> {
+        self.incoming_edges
+            .borrow()
+            .get(name)
+            .map(|set| set.iter().map(str::to_owned).collect())
+            .unwrap_or_default()
+    }
+}
+
+/// JS's `===` on two extensions.
+fn same_extension(a: &dyn AnyLexicalExtension, b: &dyn AnyLexicalExtension) -> bool {
+    std::ptr::addr_eq(
+        a as *const dyn AnyLexicalExtension,
+        b as *const dyn AnyLexicalExtension,
+    )
+}
+
+impl LexicalBuilder {
+    /// `new LexicalBuilder(roots)`.
+    fn new(roots: Vec<AnyLexicalExtensionArgument>) -> Result<Self, LexicalError> {
+        let builder = LexicalBuilder(Rc::new(BuilderInner {
+            roots: roots.clone(),
+            extension_name_map: RefCell::new(OrderedMap::new()),
+            outgoing_config_edges: RefCell::new(OrderedMap::new()),
+            incoming_edges: RefCell::new(OrderedMap::new()),
+            conflicts: RefCell::new(OrderedMap::new()),
+            sorted_extension_reps: RefCell::new(None),
+        }));
+        for extension in &roots {
+            builder.add_extension(extension)?;
+        }
+        Ok(builder)
+    }
+
+    /// `LexicalBuilder.fromExtensions(extensions)`: a builder of
+    /// `InitialStateExtension` and the extensions.
+    pub fn from_extensions(
+        extensions: impl IntoIterator<Item = AnyLexicalExtensionArgument>,
+    ) -> Result<Self, LexicalError> {
+        let mut roots: Vec<AnyLexicalExtensionArgument> = vec![initial_state_extension().into()];
+        roots.extend(extensions);
+        Self::new(roots)
+    }
+
+    /// `LexicalBuilder.maybeFromEditor(editor)`: the builder that built the
+    /// editor, if one did.
+    pub fn maybe_from_editor(editor: &Editor) -> Option<LexicalBuilder> {
+        editor
+            .0
+            .builder
+            .borrow()
+            .as_ref()
+            .and_then(|b| b.downcast_ref::<LexicalBuilder>().cloned())
+    }
+
+    /// `LexicalBuilder.fromEditor(editor)`.
+    pub fn from_editor(editor: &Editor) -> Result<LexicalBuilder, LexicalError> {
+        Self::maybe_from_editor(editor).ok_or_else(|| {
+            LexicalError::new(
+                "LexicalBuilder.fromEditor: The given editor was not created with LexicalBuilder",
+            )
+        })
+    }
+
+    /// `constructEditor()`: the editor of the merged configuration, with
+    /// every extension built.
+    pub fn construct_editor(&self) -> Result<Editor, LexicalError> {
+        let config = self.build_create_editor_args()?;
+        // `namespace` isn't in `InitialEditorConfig` yet, so the editor gets
+        // `createEditor`'s random one.
+        let editor = create_editor(CreateEditorArgs {
+            nodes: config.nodes,
+            ..Default::default()
+        });
+        *editor.0.builder.borrow_mut() = Some(Rc::new(self.clone()));
+        for extension_rep in self.sorted_extension_reps()? {
+            extension_rep.build(&editor)?;
+        }
+        Ok(editor)
+    }
+
+    /// `buildEditor()`.
+    pub fn build_editor(&self) -> Result<LexicalEditorWithDispose, LexicalError> {
+        let editor = self.construct_editor()?;
+        // JS also detaches the root element (`setRootElement(null)`), which
+        // a headless editor doesn't have.
+        let dispose = self.register_editor(&editor)?;
+        Ok(LexicalEditorWithDispose {
+            editor,
+            dispose: Rc::new(RefCell::new(Some(dispose))),
+        })
+    }
+
+    /// `hasExtensionByName(name)`.
+    pub fn has_extension_by_name(&self, name: &str) -> bool {
+        self.0.extension_name_map.borrow().contains(name)
+    }
+
+    /// `addEdge(from, to, configs)`: an extension's configs for another
+    /// are kept in the order they were seen, even when it reaches the
+    /// other more than once.
+    fn add_edge(&self, from_extension_name: &str, to_extension_name: &str, configs: Vec<Erased>) {
+        {
+            let mut outgoing_edges = self.0.outgoing_config_edges.borrow_mut();
+            if let Some(outgoing) = outgoing_edges.get_mut(from_extension_name) {
+                if let Some(existing) = outgoing.get_mut(to_extension_name) {
+                    existing.extend(configs);
+                } else {
+                    outgoing.set(to_extension_name, configs);
+                }
+            } else {
+                let mut outgoing = OrderedMap::new();
+                outgoing.set(to_extension_name, configs);
+                outgoing_edges.set(from_extension_name, outgoing);
+            }
+        }
+        let mut incoming_edges = self.0.incoming_edges.borrow_mut();
+        if let Some(incoming) = incoming_edges.get_mut(to_extension_name) {
+            incoming.add(from_extension_name);
+        } else {
+            let mut incoming = OrderedSet::new();
+            incoming.add(from_extension_name);
+            incoming_edges.set(to_extension_name, incoming);
+        }
+    }
+
+    /// `addExtension(arg)`: adds the extension, unless it is there, then
+    /// its dependencies and the edges to them and to its peers.
+    pub fn add_extension(&self, arg: &AnyLexicalExtensionArgument) -> Result<(), LexicalError> {
+        invariant!(
+            self.0.sorted_extension_reps.borrow().is_none(),
+            "LexicalBuilder: addExtension called after finalization"
+        );
+        let extension = &arg.extension;
+        let name = extension.name();
+        let existing = self.0.extension_rep_by_name(name);
+        invariant!(
+            existing
+                .as_ref()
+                .is_none_or(|rep| same_extension(rep.extension.as_ref(), extension.as_ref())),
+            "LexicalBuilder: Multiple extensions registered with name {}, names must be unique",
+            name
+        );
+        if existing.is_some() {
+            return Ok(());
+        }
+        let extension_rep = ExtensionRep::new(Rc::downgrade(&self.0), extension.clone());
+        self.0
+            .extension_name_map
+            .borrow_mut()
+            .set(name, extension_rep);
+        let has_conflict = self.0.conflicts.borrow().get(name).cloned();
+        if let Some(has_conflict) = has_conflict {
+            return Err(LexicalError::new(format!(
+                "LexicalBuilder: extension {name} conflicts with {has_conflict}"
+            )));
+        }
+        for conflict in extension.conflicts_with() {
+            invariant!(
+                !self.0.extension_name_map.borrow().contains(conflict),
+                "LexicalBuilder: extension {} conflicts with {}",
+                name,
+                conflict
+            );
+            self.0.conflicts.borrow_mut().set(conflict, name.to_owned());
+        }
+        for dep in extension.dependencies() {
+            self.add_edge(name, dep.extension.name(), dep.configs.clone());
+            self.add_extension(dep)?;
+        }
+        for peer in extension.peer_dependencies() {
+            self.add_edge(name, peer.name(), peer.config.iter().cloned().collect());
+        }
+        Ok(())
+    }
+
+    fn visit(
+        &self,
+        rep: &Rc<ExtensionRep>,
+        from_extension_name: Option<&str>,
+        sorted: &mut Vec<Rc<ExtensionRep>>,
+    ) -> Result<(), LexicalError> {
+        let mark = rep.id();
+        if mark == StateId::Permanent {
+            return Ok(());
+        }
+        let extension_name = rep.extension.name().to_owned();
+        invariant!(
+            mark == StateId::Unmarked,
+            "LexicalBuilder: Circular dependency detected for Extension {} from {}",
+            extension_name,
+            from_extension_name.unwrap_or("[unknown]")
+        );
+        rep.set_id(StateId::Temporary);
+        let to_names: Vec<String> = self
+            .0
+            .outgoing_config_edges
+            .borrow()
+            .get(&extension_name)
+            .map(|edges| edges.keys().map(str::to_owned).collect())
+            .unwrap_or_default();
+        for to_extension_name in to_names {
+            // None for an optional peer dependency.
+            if let Some(to_rep) = self.0.extension_rep_by_name(&to_extension_name) {
+                self.visit(&to_rep, Some(&extension_name), sorted)?;
+            }
+        }
+        rep.set_id(StateId::Permanent);
+        sorted.push(rep.clone());
+        Ok(())
+    }
+
+    /// `sortedExtensionReps()`: the extensions in dependency order (a
+    /// depth-first topological sort, dependencies and peers first), with
+    /// each one's configs from its dependents in that order, then from the
+    /// roots.
+    pub(crate) fn sorted_extension_reps(&self) -> Result<Vec<Rc<ExtensionRep>>, LexicalError> {
+        if let Some(sorted) = self.0.sorted_extension_reps.borrow().clone() {
+            return Ok(sorted);
+        }
+        let mut sorted_extension_reps = Vec::new();
+        let reps: Vec<Rc<ExtensionRep>> = self
+            .0
+            .extension_name_map
+            .borrow()
+            .values()
+            .cloned()
+            .collect();
+        for rep in &reps {
+            if rep.id() == StateId::Unmarked {
+                self.visit(rep, None, &mut sorted_extension_reps)?;
+            }
+        }
+        for rep in &sorted_extension_reps {
+            let edges: Vec<(String, Vec<Erased>)> = self
+                .0
+                .outgoing_config_edges
+                .borrow()
+                .get(rep.extension.name())
+                .map(|edges| {
+                    edges
+                        .iter()
+                        .map(|(k, v)| (k.to_owned(), v.clone()))
+                        .collect()
+                })
+                .unwrap_or_default();
+            for (to_extension_name, configs) in edges {
+                if let Some(to_rep) = self.0.extension_rep_by_name(&to_extension_name) {
+                    for config in &configs {
+                        to_rep.add_config(config);
+                    }
+                }
+            }
+        }
+        for root in &self.0.roots {
+            if !root.configs.is_empty() {
+                let to_rep = self.0.extension_rep_by_name(root.extension.name());
+                let Some(to_rep) = to_rep else {
+                    return Err(LexicalError::new(format!(
+                        "LexicalBuilder: Expecting existing ExtensionRep for {}",
+                        root.extension.name()
+                    )));
+                };
+                for config in &root.configs {
+                    to_rep.add_config(config);
+                }
+            }
+        }
+        *self.0.sorted_extension_reps.borrow_mut() = Some(sorted_extension_reps.clone());
+        Ok(sorted_extension_reps)
+    }
+
+    /// `registerEditor(editor)`: registers every extension, then runs every
+    /// `afterRegistration`, and returns the clean-up of all of it.
+    pub fn register_editor(&self, editor: &Editor) -> Result<Unregister, LexicalError> {
+        let extension_reps = self.sorted_extension_reps()?;
+        let controller = AbortController::new();
+        let signal = controller.signal();
+        let mut cleanups: Vec<Unregister> = vec![Box::new(move || controller.abort())];
+        for extension_rep in &extension_reps {
+            cleanups.push(extension_rep.register(editor, signal.clone())?);
+        }
+        for extension_rep in &extension_reps {
+            if let Some(cleanup) = extension_rep.after_registration(editor)? {
+                cleanups.push(cleanup);
+            }
+        }
+        Ok(merge_register(cleanups))
+    }
+
+    /// `buildCreateEditorArgs()`: the editor configuration the extensions
+    /// contribute, merged in dependency order (the last
+    /// `$initialEditorState` wins, nodes are added once), after every
+    /// extension's `init` has seen it.
+    pub fn build_create_editor_args(&self) -> Result<InitialEditorConfig, LexicalError> {
+        let mut config = InitialEditorConfig::default();
+        let mut nodes: Vec<NodeClass> = Vec::new();
+        let extension_reps = self.sorted_extension_reps()?;
+        for extension_rep in &extension_reps {
+            let extension = &extension_rep.extension;
+            if let Some(initial_editor_state) = extension.initial_editor_state() {
+                config.initial_editor_state = Some(initial_editor_state.clone());
+            }
+            for node in extension.nodes() {
+                if !nodes.iter().any(|n| n.node_type() == node.node_type()) {
+                    nodes.push(*node);
+                }
+            }
+        }
+        config.nodes = nodes;
+        for extension_rep in &extension_reps {
+            extension_rep.init(&mut config)?;
+        }
+        Ok(config)
+    }
+}
diff --git a/rust/lexical-editor/src/extension/mod.rs b/rust/lexical-editor/src/extension/mod.rs
index 261736380a3..6cc4f8277fc 100644
--- a/rust/lexical-editor/src/extension/mod.rs
+++ b/rust/lexical-editor/src/extension/mod.rs
@@ -8,26 +8,73 @@
 //! ([`register_normalize_inline_elements`]), which `RichTextExtension`
 //! depends on.
 //!
-//! Not ported: their `createDOM`, `updateDOM`, `exportDOM` and `importDOM`,
-//! which come with `html`; `applyFormatFromStyle`, which reads a CSS style
-//! declaration; and the extensions themselves, which need the extension
-//! API: `HorizontalRuleExtension`'s `INSERT_HORIZONTAL_RULE_COMMAND`, click
-//! and selected-class handling, and `DecoratorTextExtension` (their `nodes`
-//! are [`extension_nodes`]). The rest of `@lexical/extension` is the
-//! extension API itself (rust/PARITY.md).
+//!
+//! The extension API: [`build_editor_from_extensions`] and the builder
+//! (`LexicalBuilder.ts`, `internal/ExtensionRep.ts`), the dependency
+//! lookups (`getExtensionDependencyFromEditor`,
+//! `getPeerDependencyFromEditor` and their `$` forms), `namedSignals`,
+//! `watchedSignal` and the signals it is built on (`signals`, a port of
+//! `@preact/signals-core`), `getKnownTypesAndNodes`, and the model-level
+//! extensions `InitialStateExtension`, `ClearEditorExtension`,
+//! `EditorStateExtension` and `DecoratorTextExtension`. The types it builds
+//! on are `lexical`'s `extension-core`, at the crate root
+//! ([`LexicalExtension`](crate::LexicalExtension),
+//! [`define_extension`](crate::define_extension)...).
+//!
+//! Not ported: the decorators' `createDOM`, `updateDOM`, `exportDOM` and
+//! `importDOM`, which come with `html`; `applyFormatFromStyle`, which reads
+//! a CSS style declaration; `HorizontalRuleExtension`, which needs
+//! `NodeSelectionExtension`, clicks and the DOM (its `nodes` are in
+//! [`extension_nodes`]); and the package's other extensions (rust/PARITY.md).
 
+mod clear_editor_extension;
+mod config;
 mod decorator_text_extension;
+mod editor_state_extension;
+mod extension_rep;
+mod get_extension_dependency;
+mod get_extension_dependency_from_editor;
+mod get_peer_dependency_from_editor;
 mod horizontal_rule_extension;
+mod initial_state_extension;
+mod lexical_builder;
+mod named_signals;
 mod normalize_inline_elements_extension;
+pub mod signals;
+mod watched_signal;
 
+pub use clear_editor_extension::{
+    ClearEditorConfig, ClearEditorConfigOverrides, ClearEditorExtensionType, ClearEditorOutput,
+    OnClear, clear_editor_extension, register_clear_editor,
+};
+pub use config::{KnownTypesAndNodes, get_known_types_and_nodes, get_node_config};
 pub use decorator_text_extension::{
-    DecoratorTextNode, create_decorator_text_node, decorator_text_format_state,
-    is_decorator_text_node,
+    DecoratorTextNode, create_decorator_text_node, decorator_text_extension,
+    decorator_text_format_state, is_decorator_text_node,
+};
+pub use editor_state_extension::{EditorStateExtensionType, editor_state_extension};
+pub use get_extension_dependency::{
+    get_extension_dependency, get_extension_output, get_peer_dependency,
+};
+pub use get_extension_dependency_from_editor::get_extension_dependency_from_editor;
+pub use get_peer_dependency_from_editor::{
+    get_peer_dependency_from_editor, get_peer_dependency_from_editor_or_throw,
 };
 pub use horizontal_rule_extension::{
     HorizontalRuleNode, create_horizontal_rule_node, is_horizontal_rule_node,
 };
+pub use initial_state_extension::{
+    EditorSetOptions, InitialStateConfig, InitialStateConfigOverrides, InitialStateExtensionType,
+    InitialStateInit, initial_state_extension,
+};
+pub use lexical_builder::{LexicalBuilder, LexicalEditorWithDispose, build_editor_from_extensions};
+pub use named_signals::{NamedSignalsOutput, named_signals};
 pub use normalize_inline_elements_extension::register_normalize_inline_elements;
+pub use signals::{
+    ReadonlySignal, Signal, SignalCallback, SignalOptions, SignalValue, batch, computed, effect,
+    signal, signal_with_options, untracked,
+};
+pub use watched_signal::watched_signal;
 
 use crate::NodeClass;
 
diff --git a/rust/lexical-editor/src/extension/named_signals.rs b/rust/lexical-editor/src/extension/named_signals.rs
new file mode 100644
index 00000000000..77c71e1a69c
--- /dev/null
+++ b/rust/lexical-editor/src/extension/named_signals.rs
@@ -0,0 +1,42 @@
+//! `namedSignals.ts`.
+
+use super::signals::{Signal, signal};
+use crate::json::{Object, Value};
+
+/// `NamedSignalsOutput`: a signal per key of an object, in its key order.
+#[derive(Clone, Default)]
+pub struct NamedSignalsOutput {
+    signals: Vec<(String, Signal<Value>)>,
+}
+
+impl NamedSignalsOutput {
+    /// The signal of `key`.
+    pub fn get(&self, key: &str) -> Option<&Signal<Value>> {
+        self.signals.iter().find(|(k, _)| k == key).map(|(_, s)| s)
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = (&str, &Signal<Value>)> {
+        self.signals.iter().map(|(k, s)| (k.as_str(), s))
+    }
+}
+
+/// `namedSignals(defaults, opts)`: a [`Signal`] for each key of `defaults`,
+/// holding the value of `opts` for the key unless that is absent or
+/// `undefined`, otherwise the default. Typically a reactive copy of part
+/// of an extension's config, so it can be reconfigured at runtime.
+///
+/// JS takes any object; this takes a JSON object. An extension with a
+/// typed config makes its signals with [`signal`] instead, one field each.
+pub fn named_signals(defaults: &Object, opts: Option<&Object>) -> NamedSignalsOutput {
+    let signals = defaults
+        .iter()
+        .map(|(k, default)| {
+            let value = match opts.and_then(|o| o.get(k)) {
+                None | Some(Value::Undefined) => default.clone(),
+                Some(v) => v.clone(),
+            };
+            (k.to_owned(), signal(value))
+        })
+        .collect();
+    NamedSignalsOutput { signals }
+}
diff --git a/rust/lexical-editor/src/extension/signals.rs b/rust/lexical-editor/src/extension/signals.rs
new file mode 100644
index 00000000000..8729f306617
--- /dev/null
+++ b/rust/lexical-editor/src/extension/signals.rs
@@ -0,0 +1,758 @@
+//! `signals.ts`: the reactive core `@lexical/extension` re-exports from
+//! `@preact/signals-core` 1.14.4 (MIT, Copyright (c) 2022-present Preact
+//! Team): `signal`, `computed`, `effect`, `batch` and `untracked`, ported
+//! without a dependency. The algorithm is preact's: versioned dependency
+//! nodes, lazily recomputed computeds, batched effects, and the batch
+//! snapshots that keep a value set back to what it was inside a batch from
+//! rerunning anything. Its linked lists are vectors kept in the same order,
+//! so targets are notified and effects run in preact's order. The state is
+//! per thread, as signals are neither `Send` nor `Sync`.
+//!
+//! Where it differs, from Rust: a value is compared with `==`
+//! ([`SignalValue`]), where JS's `!==` compares objects by identity (a type
+//! whose `==` is `Rc::ptr_eq` compares as JS does); effect and computed bodies can't throw, so
+//! preact's error paths (`HAS_ERROR`, rethrowing after a batch) have no
+//! counterpart, and a cycle panics with preact's message. `name`, `action`,
+//! `createModel` and `Symbol.dispose` aren't ported.
+
+use crate::{EditorState, Unregister};
+use std::any::Any;
+use std::cell::{Cell, RefCell};
+use std::marker::PhantomData;
+use std::rc::{Rc, Weak};
+
+const RUNNING: u8 = 1 << 0;
+const NOTIFIED: u8 = 1 << 1;
+const OUTDATED: u8 = 1 << 2;
+const DISPOSED: u8 = 1 << 3;
+const TRACKING: u8 = 1 << 5;
+
+type Value = Rc<dyn Any>;
+type SourceCallback = Option<Rc<dyn Fn(&Rc<Source>)>>;
+type EffectFn = Rc<dyn Fn() -> Option<Unregister>>;
+/// `SignalOptions`' `watched` and `unwatched`.
+pub type SignalCallback<T> = Option<Rc<dyn Fn(&Signal<T>)>>;
+
+/// A dependency edge (preact's `Node`): `target` read `source` at
+/// `version`.
+struct Node {
+    source: Rc<Source>,
+    target: Target,
+    version: Cell<i64>,
+    rollback_node: RefCell<Option<Rc<Node>>>,
+}
+
+/// What reads signals: a computed (weakly, as it owns its sources) or an
+/// effect.
+#[derive(Clone)]
+enum Target {
+    Computed(Weak<Source>),
+    Effect(Rc<EffectInner>),
+}
+
+impl Target {
+    fn is(&self, other: &Target) -> bool {
+        match (self, other) {
+            (Target::Computed(a), Target::Computed(b)) => a.ptr_eq(b),
+            (Target::Effect(a), Target::Effect(b)) => Rc::ptr_eq(a, b),
+            _ => false,
+        }
+    }
+
+    fn flags(&self) -> u8 {
+        match self {
+            Target::Computed(c) => c
+                .upgrade()
+                .map_or(0, |c| c.computed.as_ref().expect("computed").flags.get()),
+            Target::Effect(e) => e.flags.get(),
+        }
+    }
+
+    fn with_sources<R>(&self, f: impl FnOnce(&RefCell<Vec<Rc<Node>>>) -> R) -> Option<R> {
+        match self {
+            Target::Computed(c) => {
+                let c = c.upgrade()?;
+                Some(f(&c.computed.as_ref().expect("computed").sources))
+            }
+            Target::Effect(e) => Some(f(&e.sources)),
+        }
+    }
+
+    fn notify(&self) {
+        match self {
+            Target::Computed(c) => {
+                if let Some(c) = c.upgrade() {
+                    computed_notify(&c);
+                }
+            }
+            Target::Effect(e) => effect_notify(e),
+        }
+    }
+}
+
+/// A signal or a computed (preact's `Signal`, which `Computed` extends).
+struct Source {
+    value: RefCell<Option<Value>>,
+    version: Cell<i64>,
+    node: RefCell<Option<Rc<Node>>>,
+    /// `_targets`, head first: the newest subscriber is notified first.
+    targets: RefCell<Vec<Rc<Node>>>,
+    batch_snapshot_version: Cell<u64>,
+    watched: SourceCallback,
+    unwatched: SourceCallback,
+    /// JS's `===` on two values of this source.
+    same: fn(&dyn Any, &dyn Any) -> bool,
+    computed: Option<ComputedData>,
+}
+
+struct ComputedData {
+    func: Box<dyn Fn() -> Value>,
+    sources: RefCell<Vec<Rc<Node>>>,
+    global_version: Cell<u64>,
+    flags: Cell<u8>,
+}
+
+struct EffectInner {
+    func: RefCell<Option<EffectFn>>,
+    cleanup: RefCell<Option<Unregister>>,
+    sources: RefCell<Vec<Rc<Node>>>,
+    flags: Cell<u8>,
+}
+
+struct BatchSnapshot {
+    source: Rc<Source>,
+    value: Option<Value>,
+    version: i64,
+}
+
+/// signals-core's module-scope variables.
+#[derive(Default)]
+struct State {
+    eval_context: RefCell<Option<Target>>,
+    /// `batchedEffect`, in notification order; preact runs the newest first.
+    batched_effects: RefCell<Vec<Rc<EffectInner>>>,
+    batch_depth: Cell<u32>,
+    batch_iteration: Cell<u32>,
+    batch_snapshot_version: Cell<u64>,
+    current_batch_snapshot_version: Cell<u64>,
+    /// `batchSnapshots`, head first.
+    batch_snapshots: RefCell<Vec<BatchSnapshot>>,
+    global_version: Cell<u64>,
+}
+
+thread_local! {
+    static STATE: State = State::default();
+}
+
+fn with_state<R>(f: impl FnOnce(&State) -> R) -> R {
+    STATE.with(f)
+}
+
+/// A value a signal can hold: JS's `===` on it is [`is_same`](Self::is_same),
+/// which is `==` for any `PartialEq` value. An [`EditorState`] is the same
+/// only as itself, as JS compares the objects.
+pub trait SignalValue: Clone + 'static {
+    fn is_same(&self, other: &Self) -> bool;
+}
+
+impl<T: Clone + PartialEq + 'static> SignalValue for T {
+    fn is_same(&self, other: &Self) -> bool {
+        self == other
+    }
+}
+
+impl SignalValue for EditorState {
+    fn is_same(&self, other: &Self) -> bool {
+        self.ptr_eq(other)
+    }
+}
+
+fn same_value<T: SignalValue>(a: &dyn Any, b: &dyn Any) -> bool {
+    match (a.downcast_ref::<T>(), b.downcast_ref::<T>()) {
+        (Some(a), Some(b)) => a.is_same(b),
+        _ => false,
+    }
+}
+
+fn values_same(source: &Source, a: &Option<Value>, b: &Option<Value>) -> bool {
+    match (a, b) {
+        (Some(a), Some(b)) => (source.same)(a.as_ref(), b.as_ref()),
+        (None, None) => true,
+        _ => false,
+    }
+}
+
+fn start_batch() {
+    with_state(|s| s.batch_depth.set(s.batch_depth.get() + 1));
+}
+
+fn end_batch() {
+    if with_state(|s| {
+        let depth = s.batch_depth.get();
+        if depth > 1 {
+            s.batch_depth.set(depth - 1);
+        }
+        depth > 1
+    }) {
+        return;
+    }
+    reconcile_batch_snapshots();
+    loop {
+        let effects = with_state(|s| std::mem::take(&mut *s.batched_effects.borrow_mut()));
+        if effects.is_empty() {
+            break;
+        }
+        with_state(|s| s.batch_iteration.set(s.batch_iteration.get() + 1));
+        for effect in effects.iter().rev() {
+            effect.flags.set(effect.flags.get() & !NOTIFIED);
+            if effect.flags.get() & DISPOSED == 0
+                && needs_to_recompute(&Target::Effect(effect.clone()))
+            {
+                effect_callback(effect);
+            }
+        }
+    }
+    with_state(|s| {
+        s.batch_iteration.set(0);
+        s.batch_depth.set(s.batch_depth.get() - 1);
+    });
+}
+
+/// `batch(fn)`: runs `fn`, and the effects the signals it sets trigger once,
+/// when it returns (or when the outermost batch does).
+pub fn batch<R>(f: impl FnOnce() -> R) -> R {
+    if with_state(|s| s.batch_depth.get() > 0) {
+        return f();
+    }
+    with_state(|s| {
+        let version = s.batch_snapshot_version.get() + 1;
+        s.batch_snapshot_version.set(version);
+        s.current_batch_snapshot_version.set(version);
+    });
+    start_batch();
+    let result = f();
+    end_batch();
+    result
+}
+
+/// Restores the evaluation context when dropped.
+struct ContextGuard(Option<Target>);
+
+impl Drop for ContextGuard {
+    fn drop(&mut self) {
+        let prev = self.0.take();
+        with_state(|s| *s.eval_context.borrow_mut() = prev);
+    }
+}
+
+fn set_eval_context(target: Option<Target>) -> Option<Target> {
+    with_state(|s| std::mem::replace(&mut *s.eval_context.borrow_mut(), target))
+}
+
+/// `untracked(fn)`: runs `fn` without subscribing the running computed or
+/// effect to the signals it reads.
+pub fn untracked<R>(f: impl FnOnce() -> R) -> R {
+    let _guard = ContextGuard(set_eval_context(None));
+    f()
+}
+
+fn record_batch_snapshot(source: &Rc<Source>) {
+    with_state(|s| {
+        if s.batch_depth.get() == 0 || s.batch_iteration.get() != 0 {
+            return;
+        }
+        let current = s.current_batch_snapshot_version.get();
+        if source.batch_snapshot_version.get() != current {
+            source.batch_snapshot_version.set(current);
+            s.batch_snapshots.borrow_mut().insert(
+                0,
+                BatchSnapshot {
+                    source: source.clone(),
+                    value: source.value.borrow().clone(),
+                    version: source.version.get(),
+                },
+            );
+        }
+    });
+}
+
+fn reconcile_batch_snapshots() {
+    let snapshots = with_state(|s| std::mem::take(&mut *s.batch_snapshots.borrow_mut()));
+    for snapshot in snapshots {
+        let source = &snapshot.source;
+        if values_same(source, &source.value.borrow(), &snapshot.value) {
+            for node in source.targets.borrow().iter() {
+                if node.version.get() == snapshot.version {
+                    node.version.set(source.version.get());
+                }
+            }
+        }
+    }
+}
+
+fn add_dependency(source: &Rc<Source>) -> Option<Rc<Node>> {
+    let context = with_state(|s| s.eval_context.borrow().clone())?;
+    let existing = source.node.borrow().clone();
+    match existing {
+        Some(node) if node.target.is(&context) => {
+            if node.version.get() != -1 {
+                return None;
+            }
+            node.version.set(0);
+            // Moves the node to the end of the sources, so they stay in the
+            // order they were first read.
+            context.with_sources(|sources| {
+                let mut sources = sources.borrow_mut();
+                if let Some(i) = sources.iter().position(|n| Rc::ptr_eq(n, &node))
+                    && i != sources.len() - 1
+                {
+                    let node = sources.remove(i);
+                    sources.push(node);
+                }
+            });
+            Some(node)
+        }
+        existing => {
+            let node = Rc::new(Node {
+                source: source.clone(),
+                target: context.clone(),
+                version: Cell::new(0),
+                rollback_node: RefCell::new(existing),
+            });
+            context.with_sources(|sources| sources.borrow_mut().push(node.clone()));
+            *source.node.borrow_mut() = Some(node.clone());
+            if context.flags() & TRACKING != 0 {
+                subscribe(source, &node);
+            }
+            Some(node)
+        }
+    }
+}
+
+fn subscribe(source: &Rc<Source>, node: &Rc<Node>) {
+    if let Some(computed) = &source.computed
+        && source.targets.borrow().is_empty()
+    {
+        computed
+            .flags
+            .set(computed.flags.get() | OUTDATED | TRACKING);
+        let sources = computed.sources.borrow().clone();
+        for n in &sources {
+            subscribe(&n.source, n);
+        }
+    }
+    let was_empty = {
+        let mut targets = source.targets.borrow_mut();
+        if targets.iter().any(|n| Rc::ptr_eq(n, node)) {
+            return;
+        }
+        let was_empty = targets.is_empty();
+        targets.insert(0, node.clone());
+        was_empty
+    };
+    if was_empty && let Some(watched) = source.watched.clone() {
+        untracked(|| watched(source));
+    }
+}
+
+fn unsubscribe(source: &Rc<Source>, node: &Rc<Node>) {
+    if source.targets.borrow().is_empty() {
+        return;
+    }
+    let removed_last = {
+        let mut targets = source.targets.borrow_mut();
+        match targets.iter().position(|n| Rc::ptr_eq(n, node)) {
+            Some(i) => {
+                targets.remove(i);
+                targets.is_empty()
+            }
+            None => false,
+        }
+    };
+    if removed_last && let Some(unwatched) = source.unwatched.clone() {
+        untracked(|| unwatched(source));
+    }
+    // `Computed._unsubscribe`: a computed nothing reads stops tracking its
+    // sources.
+    if let Some(computed) = &source.computed
+        && source.targets.borrow().is_empty()
+    {
+        computed.flags.set(computed.flags.get() & !TRACKING);
+        let sources = computed.sources.borrow().clone();
+        for n in &sources {
+            unsubscribe(&n.source, n);
+        }
+    }
+}
+
+fn refresh(source: &Rc<Source>) -> bool {
+    match &source.computed {
+        None => true,
+        Some(_) => computed_refresh(source),
+    }
+}
+
+fn needs_to_recompute(target: &Target) -> bool {
+    let sources = target
+        .with_sources(|s| s.borrow().clone())
+        .unwrap_or_default();
+    for node in &sources {
+        if node.source.version.get() != node.version.get()
+            || !refresh(&node.source)
+            || node.source.version.get() != node.version.get()
+        {
+            return true;
+        }
+    }
+    false
+}
+
+fn prepare_sources(target: &Target) {
+    target.with_sources(|sources| {
+        for node in sources.borrow().iter() {
+            if let Some(rollback) = node.source.node.borrow().clone() {
+                *node.rollback_node.borrow_mut() = Some(rollback);
+            }
+            *node.source.node.borrow_mut() = Some(node.clone());
+            node.version.set(-1);
+        }
+    });
+}
+
+fn cleanup_sources(target: &Target) {
+    let sources = target
+        .with_sources(|s| s.borrow().clone())
+        .unwrap_or_default();
+    let mut kept = Vec::new();
+    for node in sources.iter().rev() {
+        if node.version.get() == -1 {
+            unsubscribe(&node.source, node);
+        } else {
+            kept.push(node.clone());
+        }
+        let rollback = node.rollback_node.borrow_mut().take();
+        *node.source.node.borrow_mut() = rollback;
+    }
+    kept.reverse();
+    target.with_sources(|s| *s.borrow_mut() = kept);
+}
+
+fn computed_refresh(source: &Rc<Source>) -> bool {
+    let computed = source.computed.as_ref().expect("computed");
+    let flags = &computed.flags;
+    flags.set(flags.get() & !NOTIFIED);
+    if flags.get() & RUNNING != 0 {
+        return false;
+    }
+    if flags.get() & (OUTDATED | TRACKING) == TRACKING {
+        return true;
+    }
+    flags.set(flags.get() & !OUTDATED);
+    let global_version = with_state(|s| s.global_version.get());
+    if computed.global_version.get() == global_version {
+        return true;
+    }
+    computed.global_version.set(global_version);
+    flags.set(flags.get() | RUNNING);
+    let target = Target::Computed(Rc::downgrade(source));
+    if source.version.get() > 0 && !needs_to_recompute(&target) {
+        flags.set(flags.get() & !RUNNING);
+        return true;
+    }
+    prepare_sources(&target);
+    let prev = set_eval_context(Some(target.clone()));
+    let value = Some((computed.func)());
+    if source.version.get() == 0 || !values_same(source, &source.value.borrow(), &value) {
+        *source.value.borrow_mut() = value;
+        source.version.set(source.version.get() + 1);
+    }
+    set_eval_context(prev);
+    cleanup_sources(&target);
+    flags.set(flags.get() & !RUNNING);
+    true
+}
+
+fn computed_notify(source: &Rc<Source>) {
+    let computed = source.computed.as_ref().expect("computed");
+    if computed.flags.get() & NOTIFIED == 0 {
+        computed
+            .flags
+            .set(computed.flags.get() | OUTDATED | NOTIFIED);
+        let targets = source.targets.borrow().clone();
+        for node in &targets {
+            node.target.notify();
+        }
+    }
+}
+
+fn effect_notify(effect: &Rc<EffectInner>) {
+    if effect.flags.get() & NOTIFIED == 0 {
+        effect.flags.set(effect.flags.get() | NOTIFIED);
+        with_state(|s| s.batched_effects.borrow_mut().push(effect.clone()));
+    }
+}
+
+fn effect_callback(effect: &Rc<EffectInner>) {
+    let prev = effect_start(effect);
+    if effect.flags.get() & DISPOSED == 0 {
+        let func = effect.func.borrow().clone();
+        if let Some(func) = func
+            && let Some(cleanup) = func()
+        {
+            *effect.cleanup.borrow_mut() = Some(cleanup);
+        }
+    }
+    effect_end(effect, prev);
+}
+
+fn effect_start(effect: &Rc<EffectInner>) -> Option<Target> {
+    if effect.flags.get() & RUNNING != 0 {
+        panic!("Cycle detected");
+    }
+    effect.flags.set((effect.flags.get() | RUNNING) & !DISPOSED);
+    cleanup_effect(effect);
+    let target = Target::Effect(effect.clone());
+    prepare_sources(&target);
+    start_batch();
+    set_eval_context(Some(target))
+}
+
+fn effect_end(effect: &Rc<EffectInner>, prev: Option<Target>) {
+    let target = Target::Effect(effect.clone());
+    let current = with_state(|s| s.eval_context.borrow().clone());
+    assert!(
+        current.is_some_and(|c| c.is(&target)),
+        "Out-of-order effect"
+    );
+    cleanup_sources(&target);
+    set_eval_context(prev);
+    effect.flags.set(effect.flags.get() & !RUNNING);
+    if effect.flags.get() & DISPOSED != 0 {
+        dispose_effect(effect);
+    }
+    end_batch();
+}
+
+fn cleanup_effect(effect: &Rc<EffectInner>) {
+    let cleanup = effect.cleanup.borrow_mut().take();
+    if let Some(cleanup) = cleanup {
+        start_batch();
+        let prev = set_eval_context(None);
+        cleanup();
+        set_eval_context(prev);
+        end_batch();
+    }
+}
+
+fn dispose_effect(effect: &Rc<EffectInner>) {
+    let sources = std::mem::take(&mut *effect.sources.borrow_mut());
+    for node in &sources {
+        unsubscribe(&node.source, node);
+    }
+    *effect.func.borrow_mut() = None;
+    cleanup_effect(effect);
+}
+
+fn effect_dispose(effect: &Rc<EffectInner>) {
+    effect.flags.set(effect.flags.get() | DISPOSED);
+    if effect.flags.get() & RUNNING == 0 {
+        dispose_effect(effect);
+    }
+}
+
+/// `SignalOptions`: callbacks for when the signal gains its first
+/// subscriber (`watched`) and loses its last (`unwatched`).
+pub struct SignalOptions<T> {
+    pub watched: SignalCallback<T>,
+    pub unwatched: SignalCallback<T>,
+}
+
+impl<T> Default for SignalOptions<T> {
+    fn default() -> Self {
+        Self {
+            watched: None,
+            unwatched: None,
+        }
+    }
+}
+
+/// `Signal`: a value that the computeds and effects reading it track.
+/// Cloning it shares the signal.
+pub struct Signal<T>(Rc<Source>, PhantomData<T>);
+
+impl<T> Clone for Signal<T> {
+    fn clone(&self) -> Self {
+        Signal(self.0.clone(), PhantomData)
+    }
+}
+
+/// `ReadonlySignal`: a signal that can only be read, such as a
+/// [`computed`].
+pub struct ReadonlySignal<T>(Rc<Source>, PhantomData<T>);
+
+impl<T> Clone for ReadonlySignal<T> {
+    fn clone(&self) -> Self {
+        ReadonlySignal(self.0.clone(), PhantomData)
+    }
+}
+
+fn read_value<T: Clone + 'static>(source: &Rc<Source>) -> T {
+    source
+        .value
+        .borrow()
+        .as_ref()
+        .and_then(|v| v.downcast_ref::<T>())
+        .cloned()
+        .expect("a signal holds a value of its type")
+}
+
+fn source_value<T: Clone + 'static>(source: &Rc<Source>) -> T {
+    if let Some(computed) = &source.computed {
+        if computed.flags.get() & RUNNING != 0 {
+            panic!("Cycle detected");
+        }
+        let node = add_dependency(source);
+        computed_refresh(source);
+        if let Some(node) = node {
+            node.version.set(source.version.get());
+        }
+    } else if let Some(node) = add_dependency(source) {
+        node.version.set(source.version.get());
+    }
+    read_value(source)
+}
+
+/// `signal(value)`.
+pub fn signal<T: SignalValue>(value: T) -> Signal<T> {
+    signal_with_options(value, SignalOptions::default())
+}
+
+/// `signal(value, options)`.
+pub fn signal_with_options<T: SignalValue>(value: T, options: SignalOptions<T>) -> Signal<T> {
+    let typed = |f: SignalCallback<T>| -> SourceCallback {
+        f.map(|f| Rc::new(move |s: &Rc<Source>| f(&Signal(s.clone(), PhantomData))) as _)
+    };
+    Signal(
+        Rc::new(Source {
+            value: RefCell::new(Some(Rc::new(value))),
+            version: Cell::new(0),
+            node: RefCell::new(None),
+            targets: RefCell::new(Vec::new()),
+            batch_snapshot_version: Cell::new(0),
+            watched: typed(options.watched),
+            unwatched: typed(options.unwatched),
+            same: same_value::<T>,
+            computed: None,
+        }),
+        PhantomData,
+    )
+}
+
+impl<T: SignalValue> Signal<T> {
+    /// `signal.value`: the value, subscribing the running computed or effect
+    /// to the signal.
+    pub fn value(&self) -> T {
+        source_value(&self.0)
+    }
+
+    /// `signal.value = value`: sets the value and, unless it is the same
+    /// (`==`), runs the effects that depend on it, at the end of the batch
+    /// if one is running.
+    pub fn set_value(&self, value: T) {
+        let source = &self.0;
+        if source
+            .value
+            .borrow()
+            .as_ref()
+            .and_then(|v| v.downcast_ref::<T>())
+            .is_some_and(|v| v.is_same(&value))
+        {
+            return;
+        }
+        if with_state(|s| s.batch_iteration.get()) > 100 {
+            panic!("Cycle detected");
+        }
+        record_batch_snapshot(source);
+        *source.value.borrow_mut() = Some(Rc::new(value));
+        source.version.set(source.version.get() + 1);
+        with_state(|s| s.global_version.set(s.global_version.get() + 1));
+        start_batch();
+        let targets = source.targets.borrow().clone();
+        for node in &targets {
+            node.target.notify();
+        }
+        end_batch();
+    }
+
+    /// `signal.peek()`: the value, without subscribing.
+    pub fn peek(&self) -> T {
+        untracked(|| self.value())
+    }
+
+    /// `signal.subscribe(fn)`: calls `fn` with the value now and after each
+    /// change; returns the function that stops it.
+    pub fn subscribe(&self, f: impl Fn(T) + 'static) -> Unregister {
+        let this = self.clone();
+        effect(move || {
+            let value = this.value();
+            untracked(|| f(value));
+            None
+        })
+    }
+
+    /// This signal, read-only.
+    pub fn as_readonly(&self) -> ReadonlySignal<T> {
+        ReadonlySignal(self.0.clone(), PhantomData)
+    }
+}
+
+impl<T: Clone + 'static> ReadonlySignal<T> {
+    /// `signal.value`.
+    pub fn value(&self) -> T {
+        source_value(&self.0)
+    }
+
+    /// `signal.peek()`.
+    pub fn peek(&self) -> T {
+        untracked(|| self.value())
+    }
+}
+
+/// `computed(fn)`: a signal whose value `fn` computes from the signals it
+/// reads, lazily, again only after one of them changed.
+pub fn computed<T: SignalValue>(f: impl Fn() -> T + 'static) -> ReadonlySignal<T> {
+    let global_version = with_state(|s| s.global_version.get());
+    ReadonlySignal(
+        Rc::new(Source {
+            value: RefCell::new(None),
+            version: Cell::new(0),
+            node: RefCell::new(None),
+            targets: RefCell::new(Vec::new()),
+            batch_snapshot_version: Cell::new(0),
+            watched: None,
+            unwatched: None,
+            same: same_value::<T>,
+            computed: Some(ComputedData {
+                func: Box::new(move || Rc::new(f()) as Value),
+                sources: RefCell::new(Vec::new()),
+                global_version: Cell::new(global_version.wrapping_sub(1)),
+                flags: Cell::new(OUTDATED),
+            }),
+        }),
+        PhantomData,
+    )
+}
+
+/// `effect(fn)`: runs `fn` now and again after a signal it read changes.
+/// The clean-up `fn` returns runs before its next run and when it is
+/// disposed. Returns the function that disposes it.
+pub fn effect(f: impl Fn() -> Option<Unregister> + 'static) -> Unregister {
+    let effect = Rc::new(EffectInner {
+        func: RefCell::new(Some(Rc::new(f))),
+        cleanup: RefCell::new(None),
+        sources: RefCell::new(Vec::new()),
+        flags: Cell::new(TRACKING),
+    });
+    effect_callback(&effect);
+    Box::new(move || effect_dispose(&effect))
+}
diff --git a/rust/lexical-editor/src/extension/watched_signal.rs b/rust/lexical-editor/src/extension/watched_signal.rs
new file mode 100644
index 00000000000..2c9de9f2ed8
--- /dev/null
+++ b/rust/lexical-editor/src/extension/watched_signal.rs
@@ -0,0 +1,36 @@
+//! `watchedSignal.ts`.
+
+use super::signals::{Signal, SignalOptions, SignalValue, signal_with_options};
+use crate::Unregister;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+/// `watchedSignal(getSnapshot, register)`: a signal that subscribes to an
+/// external store while something watches it, as React's
+/// `useSyncExternalStore` does. When it gains its first subscriber it takes
+/// the store's value (`get_snapshot`) and calls `register`, which keeps it
+/// up to date; when it loses its last, it calls what `register` returned.
+pub fn watched_signal<T: SignalValue>(
+    get_snapshot: impl Fn() -> T + 'static,
+    register: impl Fn(&Signal<T>) -> Unregister + 'static,
+) -> Signal<T> {
+    let dispose: Rc<RefCell<Option<Unregister>>> = Rc::new(RefCell::new(None));
+    let get_snapshot = Rc::new(get_snapshot);
+    let initial = get_snapshot();
+    let unwatched_dispose = dispose.clone();
+    signal_with_options(
+        initial,
+        SignalOptions {
+            unwatched: Some(Rc::new(move |_| {
+                let dispose = unwatched_dispose.borrow_mut().take();
+                if let Some(dispose) = dispose {
+                    dispose();
+                }
+            })),
+            watched: Some(Rc::new(move |this| {
+                this.set_value(get_snapshot());
+                *dispose.borrow_mut() = Some(register(this));
+            })),
+        },
+    )
+}
diff --git a/rust/lexical-editor/src/extension_core/define_extension.rs b/rust/lexical-editor/src/extension_core/define_extension.rs
new file mode 100644
index 00000000000..35feed8caec
--- /dev/null
+++ b/rust/lexical-editor/src/extension_core/define_extension.rs
@@ -0,0 +1,49 @@
+//! `extension-core/defineExtension.ts`: `defineExtension`,
+//! `configExtension` and `declarePeerDependency`.
+
+use super::types::{
+    AnyLexicalExtensionArgument, Erased, ExtensionConfigBase, LexicalExtension,
+    NormalizedPeerDependency,
+};
+use std::rc::Rc;
+
+/// `defineExtension(extension)`: the extension, behind the `Rc` whose
+/// identity the builder tells extensions apart by (JS returns the object
+/// itself, compared with `===`). Define each extension once and share the
+/// `Rc`: two definitions with one name can't be built together.
+pub fn define_extension<C: ExtensionConfigBase, O: 'static, I: 'static>(
+    extension: LexicalExtension<C, O, I>,
+) -> Rc<LexicalExtension<C, O, I>> {
+    Rc::new(extension)
+}
+
+/// `configExtension(extension, ...configs)`: the extension with config
+/// overrides, for another extension's `dependencies` or for
+/// [`build_editor_from_extensions`](crate::extension::build_editor_from_extensions).
+/// The builder merges them with `mergeConfig`, or with
+/// [`shallow_merge_config`](crate::shallow_merge_config).
+pub fn config_extension<C: ExtensionConfigBase, O: 'static, I: 'static>(
+    extension: &Rc<LexicalExtension<C, O, I>>,
+    configs: impl IntoIterator<Item = C::Partial>,
+) -> AnyLexicalExtensionArgument {
+    AnyLexicalExtensionArgument {
+        extension: extension.clone(),
+        configs: configs
+            .into_iter()
+            .map(|config| Rc::new(config) as Erased)
+            .collect(),
+    }
+}
+
+/// `declarePeerDependency(name, config?)`: a peer dependency on the
+/// extension named `name`, whose config is a `C` (JS gives the extension's
+/// type as a type argument), optionally with config overrides.
+pub fn declare_peer_dependency<C: ExtensionConfigBase>(
+    name: &str,
+    config: Option<C::Partial>,
+) -> NormalizedPeerDependency {
+    NormalizedPeerDependency {
+        name: name.to_owned(),
+        config: config.map(|config| Rc::new(config) as Erased),
+    }
+}
diff --git a/rust/lexical-editor/src/extension_core/mod.rs b/rust/lexical-editor/src/extension_core/mod.rs
new file mode 100644
index 00000000000..9a28ecf72e8
--- /dev/null
+++ b/rust/lexical-editor/src/extension_core/mod.rs
@@ -0,0 +1,23 @@
+//! `packages/lexical/src/extension-core` (the `extension` feature): the
+//! types of the extension API and the helpers that define extensions. JS
+//! keeps them in `lexical`, whose packages define their extensions with
+//! them; the builder that uses them is `@lexical/extension`'s
+//! ([`crate::extension`]). They are re-exported at the crate root, as JS
+//! exports them from `lexical`.
+
+mod define_extension;
+mod safe_cast;
+mod shallow_merge_config;
+mod types;
+
+pub use define_extension::{config_extension, declare_peer_dependency, define_extension};
+pub use safe_cast::safe_cast;
+pub use shallow_merge_config::shallow_merge_config;
+pub use types::{
+    AbortController, AbortSignal, AnyLexicalExtension, AnyLexicalExtensionArgument,
+    ExtensionBuildFn, ExtensionBuildState, ExtensionConfigBase, ExtensionInitFn,
+    ExtensionInitState, ExtensionMergeConfigFn, ExtensionRegisterFn, ExtensionRegisterState,
+    InitialEditorConfig, InitialEditorStateFn, InitialEditorStateType, LexicalExtension,
+    LexicalExtensionDependency, NormalizedPeerDependency,
+};
+pub(crate) use types::{AnyExtensionDependency, Erased, ExtensionRepAccess};
diff --git a/rust/lexical-editor/src/extension_core/safe_cast.rs b/rust/lexical-editor/src/extension_core/safe_cast.rs
new file mode 100644
index 00000000000..3c593ea8a15
--- /dev/null
+++ b/rust/lexical-editor/src/extension_core/safe_cast.rs
@@ -0,0 +1,8 @@
+//! `extension-core/safeCast.ts`.
+
+/// `safeCast(value)`: `value`. JS uses it to give a config its type where
+/// inference wouldn't; Rust infers it from the annotation, so this only
+/// keeps ported code close to JS.
+pub fn safe_cast<T>(value: T) -> T {
+    value
+}
diff --git a/rust/lexical-editor/src/extension_core/shallow_merge_config.rs b/rust/lexical-editor/src/extension_core/shallow_merge_config.rs
new file mode 100644
index 00000000000..ef82c7f265a
--- /dev/null
+++ b/rust/lexical-editor/src/extension_core/shallow_merge_config.rs
@@ -0,0 +1,16 @@
+//! `extension-core/shallowMergeConfig.ts`.
+
+use super::types::ExtensionConfigBase;
+
+/// `shallowMergeConfig(config, overrides)`: the default merge of config
+/// overrides, `config` without them, otherwise
+/// [`ExtensionConfigBase::shallow_merge`] (`{...config, ...overrides}`).
+pub fn shallow_merge_config<C: ExtensionConfigBase>(
+    config: &C,
+    overrides: Option<&C::Partial>,
+) -> C {
+    match overrides {
+        None => config.clone(),
+        Some(overrides) => config.shallow_merge(overrides),
+    }
+}
diff --git a/rust/lexical-editor/src/extension_core/types.rs b/rust/lexical-editor/src/extension_core/types.rs
new file mode 100644
index 00000000000..ac5aad7d355
--- /dev/null
+++ b/rust/lexical-editor/src/extension_core/types.rs
@@ -0,0 +1,649 @@
+//! `extension-core/types.ts`: the types of an extension and of what the
+//! builder hands its phases.
+//!
+//! JS types an extension by its `Config`, `Output` and `Init`, and the
+//! builder works on any extension (`AnyLexicalExtension`). Here an extension
+//! is a [`LexicalExtension<Config, Output, Init>`] behind an `Rc`, whose
+//! identity is the extension's (JS compares extensions with `===`), and the
+//! builder sees it as `dyn AnyLexicalExtension`. A config names the type of
+//! its overrides (JS `Partial<Config>`) through [`ExtensionConfigBase`].
+
+use crate::json::{Object, Value};
+use crate::{Editor, EditorState, LexicalError, NodeClass, Unregister};
+use std::any::Any;
+use std::cell::{Cell, RefCell};
+use std::marker::PhantomData;
+use std::rc::Rc;
+
+/// `ExtensionConfigBase`: what an extension's config is. JS configs are
+/// objects, their overrides are `Partial<Config>`, and `shallowMergeConfig`
+/// merges one as `{...config, ...overrides}`. A Rust config names its
+/// overrides' type and how they apply: [`Object`], the JS form, merges as
+/// JS does; `()` is the config of an extension with none (JS `{}`).
+pub trait ExtensionConfigBase: Clone + 'static {
+    /// `Partial<Config>`.
+    type Partial: Clone + 'static;
+
+    /// `{...config, ...overrides}`, or the config itself when no override
+    /// differs from it (see [`shallow_merge_config`](crate::shallow_merge_config)).
+    fn shallow_merge(&self, overrides: &Self::Partial) -> Self;
+}
+
+impl ExtensionConfigBase for () {
+    type Partial = ();
+
+    fn shallow_merge(&self, _overrides: &()) -> Self {}
+}
+
+impl ExtensionConfigBase for Object {
+    type Partial = Object;
+
+    /// `shallowMergeConfig`'s body: the config when every key of the
+    /// overrides holds what the config holds (an absent key holds
+    /// `undefined`), otherwise `{...config, ...overrides}`. Values compare
+    /// by `==` where JS's `!==` compares objects by identity, which only
+    /// decides whether the result is a copy.
+    fn shallow_merge(&self, overrides: &Object) -> Self {
+        let same = overrides
+            .iter()
+            .all(|(k, v)| self.get(k).unwrap_or(&Value::Undefined) == v);
+        if same {
+            return self.clone();
+        }
+        let mut merged = self.clone();
+        for (k, v) in overrides.iter() {
+            merged.insert(k, v.clone());
+        }
+        merged
+    }
+}
+
+/// `InitialEditorStateType`: how `InitialStateExtension` fills a new editor.
+#[derive(Clone)]
+pub enum InitialEditorStateType {
+    /// `null`: leave the root as it is, empty.
+    Null,
+    /// An editor state serialized to a JSON string.
+    Json(String),
+    /// A serialized editor state (`SerializedEditorState`), already parsed.
+    Serialized(Value),
+    /// An editor state that has been deserialized already.
+    EditorState(EditorState),
+    /// A function that updates the editor, called once inside an update.
+    Update(InitialEditorStateFn),
+}
+
+/// `(editor: LexicalEditor) => void`, an initial state that updates the
+/// editor.
+pub type InitialEditorStateFn = Rc<dyn Fn(&Editor) -> Result<(), LexicalError>>;
+
+/// `InitialEditorConfig`: the editor configuration an extension contributes,
+/// and what `init` may change. Of JS's fields, the ones the port has: the
+/// node classes and `$initialEditorState`. `namespace`, `theme`, `html`,
+/// `editable`, `onError`, `onWarn`, `parentEditor`, `disableEvents` and
+/// `dom` are editor options a headless Rust editor doesn't have.
+#[derive(Clone, Default)]
+pub struct InitialEditorConfig {
+    /// `nodes`.
+    pub nodes: Vec<NodeClass>,
+    /// `$initialEditorState`; `None` is JS's `undefined`.
+    pub initial_editor_state: Option<InitialEditorStateType>,
+}
+
+/// `init` (`LexicalExtension.init`).
+pub type ExtensionInitFn<Config, Init> = Rc<
+    dyn Fn(&mut InitialEditorConfig, &Config, &ExtensionInitState) -> Result<Init, LexicalError>,
+>;
+
+/// `build` (`LexicalExtension.build`).
+pub type ExtensionBuildFn<Config, Output, Init> =
+    Rc<dyn Fn(&Editor, &Config, &ExtensionBuildState<Init>) -> Result<Output, LexicalError>>;
+
+/// `register` and `afterRegistration` (`LexicalExtension.register`): they
+/// return the clean-up function.
+pub type ExtensionRegisterFn<Config, Output, Init> = Rc<
+    dyn Fn(
+        &Editor,
+        &Config,
+        &ExtensionRegisterState<Init, Output>,
+    ) -> Result<Unregister, LexicalError>,
+>;
+
+/// `mergeConfig` (`LexicalExtension.mergeConfig`).
+pub type ExtensionMergeConfigFn<Config> =
+    Rc<dyn Fn(&Config, &<Config as ExtensionConfigBase>::Partial) -> Config>;
+
+/// `LexicalExtension`: a composable, named unit of editor configuration
+/// (nodes, the initial state) and of behavior registered once the editor
+/// exists. Write one with struct update syntax over
+/// [`LexicalExtension::new`], and make it with
+/// [`define_extension`](crate::define_extension).
+///
+/// An extension without `build` has no output, and one without `init` no
+/// init result (JS's `undefined`).
+pub struct LexicalExtension<
+    Config: ExtensionConfigBase = (),
+    Output: 'static = (),
+    Init: 'static = (),
+> {
+    /// `name`: unique in an editor.
+    pub name: String,
+    /// `conflictsWith`: names of extensions this one can't be built with.
+    pub conflicts_with: Vec<String>,
+    /// `dependencies`: other extensions, optionally with config overrides.
+    pub dependencies: Vec<AnyLexicalExtensionArgument>,
+    /// `peerDependencies`: extensions, by name, this one configures or
+    /// reads when another extension brings them.
+    pub peer_dependencies: Vec<NormalizedPeerDependency>,
+    /// `config`: the default config.
+    pub config: Config,
+    /// `mergeConfig`; without it, [`ExtensionConfigBase::shallow_merge`].
+    pub merge_config: Option<ExtensionMergeConfigFn<Config>>,
+    /// `nodes`.
+    pub nodes: Vec<NodeClass>,
+    /// `$initialEditorState`.
+    pub initial_editor_state: Option<InitialEditorStateType>,
+    pub init: Option<ExtensionInitFn<Config, Init>>,
+    pub build: Option<ExtensionBuildFn<Config, Output, Init>>,
+    pub register: Option<ExtensionRegisterFn<Config, Output, Init>>,
+    pub after_registration: Option<ExtensionRegisterFn<Config, Output, Init>>,
+}
+
+impl<Config: ExtensionConfigBase, Output: 'static, Init: 'static>
+    LexicalExtension<Config, Output, Init>
+{
+    /// An extension with a name and a default config, and nothing else.
+    pub fn new(name: impl Into<String>, config: Config) -> Self {
+        Self {
+            name: name.into(),
+            conflicts_with: Vec::new(),
+            dependencies: Vec::new(),
+            peer_dependencies: Vec::new(),
+            config,
+            merge_config: None,
+            nodes: Vec::new(),
+            initial_editor_state: None,
+            init: None,
+            build: None,
+            register: None,
+            after_registration: None,
+        }
+    }
+}
+
+/// An extension's config, init result or output, type-erased.
+pub(crate) type Erased = Rc<dyn Any>;
+
+mod sealed {
+    pub trait Sealed {}
+}
+
+/// `AnyLexicalExtension`: any [`LexicalExtension`], as the builder sees it.
+/// Only `LexicalExtension` implements it.
+pub trait AnyLexicalExtension: sealed::Sealed + 'static {
+    fn name(&self) -> &str;
+    fn conflicts_with(&self) -> &[String];
+    fn dependencies(&self) -> &[AnyLexicalExtensionArgument];
+    fn peer_dependencies(&self) -> &[NormalizedPeerDependency];
+    fn nodes(&self) -> &[NodeClass];
+    fn initial_editor_state(&self) -> Option<&InitialEditorStateType>;
+    /// Whether it defines `init` (`getInitResult` requires it).
+    fn has_init(&self) -> bool;
+    #[doc(hidden)]
+    fn merge_configs_erased(&self, configs: &[Erased]) -> Result<Erased, LexicalError>;
+    #[doc(hidden)]
+    fn init_erased(
+        &self,
+        editor_config: &mut InitialEditorConfig,
+        config: &Erased,
+        state: &ExtensionInitState,
+    ) -> Result<Option<Erased>, LexicalError>;
+    #[doc(hidden)]
+    fn build_erased(
+        &self,
+        editor: &Editor,
+        config: &Erased,
+        state: &ExtensionBuildState<()>,
+    ) -> Result<Option<Erased>, LexicalError>;
+    #[doc(hidden)]
+    fn register_erased(
+        &self,
+        editor: &Editor,
+        config: &Erased,
+        state: &ExtensionRegisterState<(), ()>,
+        after: bool,
+    ) -> Result<Option<Unregister>, LexicalError>;
+}
+
+fn config_of<C: 'static>(config: &Erased) -> &C {
+    config
+        .downcast_ref::<C>()
+        .expect("an extension's merged config has its config type")
+}
+
+impl<C: ExtensionConfigBase, O: 'static, I: 'static> sealed::Sealed for LexicalExtension<C, O, I> {}
+
+impl<C: ExtensionConfigBase, O: 'static, I: 'static> AnyLexicalExtension
+    for LexicalExtension<C, O, I>
+{
+    fn name(&self) -> &str {
+        &self.name
+    }
+    fn conflicts_with(&self) -> &[String] {
+        &self.conflicts_with
+    }
+    fn dependencies(&self) -> &[AnyLexicalExtensionArgument] {
+        &self.dependencies
+    }
+    fn peer_dependencies(&self) -> &[NormalizedPeerDependency] {
+        &self.peer_dependencies
+    }
+    fn nodes(&self) -> &[NodeClass] {
+        &self.nodes
+    }
+    fn initial_editor_state(&self) -> Option<&InitialEditorStateType> {
+        self.initial_editor_state.as_ref()
+    }
+    fn has_init(&self) -> bool {
+        self.init.is_some()
+    }
+
+    /// `ExtensionRep.mergeConfigs`: the default config with each override
+    /// merged in, in order.
+    fn merge_configs_erased(&self, configs: &[Erased]) -> Result<Erased, LexicalError> {
+        let mut config = self.config.clone();
+        for cfg in configs {
+            let Some(cfg) = cfg.downcast_ref::<C::Partial>() else {
+                return Err(LexicalError::new(format!(
+                    "LexicalBuilder: a config for {} has the wrong type",
+                    self.name
+                )));
+            };
+            config = match &self.merge_config {
+                Some(merge_config) => merge_config(&config, cfg),
+                None => config.shallow_merge(cfg),
+            };
+        }
+        Ok(Rc::new(config))
+    }
+
+    fn init_erased(
+        &self,
+        editor_config: &mut InitialEditorConfig,
+        config: &Erased,
+        state: &ExtensionInitState,
+    ) -> Result<Option<Erased>, LexicalError> {
+        let Some(init) = &self.init else {
+            return Ok(None);
+        };
+        let result = init(editor_config, config_of::<C>(config), state)?;
+        Ok(Some(Rc::new(result)))
+    }
+
+    fn build_erased(
+        &self,
+        editor: &Editor,
+        config: &Erased,
+        state: &ExtensionBuildState<()>,
+    ) -> Result<Option<Erased>, LexicalError> {
+        let Some(build) = &self.build else {
+            return Ok(None);
+        };
+        let output = build(editor, config_of::<C>(config), &state.retyped())?;
+        Ok(Some(Rc::new(output)))
+    }
+
+    fn register_erased(
+        &self,
+        editor: &Editor,
+        config: &Erased,
+        state: &ExtensionRegisterState<(), ()>,
+        after: bool,
+    ) -> Result<Option<Unregister>, LexicalError> {
+        let register = if after {
+            &self.after_registration
+        } else {
+            &self.register
+        };
+        let Some(register) = register else {
+            return Ok(None);
+        };
+        register(editor, config_of::<C>(config), &state.retyped()).map(Some)
+    }
+}
+
+/// `AnyLexicalExtensionArgument`: an extension, alone or with config
+/// overrides (`NormalizedLexicalExtensionArgument`, which
+/// [`config_extension`](crate::config_extension) makes). Every extension
+/// converts into one.
+#[derive(Clone)]
+pub struct AnyLexicalExtensionArgument {
+    pub(crate) extension: Rc<dyn AnyLexicalExtension>,
+    /// Each a `Partial<Config>` of the extension.
+    pub(crate) configs: Vec<Erased>,
+}
+
+impl AnyLexicalExtensionArgument {
+    /// The extension.
+    pub fn extension(&self) -> &Rc<dyn AnyLexicalExtension> {
+        &self.extension
+    }
+}
+
+impl<C: ExtensionConfigBase, O: 'static, I: 'static> From<Rc<LexicalExtension<C, O, I>>>
+    for AnyLexicalExtensionArgument
+{
+    fn from(extension: Rc<LexicalExtension<C, O, I>>) -> Self {
+        Self {
+            extension,
+            configs: Vec::new(),
+        }
+    }
+}
+
+impl<C: ExtensionConfigBase, O: 'static, I: 'static> From<&Rc<LexicalExtension<C, O, I>>>
+    for AnyLexicalExtensionArgument
+{
+    fn from(extension: &Rc<LexicalExtension<C, O, I>>) -> Self {
+        extension.clone().into()
+    }
+}
+
+/// `NormalizedPeerDependency`: `[name, config?]`, from
+/// [`declare_peer_dependency`](crate::declare_peer_dependency).
+#[derive(Clone)]
+pub struct NormalizedPeerDependency {
+    pub(crate) name: String,
+    /// A `Partial<Config>` of the peer.
+    pub(crate) config: Option<Erased>,
+}
+
+impl NormalizedPeerDependency {
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+}
+
+/// `LexicalExtensionDependency`: a built extension's merged config, its
+/// init result and its output (`None` without `init` or `build`, JS's
+/// `undefined`).
+pub struct LexicalExtensionDependency<Config, Output = (), Init = ()> {
+    pub config: Rc<Config>,
+    pub init: Option<Rc<Init>>,
+    pub output: Option<Rc<Output>>,
+}
+
+impl<C, O, I> Clone for LexicalExtensionDependency<C, O, I> {
+    fn clone(&self) -> Self {
+        Self {
+            config: self.config.clone(),
+            init: self.init.clone(),
+            output: self.output.clone(),
+        }
+    }
+}
+
+/// A dependency as the builder keeps it, type-erased.
+#[derive(Clone)]
+pub(crate) struct AnyExtensionDependency {
+    pub(crate) config: Erased,
+    pub(crate) init: Option<Erased>,
+    pub(crate) output: Option<Erased>,
+}
+
+fn wrong_type(name: &str) -> LexicalError {
+    LexicalError::new(format!(
+        "Extension {name} does not have the requested config, init or output type"
+    ))
+}
+
+impl AnyExtensionDependency {
+    pub(crate) fn typed<C: 'static, O: 'static, I: 'static>(
+        &self,
+        name: &str,
+    ) -> Result<LexicalExtensionDependency<C, O, I>, LexicalError> {
+        let config = self
+            .config
+            .clone()
+            .downcast::<C>()
+            .map_err(|_| wrong_type(name))?;
+        let init = match &self.init {
+            None => None,
+            Some(init) => Some(init.clone().downcast::<I>().map_err(|_| wrong_type(name))?),
+        };
+        let output = match &self.output {
+            None => None,
+            Some(output) => Some(
+                output
+                    .clone()
+                    .downcast::<O>()
+                    .map_err(|_| wrong_type(name))?,
+            ),
+        };
+        Ok(LexicalExtensionDependency {
+            config,
+            init,
+            output,
+        })
+    }
+}
+
+/// What the builder's record of an extension (`ExtensionRep`) answers for
+/// the phase states.
+pub(crate) trait ExtensionRepAccess {
+    fn extension_name(&self) -> String;
+    /// `getInitDependency(dep).config`.
+    fn get_init_dependency(&self, dep: &dyn AnyLexicalExtension) -> Result<Erased, LexicalError>;
+    /// `getInitPeer(name)?.config`.
+    fn get_init_peer(&self, name: &str) -> Result<Option<Erased>, LexicalError>;
+    fn get_dependency(
+        &self,
+        dep: &dyn AnyLexicalExtension,
+    ) -> Result<AnyExtensionDependency, LexicalError>;
+    fn get_peer(&self, name: &str) -> Result<Option<AnyExtensionDependency>, LexicalError>;
+    fn get_init_result(&self) -> Result<Option<Erased>, LexicalError>;
+    fn get_direct_dependent_names(&self) -> Vec<String>;
+    fn get_peer_name_set(&self) -> Vec<String>;
+    fn get_signal(&self) -> Result<AbortSignal, LexicalError>;
+    fn get_output(&self) -> Option<Erased>;
+}
+
+fn downcast_config<C: 'static>(config: Erased, name: &str) -> Result<Rc<C>, LexicalError> {
+    config.downcast::<C>().map_err(|_| {
+        LexicalError::new(format!(
+            "Extension {name} does not have the requested config type"
+        ))
+    })
+}
+
+/// `ExtensionInitState`: what `init` can ask of the builder about other
+/// extensions, whose configs are merged before it runs.
+pub struct ExtensionInitState {
+    pub(crate) rep: Rc<dyn ExtensionRepAccess>,
+}
+
+impl ExtensionInitState {
+    /// `getPeer(name)?.config`: the config of the peer named `name`, if the
+    /// editor has it, as a `Config`.
+    pub fn get_peer<Config: 'static>(
+        &self,
+        name: &str,
+    ) -> Result<Option<Rc<Config>>, LexicalError> {
+        match self.rep.get_init_peer(name)? {
+            None => Ok(None),
+            Some(config) => downcast_config(config, name).map(Some),
+        }
+    }
+
+    /// `getDependency(dep).config`: the config of a dependency.
+    pub fn get_dependency<C: ExtensionConfigBase, O: 'static, I: 'static>(
+        &self,
+        dep: &Rc<LexicalExtension<C, O, I>>,
+    ) -> Result<Rc<C>, LexicalError> {
+        downcast_config(self.rep.get_init_dependency(dep.as_ref())?, &dep.name)
+    }
+
+    /// `getDirectDependentNames()`: the names of the extensions that depend
+    /// on this one directly, in the order they were added.
+    pub fn get_direct_dependent_names(&self) -> Vec<String> {
+        self.rep.get_direct_dependent_names()
+    }
+
+    /// `getPeerNameSet()`: the names of this extension's peer dependencies.
+    pub fn get_peer_name_set(&self) -> Vec<String> {
+        self.rep.get_peer_name_set()
+    }
+}
+
+/// `ExtensionBuildState`: what `build` can ask of the builder; its
+/// dependencies are built before it.
+pub struct ExtensionBuildState<Init> {
+    pub(crate) rep: Rc<dyn ExtensionRepAccess>,
+    pub(crate) _init: PhantomData<fn() -> Init>,
+}
+
+impl<Init: 'static> ExtensionBuildState<Init> {
+    fn retyped<I>(&self) -> ExtensionBuildState<I> {
+        ExtensionBuildState {
+            rep: self.rep.clone(),
+            _init: PhantomData,
+        }
+    }
+
+    /// `getPeer(name)`: the peer named `name`, if the editor has it, as an
+    /// extension of the given types.
+    pub fn get_peer<C: 'static, O: 'static, I: 'static>(
+        &self,
+        name: &str,
+    ) -> Result<Option<LexicalExtensionDependency<C, O, I>>, LexicalError> {
+        match self.rep.get_peer(name)? {
+            None => Ok(None),
+            Some(dep) => dep.typed(name).map(Some),
+        }
+    }
+
+    /// `getDependency(dep)`: a dependency's config, init result and output.
+    pub fn get_dependency<C: ExtensionConfigBase, O: 'static, I: 'static>(
+        &self,
+        dep: &Rc<LexicalExtension<C, O, I>>,
+    ) -> Result<LexicalExtensionDependency<C, O, I>, LexicalError> {
+        self.rep.get_dependency(dep.as_ref())?.typed(&dep.name)
+    }
+
+    /// `getInitResult()`: what this extension's `init` returned.
+    pub fn get_init_result(&self) -> Result<Rc<Init>, LexicalError> {
+        let result = self.rep.get_init_result()?;
+        result
+            .and_then(|r| r.downcast::<Init>().ok())
+            .ok_or_else(|| {
+                LexicalError::new(format!(
+                    "ExtensionRep: getInitResult() for Extension {} has another type",
+                    self.rep.extension_name()
+                ))
+            })
+    }
+
+    pub fn get_direct_dependent_names(&self) -> Vec<String> {
+        self.rep.get_direct_dependent_names()
+    }
+
+    pub fn get_peer_name_set(&self) -> Vec<String> {
+        self.rep.get_peer_name_set()
+    }
+}
+
+/// `ExtensionRegisterState`: what `register` and `afterRegistration` can
+/// ask of the builder.
+pub struct ExtensionRegisterState<Init, Output> {
+    pub(crate) build: ExtensionBuildState<Init>,
+    pub(crate) _output: PhantomData<fn() -> Output>,
+}
+
+impl<Init: 'static, Output: 'static> ExtensionRegisterState<Init, Output> {
+    fn retyped<I, O>(&self) -> ExtensionRegisterState<I, O> {
+        ExtensionRegisterState {
+            build: ExtensionBuildState {
+                rep: self.build.rep.clone(),
+                _init: PhantomData,
+            },
+            _output: PhantomData,
+        }
+    }
+
+    /// `getOutput()`: what this extension's `build` returned, `None`
+    /// without `build`.
+    pub fn get_output(&self) -> Option<Rc<Output>> {
+        self.build
+            .rep
+            .get_output()
+            .and_then(|o| o.downcast::<Output>().ok())
+    }
+
+    /// `getSignal()`: aborted when the editor's registration is disposed.
+    pub fn get_signal(&self) -> Result<AbortSignal, LexicalError> {
+        self.build.rep.get_signal()
+    }
+}
+
+impl<Init, Output> std::ops::Deref for ExtensionRegisterState<Init, Output> {
+    type Target = ExtensionBuildState<Init>;
+
+    fn deref(&self) -> &ExtensionBuildState<Init> {
+        &self.build
+    }
+}
+
+/// `AbortSignal`, as the builder hands it to `register`: aborted once,
+/// when the editor is disposed. Cloning it shares the signal.
+#[derive(Clone, Default)]
+pub struct AbortSignal(Rc<AbortSignalInner>);
+
+#[derive(Default)]
+struct AbortSignalInner {
+    aborted: Cell<bool>,
+    listeners: RefCell<Vec<Box<dyn FnOnce()>>>,
+}
+
+impl AbortSignal {
+    /// `signal.aborted`.
+    pub fn aborted(&self) -> bool {
+        self.0.aborted.get()
+    }
+
+    /// `signal.addEventListener('abort', listener)`: calls `listener` when
+    /// the signal aborts. Listeners added after that never run, as in JS.
+    pub fn add_abort_listener(&self, listener: impl FnOnce() + 'static) {
+        if !self.aborted() {
+            self.0.listeners.borrow_mut().push(Box::new(listener));
+        }
+    }
+}
+
+/// `AbortController`: what aborts an [`AbortSignal`].
+#[derive(Default)]
+pub struct AbortController {
+    signal: AbortSignal,
+}
+
+impl AbortController {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn signal(&self) -> AbortSignal {
+        self.signal.clone()
+    }
+
+    /// `controller.abort()`: aborts the signal and calls its listeners, in
+    /// the order they were added, once.
+    pub fn abort(&self) {
+        let inner = &self.signal.0;
+        if inner.aborted.replace(true) {
+            return;
+        }
+        let listeners = std::mem::take(&mut *inner.listeners.borrow_mut());
+        for listener in listeners {
+            listener();
+        }
+    }
+}
diff --git a/rust/lexical-editor/src/lib.rs b/rust/lexical-editor/src/lib.rs
index 5d85599c547..afdf449748b 100644
--- a/rust/lexical-editor/src/lib.rs
+++ b/rust/lexical-editor/src/lib.rs
@@ -58,6 +58,8 @@ mod editor_state;
 mod error;
 #[cfg(feature = "extension")]
 pub mod extension;
+#[cfg(feature = "extension")]
+mod extension_core;
 #[cfg(feature = "file")]
 pub mod file;
 mod gc;
@@ -73,6 +75,8 @@ mod lexical_utils;
 pub mod link;
 #[cfg(feature = "list")]
 pub mod list;
+#[cfg(feature = "extension")]
+mod merge_register;
 mod node;
 mod node_state;
 pub mod nodes;
@@ -134,6 +138,15 @@ pub use editor::{
 };
 pub use editor_state::EditorState;
 pub use error::LexicalError;
+#[cfg(feature = "extension")]
+pub use extension_core::{
+    AbortController, AbortSignal, AnyLexicalExtension, AnyLexicalExtensionArgument,
+    ExtensionBuildFn, ExtensionBuildState, ExtensionConfigBase, ExtensionInitFn,
+    ExtensionInitState, ExtensionMergeConfigFn, ExtensionRegisterFn, ExtensionRegisterState,
+    InitialEditorConfig, InitialEditorStateFn, InitialEditorStateType, LexicalExtension,
+    LexicalExtensionDependency, NormalizedPeerDependency, config_extension,
+    declare_peer_dependency, define_extension, safe_cast, shallow_merge_config,
+};
 pub use lexical_selection::{
     NodeSelection, Point, PointType, RangeSelection, Selection, SelectionRef, Which,
     create_node_selection, create_range_selection, get_selection, set_selection,
@@ -141,6 +154,8 @@ pub use lexical_selection::{
 pub use lexical_utils::{
     copy_node, get_node_by_key, get_root, get_text_direction, reset_random_key,
 };
+#[cfg(feature = "extension")]
+pub use merge_register::merge_register;
 pub use node::{LexicalNode, NodeBase, NodeClone, NodeKey, NodeRef};
 pub use node_state::{
     AnyStateConfig, RequiredNodeStateConfig, StateConfig, StateIsEqual, StateValue,
diff --git a/rust/lexical-editor/src/merge_register.rs b/rust/lexical-editor/src/merge_register.rs
new file mode 100644
index 00000000000..1a225779e1a
--- /dev/null
+++ b/rust/lexical-editor/src/merge_register.rs
@@ -0,0 +1,14 @@
+//! `utils/mergeRegister.ts`.
+
+use crate::Unregister;
+
+/// `mergeRegister(...func)`: one clean-up function that calls each of
+/// `funcs` in reverse order, as clean-ups usually need to run in the reverse
+/// of the order they were registered.
+pub fn merge_register(funcs: Vec<Unregister>) -> Unregister {
+    Box::new(move || {
+        for func in funcs.into_iter().rev() {
+            func();
+        }
+    })
+}
diff --git a/rust/lexical-editor/src/ordered.rs b/rust/lexical-editor/src/ordered.rs
index e7130911a8b..bf599ad8e59 100644
--- a/rust/lexical-editor/src/ordered.rs
+++ b/rust/lexical-editor/src/ordered.rs
@@ -39,6 +39,24 @@ impl<V> OrderedMap<V> {
         self.index.contains_key(key)
     }
 
+    /// `map.get(key)`.
+    #[cfg(feature = "extension")]
+    pub(crate) fn get(&self, key: &str) -> Option<&V> {
+        let &i = self.index.get(key)?;
+        self.entries[i].as_ref().map(|(_, v)| v)
+    }
+
+    #[cfg(feature = "extension")]
+    pub(crate) fn get_mut(&mut self, key: &str) -> Option<&mut V> {
+        let &i = self.index.get(key)?;
+        self.entries[i].as_mut().map(|(_, v)| v)
+    }
+
+    #[cfg(feature = "extension")]
+    pub(crate) fn values(&self) -> impl Iterator<Item = &V> {
+        self.iter().map(|(_, v)| v)
+    }
+
     /// `map.set(key, value)`.
     pub(crate) fn set(&mut self, key: &str, value: V) {
         if let Some(&i) = self.index.get(key) {
diff --git a/swift/Tests/ConformanceTests/ExtensionOps.swift b/swift/Tests/ConformanceTests/ExtensionOps.swift
new file mode 100644
index 00000000000..5dcb7653fc8
--- /dev/null
+++ b/swift/Tests/ConformanceTests/ExtensionOps.swift
@@ -0,0 +1,332 @@
+import Foundation
+import Lexical
+import LexicalExtension
+
+// Scripts with `extensions` (ops.ts): the editor is built with
+// `buildEditorFromExtensions` from test extensions that ops.ts's
+// `testExtension` makes from JSON (`ExtensionSpec`), and a few of
+// @lexical/extension's own (`REAL_EXTENSIONS`). Each test extension logs
+// every phase it runs, so the log is the order the builder ran them in.
+
+/// A test extension's config: JSON, whose overrides are a
+/// `Partial<JSONObject>` of `\JSONObject[key]` key paths.
+typealias TestConfig = JSONObject
+
+/// A test extension. Its output is the `namedSignals` of its config (with
+/// `signals`), its init result `{init: name}`; both are `Any`, as an
+/// extension without `build` or `init` has none.
+typealias TestExtension = LexicalExtension<TestConfig, Any, Any>
+
+/// The overrides `config` writes, key by key.
+func testPartial(_ config: JSONObject) -> Partial<TestConfig> {
+  Partial { partial in
+    for (key, value) in config {
+      partial.set(\TestConfig[key], value)
+    }
+  }
+}
+
+/// `REAL_EXTENSIONS` in ops.ts.
+private func realExtension(_ key: String) -> (any AnyLexicalExtensionArgument)? {
+  switch key {
+  case "ClearEditorExtension": ClearEditorExtension
+  case "DecoratorTextExtension": DecoratorTextExtension
+  case "EditorStateExtension": EditorStateExtension
+  default: nil
+  }
+}
+
+private let extensionPhases = ["init", "build", "register", "afterRegistration"]
+
+/// The test extensions of one script: ops.ts's `extensionOf`, which makes
+/// each on first use.
+final class TestExtensions {
+  let defs: JSONObject
+  var made: [String: TestExtension] = [:]
+  var log: (JSONValue) -> Void = { _ in }
+  var command: (String) -> LexicalCommand<JSONValue> = { LexicalCommand($0) }
+
+  init(_ defs: JSONObject) { self.defs = defs }
+
+  func of(_ key: String) throws -> TestExtension {
+    if let made = made[key] { return made }
+    guard let spec = defs[key]?.objectValue else {
+      throw ScriptError("unknown extension \(key)")
+    }
+    let extension_ = try make(spec)
+    made[key] = extension_
+    return extension_
+  }
+
+  /// `extensionArg(ctx, arg)`.
+  func arg(_ arg: JSONValue) throws -> any AnyLexicalExtensionArgument {
+    if let key = arg.stringValue {
+      return try realExtension(key) ?? of(key)
+    }
+    guard let parts = arg.arrayValue, let key = parts.first?.stringValue else {
+      throw ScriptError("bad extension argument \(arg.stringify())")
+    }
+    let configs = try parts.dropFirst().map { config in
+      guard let object = config.objectValue else { throw ScriptError("bad config") }
+      return testPartial(object)
+    }
+    let extension_ = try of(key)
+    // `configExtension(extension, ...configs)`, which Swift spells variadically.
+    switch configs.count {
+    case 0: return extension_
+    case 1: return configExtension(extension_, configs[0])
+    case 2: return configExtension(extension_, configs[0], configs[1])
+    default: throw ScriptError("too many configs of \(key)")
+    }
+  }
+
+  private func strings(_ value: JSONValue?) -> [String] {
+    (value?.arrayValue ?? []).compactMap(\.stringValue)
+  }
+
+  /// `testExtension(ctx, spec)`.
+  private func make(_ spec: JSONObject) throws -> TestExtension {
+    guard let name = spec["name"]?.stringValue else {
+      throw ScriptError("an extension needs a name")
+    }
+    let phases = spec["phases"] == nil ? extensionPhases : strings(spec["phases"])
+    let flag = { (key: String) in spec[key]?.boolValue == true }
+    let log = { [unowned self] (entry: [JSONValue]) in self.log(.array(entry)) }
+    let rootText = { (editor: Editor) -> JSONValue in
+      .string(try editor.getEditorState().read { try getRoot().getTextContent() })
+    }
+    var editorConfig = InitialEditorConfig()
+    switch spec["initialEditorState"] {
+    case nil: break
+    case .null?: editorConfig.initialEditorState = InitialEditorStateType.none
+    case .object(let initial)?:
+      if let json = initial["json"] {
+        editorConfig.initialEditorState = .json(json.stringify())
+      } else if let text = initial["text"]?.stringValue {
+        editorConfig.initialEditorState = .update { _ in
+          try getRoot().append(try createParagraphNode().append(try createTextNode(text)))
+        }
+      } else {
+        throw ScriptError("bad initialEditorState")
+      }
+    default: throw ScriptError("bad initialEditorState")
+    }
+    var nodes: [LexicalNodeConfig] = []
+    for type in strings(spec["nodes"]) {
+      switch type {
+      case "decorator-text": nodes.append(.klass(DecoratorTextNode.self))
+      case "horizontalrule": nodes.append(.klass(HorizontalRuleNode.self))
+      default: throw ScriptError("unknown node type \(type)")
+      }
+    }
+    var mergeConfig: ((TestConfig, Partial<TestConfig>) throws -> TestConfig)?
+    if spec["mergeConfig"]?.stringValue == "concat" {
+      mergeConfig = { config, overrides in
+        var merged = shallowMergeConfig(config, overrides)
+        for key in config.keys where overrides.has(\TestConfig[key]) {
+          if case .array(let a)? = config[key],
+            case .array(let b)?? = overrides[dynamicMember: \TestConfig[key]]
+          {
+            merged[key] = .array(a + b)
+          }
+        }
+        return merged
+      }
+    }
+    let inspect = flag("inspect")
+    let initPeers = strings(spec["initPeers"])
+    let buildPeers = strings(spec["buildPeers"])
+    let lookups = strings(spec["lookups"])
+    let initFn: ((inout InitialEditorConfig, TestConfig, ExtensionInitState) throws -> Any)? =
+      phases.contains("init")
+      ? { [unowned self] editorConfig, config, state in
+        log(["init", .string(name), .object(config)])
+        if inspect {
+          let types = try getKnownTypesAndNodes(editorConfig.nodes ?? []).types
+          log(["knownTypes", .string(name), .array(types.array.map { .string($0) })])
+          log([
+            "dependents", .string(name),
+            .array(state.getDirectDependentNames().array.map { .string($0) }),
+          ])
+          log([
+            "peerNames", .string(name), .array(state.getPeerNameSet().array.map { .string($0) }),
+          ])
+        }
+        for peer in initPeers {
+          let dep = try state.getPeer(peer, config: TestConfig.self)
+          log(["initPeer", .string(name), .string(peer), dep.map { .object($0.config) } ?? .null])
+        }
+        for key in lookups {
+          let dep = try state.getDependency(try self.of(key))
+          log(["initDependency", .string(name), .string(key), .object(dep.config)])
+        }
+        return JSONValue.object(JSONObject([("init", .string(name))]))
+      } : nil
+    let signals = flag("signals")
+    let buildFn: ((Editor, TestConfig, ExtensionBuildState<Any>) throws -> Any)? =
+      phases.contains("build")
+      ? { [unowned self] _, config, state in
+        log(["build", .string(name), .object(config)])
+        for peer in buildPeers {
+          let dep = try state.getPeer(peer)
+          log([
+            "buildPeer", .string(name), .string(peer),
+            (dep?.config as? TestConfig).map { .object($0) } ?? .null,
+          ])
+        }
+        for key in lookups {
+          let dep = try state.getDependency(try self.of(key))
+          log(["buildDependency", .string(name), .string(key), .object(dep.config)])
+        }
+        return signals ? namedSignals(config) : ()
+      } : nil
+    let (initResult, abort, listen, editorState) = (
+      flag("initResult"), flag("abort"), flag("listen"), flag("editorState")
+    )
+    let registerFn: ((Editor, TestConfig, ExtensionRegisterState<Any, Any>) throws -> () -> Void)? =
+      phases.contains("register")
+      ? { [unowned self] editor, config, state in
+        log(["register", .string(name), .object(config), try rootText(editor)])
+        if initResult {
+          log(["initResult", .string(name), try state.getInitResult() as? JSONValue ?? .null])
+        }
+        var cleanups: [() -> Void] = []
+        if abort {
+          try state.getSignal().addAbortListener { log(["aborted", .string(name)]) }
+        }
+        if listen {
+          cleanups.append(
+            editor.registerUpdateListener { (payload: UpdateListenerPayload) in
+              log([
+                "update", .string(name), .array(Array(payload.tags).sorted().map { .string($0) }),
+              ])
+            })
+        }
+        let command = self.command("EXTENSION_COMMAND")
+        if signals {
+          guard let output = state.getOutput() as? NamedSignals<TestConfig> else {
+            throw ScriptError("no output")
+          }
+          let disabled = output[dynamicMember: \TestConfig["disabled"]]
+          let label = output[dynamicMember: \TestConfig["label"]]
+          let summary = computed { () -> String in
+            if truthy(disabled.value) { return "off" }
+            return "on:\(template(label.value))"
+          }
+          cleanups.append(
+            try effect { log(["summary", .string(name), .string(summary.value)]) })
+          cleanups.append(
+            try effect { () -> (() -> Void)? in
+              if truthy(disabled.value) { return nil }
+              let current = untracked { label.value } ?? .null
+              log(["enable", .string(name), current])
+              let unregister = editor.registerCommand(
+                command,
+                { payload, _ in
+                  log(["handled", .string(name), current, payload])
+                  return false
+                }, COMMAND_PRIORITY_EDITOR)
+              return {
+                log(["disable", .string(name)])
+                unregister()
+              }
+            })
+        } else {
+          cleanups.append(
+            editor.registerCommand(
+              command,
+              { payload, _ in
+                log(["handled", .string(name), payload])
+                return false
+              }, COMMAND_PRIORITY_EDITOR))
+        }
+        if editorState {
+          let signal = try state.getDependency(EditorStateExtension).output
+          cleanups.append(
+            try effect {
+              let text = try signal.value.read { try getRoot().getTextContent() }
+              log(["editorState", .string(name), .string(text)])
+            })
+        }
+        return {
+          log(["unregister", .string(name)])
+          for cleanup in cleanups.reversed() { cleanup() }
+        }
+      } : nil
+    let afterRegistrationFn:
+      ((Editor, TestConfig, ExtensionRegisterState<Any, Any>) throws -> () -> Void)? =
+        phases.contains("afterRegistration")
+        ? { editor, config, _ in
+          log(["afterRegistration", .string(name), .object(config), try rootText(editor)])
+          return { log(["afterUnregister", .string(name)]) }
+        } : nil
+    return TestExtension(
+      name: name, config: spec["config"]?.objectValue ?? JSONObject(),
+      conflictsWith: strings(spec["conflictsWith"]),
+      dependencies: try (spec["dependencies"]?.arrayValue ?? []).map { try arg($0) },
+      peerDependencies: try (spec["peerDependencies"]?.arrayValue ?? []).map { peer in
+        guard let peerName = peer.arrayValue?.first?.stringValue else {
+          throw ScriptError("bad peer dependency")
+        }
+        guard let config = peer.arrayValue?.dropFirst().first?.objectValue else {
+          return declarePeerDependency(peerName)
+        }
+        return declarePeerDependency(peerName, config: TestConfig.self) { partial in
+          partial = testPartial(config)
+        }
+      },
+      mergeConfig: mergeConfig, nodes: nodes.isEmpty ? nil : { nodes },
+      editorConfig: editorConfig, init: initFn, build: buildFn, register: registerFn,
+      afterRegistration: afterRegistrationFn)
+  }
+
+  /// `runExtensionStep(step, ctx)`.
+  func runStep(_ step: JSONValue, _ editor: Editor) throws {
+    let object = step.objectValue ?? JSONObject()
+    if object["dispose"] != nil {
+      editor.dispose()
+    } else if let entries = object["setSignals"]?.arrayValue {
+      try batch {
+        for entry in entries {
+          guard let parts = entry.arrayValue, parts.count == 3, let key = parts[0].stringValue,
+            let signalName = parts[1].stringValue
+          else { throw ScriptError("bad setSignals") }
+          let output = try getExtensionDependencyFromEditor(editor, try of(key)).output
+          guard let signals = output as? NamedSignals<TestConfig> else {
+            throw ScriptError("no signals of \(key)")
+          }
+          try signals[dynamicMember: \TestConfig[signalName]].set(parts[2])
+        }
+      }
+    } else if let key = object["logDependency"]?.stringValue {
+      let dep = try getExtensionDependencyFromEditor(editor, try of(key))
+      log(.array(["dependency", .string(key), .object(dep.config)]))
+    } else if let peerName = object["logPeer"]?.stringValue {
+      let dep = try getPeerDependencyFromEditor(editor, peerName)
+      log(
+        .array([
+          "peer", .string(peerName), (dep?.config as? TestConfig).map { .object($0) } ?? .null,
+        ]))
+    } else {
+      throw ScriptError("unknown step \(step.stringify())")
+    }
+  }
+}
+
+/// JS's truthiness of a JSON value (`undefined` is `nil`).
+private func truthy(_ value: JSONValue?) -> Bool {
+  switch value {
+  case nil, .null?: false
+  case .bool(let b)?: b
+  case .number(let n)?: n != 0 && !n.isNaN
+  case .string(let s)?: !s.isEmpty
+  default: true
+  }
+}
+
+/// `${value}` of a JSON value.
+private func template(_ value: JSONValue?) -> String {
+  guard let value else { return "undefined" }
+  if case .string(let s) = value { return s }
+  return value.stringify()
+}
diff --git a/swift/Tests/ConformanceTests/Ops.swift b/swift/Tests/ConformanceTests/Ops.swift
index 73b3dad3153..da8a0dd57ae 100644
--- a/swift/Tests/ConformanceTests/Ops.swift
+++ b/swift/Tests/ConformanceTests/Ops.swift
@@ -169,13 +169,15 @@ private struct ScriptState {
 }
 
 private final class ScriptContext {
-  let editor: Editor
+  /// Set once the editor is made: a script with `extensions` makes it after
+  /// its extensions have started logging.
+  var editor: Editor!
   var log: [JSONValue] = []
   var commands: [String: LexicalCommand<JSONValue>] = [:]
   /// The session's clock (ms): what the history listener reads as `Date.now()`.
   var clock: Double = 0
 
-  init(_ editor: Editor) { self.editor = editor }
+  init(_ editor: Editor? = nil) { self.editor = editor }
 
   // ops.ts's `STATES`, one set per session (JS's are shared by every
   // session, which no session can tell: a node type learns a config in one
@@ -261,26 +263,28 @@ private final class ScriptContext {
   }
 
   /// `editor.registerCommand(command(ctx, name), listener, priority)`.
+  @discardableResult
   func register(
     _ name: String, _ priority: Int, _ listener: @escaping (JSONValue) throws -> Bool
-  ) {
+  ) -> () -> Void {
     switch coreCommands[name] {
     case .void(let command):
-      _ = editor.registerCommand(command, { _, _ in try listener(.null) }, priority)
+      return editor.registerCommand(command, { _, _ in try listener(.null) }, priority)
     case .bool(let command):
-      _ = editor.registerCommand(command, { payload, _ in try listener(.bool(payload)) }, priority)
+      return editor.registerCommand(
+        command, { payload, _ in try listener(.bool(payload)) }, priority)
     case .string(let command):
-      _ = editor.registerCommand(
+      return editor.registerCommand(
         command, { payload, _ in try listener(.string(payload)) }, priority)
     case .formats(let command):
-      _ = editor.registerCommand(
+      return editor.registerCommand(
         command,
         { payload, _ in try listener(.object(JSONObject(payload.map { ($0, .bool($1)) }))) },
         priority)
     case .keyboard(let command):
-      _ = editor.registerCommand(command, { _, _ in try listener(.null) }, priority)
+      return editor.registerCommand(command, { _, _ in try listener(.null) }, priority)
     case .listStart(let command):
-      _ = editor.registerCommand(
+      return editor.registerCommand(
         command,
         { payload, _ in
           try listener(
@@ -290,10 +294,10 @@ private final class ScriptContext {
               ])))
         }, priority)
     case .toggleLink(let command):
-      _ = editor.registerCommand(
+      return editor.registerCommand(
         command, { payload, _ in try listener(toggleLinkJSON(payload)) }, priority)
     case nil:
-      _ = editor.registerCommand(
+      return editor.registerCommand(
         self.command(name), { payload, _ in try listener(payload) }, priority)
     }
   }
@@ -632,7 +636,7 @@ private func runAction(_ action: JSONValue, _ ctx: ScriptContext) throws {
 }
 
 private func registerTransform(_ name: String, _ ctx: ScriptContext) throws {
-  let editor = ctx.editor
+  let editor: Editor = ctx.editor
   func log(_ key: NodeKey) {
     ctx.log.append(.array([.string("transform"), .string(name), .string(key)]))
   }
@@ -682,7 +686,52 @@ private func registerTransform(_ name: String, _ ctx: ScriptContext) throws {
 /// `runScript` in ops.ts: runs `script` on a new editor and records every
 /// step.
 func runScript(_ script: JSONValue) throws -> [StepRecord] {
+  try runScriptWithBuild(script).steps
+}
+
+/// `runScript` with what building the editor from the script's `extensions`
+/// recorded (`build`: the log, then the editor's state, selection and text,
+/// or the message it threw, after which there are no steps).
+func runScriptWithBuild(_ script: JSONValue) throws -> (build: JSONValue?, steps: [StepRecord]) {
   resetRandomKey()
+  let ctx = ScriptContext()
+  var built: TestExtensions?
+  var build: JSONValue?
+  if let extensions = script["extensions"]?.arrayValue {
+    for flag in [
+      "richText", "plainText", "list", "link", "code", "overflow", "hashtag", "extension",
+    ]
+    where script[flag]?.boolValue == true {
+      throw ScriptError("extensions and \(flag) don't mix")
+    }
+    let defs = TestExtensions(script["extensionDefs"]?.objectValue ?? JSONObject())
+    defs.log = { [unowned ctx] in ctx.log.append($0) }
+    defs.command = { [unowned ctx] in ctx.command($0) }
+    built = defs
+    do {
+      ctx.editor = try buildEditorFromExtensions(try extensions.map { try defs.arg($0) })
+    } catch {
+      let message = (error as? LexicalError)?.message ?? "\(error)"
+      return (.object(JSONObject([("error", .string(message)), ("log", .array(ctx.log))])), [])
+    }
+    let (selection, content) = try ctx.editor.read {
+      (try selectionSnapshot(), try getRoot().getTextContent())
+    }
+    let state = ctx.editor.getEditorState()
+    build = .object(
+      JSONObject([
+        ("log", .array(ctx.log)), ("selection", selection), ("text", .string(content)),
+        ("state", .string(try state.toJSON().stringify())),
+        ("compact", .string(try state.toJSON(true).stringify())),
+      ]))
+  } else {
+    ctx.editor = try makeEditor(script)
+  }
+  return (build, try runSteps(script, ctx, built))
+}
+
+/// `createEditor` with the nodes of the script's package flags.
+private func makeEditor(_ script: JSONValue) throws -> Editor {
   // `richText: true` registers @lexical/rich-text's nodes and
   // `registerRichText`, `list: true` @lexical/list's nodes,
   // `registerList` and `registerCheckList`, and `link: true` @lexical/link's
@@ -713,9 +762,16 @@ func runScript(_ script: JSONValue) throws -> [StepRecord] {
   if script["extension"]?.boolValue == true {
     nodes += [.klass(HorizontalRuleNode.self), .klass(DecoratorTextNode.self)]
   }
-  let editor = try createEditor(
+  return try createEditor(
     CreateEditorArgs(namespace: "", nodes: nodes, onError: { throw $0 }))
-  let ctx = ScriptContext(editor)
+}
+
+/// Registers the script's packages, transforms, handlers, listeners and
+/// history on `ctx.editor`, then runs and records the steps.
+private func runSteps(
+  _ script: JSONValue, _ ctx: ScriptContext, _ extensions: TestExtensions?
+) throws -> [StepRecord] {
+  let editor: Editor = ctx.editor
   if script["richText"]?.boolValue == true {
     _ = registerRichText(editor)
   }
@@ -823,10 +879,11 @@ func runScript(_ script: JSONValue) throws -> [StepRecord] {
               try runAction(action, ctx)
             }
           }, EditorUpdateOptions(tag: tags, discrete: true))
-      } else {
-        let name = try step["dispatch"]?.stringValue.orThrow() ?? ""
+      } else if let name = step["dispatch"]?.stringValue {
         let handled = try ctx.dispatch(name, step["payload"] ?? .null)
         ctx.log.append(.array([.string("dispatched"), .string(name), .bool(handled)]))
+      } else {
+        try extensions.orThrow().runStep(step, editor)
       }
     } catch {
       failed = true
diff --git a/swift/Tests/ConformanceTests/ScriptTests.swift b/swift/Tests/ConformanceTests/ScriptTests.swift
index 10555b9469b..a5527951085 100644
--- a/swift/Tests/ConformanceTests/ScriptTests.swift
+++ b/swift/Tests/ConformanceTests/ScriptTests.swift
@@ -19,7 +19,8 @@ struct ScriptTests {
     "scripts/listeners", "scripts/caret", "scripts/rich-text", "scripts/rich-text-commands",
     "scripts/plain-text", "scripts/history", "scripts/list", "scripts/link",
     "scripts/autolink", "scripts/code", "scripts/overflow", "scripts/node-state",
-    "scripts/set-blocks-type", "scripts/decorator", "scripts/text", "fuzz/core",
+    "scripts/set-blocks-type", "scripts/decorator", "scripts/text", "scripts/extensions",
+    "fuzz/core",
   ]
 
   static let cases: [Case] = files.flatMap { file in
@@ -31,7 +32,20 @@ struct ScriptTests {
   @Test(arguments: cases)
   func replay(_ vector: Case) throws {
     let expected = vector.script.objectValue?["results"]?.arrayValue ?? []
-    let actual = try runScript(vector.script)
+    let (build, actual) = try runScriptWithBuild(vector.script)
+    // A script with `extensions` records its build: the log, then the
+    // editor's state, selection and text, or the error.
+    let wantBuild = vector.script.objectValue?["build"]
+    #expect((build == nil) == (wantBuild == nil))
+    if let build, let wantBuild {
+      for field in ["log", "selection", "text", "state", "compact", "error"] {
+        let got = build.objectValue?[field]?.stringify()
+        let want = wantBuild.objectValue?[field]?.stringify()
+        if got != want {
+          Issue.record("build \(field) differs\n\(difference(got ?? "nil", want ?? "nil"))")
+        }
+      }
+    }
     #expect(actual.count == expected.count)
     let steps = vector.script.objectValue?["steps"]?.arrayValue ?? []
     // Only the first divergent step is reported: later steps diverge with it.