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.