@bloklabs/angular 1.15.2 → 1.16.1

package/types/bloklabs-angular.d.ts

@@ -1,18 +1,16 @@
-import * as i0 from '@angular/core';
-import { AfterViewInit, DoCheck, EventEmitter, OnDestroy, InjectionToken, EnvironmentProviders, Type, Signal, ElementRef } from '@angular/core';
-import { ControlValueAccessor } from '@angular/forms';
-import { BlokConfig, EditorWidth, Blok, OutputData, API, BlockMutationEvent, ResolvedTheme, BlocksRenderedPayload, BlockRenderedPayload, OutputBlockData, ThemeMode, LooseOutputData, BlockToolData, BlockTuneData, MarkdownImportConfig, BlockOrigin, BlockToolConstructable, ToolboxConfig, BlockAPI, BlockToolConstructorOptions } from '@bloklabs/core';
-
+import * as i0 from "@angular/core";
+import { AfterViewInit, DoCheck, ElementRef, EnvironmentProviders, EventEmitter, InjectionToken, OnDestroy, Signal, Type } from "@angular/core";
+import { ControlValueAccessor } from "@angular/forms";
+import { API, BlockAPI, BlockMutationEvent, BlockOrigin, BlockPosition, BlockRenderedPayload, BlockToolConstructable, BlockToolConstructorOptions, BlockToolData, BlockTuneData, BlocksRenderedPayload, Blok, BlokConfig, EditorWidth, LooseOutputBlockData, LooseOutputData, MarkdownImportConfig, OutputBlockData, OutputData, ReadOnlyModeConfig, ResolvedTheme, ThemeMode, ToolboxConfig } from "@bloklabs/core";
 /**
  * Configuration for the Angular adapter. Same as `BlokConfig` but without
  * `holder` (the adapter owns the host element), plus the reactive `width` prop.
  * Mirrors the React adapter's `UseBlokConfig`.
  */
 type BlokAngularConfig = Omit<BlokConfig, 'holder'> & {
-    /** Editor content width mode. Synced reactively after mount via `editor.width.set()`. */
-    width?: EditorWidth;
+  /** Editor content width mode. Synced reactively after mount via `editor.width.set()`. */
+  width?: EditorWidth;
 };
-
 /**
  * The blessed all-in-one Angular component for embedding Blok (mirrors React's
  * `BlokEditor`). Delegates instance lifecycle to an internal `BlokContentDirective`
@@ -35,227 +33,343 @@ type BlokAngularConfig = Omit<BlokConfig, 'holder'> & {
  * `BlokContentDirective`. Each reactive input is backed by an internal `signal`
  * so effect-based syncing still works; the public template API is unchanged.
  */
-declare class BlokEditorComponent implements AfterViewInit, DoCheck, ControlValueAccessor {
-    private readonly ngZone;
-    /** App-wide defaults from `provideBlok()`; merged UNDER per-instance inputs. */
-    private readonly defaults;
-    private contentQuery?;
-    /** Signal bridge for the @ViewChild directive so effects react to its arrival. */
-    private readonly content;
-    /**
-     * Output half of two-way `[(data)]`. Emits the editor's serialized content on
-     * every change. Wiring the core `onSave` callback is gated on this being
-     * observed, since its mere presence makes the core serialize on every batch.
-     */
-    /** Emits the live Blok instance once ready, after `instance()` is populated. */
-    readonly ready: EventEmitter<Blok>;
-    readonly dataChange: EventEmitter<OutputData>;
-    /** Fires with the full serialized content on every change (notification half). */
-    readonly save: EventEmitter<OutputData>;
-    /** Raw block mutation channel (core `onChange`). */
-    readonly change: EventEmitter<{
-        api: API;
-        event: BlockMutationEvent | BlockMutationEvent[];
-    }>;
-    /** Fires after the editor finishes (re-)rendering (core `onAfterRender`). */
-    readonly afterRender: EventEmitter<API>;
-    /** Fires with the resolved theme whenever it changes (core `onThemeChange`). */
-    readonly themeChange: EventEmitter<ResolvedTheme>;
-    /** Fires after a batch render completes (core `blocks:rendered` event). */
-    readonly blocksRendered: EventEmitter<BlocksRenderedPayload>;
-    /** Fires for each block rendered into the DOM (core `block:rendered` event). */
-    readonly blockRendered: EventEmitter<BlockRenderedPayload>;
-    /**
-     * Transform hook applied to blocks before render (core `onBeforeRender`). Must
-     * return the (possibly modified) block list. An input, not an output, because
-     * it returns a value.
-     */
-    onBeforeRender?: (blocks: OutputBlockData[]) => OutputBlockData[];
-    /**
-     * Transform hook applied to pasted HTML (core `onBeforePaste`). Returns the
-     * (possibly modified) html, or null to drop the paste.
-     */
-    onBeforePaste?: (html: string) => string | null;
-    /**
-     * Error channel (core `onError`). Fires with the raised error whenever an
-     * editor operation — currently serialization — fails instead of only logging.
-     */
-    onError?: BlokConfig['onError'];
-    private readonly readOnly$;
-    set readOnly(value: BlokConfig['readOnly'] | undefined);
-    private readonly hideToolbar$;
-    set hideToolbar(value: boolean | undefined);
-    private readonly toolbarPosition$;
-    set toolbarPosition(value: BlokConfig['toolbarPosition'] | undefined);
-    private readonly inlineToolbar$;
-    set inlineToolbar(value: boolean | string[] | undefined);
-    private readonly theme$;
-    set theme(value: ThemeMode | undefined);
-    private readonly width$;
-    set width(value: EditorWidth | undefined);
-    private readonly placeholder$;
-    set placeholder(value: string | false | undefined);
-    /**
-     * Theme tokens. Construction-only config forced hosts with a live light/dark
-     * toggle to recreate the editor or hand-write the global stylesheet Blok
-     * already injects; this drives the runtime `tokens` API instead.
-     */
-    private readonly styleTokens$;
-    set styleTokens(value: Record<string, string> | undefined);
-    /**
-     * Locale, host message overrides and text direction. `config.i18n` was
-     * consumed once at boot, so a host driving a language switcher had to
-     * recreate the editor (losing caret, focus and undo stack) to relabel the
-     * UI; this drives the runtime `i18n.update` API instead. `defaultLocale` is
-     * not forwarded — it only affects the INITIAL locale resolution.
-     */
-    private readonly i18n$;
-    set i18n(value: BlokConfig['i18n'] | undefined);
-    private readonly autofocus$;
-    set autofocus(value: boolean | undefined);
-    private readonly data$;
-    set data(value: OutputData | LooseOutputData | null | undefined);
-    tools?: BlokConfig['tools'];
-    /** Host-supplied per-type block migrations applied at load (merged across layers). */
-    migrations?: BlokConfig['migrations'];
-    /**
-     * Escape hatch: a full config object for keys without a dedicated input
-     * (sanitizer, minHeight, …). Layered between provideBlok
-     * defaults and the discrete inputs.
-     */
-    config?: Partial<BlokAngularConfig>;
-    /** Changing this input's identity destroys and recreates the editor (≙ React `deps`). */
-    recreateKey: unknown;
-    /**
-     * Content the editor currently reflects. Set when seeded, when the data effect
-     * renders, when the editor emits its own output (`coreOnSave`) and when the
-     * imperative `render()` facade lands. A controlled `data` echo that
-     * content-equals this baseline is a no-op, so it won't clobber the caret.
-     * Renders are serialized via `renderChain`. `undefined` means "nothing recorded
-     * yet" — never an empty document.
-     */
-    private lastRenderedData?;
-    /** Last token set pushed through `tokens.set`, for deep-equal deduping. */
-    private appliedTokens?;
-    /** Last i18n config pushed through `i18n.update`, for deep-equal deduping. */
-    private appliedI18n?;
-    /** Editor instance the i18n baseline above belongs to. */
-    private i18nAppliedFor;
-    /** Last value pushed through `tools.setInlineToolbar`, for content-compare deduping. */
-    private appliedInlineToolbar?;
-    private seededEditor;
-    private renderChain;
-    /** One collaboration warning per component instance (see the data effect). */
-    private collaborationWarned;
-    /**
-     * The `collaboration` the live editor was CONSTRUCTED with. The key is
-     * mount-fixed, so dropping it from `[config]` (`collaboration: on ? {...} :
-     * undefined`) cannot turn a live session into a single-player editor —
-     * reading the current input instead would let that change fall through into
-     * render(), which refuses under collaboration and rejects with nothing
-     * surfaced anywhere.
-     */
-    private constructedCollaboration;
-    /** Editor the capture above belongs to (recaptured on recreate). */
-    private collaborationCapturedFor;
-    /** Registered by `ControlValueAccessor.registerOnChange` (Angular forms). */
-    private cvaOnChange?;
-    private cvaOnTouched?;
-    /**
-     * Core `onSave` wrapper. Records the editor's own serialized output as the
-     * rendered baseline BEFORE notifying Angular, so a controlled consumer echoing
-     * it straight back into `data` deep-equals the baseline and is deduped to a
-     * no-op (no redundant render, no caret reset). Re-enters the Angular zone since
-     * the editor runs outside it.
-     *
-     * Falls back to an escape-hatch `[config]` callback when nothing Angular-side
-     * consumes the save — the baseline is recorded either way, so the controlled
-     * `data` dedupe works on both paths.
-     */
-    private readonly coreOnSave;
-    /**
-     * Stable wrappers for the remaining live callbacks. Each resolves its target
-     * at call time (an observed output, else the `[config]` escape hatch), so a
-     * pushed handler never goes stale and only PRESENCE has to be synced.
-     */
-    private readonly coreOnChange;
-    private readonly coreOnAfterRender;
-    private readonly coreOnBeforeRender;
-    private readonly coreOnEnter;
-    private readonly coreOnSubmit;
-    /** provideBlok defaults merged under the `[config]` escape hatch. */
-    private escapeHatchConfig;
-    /** True when an output, a two-way binding or Angular forms consumes `onSave`. */
-    private hasSaveConsumer;
-    /**
-     * The live callbacks this component currently wires into core, keyed by
-     * handler name — `undefined` for the ones nothing consumes.
-     *
-     * PRESENCE is the semantics in core (an `onSubmit` turns Enter into
-     * serialize-and-submit, an `onSave` arms the change-observation pipeline), so
-     * an unconsumed callback must stay absent. One source of truth for both the
-     * construction config and the runtime sync in `ngDoCheck`, so the two cannot
-     * drift.
-     * @returns the wrappers to install, `undefined` where nothing is wired
-     */
-    private liveHandlers;
-    /** Handler presence installed on the live editor (the sync dedupe baseline). */
-    private appliedHandlers;
-    /** Live Blok instance, or null until `isReady` resolves / after destroy. */
-    readonly instance: i0.Signal<Blok | null>;
-    /** Guards `ready` to one emission per editor instance. */
-    private lastReadyInstance;
-    /**
-     * Construction config handed to the directive. Seeds the editor's initial
-     * values; the directive only reads it once (at construction), so post-mount
-     * changes to construction-only inputs are no-ops by design.
-     */
-    buildConfig(): Partial<BlokAngularConfig>;
-    ngAfterViewInit(): void;
-    /**
-     * Reactive callback presence.
-     *
-     * Callback wiring was decided once, at construction, and in core the presence
-     * of a handler IS the semantics: an `onSubmit` makes Enter serialize-and-submit
-     * instead of splitting the block, an `onSave` arms the whole change-observation
-     * pipeline. A `[config]` swap, an `*ngIf`-gated `(save)` output or a
-     * `registerOnChange` from Angular forms arriving after mount therefore needed a
-     * `recreateKey` bump — destroying the editor and losing caret and undo history.
-     *
-     * Diff the wired handlers against what is installed and push genuine flips
-     * through the runtime `handlers.set` API, writing `undefined` for a handler
-     * that lost its consumer so the change stays reversible. `ngDoCheck` (not an
-     * `effect`) because `EventEmitter.observed` and the plain `@Input` transforms
-     * are not signals; the comparison is six identity checks against stable
-     * wrappers, so an unchanged cycle pushes nothing.
-     */
-    ngDoCheck(): void;
-    /** Serialize the current content. Resolves undefined until the editor is ready. */
-    save$(): Promise<OutputData> | undefined;
-    /** Move the caret into the editor. */
-    focus(atEnd?: boolean): void;
-    /**
-     * Replace the editor content. Resolves undefined until the editor is ready.
-     *
-     * Safe to mix with a controlled `[data]` input: the rendered document becomes
-     * the content baseline once the call lands, so a later `[data]` change back to
-     * the previous document still re-renders instead of being deduped against a
-     * baseline the editor no longer reflects. Recorded only on the resolved path —
-     * a failed render leaves the editor on its previous content.
-     * @param data - the document to render
-     */
-    render(data: OutputData | LooseOutputData): Promise<void> | undefined;
-    constructor();
-    /** Seeds/renders an externally-set form value through the same dedup machinery. */
-    writeValue(value: OutputData | LooseOutputData | null): void;
-    registerOnChange(fn: (data: OutputData) => void): void;
-    registerOnTouched(fn: () => void): void;
-    /** Form disabled state maps to the editor's read-only mode (via the readOnly effect). */
-    setDisabledState(isDisabled: boolean): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BlokEditorComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BlokEditorComponent, "blok-editor", ["blok"], { "onBeforeRender": { "alias": "onBeforeRender"; "required": false; }; "onBeforePaste": { "alias": "onBeforePaste"; "required": false; }; "onError": { "alias": "onError"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; "hideToolbar": { "alias": "hideToolbar"; "required": false; }; "toolbarPosition": { "alias": "toolbarPosition"; "required": false; }; "inlineToolbar": { "alias": "inlineToolbar"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; "width": { "alias": "width"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "styleTokens": { "alias": "styleTokens"; "required": false; }; "i18n": { "alias": "i18n"; "required": false; }; "autofocus": { "alias": "autofocus"; "required": false; }; "data": { "alias": "data"; "required": false; }; "tools": { "alias": "tools"; "required": false; }; "migrations": { "alias": "migrations"; "required": false; }; "config": { "alias": "config"; "required": false; }; "recreateKey": { "alias": "recreateKey"; "required": false; }; }, { "ready": "ready"; "dataChange": "dataChange"; "save": "save"; "change": "change"; "afterRender": "afterRender"; "themeChange": "themeChange"; "blocksRendered": "blocksRendered"; "blockRendered": "blockRendered"; }, never, never, true, never>;
+export declare class BlokEditorComponent implements AfterViewInit, DoCheck, OnDestroy, ControlValueAccessor {
+  private readonly ngZone;
+  /** App-wide defaults from `provideBlok()`; merged UNDER per-instance inputs. */
+  private readonly defaults;
+  private contentQuery?;
+  /** Signal bridge for the @ViewChild directive so effects react to its arrival. */
+  private readonly content;
+  /**
+   * Output half of two-way `[(data)]`. Emits the editor's serialized content on
+   * every change. Wiring the core `onSave` callback is gated on this being
+   * observed, since its mere presence makes the core serialize on every batch.
+   */
+  /** Emits the live Blok instance once ready, after `instance()` is populated. */
+  readonly ready: EventEmitter<Blok>;
+  readonly dataChange: EventEmitter<OutputData>;
+  /** Fires with the full serialized content on every change (notification half). */
+  readonly save: EventEmitter<OutputData>;
+  /** Raw block mutation channel (core `onChange`). */
+  readonly change: EventEmitter<{
+    api: API;
+    event: BlockMutationEvent | BlockMutationEvent[];
+  }>;
+  /** Fires after the editor finishes (re-)rendering (core `onAfterRender`). */
+  readonly afterRender: EventEmitter<API>;
+  /** Fires with the resolved theme whenever it changes (core `onThemeChange`). */
+  readonly themeChange: EventEmitter<ResolvedTheme>;
+  /** Fires after a batch render completes (core `blocks:rendered` event). */
+  readonly blocksRendered: EventEmitter<BlocksRenderedPayload>;
+  /** Fires for each block rendered into the DOM (core `block:rendered` event). */
+  readonly blockRendered: EventEmitter<BlockRenderedPayload>;
+  /**
+   * Transform hook applied to blocks before render (core `onBeforeRender`). Must
+   * return the (possibly modified) block list. An input, not an output, because
+   * it returns a value.
+   */
+  onBeforeRender?: (blocks: OutputBlockData[]) => OutputBlockData[];
+  /**
+   * Transform hook applied to pasted HTML (core `onBeforePaste`). Returns the
+   * (possibly modified) html, or null to drop the paste.
+   */
+  onBeforePaste?: (html: string) => string | null;
+  /**
+   * Error channel (core `onError`). Fires with the raised error whenever an
+   * editor operation — currently serialization — fails instead of only logging.
+   */
+  onError?: BlokConfig['onError'];
+  /**
+   * Failed-image channel (core `onImageFailure`). Return false to replace blok's own notice.
+   */
+  onImageFailure?: BlokConfig['onImageFailure'];
+  private readonly readOnly$;
+  set readOnly(value: BlokConfig['readOnly'] | undefined);
+  private readonly hideToolbar$;
+  set hideToolbar(value: boolean | undefined);
+  private readonly toolbarPosition$;
+  set toolbarPosition(value: BlokConfig['toolbarPosition'] | undefined);
+  private readonly inlineToolbar$;
+  set inlineToolbar(value: boolean | string[] | undefined);
+  private readonly theme$;
+  set theme(value: ThemeMode | undefined);
+  private readonly width$;
+  set width(value: EditorWidth | undefined);
+  private readonly placeholder$;
+  set placeholder(value: string | false | undefined);
+  /**
+   * Theme tokens. Construction-only config forced hosts with a live light/dark
+   * toggle to recreate the editor or hand-write the global stylesheet Blok
+   * already injects; this drives the runtime `tokens` API instead.
+   */
+  private readonly styleTokens$;
+  set styleTokens(value: Record<string, string> | undefined);
+  /**
+   * Locale, host message overrides and text direction. `config.i18n` was
+   * consumed once at boot, so a host driving a language switcher had to
+   * recreate the editor (losing caret, focus and undo stack) to relabel the
+   * UI; this drives the runtime `i18n.update` API instead. `defaultLocale` is
+   * not forwarded — it only affects the INITIAL locale resolution.
+   */
+  private readonly i18n$;
+  set i18n(value: BlokConfig['i18n'] | undefined);
+  private readonly autofocus$;
+  set autofocus(value: boolean | undefined);
+  private readonly data$;
+  set data(value: OutputData | LooseOutputData | null | undefined);
+  tools?: BlokConfig['tools'];
+  /** Host-supplied per-type block migrations applied at load (merged across layers). */
+  migrations?: BlokConfig['migrations'];
+  /**
+   * Escape hatch: a full config object for keys without a dedicated input
+   * (sanitizer, minHeight, …). Layered between provideBlok
+   * defaults and the discrete inputs.
+   */
+  config?: Partial<BlokAngularConfig>;
+  /** Changing this input's identity destroys and recreates the editor (≙ React `deps`). */
+  recreateKey: unknown;
+  /**
+   * Content the editor currently reflects. Set when seeded, when the data effect
+   * renders, when the editor emits its own output (`coreOnSave`) and when the
+   * imperative `render()` facade lands. A controlled `data` echo that
+   * content-equals this baseline is a no-op, so it won't clobber the caret.
+   * Renders are serialized via `renderChain`. `undefined` means "nothing recorded
+   * yet" — never an empty document.
+   */
+  private lastRenderedData?;
+  /**
+   * Content of the render currently queued or in flight — distinct from
+   * `lastRenderedData`, which names the last SUCCESSFUL one. The data effect
+   * dedupes against both, so an echo arriving mid-render is suppressed without
+   * the baseline having to move before the render resolves (a failed render
+   * would then strand it on content the editor never showed, and the host's
+   * retry of that same content would be deduped away forever).
+   * `undefined` means "nothing in flight".
+   */
+  private pendingData?;
+  /**
+   * Window of recently emitted `onSave` payloads. `lastRenderedData` remembers
+   * only the LAST one, but a host that persists on save and refetches can echo
+   * an EARLIER save back after a newer one already replaced the baseline (the
+   * user kept typing). That stale echo is still the editor's own output, and
+   * rendering it is a whole-document replace — it would drop every character
+   * typed between the two saves and hand the rewound document to the next save,
+   * making the loss permanent in the host's store. Every `[data]` path funnels
+   * through the `data$` signal (the template input AND `writeValue`), so the one
+   * check in the data effect covers `patchValue` / `setValue` / `reset` too.
+   */
+  private readonly emittedEcho;
+  /** Last token set pushed through `tokens.set`, for deep-equal deduping. */
+  private appliedTokens?;
+  /** Last i18n config pushed through `i18n.update`, for deep-equal deduping. */
+  private appliedI18n?;
+  /** Editor instance the i18n baseline above belongs to. */
+  private i18nAppliedFor;
+  /** Last value pushed through `tools.setInlineToolbar`, for content-compare deduping. */
+  private appliedInlineToolbar?;
+  private seededEditor;
+  private renderChain;
+  /**
+   * Editor the single collaboration warning has already been emitted for. Keyed
+   * by the editor, not a boolean, so the editor a `recreateKey` bump creates
+   * warns on its own first ignored `data` change instead of inheriting the
+   * previous editor's "already warned" flag and going silent.
+   */
+  private collaborationWarnedFor;
+  /** Registered by `ControlValueAccessor.registerOnChange` (Angular forms). */
+  private cvaOnChange?;
+  private cvaOnTouched?;
+  /**
+   * Core `onSave` wrapper. Records the editor's own serialized output as the
+   * rendered baseline BEFORE notifying Angular, so a controlled consumer echoing
+   * it straight back into `data` deep-equals the baseline and is deduped to a
+   * no-op (no redundant render, no caret reset). Re-enters the Angular zone since
+   * the editor runs outside it.
+   *
+   * Falls back to an escape-hatch `[config]` callback when nothing Angular-side
+   * consumes the save — the baseline is recorded either way, so the controlled
+   * `data` dedupe works on both paths.
+   */
+  private readonly coreOnSave;
+  /**
+   * Stable wrappers for the remaining live callbacks. Each resolves its target
+   * at call time (an observed output, else the `[config]` escape hatch), so a
+   * pushed handler never goes stale and only PRESENCE has to be synced.
+   */
+  private readonly coreOnChange;
+  private readonly coreOnAfterRender;
+  private readonly coreOnBeforeRender;
+  private readonly coreOnEnter;
+  private readonly coreOnSubmit;
+  /** provideBlok defaults merged under the `[config]` escape hatch. */
+  private escapeHatchConfig;
+  /** True when an output, a two-way binding or Angular forms consumes `onSave`. */
+  private hasSaveConsumer;
+  /**
+   * The live callbacks this component currently wires into core, keyed by
+   * handler name — `undefined` for the ones nothing consumes.
+   *
+   * PRESENCE is the semantics in core (an `onSubmit` turns Enter into
+   * serialize-and-submit, an `onSave` arms the change-observation pipeline), so
+   * an unconsumed callback must stay absent. One source of truth for both the
+   * construction config and the runtime sync in `ngDoCheck`, so the two cannot
+   * drift.
+   * @returns the wrappers to install, `undefined` where nothing is wired
+   */
+  private liveHandlers;
+  /** Handler presence installed on the live editor (the sync dedupe baseline). */
+  private appliedHandlers;
+  /** Live Blok instance, or null until `isReady` resolves / after destroy. */
+  readonly instance: import("@angular/core").Signal<Blok | null>;
+  /** Guards `ready` to one emission per editor instance. */
+  private lastReadyInstance;
+  /**
+   * Construction config handed to the directive. Seeds the editor's initial
+   * values; the directive only reads it once (at construction), so post-mount
+   * changes to construction-only inputs are no-ops by design.
+   */
+  buildConfig(): Partial<BlokAngularConfig>;
+  ngAfterViewInit(): void;
+  /** Save consumers captured at destroy, for core's final save. */
+  private saveHandlersAtDestroy;
+  ngOnDestroy(): void;
+  /**
+   * Reactive callback presence.
+   *
+   * Callback wiring was decided once, at construction, and in core the presence
+   * of a handler IS the semantics: an `onSubmit` makes Enter serialize-and-submit
+   * instead of splitting the block, an `onSave` arms the whole change-observation
+   * pipeline. A `[config]` swap, an `*ngIf`-gated `(save)` output or a
+   * `registerOnChange` from Angular forms arriving after mount therefore needed a
+   * `recreateKey` bump — destroying the editor and losing caret and undo history.
+   *
+   * Diff the wired handlers against what is installed and push genuine flips
+   * through the runtime `handlers.set` API, writing `undefined` for a handler
+   * that lost its consumer so the change stays reversible. `ngDoCheck` (not an
+   * `effect`) because `EventEmitter.observed` and the plain `@Input` transforms
+   * are not signals; the comparison is six identity checks against stable
+   * wrappers, so an unchanged cycle pushes nothing.
+   */
+  ngDoCheck(): void;
+  /** Serialize the current content. Resolves undefined until the editor is ready. */
+  save$(): Promise<OutputData> | undefined;
+  /** Ask before an in-app navigation (see `Blok.confirmLeave`). Resolves true until the editor is ready. */
+  confirmLeave(): Promise<boolean>;
+  /** Move the caret into the editor. */
+  focus(atEnd?: boolean): void;
+  /**
+   * Replace the editor content. Resolves undefined until the editor is ready.
+   *
+   * Safe to mix with a controlled `[data]` input: the rendered document becomes
+   * the content baseline once the call lands, so a later `[data]` change back to
+   * the previous document still re-renders instead of being deduped against a
+   * baseline the editor no longer reflects. Recorded only on the resolved path —
+   * a failed render leaves the editor on its previous content.
+   * @param data - the document to render
+   */
+  render(data: OutputData | LooseOutputData): Promise<void> | undefined;
+  constructor();
+  /** Seeds/renders an externally-set form value through the same dedup machinery. */
+  writeValue(value: OutputData | LooseOutputData | null): void;
+  registerOnChange(fn: (data: OutputData) => void): void;
+  registerOnTouched(fn: () => void): void;
+  /** Form disabled state maps to the editor's read-only mode (via the readOnly effect). */
+  setDisabledState(isDisabled: boolean): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BlokEditorComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BlokEditorComponent, "blok-editor", ["blok"], {
+    "onBeforeRender": {
+      "alias": "onBeforeRender";
+      "required": false;
+    };
+    "onBeforePaste": {
+      "alias": "onBeforePaste";
+      "required": false;
+    };
+    "onError": {
+      "alias": "onError";
+      "required": false;
+    };
+    "onImageFailure": {
+      "alias": "onImageFailure";
+      "required": false;
+    };
+    "readOnly": {
+      "alias": "readOnly";
+      "required": false;
+    };
+    "hideToolbar": {
+      "alias": "hideToolbar";
+      "required": false;
+    };
+    "toolbarPosition": {
+      "alias": "toolbarPosition";
+      "required": false;
+    };
+    "inlineToolbar": {
+      "alias": "inlineToolbar";
+      "required": false;
+    };
+    "theme": {
+      "alias": "theme";
+      "required": false;
+    };
+    "width": {
+      "alias": "width";
+      "required": false;
+    };
+    "placeholder": {
+      "alias": "placeholder";
+      "required": false;
+    };
+    "styleTokens": {
+      "alias": "styleTokens";
+      "required": false;
+    };
+    "i18n": {
+      "alias": "i18n";
+      "required": false;
+    };
+    "autofocus": {
+      "alias": "autofocus";
+      "required": false;
+    };
+    "data": {
+      "alias": "data";
+      "required": false;
+    };
+    "tools": {
+      "alias": "tools";
+      "required": false;
+    };
+    "migrations": {
+      "alias": "migrations";
+      "required": false;
+    };
+    "config": {
+      "alias": "config";
+      "required": false;
+    };
+    "recreateKey": {
+      "alias": "recreateKey";
+      "required": false;
+    };
+  }, {
+    "ready": "ready";
+    "dataChange": "dataChange";
+    "save": "save";
+    "change": "change";
+    "afterRender": "afterRender";
+    "themeChange": "themeChange";
+    "blocksRendered": "blocksRendered";
+    "blockRendered": "blockRendered";
+  }, never, never, true, never>;
 }
-
+/**
+ * The `collaboration` the given editor was constructed with.
+ * @param editor - a Blok instance built by `BlokContentDirective`
+ * @returns the mount-time collaboration config, `undefined` when there was none
+ */
+declare function getConstructedCollaboration(editor: WeakKey): BlokAngularConfig['collaboration'];
 /**
  * Escape-hatch directive and lifecycle engine for Blok (mirrors React's
  * `useBlok` + `BlokContent`). Constructs a Blok instance into its own host
@@ -274,47 +388,57 @@ declare class BlokEditorComponent implements AfterViewInit, DoCheck, ControlValu
  * adapter via JIT, which does not register signal-based members. `instance`
  * remains a plain `signal` (runtime API, JIT-safe) for reactive consumption.
  */
-declare class BlokContentDirective implements OnDestroy {
-    private readonly host;
-    private readonly ngZone;
-    private readonly isBrowser;
-    /**
-     * App-wide defaults from `provideBlok()`, merged UNDER the bound `[config]` so
-     * the escape-hatch path honors them just like `<blok-editor>` (which also
-     * merges, idempotently). Mirrors React's `useBlok` merging context defaults.
-     */
-    private readonly defaults;
-    private readonly envInjector;
-    private readonly appRef;
-    private readonly errorHandler;
-    /** Construction-time Blok config (everything except `holder`, which the directive owns). */
-    config: Partial<BlokAngularConfig>;
-    /** Changing this input's identity (after the first build) destroys + recreates the editor. */
-    set recreateKey(value: unknown);
-    /** Emits the live Blok instance once it is ready, after `instance` is populated. */
-    readonly ready: EventEmitter<Blok>;
-    /** The live Blok instance, or null before `isReady` resolves / after destroy. */
-    readonly instance: i0.WritableSignal<Blok | null>;
-    /** The editor created by the most recent construction; used as the staleness key. */
-    private current;
-    private destroyed;
-    private built;
-    private currentKey;
-    /** The portal registry for the current editor (Angular-block mounting). */
-    private registry;
-    constructor();
-    /** Construct a Blok into the host element and publish it once ready. */
-    private build;
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BlokContentDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BlokContentDirective, "[blokContent]", never, { "config": { "alias": "config"; "required": false; }; "recreateKey": { "alias": "recreateKey"; "required": false; }; }, { "ready": "ready"; }, never, never, true, never>;
+export declare class BlokContentDirective implements OnDestroy {
+  private readonly host;
+  private readonly ngZone;
+  private readonly isBrowser;
+  /**
+   * App-wide defaults from `provideBlok()`, merged UNDER the bound `[config]` so
+   * the escape-hatch path honors them just like `<blok-editor>` (which also
+   * merges, idempotently). Mirrors React's `useBlok` merging context defaults.
+   */
+  private readonly defaults;
+  private readonly envInjector;
+  private readonly appRef;
+  private readonly errorHandler;
+  /** Construction-time Blok config (everything except `holder`, which the directive owns). */
+  config: Partial<BlokAngularConfig>;
+  /** Changing this input's identity (after the first build) destroys + recreates the editor. */
+  set recreateKey(value: unknown);
+  /** Emits the live Blok instance once it is ready, after `instance` is populated. */
+  readonly ready: EventEmitter<Blok>;
+  /** The live Blok instance, or null before `isReady` resolves / after destroy. */
+  readonly instance: import("@angular/core").WritableSignal<Blok | null>;
+  /** The editor created by the most recent construction; used as the staleness key. */
+  private current;
+  private destroyed;
+  private built;
+  private currentKey;
+  /** The portal registry for the current editor (Angular-block mounting). */
+  private registry;
+  constructor();
+  /** Construct a Blok into the host element and publish it once ready. */
+  private build;
+  ngOnDestroy(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BlokContentDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<BlokContentDirective, "[blokContent]", never, {
+    "config": {
+      "alias": "config";
+      "required": false;
+    };
+    "recreateKey": {
+      "alias": "recreateKey";
+      "required": false;
+    };
+  }, {
+    "ready": "ready";
+  }, never, never, true, never>;
 }
-
 /**
  * DI token holding app-wide Blok defaults (shared tools registry, default theme,
  * i18n). Merged under per-instance inputs by `BlokEditorComponent`.
  */
-declare const BLOK_DEFAULT_CONFIG: InjectionToken<Partial<BlokAngularConfig>>;
+export declare const BLOK_DEFAULT_CONFIG: InjectionToken<Partial<BlokAngularConfig>>;
 /**
  * Standalone provider registering app-wide Blok defaults.
  *
@@ -325,16 +449,15 @@ declare const BLOK_DEFAULT_CONFIG: InjectionToken<Partial<BlokAngularConfig>>;
  * });
  * ```
  */
-declare function provideBlok(defaults: Partial<BlokAngularConfig>): EnvironmentProviders;
-
+export declare function provideBlok(defaults: Partial<BlokAngularConfig>): EnvironmentProviders;
 /**
  * Where to place the caret within a block. `position` selects the input
  * (`'start'`/`'end'`/`'default'`) and `offset` is the character offset within it
  * — the same shape core's `caret.setToBlock` accepts.
  */
 interface CaretTarget {
-    position?: 'start' | 'end' | 'default';
-    offset?: number;
+  position?: 'start' | 'end' | 'default';
+  offset?: number;
 }
 /**
  * A plain, serializable view of one block in the tree.
@@ -346,52 +469,48 @@ interface CaretTarget {
  * identity; depend on the `id` instead.
  */
 interface BlockNode {
-    id: string;
-    type: string;
-    parentId: string | null;
-    contentIds: readonly string[];
+  id: string;
+  type: string;
+  parentId: string | null;
+  contentIds: readonly string[];
 }
 /** Where to place a block among its siblings. */
-type InsertPosition = 'start' | 'end' | {
-    before: string;
-} | {
-    after: string;
-};
+type InsertPosition = BlockPosition;
 interface InsertSpec {
-    type?: string;
-    data?: BlockToolData;
-    parentId?: string | null;
-    position?: InsertPosition;
-    /**
-     * Move the caret into the new block. Defaults to `false`: a programmatic
-     * insert from React must not steal focus from wherever the user is typing.
-     * Set `true` for an explicit "add a block and start editing it" flow.
-     */
-    focus?: boolean;
-    /**
-     * Replace the block at the resolved slot instead of inserting a new one — a
-     * programmatic "turn into". Combine with a `position` that targets the block
-     * to replace, e.g. `{ position: { before: id }, replace: true }`.
-     */
-    replace?: boolean;
-    /**
-     * Explicit id for the new block (generated when omitted). Passing a stable id
-     * makes the insert idempotent: if a block with this id already exists the
-     * existing node is returned and nothing is inserted ("insert if absent"),
-     * so an effect that re-runs won't create duplicates.
-     */
-    id?: string;
-    /** Block tune data to apply at creation, keyed by tune name. */
-    tunes?: {
-        [name: string]: BlockTuneData;
-    };
-    /**
-     * Place the caret inside the newly-created block at a specific position/offset
-     * (e.g. `{ offset: 3 }`). Implies focus. Applied ONLY when a block is actually
-     * created — an insert-if-absent hit (existing id) does not move the caret.
-     * Use this instead of the boolean `focus` when you need a specific offset.
-     */
-    caret?: CaretTarget;
+  type?: string;
+  data?: BlockToolData;
+  parentId?: string | null;
+  position?: InsertPosition;
+  /**
+   * Move the caret into the new block. Defaults to `false`: a programmatic
+   * insert from React must not steal focus from wherever the user is typing.
+   * Set `true` for an explicit "add a block and start editing it" flow.
+   */
+  focus?: boolean;
+  /**
+   * Replace the block at the resolved slot instead of inserting a new one — a
+   * programmatic "turn into". Combine with a `position` that targets the block
+   * to replace, e.g. `{ position: { before: id }, replace: true }`.
+   */
+  replace?: boolean;
+  /**
+   * Explicit id for the new block (generated when omitted). Passing a stable id
+   * makes the insert idempotent: if a block with this id already exists the
+   * existing node is returned and nothing is inserted ("insert if absent"),
+   * so an effect that re-runs won't create duplicates.
+   */
+  id?: string;
+  /** Block tune data to apply at creation, keyed by tune name. */
+  tunes?: {
+    [name: string]: BlockTuneData;
+  };
+  /**
+   * Place the caret inside the newly-created block at a specific position/offset
+   * (e.g. `{ offset: 3 }`). Implies focus. Applied ONLY when a block is actually
+   * created — an insert-if-absent hit (existing id) does not move the caret.
+   * Use this instead of the boolean `focus` when you need a specific offset.
+   */
+  caret?: CaretTarget;
 }
 /**
  * One node of a pre-built nested subtree for {@link UseBlocksApi.insertTree}.
@@ -403,270 +522,517 @@ interface InsertSpec {
  * is always their enclosing node.
  */
 interface TreeInsertSpec {
-    type?: string;
-    data?: BlockToolData;
-    tunes?: {
-        [name: string]: BlockTuneData;
-    };
-    /**
-     * Explicit id for this node (generated when omitted). Unlike `insert`, this is
-     * NOT insert-if-absent: a tree insert always creates fresh blocks. A colliding
-     * id — one that already exists in the document, or is reused by another node
-     * in the same spec — is REJECTED up front: nothing is inserted and `insertTree`
-     * returns `null` (a duplicate id would corrupt every id-keyed lookup).
-     */
-    id?: string;
-    /** Direct children, inserted nested under this node, in array order. */
-    children?: TreeInsertSpec[];
-    /** Root-only: where to place the whole subtree. Ignored on nested children. */
-    parentId?: string | null;
-    /** Root-only: slot among siblings of `parentId`. Ignored on nested children. */
-    position?: InsertPosition;
+  type?: string;
+  data?: BlockToolData;
+  tunes?: {
+    [name: string]: BlockTuneData;
+  };
+  /**
+   * Explicit id for this node (generated when omitted). Unlike `insert`, this is
+   * NOT insert-if-absent: a tree insert always creates fresh blocks. A colliding
+   * id — one that already exists in the document, or is reused by another node
+   * in the same spec — is REJECTED up front: nothing is inserted and `insertTree`
+   * returns `null` (a duplicate id would corrupt every id-keyed lookup).
+   */
+  id?: string;
+  /** Direct children, inserted nested under this node, in array order. */
+  children?: TreeInsertSpec[];
+  /** Root-only: where to place the whole subtree. Ignored on nested children. */
+  parentId?: string | null;
+  /** Root-only: slot among siblings of `parentId`. Ignored on nested children. */
+  position?: InsertPosition;
 }
 /**
  * Where to move an existing block.
  *
- * `before`/`after` are POSITION targets, not parent assignments: the block is
- * relocated to that flat slot and — because Blok keeps the flat array as the
- * canonical document order — ADOPTS the parent of wherever it lands. Moving a
- * nested block to `{ after: someRootBlock }` therefore unnests it to root, and
- * moving a root block in among a container's children nests it. Use
- * `nest`/`unnest` when you want to change the parent without choosing a sibling
- * slot. `toIndex` is an absolute flat index (clamped into range).
+ * `before`/`after` make the block a sibling of the ref: it takes the ref's
+ * parent. Moving a nested block to `{ after: someRootBlock }` therefore unnests
+ * it to root, and moving a root block next to a container's child nests it.
+ * Use `nest`/`unnest` when you want to change the parent without choosing a
+ * sibling slot. `toIndex` is an absolute flat index (clamped into range).
  */
 type MoveTarget = {
-    before: string;
+  before: string;
 } | {
-    after: string;
+  after: string;
 } | {
-    toIndex: number;
+  toIndex: number;
 };
 interface UseBlocksApi {
-    getById(id: string): BlockNode | null;
-    getChildren(parentId: string | null): BlockNode[];
-    /**
-     * Insert one block; returns the created node or null when rejected (unknown
-     * tool type, dangling `parentId`, or a `replace` whose target is missing). An
-     * explicit `id` that already exists is insert-if-absent (returns the existing
-     * node, creates nothing). Atomic — one undo step. The returned node is
-     * {@link BlockNode}-volatile; read it now, don't put it in a dep array.
-     */
-    insert(spec?: InsertSpec): BlockNode | null;
-    /**
-     * Insert several blocks atomically, in array order, as ONE undo step. Each
-     * spec is a full {@link InsertSpec} (own type/data/parentId/position), routed
-     * through the same single-`insert` path, so per-spec parent assertion and
-     * positioning still apply. Specs that fail to insert (e.g. a dangling
-     * parentId, or a replace whose target is missing) are dropped; the returned
-     * array holds only the successfully created nodes. An empty input is a no-op
-     * (returns `[]`, opens no transaction). Like `insert`, the returned nodes are
-     * fresh-snapshot volatile — read them now, don't stash them in dep arrays.
-     */
-    insertMany(specs: InsertSpec[]): BlockNode[];
-    /**
-     * Insert a pre-built NESTED subtree in ONE atomic operation (one undo step).
-     * Each {@link TreeInsertSpec} node becomes a block; its `children` are inserted
-     * nested under it (recursively, in array order) so the whole hierarchy lands in
-     * a single call — no follow-up `nest` round-trips. Delegates to core's
-     * tree-aware `blocks.insertMany`, which composes the flat DFS pre-order array
-     * honoring each node's `parent`/`content` links.
-     *
-     * Placement is root-only: the root node's `parentId`/`position` position the
-     * whole subtree among existing blocks (default: appended at the document end);
-     * nested children ignore those fields (their parent is their enclosing node). A
-     * dangling root `parentId` is rejected — nothing is inserted and `null` is
-     * returned (mirrors {@link insert}). Returns the root {@link BlockNode}, which
-     * is fresh-snapshot volatile — read it now, don't stash it in a dep array.
-     */
-    insertTree(spec: TreeInsertSpec): BlockNode | null;
-    /**
-     * Convert a Markdown string to blocks and insert them ADDITIVELY at a
-     * position, WITHOUT clearing the document (unlike core's `importMarkdown` /
-     * `renderFromHTML`, which replace the whole document). This is the React
-     * "paste markdown → blocks appear" path.
-     *
-     * Async: the markdown converter is lazy-loaded (kept out of the main bundle),
-     * so this is the ONE async creator in the API — `await` the returned promise.
-     * The whole batch is inserted as a single atomic undo step.
-     *
-     * `position` (default `'end'`) places the converted run among `parentId`'s
-     * children (or root siblings when `parentId` is omitted/null), reusing the
-     * same `start`/`end`/`before`/`after` semantics as {@link insert}.
-     *
-     * `parentId` (default `null` = root) nests the import: every TOP-LEVEL
-     * converted block (one the converter left un-parented) is reparented under
-     * `parentId`, while blocks the markdown nested internally (e.g. table-cell
-     * children) keep their intra-import parent. A dangling `parentId` is a no-op
-     * (returns `[]`, opens no transaction), matching {@link insert}.
-     *
-     * `config` (optional {@link MarkdownImportConfig}) is forwarded to the
-     * converter so custom-tool consumers can map markdown nodes into their tools
-     * (`toolMap`/`onUnknownNode`), toggle GFM, or add micromark/mdast extensions.
-     *
-     * Returns ALL created {@link BlockNode}s in document order — including any the
-     * markdown nested internally (e.g. a table's cell children), not just the
-     * top-level run (this differs from {@link insertTree}, which returns only the
-     * root). Empty or whitespace-only markdown, a dangling `parentId` (checked
-     * again after the async convert, so a parent removed mid-flight also no-ops),
-     * and a converter failure (chunk-load or parse error, swallowed) all return
-     * `[]` and open no transaction. The nodes are fresh-snapshot volatile — read
-     * them now, don't stash them in dep arrays.
-     */
-    insertMarkdown(markdown: string, options?: {
-        parentId?: string | null;
-        position?: InsertPosition;
-        config?: MarkdownImportConfig;
-    }): Promise<BlockNode[]>;
-    /**
-     * Serialize the WHOLE document to a Markdown string — the outbound twin of
-     * core's `blocks.exportMarkdown` (and the read-side counterpart of the
-     * additive {@link insertMarkdown}). Async: the serializer is lazy-loaded, like
-     * the importer. Markdown cannot express every block, so some structure is
-     * dropped (table `colspan`/`rowspan`, heading columns). Returns `''` for an
-     * empty document. Pre-ready: resolves to `''`.
-     */
-    exportMarkdown(): Promise<string>;
-    move(id: string, target: MoveTarget): void;
-    nest(id: string, parentId: string): void;
-    unnest(id: string): void;
-    remove(id: string): void;
-    /**
-     * Update a block's data and/or tunes by id. Delegates to core's async
-     * `blocks.update`, which forms its OWN undo step — the call is NOT wrapped in
-     * `transact` (that would close the group before the async write lands). An
-     * unknown id is a silent no-op; a rejected update is swallowed so it can't
-     * surface as an unhandled rejection. Reads refresh reactively once core emits
-     * 'block changed'. Returns `void`.
-     */
-    update(id: string, data?: BlockToolData, tunes?: {
-        [name: string]: BlockTuneData;
-    }): void;
-    /**
-     * Convert a block to another type ("turn into") by id. Delegates to core's
-     * async `blocks.convert`; both tools must provide a `conversionConfig` or core
-     * rejects — that rejection (and any other) is swallowed so a non-convertible
-     * block is a graceful no-op rather than an unhandled rejection. An unknown id
-     * is a silent no-op. Not wrapped in `transact` (core owns its history step).
-     * Returns `void`.
-     */
-    convert(id: string, newType: string, dataOverrides?: BlockToolData, options?: {
-        caret?: CaretTarget;
-    }): void;
-    transact(fn: () => void): void;
-    /**
-     * Run `fn` as one atomic operation that is NOT captured in the undo history —
-     * the React-surface counterpart of core's `transactWithoutCapture`. Use for
-     * silent auto-repair/normalization that a user's CMD+Z should never step
-     * through. Mutations inside still emit reactively. Pre-ready it just runs `fn`.
-     */
-    transactWithoutCapture(fn: () => void): void;
-    /**
-     * The current block count. Reactive (re-reads on 'block changed'). Pre-ready: 0.
-     */
-    getBlocksCount(): number;
-    /**
-     * The flat index of the block holding the caret, or -1 when none. Pre-ready: -1.
-     */
-    getCurrentBlockIndex(): number;
-    /** The block at a flat index as a snapshot {@link BlockNode}, or null. */
-    getBlockByIndex(index: number): BlockNode | null;
-    /**
-     * The absolute flat index of a block by id, or null when unknown. The
-     * counterpart to {@link getBlockByIndex} — use it to target an off-caret
-     * {@link splitBlock} (whose `insertIndex` is absolute) without the ref. Unknown
-     * ids return null silently (no console warn). Pre-ready: null.
-     */
-    getBlockIndex(id: string): number | null;
-    /**
-     * Read a block's current `data` and `tunes` by id WITHOUT mutating anything —
-     * the synchronous last-extracted view (the same snapshot clipboard ops use).
-     * Makes a client-side duplicate composable from the hook alone: read a node,
-     * then `insert({ type, data, tunes, position })`, no ref escape hatch. Unknown
-     * id returns null. Pre-ready: null.
-     */
-    getBlockData(id: string): {
-        data: BlockToolData;
-        tunes: {
-            [name: string]: BlockTuneData;
-        };
-    } | null;
-    /**
-     * The block whose holder contains/equals `element`, as a snapshot
-     * {@link BlockNode}, or null. Useful for mapping a DOM event target back to a
-     * block.
-     */
-    getBlockByElement(element: HTMLElement): BlockNode | null;
-    /**
-     * Read a tool's default empty data WITHOUT inserting anything — delegates to
-     * core's `composeBlockData`. Async (a tool's data may be composed lazily).
-     * Rejects (via core) for an unknown tool. Pre-ready: resolves to `{}`.
-     */
-    composeBlockData(toolName: string): Promise<BlockToolData>;
-    /**
-     * Replace the WHOLE document with blocks parsed from an HTML string —
-     * delegates to core's `renderFromHTML`. Unlike {@link insertMarkdown} (which is
-     * additive), this CLEARS existing content first, so it's a document-load
-     * primitive, not an insert. Async. Pre-ready: resolves immediately (no-op).
-     */
-    renderFromHTML(html: string): Promise<void>;
-    /**
-     * Insert a flat array of already-serialized {@link OutputBlockData} (the
-     * `save()` shape) directly, honoring each block's `parent`/`content` links —
-     * the raw counterpart of core's `blocks.insertMany`. Use to re-insert a saved
-     * document fragment without reshaping it into {@link TreeInsertSpec}. One
-     * atomic undo step. Returns the created nodes; pre-ready: `[]` (no insert).
-     */
-    insertOutputData(blocks: OutputBlockData[], options?: {
-        index?: number;
-    }): BlockNode[];
-    /**
-     * Atomically split a block: update `currentBlockId` with `currentBlockData`
-     * and insert a new `newBlockType` block at `insertIndex`, as ONE undo step.
-     * Delegates to core's `splitBlock`. Returns the new node, or null pre-ready /
-     * on an unknown id.
-     */
-    splitBlock(currentBlockId: string, currentBlockData: Partial<BlockToolData>, newBlockType: string, newBlockData: BlockToolData, insertIndex: number): BlockNode | null;
-    /**
-     * Insert a single child block under `parentId` at flat `insertIndex`, atomically
-     * (block creation AND parent assignment in ONE undo step) — delegates to core's
-     * `blocks.insertInsideParent`. This is the atomic nested-child creator: prefer it
-     * over `insert()` + `nest()`, which is TWO undo steps. A dangling `parentId` is a
-     * no-op returning `null` (mirrors {@link insert}); an unknown child tool returns
-     * `null`. `childData` defaults to an empty paragraph. Returns the created
-     * {@link BlockNode}, fresh-snapshot volatile — read it now, don't stash it in a
-     * dep array. Pre-ready: `null`.
-     */
-    insertInsideParent(parentId: string, insertIndex: number, childData?: BlockToolData): BlockNode | null;
-    /**
-     * Replace the WHOLE document with blocks parsed from saved {@link OutputData}
-     * (the `save()` shape) — delegates to core's `blocks.render`. Unlike
-     * {@link insertOutputData}/{@link insertMarkdown} (which are ADDITIVE), this
-     * CLEARS existing content first: a document-LOAD primitive, not an insert. The
-     * HTML counterpart is {@link renderFromHTML}. Async. Pre-ready: resolves
-     * immediately (no-op).
-     */
-    render(data: OutputData): Promise<void>;
-    /**
-     * Remove EVERY block from the document — delegates to core's `blocks.clear`. A
-     * document-reset primitive (pairs with {@link render}). Async. Pre-ready:
-     * resolves immediately (no-op).
-     */
-    clear(): Promise<void>;
-    /**
-     * Whether a Yjs sync (undo/redo) is currently in progress — the React mirror of
-     * core's `blocks.isSyncingFromYjs`. A METHOD (not a property) so it reads the
-     * LIVE flag at call time even though the api handle is memoized. Use it to skip
-     * cleanup that would fight Yjs state during an undo/redo. Pre-ready: `false`.
-     */
-    isSyncingFromYjs(): boolean;
+  getById(id: string): BlockNode | null;
+  getChildren(parentId: string | null): BlockNode[];
+  /**
+   * Insert one block; returns the created node or null when rejected (unknown
+   * tool type, dangling `parentId`, or a `replace` whose target is missing). An
+   * explicit `id` that already exists is insert-if-absent (returns the existing
+   * node, creates nothing). Atomic — one undo step. The returned node is
+   * {@link BlockNode}-volatile; read it now, don't put it in a dep array.
+   */
+  insert(spec?: InsertSpec): BlockNode | null;
+  /**
+   * Insert several blocks atomically, in array order, as ONE undo step. Each
+   * spec is a full {@link InsertSpec} (own type/data/parentId/position), routed
+   * through the same single-`insert` path, so per-spec parent assertion and
+   * positioning still apply. Specs that fail to insert (e.g. a dangling
+   * parentId, or a replace whose target is missing) are dropped; the returned
+   * array holds only the successfully created nodes. An empty input is a no-op
+   * (returns `[]`, opens no transaction). Like `insert`, the returned nodes are
+   * fresh-snapshot volatile — read them now, don't stash them in dep arrays.
+   */
+  insertMany(specs: InsertSpec[]): BlockNode[];
+  /**
+   * Insert a pre-built NESTED subtree in ONE atomic operation (one undo step).
+   * Each {@link TreeInsertSpec} node becomes a block; its `children` are inserted
+   * nested under it (recursively, in array order) so the whole hierarchy lands in
+   * a single call — no follow-up `nest` round-trips. Delegates to core's
+   * tree-aware `blocks.insertMany`, which composes the flat DFS pre-order array
+   * honoring each node's `parent`/`content` links.
+   *
+   * Placement is root-only: the root node's `parentId`/`position` position the
+   * whole subtree among existing blocks (default: appended at the document end);
+   * nested children ignore those fields (their parent is their enclosing node). A
+   * dangling root `parentId` is rejected — nothing is inserted and `null` is
+   * returned (mirrors {@link insert}). Returns the root {@link BlockNode}, which
+   * is fresh-snapshot volatile — read it now, don't stash it in a dep array.
+   */
+  insertTree(spec: TreeInsertSpec): BlockNode | null;
+  /**
+   * Convert a Markdown string to blocks and insert them ADDITIVELY at a
+   * position, WITHOUT clearing the document (unlike core's `importMarkdown` /
+   * `renderFromHTML`, which replace the whole document). This is the React
+   * "paste markdown → blocks appear" path.
+   *
+   * Async: the markdown converter is lazy-loaded (kept out of the main bundle),
+   * so this is the ONE async creator in the API — `await` the returned promise.
+   * The whole batch is inserted as a single atomic undo step.
+   *
+   * `position` (default `'end'`) places the converted run among `parentId`'s
+   * children (or root siblings when `parentId` is omitted/null), reusing the
+   * same `start`/`end`/`before`/`after` semantics as {@link insert}.
+   *
+   * `parentId` (default `null` = root) nests the import: every TOP-LEVEL
+   * converted block (one the converter left un-parented) is reparented under
+   * `parentId`, while blocks the markdown nested internally (e.g. table-cell
+   * children) keep their intra-import parent. A dangling `parentId` is a no-op
+   * (returns `[]`, opens no transaction), matching {@link insert}.
+   *
+   * `config` (optional {@link MarkdownImportConfig}) is forwarded to the
+   * converter so custom-tool consumers can map markdown nodes into their tools
+   * (`toolMap`/`onUnknownNode`), toggle GFM, or add micromark/mdast extensions.
+   *
+   * Returns ALL created {@link BlockNode}s in document order — including any the
+   * markdown nested internally (e.g. a table's cell children), not just the
+   * top-level run (this differs from {@link insertTree}, which returns only the
+   * root). Empty or whitespace-only markdown, a dangling `parentId` (checked
+   * again after the async convert, so a parent removed mid-flight also no-ops),
+   * and a converter failure (chunk-load or parse error, swallowed) all return
+   * `[]` and open no transaction. The nodes are fresh-snapshot volatile — read
+   * them now, don't stash them in dep arrays.
+   */
+  insertMarkdown(markdown: string, options?: {
+    parentId?: string | null;
+    position?: InsertPosition;
+    config?: MarkdownImportConfig;
+  }): Promise<BlockNode[]>;
+  /**
+   * Serialize the WHOLE document to a Markdown string — the outbound twin of
+   * core's `blocks.exportMarkdown` (and the read-side counterpart of the
+   * additive {@link insertMarkdown}). Async: the serializer is lazy-loaded, like
+   * the importer. Markdown cannot express every block, so some structure is
+   * dropped (table `colspan`/`rowspan`, heading columns). Returns `''` for an
+   * empty document. Pre-ready: resolves to `''`.
+   */
+  exportMarkdown(): Promise<string>;
+  move(id: string, target: MoveTarget): void;
+  nest(id: string, parentId: string): void;
+  unnest(id: string): void;
+  remove(id: string): void;
+  /**
+   * Update a block's data and/or tunes by id. Delegates to core's async
+   * `blocks.update`, which forms its OWN undo step — the call is NOT wrapped in
+   * `transact` (that would close the group before the async write lands). An
+   * unknown id is a silent no-op; a rejected update is swallowed so it can't
+   * surface as an unhandled rejection. Reads refresh reactively once core emits
+   * 'block changed'. Returns `void`.
+   */
+  update(id: string, data?: BlockToolData, tunes?: {
+    [name: string]: BlockTuneData;
+  }): void;
+  /**
+   * Convert a block to another type ("turn into") by id. Delegates to core's
+   * async `blocks.convert`; both tools must provide a `conversionConfig` or core
+   * rejects — that rejection (and any other) is swallowed so a non-convertible
+   * block is a graceful no-op rather than an unhandled rejection. An unknown id
+   * is a silent no-op. Not wrapped in `transact` (core owns its history step).
+   * Returns `void`.
+   */
+  convert(id: string, newType: string, dataOverrides?: BlockToolData, options?: {
+    caret?: CaretTarget;
+  }): void;
+  transact(fn: () => void): void;
+  /**
+   * Run `fn` as one atomic operation that is NOT captured in the undo history —
+   * the React-surface counterpart of core's `transactWithoutCapture`. Use for
+   * silent auto-repair/normalization that a user's CMD+Z should never step
+   * through. Mutations inside still emit reactively. Pre-ready it just runs `fn`.
+   *
+   * With `options`, the operations are data worked out from the `from` keys of
+   * block `derivedFrom` (a finished upload, for example): they join the undo
+   * entry that wrote those values, as in core.
+   */
+  transactWithoutCapture(fn: () => void, options?: {
+    derivedFrom?: string;
+    from?: readonly string[];
+  }): void;
+  /**
+   * The current block count. Reactive (re-reads on 'block changed'). Pre-ready: 0.
+   */
+  getBlocksCount(): number;
+  /**
+   * The flat index of the block holding the caret, or -1 when none. Pre-ready: -1.
+   */
+  getCurrentBlockIndex(): number;
+  /** The block at a flat index as a snapshot {@link BlockNode}, or null. */
+  getBlockByIndex(index: number): BlockNode | null;
+  /**
+   * The absolute flat index of a block by id, or null when unknown. The
+   * counterpart to {@link getBlockByIndex} — use it to target an off-caret
+   * {@link splitBlock} (whose `insertIndex` is absolute) without the ref. Unknown
+   * ids return null silently (no console warn). Pre-ready: null.
+   */
+  getBlockIndex(id: string): number | null;
+  /**
+   * Read a block's current `data` and `tunes` by id WITHOUT mutating anything —
+   * the synchronous last-extracted view (the same snapshot clipboard ops use).
+   * Makes a client-side duplicate composable from the hook alone: read a node,
+   * then `insert({ type, data, tunes, position })`, no ref escape hatch. Unknown
+   * id returns null. Pre-ready: null.
+   */
+  getBlockData(id: string): {
+    data: BlockToolData;
+    tunes: {
+      [name: string]: BlockTuneData;
+    };
+  } | null;
+  /**
+   * The block whose holder contains/equals `element`, as a snapshot
+   * {@link BlockNode}, or null. Useful for mapping a DOM event target back to a
+   * block.
+   */
+  getBlockByElement(element: HTMLElement): BlockNode | null;
+  /**
+   * Read a tool's default empty data WITHOUT inserting anything — delegates to
+   * core's `composeBlockData`. Async (a tool's data may be composed lazily).
+   * Rejects (via core) for an unknown tool. Pre-ready: resolves to `{}`.
+   */
+  composeBlockData(toolName: string): Promise<BlockToolData>;
+  /**
+   * Replace the WHOLE document with blocks parsed from an HTML string —
+   * delegates to core's `renderFromHTML`. Unlike {@link insertMarkdown} (which is
+   * additive), this CLEARS existing content first, so it's a document-load
+   * primitive, not an insert. Async. Pre-ready: resolves immediately (no-op).
+   */
+  renderFromHTML(html: string): Promise<void>;
+  /**
+   * Insert a flat array of already-serialized {@link OutputBlockData} (the
+   * `save()` shape) directly, honoring each block's `parent`/`content` links —
+   * the raw counterpart of core's `blocks.insertMany`. Use to re-insert a saved
+   * document fragment without reshaping it into {@link TreeInsertSpec}. One
+   * atomic undo step. Returns the created nodes; pre-ready: `[]` (no insert).
+   */
+  insertOutputData(blocks: OutputBlockData[], options?: {
+    index?: number;
+  }): BlockNode[];
+  /**
+   * Atomically split a block: update `currentBlockId` with `currentBlockData`
+   * and insert a new `newBlockType` block at `insertIndex`, as ONE undo step.
+   * Delegates to core's `splitBlock`. Returns the new node, or null pre-ready /
+   * on an unknown id.
+   */
+  splitBlock(currentBlockId: string, currentBlockData: Partial<BlockToolData>, newBlockType: string, newBlockData: BlockToolData, insertIndex: number): BlockNode | null;
+  /**
+   * Insert a single child block under `parentId` at flat `insertIndex`, atomically
+   * (block creation AND parent assignment in ONE undo step) — delegates to core's
+   * `blocks.insertInsideParent`. This is the atomic nested-child creator: prefer it
+   * over `insert()` + `nest()`, which is TWO undo steps. A dangling `parentId` is a
+   * no-op returning `null` (mirrors {@link insert}); an unknown child tool returns
+   * `null`. `childData` defaults to an empty paragraph. Returns the created
+   * {@link BlockNode}, fresh-snapshot volatile — read it now, don't stash it in a
+   * dep array. Pre-ready: `null`.
+   */
+  insertInsideParent(parentId: string, insertIndex: number, childData?: BlockToolData): BlockNode | null;
+  /**
+   * Replace the WHOLE document with blocks parsed from saved {@link OutputData}
+   * (the `save()` shape) — delegates to core's `blocks.render`. Unlike
+   * {@link insertOutputData}/{@link insertMarkdown} (which are ADDITIVE), this
+   * CLEARS existing content first: a document-LOAD primitive, not an insert. The
+   * HTML counterpart is {@link renderFromHTML}. Async. Pre-ready: resolves
+   * immediately (no-op).
+   */
+  render(data: OutputData): Promise<void>;
+  /**
+   * Remove EVERY block from the document — delegates to core's `blocks.clear`. A
+   * document-reset primitive (pairs with {@link render}). Async. Pre-ready:
+   * resolves immediately (no-op).
+   */
+  clear(): Promise<void>;
+  /**
+   * Whether a Yjs sync (undo/redo) is currently in progress — the React mirror of
+   * core's `blocks.isSyncingFromYjs`. A METHOD (not a property) so it reads the
+   * LIVE flag at call time even though the api handle is memoized. Use it to skip
+   * cleanup that would fight Yjs state during an undo/redo. Pre-ready: `false`.
+   */
+  isSyncingFromYjs(): boolean;
+}
+/** The minimal slice of editor.blocks that the snapshot helpers read. */
+interface BlocksReader {
+  getBlocksCount(): number;
+  getBlockByIndex(index: number): {
+    id: string;
+    name: string;
+    parentId: string | null;
+  } | undefined;
+}
+/**
+ * Enumerate the editor's blocks once into BlockNode records, in flat order,
+ * deriving each node's contentIds from the children that name it as parent.
+ */
+declare const snapshotNodes: (reader: BlocksReader) => BlockNode[];
+/** BlocksReader plus id→flat-index lookup. */
+interface IndexReader extends BlocksReader {
+  getBlockIndex(id: string): number | undefined;
+}
+/** Map of block id -> parentId, in flat order. */
+declare const parentMap: (reader: BlocksReader) => Map<string, string | null>;
+/** True if `id` descends from `ancestorId` via the parentId chain. */
+declare const isDescendantOf: (parentOf: Map<string, string | null>, id: string, ancestorId: string) => boolean;
+/**
+ * The flat index of the last block in the contiguous subtree rooted at `index`.
+ * In flat (DFS) order a block's descendants sit immediately after it, so this
+ * walks forward while blocks remain descendants of the block at `index`.
+ * Returns `index` itself when the block has no descendants.
+ */
+declare const subtreeEndIndex: (reader: BlocksReader, index: number) => number;
+/**
+ * The flat index at which a new block should be inserted.
+ *
+ * `replace` flips the meaning of a before/after `position`: under replace the
+ * ref IS the block being overwritten (a "turn into"), not a sibling anchor, so
+ * it resolves to the ref's OWN flat slot regardless of which parent it lives in
+ * — bypassing the sibling-relative parent guard that would otherwise redirect a
+ * nested target to the requested parent's end and replace the wrong block.
+ */
+declare const resolveInsertIndex: (reader: IndexReader, parentId: string | null, position: InsertPosition, replace?: boolean) => number;
+/** The flat toIndex for editor.blocks.move. */
+declare const resolveMoveIndex: (reader: IndexReader, target: MoveTarget) => number;
+/** Adapt the live editor to the IndexReader the snapshot helpers expect. */
+declare const readerFor: (editor: Blok) => IndexReader;
+/**
+ * Stable API returned while the editor is null (before the adapter resolves).
+ * Every read returns empty/null and every MUTATOR is a no-op — EXCEPT
+ * `transact`/`transactWithoutCapture`, which still invoke their callback so a
+ * consumer wrapping conditional work in `transact` still runs that work even
+ * pre-ready.
+ */
+declare const EMPTY_API: UseBlocksApi;
+/**
+ * Does a `block changed` event touch the subtree rooted at `withinId`?
+ *
+ * The reactivity filter behind `useBlocks(editor, { within })` in all three
+ * adapters. Without it every consumer of `useBlocks` re-renders on every change
+ * anywhere in the document — so a container block that only renders its own
+ * children still re-rendered on each keystroke in an unrelated block, and a page
+ * of N such containers turned one keystroke into N re-renders.
+ *
+ * INDETERMINATE READS AS "TOUCHED". The walk resolves ancestry through the LIVE
+ * tree, and a removal commonly emits after the block is already gone, so its
+ * parent chain cannot be read. Answering `false` there would leave a container
+ * rendering a child that no longer exists; answering `true` costs one extra
+ * render pass. Same for a payload with no readable target.
+ *
+ * Ancestry is walked UPWARD one `getById` at a time rather than snapshotted with
+ * `parentMap`: this runs on every emission — i.e. on every keystroke — so it must
+ * cost O(depth), not O(document).
+ * @param editor - the live Blok instance
+ * @param payload - the `block changed` payload
+ * @param withinId - id of the block whose subtree is the scope
+ * @returns true when the change is inside the scope (or cannot be placed)
+ */
+declare const changeTouchesSubtree: (editor: Blok, payload: unknown, withinId: string) => boolean;
+/**
+ * Build the framework-agnostic, id/parentId-relative block-tree API over a LIVE
+ * editor. Mutators route through the editor-level `blocks` API (core's
+ * chokepoints), so undo/redo and Yjs sync are inherited rather than
+ * re-implemented; readers enumerate the live tree on every call.
+ *
+ * This is the shared engine behind both the React (`useSyncExternalStore`) and
+ * Vue (`shallowRef` version) `useBlocks` wrappers — one implementation so the
+ * two adapters cannot drift. Each adapter supplies the `onRead` seam:
+ *
+ * - React leaves it the default no-op: `useSyncExternalStore` re-renders the
+ *   whole component on `block changed`, and the reads run live during that
+ *   render, so no per-call dependency tracking is needed.
+ * - Vue passes `() => { void version.value }` so a read inside a `computed` /
+ *   template touches the reactive version ref and re-runs on every structural
+ *   mutation.
+ *
+ * `onRead` is invoked at the top of every read method; mutators never call it.
+ * The editor MUST be the raw (non-proxied) instance — adapters `toRaw`-unwrap
+ * before calling, so a Vue reactive proxy never reaches core (Risk R0).
+ *
+ * @param editor - the live Blok instance (never null; callers gate on EMPTY_API)
+ * @param onRead - reactivity seam called at the start of each read (default no-op)
+ */
+declare const createBlocksApiForEditor: (editor: Blok, onRead?: () => void) => UseBlocksApi;
+/**
+ * Normalized shape of the `readOnly` config option
+ */
+interface NormalizedReadOnlyConfig {
+  enabled: boolean;
+  hideControls: boolean;
 }
-
+/**
+ * Single source of truth for interpreting the `readOnly` config option.
+ * The object form always means read-only is enabled.
+ * @param value - raw `readOnly` value from BlokConfig
+ */
+declare function normalizeReadOnlyConfig(value: boolean | ReadOnlyModeConfig | undefined): NormalizedReadOnlyConfig;
+/**
+ * Structural deep equality for JSON-like values (Blok `OutputData`).
+ *
+ * Framework-agnostic: shared by the React and Angular adapters to dedupe
+ * reactive `data` updates so identical content does not trigger a redundant
+ * re-render that would clobber the caret/selection. Handles the value shapes
+ * that appear in editor data: plain objects, arrays, and primitives (including
+ * `null`/`undefined`).
+ * @param a - first value to compare
+ * @param b - second value to compare
+ * @returns true when both values are structurally equal
+ */
+declare function deepEqual(a: unknown, b: unknown): boolean;
+type AnyOutputData = OutputData | LooseOutputData | null | undefined;
+/**
+ * Options for {@link equalsOutputData}.
+ */
+interface EqualsOutputDataOptions {
+  /**
+   * Ignore empty default blocks on both sides before comparing. A fresh editor
+   * always seeds one empty default paragraph, so a pristine document
+   * (`[{ type: 'paragraph', data: { text: '' } }]`) does not content-equal a
+   * saved-empty baseline (`[]`) by default. Turn this on for dirty-vs-baseline
+   * checks ("has the user actually typed anything?"): empty blocks of the
+   * default paragraph tool are dropped from both documents first, so pristine
+   * scaffolding and trailing empty lines don't register as a change. Empty
+   * NON-default blocks (a content-less divider, an empty image) are kept — they
+   * are meaningful content.
+   */
+  ignoreEmptyDefaultBlocks?: boolean;
+}
+/**
+ * Structural equality for saved documents. Compares the `blocks` arrays
+ * deeply; the volatile `time` and `version` envelope fields are ignored, so a
+ * document round-tripped through `save()` compares equal to its echo. Block
+ * ids are compared only when both sides carry one — the editor mints fresh
+ * ids for id-less content, so a legacy document still equals its saved echo.
+ * Edit metadata (`lastEditedAt`/`lastEditedBy`) is ignored for the same reason:
+ * it records who touched a block and when, not what it says. Nullish documents
+ * compare equal to `{ blocks: [] }`.
+ *
+ * Pass `{ ignoreEmptyDefaultBlocks: true }` for dirty-vs-baseline checks so a
+ * pristine editor (one empty default paragraph) equals a saved-empty baseline —
+ * see {@link EqualsOutputDataOptions}.
+ * @param a - first document to compare
+ * @param b - second document to compare
+ * @param options - comparison options
+ * @returns true when both documents hold structurally equal blocks
+ */
+declare function equalsOutputData(a: AnyOutputData, b: AnyOutputData, options?: EqualsOutputDataOptions): boolean;
+/**
+ * A bounded window of the editor's recently emitted `onSave` payloads, used by
+ * the framework adapters to recognize controlled-`data` echoes. Deduping
+ * against only the LAST emitted payload is not enough: a host that persists on
+ * save and refetches can hand the adapter a STALE echo — an earlier save
+ * arriving after a newer one already replaced the baseline — and re-rendering
+ * it would clobber the caret and any content typed since. Matching is
+ * structural ({@link equalsOutputData}), so envelopes reshaped in transit
+ * (fresh `time`, stripped ids) still count as echoes.
+ * @param capacity - number of payloads retained before the oldest is evicted
+ * @returns the echo window
+ */
+declare function createEmittedEchoWindow(capacity?: number): {
+  /** Records a payload the editor emitted via `onSave`. */
+  record(data: OutputData | LooseOutputData): void;
+  /** True when the document content-equals any recorded payload. */
+  matches(data: AnyOutputData): boolean;
+  /** Forgets all recorded payloads (external content took over). */
+  clear(): void;
+};
+/**
+ * A shared, deeply frozen empty document. Consumers persisting editor content
+ * repeatedly hand-write `{ blocks: [] }` for cleared/pristine baselines; this
+ * is the canonical value to use instead. Frozen (blocks array included) so a
+ * shared reference can never be mutated into a stale non-empty baseline.
+ */
+declare const EMPTY_OUTPUT_DATA: OutputData;
+/**
+ * Maps a controlled `data` value to something the editor's `render()` accepts.
+ * A whole-document `null` — a controlled "clear to empty" — becomes
+ * `{ blocks: [] }`; any real document passes through untouched.
+ *
+ * The framework adapters (React/Vue/Angular) route their reactive `data` path
+ * through this so a `null` never reaches `render()`, whose strict guard reads
+ * `data.blocks` and would throw on `null`. `undefined` (uncontrolled) is handled
+ * by the adapters before this point, so it is intentionally not an input here.
+ * @param data - a controlled document, or `null` for an empty document
+ * @returns a document `render()` can consume
+ */
+declare function toRenderableData(data: OutputData | LooseOutputData | null): OutputData | LooseOutputData;
+/**
+ * Normalizes blocks from the loose wire shape into the strict saved shape at
+ * the editor's input boundaries: a `null`/missing `data` becomes `{}`, a
+ * `null`/empty `id` is dropped so the block factory generates a fresh one, and
+ * nullish/empty hierarchy references (`parent`, `content`) are dropped so a
+ * root-level, childless block is spelled the one way the editor and `save()`
+ * both spell it — absent. Idempotent — strict blocks pass through unchanged
+ * (shallow-copied).
+ * @param blocks - blocks in either the strict or the loose wire shape
+ * @returns blocks in the strict saved shape
+ */
+declare function normalizeOutputBlocks(blocks: Array<OutputBlockData | LooseOutputBlockData>): OutputBlockData[];
+/**
+ * Normalizes a whole loose wire document into the strict saved
+ * {@link OutputData} shape at an input boundary. A nullish document becomes
+ * `{ blocks: [] }`; `null` envelope fields (`time`/`version`) are dropped and a
+ * non-empty `id` is kept; each
+ * block is passed through {@link normalizeOutputBlocks}, so `null`/missing
+ * `data` becomes `{}`, `null`/empty ids are dropped for regeneration and
+ * nullish/empty `parent`/`content` references are dropped as absent.
+ *
+ * Unlike a hand-written `blocks.map(...)` mapper, this preserves every block
+ * passthrough field — `tunes`, real `parent`/`content` references, `indent`,
+ * edit metadata — so a backend DTO can be turned into strict `OutputData`
+ * without silently losing hierarchy or tunes. Idempotent: a strict document
+ * passes through unchanged (shallow-copied).
+ * @param data - a document in the strict or loose wire shape, or nullish
+ * @returns the document in the strict saved shape
+ */
+declare function normalizeOutputData(data: AnyOutputData): OutputData;
+/**
+ * True when the document carries no user content: it is nullish, has no
+ * blocks, or every block's data holds only empty values (see
+ * {@link isEmptyValue}). Note that content-less visual blocks (e.g. a divider,
+ * whose data is `{}`) count as empty — check `blocks.length` when mere block
+ * presence matters.
+ * @param data - document to inspect
+ * @returns true when the document carries no user content
+ */
+declare function isEmptyOutputData(data: AnyOutputData): boolean;
 /** One field of a block's prop schema. */
 interface PropSchemaEntry {
-    /** Default value, used when the incoming data omits this key. */
-    default: unknown;
-    /** Optional allowed values (advisory; not enforced at runtime in v1). */
-    values?: readonly unknown[];
+  /** Default value, used when the incoming data omits this key. */
+  default: unknown;
+  /** Optional allowed values (advisory; not enforced at runtime in v1). */
+  values?: readonly unknown[];
 }
 /**
  * Declarative data shape. The keys here are EXACTLY the keys `save()` returns to
@@ -674,7 +1040,504 @@ interface PropSchemaEntry {
  * written as its explicit default, never dropped).
  */
 type PropSchema = Record<string, PropSchemaEntry>;
-
+/**
+ * Fill a data object against the schema: every schema key present, incoming
+ * value when defined else the schema default, and ONLY schema keys (so `save()`
+ * is never partial). Returns a frozen plain object — safe to hand straight to
+ * core's per-key Yjs sync.
+ */
+declare const fillDefaults: <Data>(schema: PropSchema, data: Record<string, unknown>) => Readonly<Data>;
+/**
+ * Every child slot carries one of these — first-party containers and every
+ * adapter's `<BlockChildren>` alike. `BlockHierarchy` reads the same selector,
+ * so the two sides agree on which blocks own a slot.
+ */
+declare const CHILD_SLOT_SELECTOR = "[data-blok-toggle-children], [data-blok-nested-blocks]";
+/**
+ * Parents that place their children themselves (per cell / per view). Their
+ * descendants must never be pulled into an enclosing slot.
+ */
+declare const SELF_PLACING_PARENTS: ReadonlySet<string>;
+/**
+ * A slotless block renders its children as flat sibling holders right after
+ * itself, in whatever slot holds the block — the same as nesting at root.
+ * @param block - the block to test
+ */
+declare const isSlotless: (block: {
+  holder: HTMLElement;
+  name?: string;
+}) => boolean;
+/**
+ * The blocks a container slot hosts: its children, each followed by the
+ * descendants of a slotless child (depth-first, flat order). A child that owns a
+ * slot keeps its own descendants.
+ * @param children - the container block's model children, in model order
+ * @param getChildren - model children of a block, by id
+ */
+declare const withSlotlessDescendants: <T extends {
+  holder: HTMLElement;
+  id?: string;
+  name?: string;
+}>(children: T[], getChildren: (id: string) => T[]) => T[];
+/**
+ * Mount child block holders into a container, skipping children that are
+ * already in place or claimed by another nested-blocks container.
+ *
+ * Used by toggle, header, column, and callout tools — and by the React, Vue and
+ * Angular block adapters — to reconcile child holders during the `rendered()`
+ * lifecycle hook. It is the standing DOM↔model reconciler for container blocks:
+ * safe to call on every render, and the only thing that heals a child holder
+ * that core parked outside the container while the container's own slot had not
+ * been created yet.
+ * @param container - the container element child holders belong in; usually the
+ *   element carrying `data-blok-nested-blocks`.
+ * @param children - the container block's MODEL children, in model order (e.g.
+ *   `api.blocks.getChildren(blockId)`).
+ */
+declare const mountChildBlocks: (container: HTMLElement, children: {
+  holder: HTMLElement;
+}[]) => void;
+/**
+ * One child's decoration: attribute name → value. `null`/`undefined` removes the
+ * attribute; a boolean or number is stringified (so `false` writes
+ * `data-active="false"`, which CSS can select, rather than dropping the hook).
+ */
+type ChildAttributes$1 = Record<string, string | number | boolean | null | undefined>;
+/** The minimum a child must expose for a decoration pass. */
+interface DecoratableChild {
+  id: string;
+  holder: HTMLElement;
+}
+/**
+ * A per-child decorator: what to write for the child at `index`.
+ *
+ * Generic over the child so an adapter can declare its decorators in terms of the
+ * full `BlockAPI` its authors receive. A non-generic `(child: DecoratableChild)`
+ * parameter would REJECT those: a function that demands a full BlockAPI is not
+ * assignable to one promising to accept the structural minimum.
+ */
+type ChildAttributesFn$1<Child extends DecoratableChild = DecoratableChild> = (child: Child, index: number) => ChildAttributes$1;
+/** What the previous decoration pass wrote for one child, so it can be undone. */
+interface StampedChild {
+  /** The element written to — a holder for one ledger, a content wrapper for the other. */
+  target: HTMLElement;
+  names: string[];
+}
+/** The ledgers a container keeps between passes; create one per child slot. */
+interface ChildDecorationLedger {
+  holders: Map<string, StampedChild>;
+  contents: Map<string, StampedChild>;
+}
+/**
+ * A fresh pair of ledgers for one container's child slot.
+ * @returns empty holder/content ledgers
+ */
+declare const createChildDecorationLedger: () => ChildDecorationLedger;
+/**
+ * Decorate a container's children: named attributes on each child's HOLDER and,
+ * separately, on each child's `[data-blok-element-content]` wrapper.
+ *
+ * The single implementation behind the React, Vue and Angular per-child
+ * decoration channels, so the three cannot drift on which element a hook lands
+ * on or on when a dropped hook is cleaned up.
+ *
+ * BOTH levels exist because core's child-holder decoration law blesses both, and
+ * a container needs both: the holder is the child's outer box (rails, indices,
+ * hover states), while the content wrapper is where the child's own text box
+ * begins — which is what a numbered rail or a connector line has to align to.
+ * With only the holder reachable, a container had to encode core's wrapper chain
+ * in its own CSS (`[data-step] > [data-blok-element-content] > …`) and broke
+ * whenever that chain changed. Neither hook may introduce an element: holders
+ * stay DIRECT children of the slot because core's reparenting and caret
+ * sibling checks compare `holder.parentElement` by identity.
+ *
+ * Both are inert with respect to change tracking: core's mutation filter drops a
+ * holder- or content-targeted attribute record for the CHILD block (both are
+ * ancestors of the child's tool element, not descendants) and scores it
+ * mutation-free for the CONTAINER (whose own `data-blok-mutation-free` host is
+ * the nearest such ancestor).
+ * @param ledger - the slot's ledgers from {@link createChildDecorationLedger}
+ * @param children - the container's model children, in model order
+ * @param decorators - the authored per-child decorators
+ * @param decorators.childAttributes - written on each child's holder
+ * @param decorators.childContentAttributes - written on each child's content wrapper
+ */
+declare const applyChildDecoration: <Child extends DecoratableChild>(ledger: ChildDecorationLedger, children: Child[], decorators: {
+  childAttributes?: ChildAttributesFn$1<Child>;
+  childContentAttributes?: ChildAttributesFn$1<Child>;
+}) => void;
+/**
+ * Centralized data attributes used across the Blok editor.
+ * This is the single source of truth for all data-blok-* attributes.
+ *
+ * Exported as Blok.DATA_ATTR for users.
+ *
+ * Naming convention:
+ * - Remove 'data-blok-' prefix and convert to camelCase
+ * - Global attributes: hidden, disabled, focused
+ * - Component prefixed: popover, popoverItem, toolbar, etc.
+ */
+declare const DATA_ATTR: {
+  /** Interface type identifier (blok, inline-toolbar, tooltip) */
+  readonly interface: "data-blok-interface";
+  /** Block element wrapper */
+  readonly element: "data-blok-element";
+  /** Block element content wrapper */
+  readonly elementContent: "data-blok-element-content";
+  /** Editor wrapper container */
+  readonly editor: "data-blok-editor";
+  /** Per-instance discriminator on the editor wrapper (a monotonic counter, as a
+   *  string). Two editors on one page share every other scope attribute, so this
+   *  is what lets a page-level stylesheet — Blok's own injected `style.fontSize`
+   *  sheet, or a host rule — address ONE editor. Public styling hook. */
+  readonly instance: "data-blok-instance";
+  /** Redactor zone */
+  readonly redactor: "data-blok-redactor";
+  /** Present on the editor wrapper once a `blocks.render()` batch has finished
+   *  inserting blocks into the DOM; removed while a re-render is in flight.
+   *  Acts as a stable render-readiness gate for consumers (e.g. E2E waits). */
+  readonly rendered: "data-blok-rendered";
+  /** Present on the editor wrapper while the loading skeleton owns it.
+   *  Public styling hook. */
+  readonly loading: "data-blok-loading";
+  /** The loading skeleton overlay (a wrapper child, never inside the redactor). */
+  readonly loadingSkeleton: "data-blok-loading-skeleton";
+  /** One skeleton row; the value is its kind: heading | paragraph | list. */
+  readonly skeletonBar: "data-blok-skeleton-bar";
+  /** Blok version number stamped on the editor wrapper (e.g. '1.10.0', 'dev').
+   *  Consumed by browser extensions to identify the running version. */
+  readonly version: "data-blok-version";
+  /** Block unique identifier */
+  readonly id: "data-blok-id";
+  readonly pageId: "data-blok-page-id";
+  /** Block component/tool type */
+  readonly component: "data-blok-component";
+  /** Tool type attribute */
+  readonly tool: "data-blok-tool";
+  readonly blockContextMenu: "data-blok-block-context-menu";
+  /** Block nesting depth (derived from the parentId chain) */
+  readonly depth: "data-blok-depth";
+  /** Flat list-nesting indentation level (0 = root); tool-agnostic, mirrors list depth */
+  readonly indent: "data-blok-indent";
+  /** Header tool's heading level (1-6). Public styling hook — keyed by level rather
+   *  than by tag name, so a level remapped to a custom tag via `levelOverrides[n].tag`
+   *  (types/tools/header.d.ts) still matches its level's typography rules. */
+  readonly headingLevel: "data-blok-heading-level";
+  /** Element is hidden from view */
+  readonly hidden: "data-blok-hidden";
+  /** Element is disabled and non-interactive */
+  readonly disabled: "data-blok-disabled";
+  /** Element is focused via keyboard navigation */
+  readonly focused: "data-blok-focused";
+  /** On a popover once a navigation key moved its cursor; gates the focus ring */
+  readonly keyboardNavigated: "data-blok-keyboard-navigated";
+  /** Block is selected */
+  readonly selected: "data-blok-selected";
+  /** On a block's spotlight target while it is being pointed out (Show in the failed-image notice) */
+  readonly spotlight: "data-blok-spotlight";
+  /** Marks the element inside a block that Show points at, e.g. the image's error card */
+  readonly spotlightTarget: "data-blok-spotlight-target";
+  /** Marks the control inside a spotlight target that receives focus, e.g. Retry */
+  readonly spotlightFocus: "data-blok-spotlight-focus";
+  /** Block is stretched */
+  readonly stretched: "data-blok-stretched";
+  /** Editor or element is empty */
+  readonly empty: "data-blok-empty";
+  /** Present on the editor wrapper while read-only mode is active.
+   *  Public styling hook — lets hosts key rules off the editing state
+   *  without JS. Deliberately does NOT collapse the gutter: plain
+   *  read-only still shows the block-hover copy-link control there, and
+   *  in-place readOnly.set() flips must not shift the layout. */
+  readonly readonly: "data-blok-readonly";
+  /** Present on the editor wrapper while read-only mode hides ALL editor
+   *  controls (readOnly: { hideControls: true }). Public styling hook —
+   *  drives the gutter auto-collapse for genuinely chromeless read-only. */
+  readonly controlsHidden: "data-blok-controls-hidden";
+  /** Present on the editor wrapper when config.hideToolbar is true.
+   *  Public styling hook — drives the gutter auto-collapse (the gutter
+   *  exists solely to house the toolbar's +/⠿ controls). */
+  readonly toolbarHidden: "data-blok-toolbar-hidden";
+  /** Which gutter the floating block controls occupy: 'left' (default,
+   *  inline-start) or 'right' (inline-end). Written on the editor wrapper from
+   *  config.toolbarPosition and kept in sync by `toolbar.setPosition()`.
+   *  Public styling hook — drives the gutter swap and the actions-bar side. */
+  readonly toolbarPosition: "data-blok-toolbar-position";
+  /** Content alignment mode (left, center, right) */
+  readonly contentAlign: "data-blok-content-align";
+  /** Right-to-left mode */
+  readonly rtl: "data-blok-rtl";
+  /** Editor content width mode (present with value "full" for wide mode; absent = narrow) */
+  readonly width: "data-blok-width";
+  /** Present on the editor wrapper when config.style.nativeSelection is true.
+   *  Public styling hook — disables Blok's ::selection repaint (preflight.css)
+   *  and re-points the fake-background highlight at the UA Highlight color
+   *  (colors.css), so selection falls back to native/host-defined colors. */
+  readonly nativeSelection: "data-blok-native-selection";
+  /** Present on the editor wrapper while a cross-block TEXT selection is painted.
+   *  Suppresses the engine's own ::selection paint (main.css) so the
+   *  ::highlight() sub-ranges are the only thing drawn — Chromium and Firefox
+   *  paint such a range natively too and would otherwise double it up. */
+  readonly crossSelection: "data-blok-cross-selection";
+  /** Block is being dragged */
+  readonly dragging: "data-blok-dragging";
+  /** Multiple blocks being dragged */
+  readonly draggingMulti: "data-blok-dragging-multi";
+  /** Block is being duplicated (Alt+drag) */
+  readonly duplicating: "data-blok-duplicating";
+  /** Drag handle element */
+  readonly dragHandle: "data-blok-drag-handle";
+  /** Toolbar element */
+  readonly toolbar: "data-blok-toolbar";
+  /** The floating block-controls bar (plus button + drag/settings handle)
+   *  inside the toolbar. Public styling hook — the side it docks to is driven
+   *  from the wrapper's `data-blok-toolbar-position`. */
+  readonly toolbarActions: "data-blok-toolbar-actions";
+  /** Settings toggler button */
+  readonly settingsToggler: "data-blok-settings-toggler";
+  /** Toolbox is open */
+  readonly toolboxOpened: "data-blok-toolbox-opened";
+  /** Block settings is open */
+  readonly blockSettingsOpened: "data-blok-block-settings-opened";
+  /** Element is opened (generic) */
+  readonly opened: "data-blok-opened";
+  /** Root popover element */
+  readonly popover: "data-blok-popover";
+  /** Popover container wrapper */
+  readonly popoverContainer: "data-blok-popover-container";
+  /** Popover items list */
+  readonly popoverItems: "data-blok-popover-items";
+  /** Custom, engine-independent scrollbar thumb overlaid on the popover items */
+  readonly popoverScrollbar: "data-blok-popover-scrollbar";
+  /** Stamped on the custom scrollbar thumb while it is being dragged (keeps it revealed) */
+  readonly popoverScrollbarDragging: "data-blok-dragging";
+  /** Stamped on a scroll container while it is actively scrolling (reveals the auto-hidden scrollbar thumb) */
+  readonly scrolling: "data-blok-scrolling";
+  /** Popover overlay element */
+  readonly popoverOverlay: "data-blok-popover-overlay";
+  /** Popover custom content area */
+  readonly popoverCustomContent: "data-blok-popover-custom-content";
+  /** Popover custom class */
+  readonly popoverCustomClass: "data-blok-popover-custom-class";
+  /** Inline popover variant */
+  readonly popoverInline: "data-blok-popover-inline";
+  /** Popover is open */
+  readonly popoverOpened: "data-blok-popover-opened";
+  /** Popover opens upward */
+  readonly popoverOpenTop: "data-blok-popover-open-top";
+  /** Popover opens leftward */
+  readonly popoverOpenLeft: "data-blok-popover-open-left";
+  /** Nested popover indicator */
+  readonly nested: "data-blok-nested";
+  /** Nesting level value */
+  readonly nestedLevel: "data-blok-nested-level";
+  /** Group label for promoted search results from nested children */
+  readonly promotedGroupLabel: "data-blok-promoted-group-label";
+  /** A nested child shown in the host menu's search results. The convert-menu styles skip it, so the host keeps its own layout. */
+  readonly promotedItem: "data-blok-promoted-item";
+  /** Group label for top-level matches in search results */
+  readonly topLevelGroupLabel: "data-blok-top-level-group-label";
+  /** Header container */
+  readonly popoverHeader: "data-blok-popover-header";
+  /** Header text element */
+  readonly popoverHeaderText: "data-blok-popover-header-text";
+  /** Back button in nested popover */
+  readonly popoverHeaderBackButton: "data-blok-popover-header-back-button";
+  /** Item container */
+  readonly popoverItem: "data-blok-popover-item";
+  /** Item icon wrapper */
+  readonly popoverItemIcon: "data-blok-popover-item-icon";
+  /** Chevron icon for nested items */
+  readonly popoverItemIconChevronRight: "data-blok-popover-item-icon-chevron-right";
+  /** Item title text */
+  readonly popoverItemTitle: "data-blok-popover-item-title";
+  /** Item secondary title */
+  readonly popoverItemSecondaryTitle: "data-blok-popover-item-secondary-title";
+  /** Item is active/selected */
+  readonly popoverItemActive: "data-blok-popover-item-active";
+  /** Item's child menu is currently open — keeps the trigger looking selected */
+  readonly popoverItemChildrenOpen: "data-blok-popover-item-children-open";
+  /** Confirmation state */
+  readonly popoverItemConfirmation: "data-blok-popover-item-confirmation";
+  /** Disable hover styling */
+  readonly popoverItemNoHover: "data-blok-popover-item-no-hover";
+  /** Disable focus handling */
+  readonly popoverItemNoFocus: "data-blok-popover-item-no-focus";
+  /** Destructive action item (e.g. delete) */
+  readonly popoverItemDestructive: "data-blok-popover-item-destructive";
+  /** Separator item */
+  readonly popoverItemSeparator: "data-blok-popover-item-separator";
+  /** Separator line element */
+  readonly popoverItemSeparatorLine: "data-blok-popover-item-separator-line";
+  /** HTML-based item */
+  readonly popoverItemHtml: "data-blok-popover-item-html";
+  /** Item has child menu */
+  readonly hasChildren: "data-blok-has-children";
+  /** Item name identifier */
+  readonly itemName: "data-blok-item-name";
+  /** No search results shown */
+  readonly nothingFoundDisplayed: "data-blok-nothing-found-displayed";
+  /** Selection overlay */
+  readonly overlay: "data-blok-overlay";
+  /** Overlay container */
+  readonly overlayContainer: "data-blok-overlay-container";
+  /** Selection rectangle */
+  readonly overlayRectangle: "data-blok-overlay-rectangle";
+  /** Overlay is hidden */
+  readonly overlayHidden: "data-blok-overlay-hidden";
+  /** Fake cursor indicator */
+  readonly fakeCursor: "data-blok-fake-cursor";
+  /** Fake background for selection */
+  readonly fakeBackground: "data-blok-fake-background";
+  /** Auto-scroll zone (top/bottom) */
+  readonly scrollZone: "data-blok-scroll-zone";
+  /** Scroll is locked */
+  readonly scrollLocked: "data-blok-scroll-locked";
+  /** Hard scroll lock */
+  readonly scrollLockedHard: "data-blok-scroll-locked-hard";
+  /** Shadow caret element */
+  readonly shadowCaret: "data-blok-shadow-caret";
+  /** Placeholder text */
+  readonly placeholder: "data-blok-placeholder";
+  /** Active placeholder text */
+  readonly placeholderActive: "data-blok-placeholder-active";
+  /** The columns row rendered by the column_list tool (the flex container).
+   *  Public styling hook — its direct `[data-blok-element]` children are the
+   *  column holders, whose shrink floor reads `--blok-column-min-width` and
+   *  whose gutter reads `--blok-column-gutter`. */
+  readonly columns: "data-blok-columns";
+  /** A single column inside a columns row. */
+  readonly column: "data-blok-column";
+  /** Drag-to-resize separator between two adjacent columns. Present only in
+   *  edit mode — the separators ARE the gutter there. */
+  readonly columnResizer: "data-blok-column-resizer";
+  /** Present on a columns row whose gutter comes from the container's own
+   *  column-gap instead of from resizer elements. Set in read-only mode, where
+   *  no resizers are built — the discriminator between an editable row and a
+   *  published one. */
+  readonly columnsStaticGutter: "data-blok-columns-static-gutter";
+  /** Container that hosts nested block holders (table cells, toggle/callout/header children).
+   *  Used as a universal guard: before moving a block holder via appendChild,
+   *  check `holder.closest([nestedBlocks])` — if truthy, the holder is already
+   *  claimed by another container and must not be stolen. */
+  readonly nestedBlocks: "data-blok-nested-blocks";
+  /** A drop zone. Empty value: an empty container's placeholder (an empty
+   *  tab); while the block's own holder shows one without the `hidden` class,
+   *  a drop on the block nests the dragged blocks as its first children.
+   *  A block id (a tab pill): a drop on the zone appends the dragged blocks
+   *  as the LAST children of that block. */
+  readonly dropInto: "data-blok-drop-into";
+  /** Set by core on a named drop zone while it is the drop target. */
+  readonly dropIntoActive: "data-blok-drop-into-active";
+  /** A container's empty-state hint that stands in for its first child block
+   *  (empty tab, empty toggle body). It is not a block, so hovering or pressing
+   *  it shows no block toolbar; the block a click creates gets its own. */
+  readonly childStandIn: "data-blok-child-stand-in";
+  /** Element excluded from mutation tracking */
+  readonly mutationFree: "data-blok-mutation-free";
+  /** Tool UI inside a block that is not the user's content (a list marker, a
+   *  checkbox, a code block's language button and line numbers). `Block.isEmpty`
+   *  and the block's copied HTML skip it. Never put it on an element that holds
+   *  child blocks or the user's text: that content would be skipped too. */
+  readonly chrome: "data-blok-chrome";
+  /** Marks a subtree whose keyboard belongs to the Tool that rendered it, not to
+   *  the editor. Blok's block-level keydown/keyup handling stands down entirely
+   *  for events originating inside it — Escape, Tab, the arrows, "/" and the
+   *  Enter/Backspace/Delete structural keys all reach the element untouched.
+   *
+   *  Blok already exempts native `<input>`/`<textarea>` from the STRUCTURAL keys
+   *  (Enter/Backspace/Delete and "/") because those are contenteditable-shaped
+   *  and would splice the document around a form field. Escape/Tab/arrows are
+   *  deliberately NOT exempt — they are how a user leaves a field. That default
+   *  is right for a one-line title input and wrong for a field with its own
+   *  keyboard semantics (Tab between sub-fields, Escape to cancel an edit, arrows
+   *  to walk a suggestion list), which is exactly what this attribute is for.
+   *  Public authoring hook. */
+  readonly keyboardOwner: "data-blok-keyboard-owner";
+  /** Marks a subtree whose links belong to the tool: Blok's link hover card
+   *  and link-click navigation stand down inside it. For a link the tool opens
+   *  and previews itself (the page block). Public authoring hook. */
+  readonly linkOwner: "data-blok-link-owner";
+  /** Block has navigation focus */
+  readonly navigationFocused: "data-blok-navigation-focused";
+  /** Flipper navigation target */
+  readonly flipperNavigationTarget: "data-blok-flipper-navigation-target";
+  /** Inline toolbar enabled on external element */
+  readonly inlineToolbar: "data-blok-inline-toolbar";
+  /** Link tool is active */
+  readonly linkToolActive: "data-blok-link-tool-active";
+  /** Link tool unlink mode */
+  readonly linkToolUnlink: "data-blok-link-tool-unlink";
+  /** Link tool input is opened */
+  readonly linkToolInputOpened: "data-blok-link-tool-input-opened";
+  /** Bold collapsed length tracking */
+  readonly boldCollapsedLength: "data-blok-bold-collapsed-length";
+  /** Bold collapsed active state */
+  readonly boldCollapsedActive: "data-blok-bold-collapsed-active";
+  /** Bold previous length tracking */
+  readonly boldPrevLength: "data-blok-bold-prev-length";
+  /** Bold leading whitespace */
+  readonly boldLeadingWs: "data-blok-bold-leading-ws";
+  /** Bold marker */
+  readonly boldMarker: "data-blok-bold-marker";
+  /** Tooltip is shown */
+  readonly shown: "data-blok-shown";
+  /** Tooltip placement */
+  readonly placement: "data-blok-placement";
+  /** Bounce in animation */
+  readonly bounceIn: "data-blok-bounce-in";
+  /** Live region announcer */
+  readonly announcer: "data-blok-announcer";
+  /** Stub block element */
+  readonly stub: "data-blok-stub";
+  /** Stub info section */
+  readonly stubInfo: "data-blok-stub-info";
+  /** Stub title */
+  readonly stubTitle: "data-blok-stub-title";
+  /** Stub subtitle */
+  readonly stubSubtitle: "data-blok-stub-subtitle";
+  /** Slash search active on content editable */
+  readonly slashSearch: "data-blok-slash-search";
+  /** Test identifier (for E2E tests) */
+  readonly testid: "data-blok-testid";
+  /** Force hover state (for tests/storybook) */
+  readonly forceHover: "data-blok-force-hover";
+};
+/**
+ * Type for DATA_ATTR keys
+ */
+type DataAttrKey = keyof typeof DATA_ATTR;
+/**
+ * Type for DATA_ATTR values
+ */
+type DataAttrValue = (typeof DATA_ATTR)[DataAttrKey];
+/**
+ * Helper function to create a CSS selector from an attribute
+ *
+ * @param attr - The data attribute name from DATA_ATTR
+ * @param value - Optional value for the attribute (defaults to presence selector)
+ * @returns CSS selector string
+ *
+ * @example
+ * createSelector(DATA_ATTR.element) // '[data-blok-element]'
+ * createSelector(DATA_ATTR.selected, true) // '[data-blok-selected="true"]'
+ * createSelector(DATA_ATTR.tool, 'paragraph') // '[data-blok-tool="paragraph"]'
+ */
+declare const createSelector: (attr: DataAttrValue, value?: string | boolean) => string;
+/**
+ * Fired when a CONTAINER block's child holders have been mounted into its
+ * child slot — the moment the child DOM has settled and a caret set into a
+ * freshly inserted child sticks.
+ *
+ * Emitted by the React, Vue and Angular block adapters, whose portals commit a
+ * frame AFTER core's `rendered()` hook; a vanilla container tool mounts its
+ * children synchronously inside `rendered()`, so for those `block:rendered`
+ * already means "settled". It fires on every reconciliation pass of the slot,
+ * not only the first, so treat it as a settle signal rather than a change
+ * signal.
+ *
+ * Public event name: `block:childrenMounted`.
+ */
+declare const BlockChildrenMounted = "block:childrenMounted";
 /**
  * Every STATIC member of core's block-tool contract an Angular block may declare
  * for itself — `ownsChildren`, `keepsChildrenOnEnter`, `conversionConfig`,
@@ -694,117 +1557,126 @@ type BlockToolStatics = Omit<BlockToolConstructable, 'toolbox' | 'isReadOnlySupp
  * off its own `BlockAPI`.
  */
 interface AngularBlockMountedContext {
-    /**
-     * Why this block instance was constructed: a CREATION origin (`user`, `api`,
-     * `convert`) means the author just made it, so seeding default children is
-     * correct; a RESTORE origin (`load`, `replay`, `paste`) means the document
-     * already says what the children are. `probe` is an off-tree instance built
-     * only to read a tool's default data — it must not touch the block tree at
-     * all. Defaults to `'api'` when the constructor was handed no origin.
-     */
-    origin: BlockOrigin;
-    /** The editor-level API (`api.blocks`, `api.caret`, `api.events`…). */
-    api: API;
+  /**
+   * Why this block instance was constructed: a CREATION origin (`user`, `api`,
+   * `convert`) means the author just made it, so seeding default children is
+   * correct; a RESTORE origin (`load`, `replay`, `paste`) means the document
+   * already says what the children are. `probe` is an off-tree instance built
+   * only to read a tool's default data — it must not touch the block tree at
+   * all. Defaults to `'api'` when the constructor was handed no origin.
+   */
+  origin: BlockOrigin;
+  /** The editor-level API (`api.blocks`, `api.caret`, `api.events`…). */
+  api: API;
 }
 /** Spec for {@link createAngularBlock}. Authored as a standalone component. */
 interface CreateAngularBlockSpec<Data = BlockToolData> {
-    /** Tool type name (registered key). */
-    type: string;
-    /** Optional toolbox entry. */
-    toolbox?: ToolboxConfig;
-    /** Declarative defaults that also define the exact `save()` key set. */
-    propSchema: PropSchema;
-    /**
-     * The standalone Angular component to render for each block. It injects the
-     * per-block context via `inject(BLOK_BLOCK_CONTEXT)`.
-     */
-    component: Type<unknown>;
-    /**
-     * Static members of core's tool contract, forwarded verbatim onto the
-     * generated tool class — the single channel for everything core reads off the
-     * CLASS rather than the instance (`ownsChildren`, `keepsChildrenOnEnter`,
-     * `conversionConfig`, `pasteConfig`, `sanitize`, `shortcut`, `upgradeData`…).
-     * Without it the only way to declare one was to subclass the generated class.
-     *
-     * `keepsChildrenOnEnter` is the per-tool Enter POLICY: declare it and Enter on
-     * this container's empty LAST child creates the new line INSIDE the container
-     * instead of escaping to the container's parent (Blok's default, which is
-     * Notion's callout behaviour). Core cannot read that off the DOM — a callout
-     * renders the same `data-blok-nested-blocks` slot as a column yet wants the
-     * escape — so before it existed a layout container (a card, a `steps` block)
-     * had to hijack the editor-global `config.onEnter` and re-derive containment.
-     *
-     * `toolbox` and `isReadOnlySupported` are owned by the factory and cannot be
-     * overridden here (see {@link BlockToolStatics}).
-     */
-    statics?: BlockToolStatics;
-    /**
-     * The element the +/drag toolbar should vertically center on — core's
-     * `getToolbarAnchorElement` hook, resolved against this block's host element
-     * on every call (never cached, so it tracks re-renders).
-     *
-     * A container block whose own chrome is not editable needs it: with no anchor,
-     * core centers the toolbar on the first `[contenteditable]` under the host,
-     * which for a container is its FIRST CHILD BLOCK. Return `null`/`undefined`
-     * (or omit the field) to keep core's default.
-     * @param host - this block's mutation-free host element
-     * @param block - this block's per-block API
-     */
-    getToolbarAnchorElement?: (host: HTMLElement, block: BlockAPI) => HTMLElement | null | undefined;
-    /** Optional lifecycle callbacks mapped from Blok's block hooks. */
-    onRendered?: (block: BlockAPI) => void;
-    /**
-     * Fired ONCE per block instance, once the component's DOM (and, for a
-     * container, the child holders its `ctx.mountChildren` adopted) exists.
-     * Angular mounts the block synchronously while core is still inside
-     * `render()`, so this lands with `rendered()` — the first hook at which the
-     * host is also in the document. The React and Vue adapters spell the same
-     * contract; there it is genuinely LATER than `onRendered`, because their
-     * portals commit a frame after core returns.
-     *
-     * It is also the create-vs-restore signal: `context.origin` says whether the
-     * author just made this block (`user`/`api`/`convert`) or the document is
-     * being re-materialised (`load`/`replay`/`paste`) — so a container can seed
-     * its default children here exactly once, without the "children are
-     * transiently empty during a replay" trap.
-     * @example
-     * ```ts
-     * onMounted: (block, { origin, api }) => {
-     *   if (origin === 'user' && block.getChildren().length === 0) {
-     *     api.blocks.insertInsideParent(block.id);
-     *   }
-     * }
-     * ```
-     */
-    onMounted?: (block: BlockAPI, context: AngularBlockMountedContext) => void;
-    /**
-     * The SEEDING hook: `onMounted`, narrowed to a genuine creation. Fired ONCE
-     * per block instance, once the component's DOM exists, and only when this
-     * instance is the author making a new block (`origin` of `user`, `api` or
-     * `convert`) — never for a `load`/`replay`/`paste` restore, and never for the
-     * off-tree `probe` instance core builds to read a tool's default data.
-     *
-     * That predicate is why the hook exists rather than leaving every block to
-     * read `context.origin` in `onMounted`: the intuitive `origin === 'user'` test
-     * is wrong. It drops `api.blocks.insert('steps')` and turn-into, so a
-     * container seeded that way comes up empty for every path except a keystroke.
-     * Core refused to ship that axis into its own `column`/`column_list`; this
-     * encodes the correct one once, here.
-     *
-     * The `context` is the same object {@link CreateAngularBlockSpec.onMounted}
-     * receives, so a block that only seeds can read `origin` for finer decisions.
-     * @example
-     * ```ts
-     * onCreated: (block, { api }) => {
-     *   if (block.getChildren().length === 0) {
-     *     api.blocks.insertInsideParent(block.id);
-     *   }
-     * }
-     * ```
-     */
-    onCreated?: (block: BlockAPI, context: AngularBlockMountedContext) => void;
-    onMoved?: (block: BlockAPI) => void;
-    onRemoved?: (block: BlockAPI) => void;
+  /** Tool type name (registered key). */
+  type: string;
+  /** Optional toolbox entry. */
+  toolbox?: ToolboxConfig;
+  /** Declarative defaults that also define the exact `save()` key set. */
+  propSchema: PropSchema;
+  /**
+   * The standalone Angular component to render for each block. It injects the
+   * per-block context via `inject(BLOK_BLOCK_CONTEXT)`.
+   */
+  component: Type<unknown>;
+  /**
+   * Static members of core's tool contract, forwarded verbatim onto the
+   * generated tool class — the single channel for everything core reads off the
+   * CLASS rather than the instance (`ownsChildren`, `keepsChildrenOnEnter`,
+   * `conversionConfig`, `pasteConfig`, `sanitize`, `shortcut`, `upgradeData`…).
+   * Without it the only way to declare one was to subclass the generated class.
+   *
+   * `keepsChildrenOnEnter` is the per-tool Enter POLICY: declare it and Enter on
+   * this container's empty LAST child creates the new line INSIDE the container
+   * instead of escaping to the container's parent (Blok's default, which is
+   * Notion's callout behaviour). Core cannot read that off the DOM — a callout
+   * renders the same `data-blok-nested-blocks` slot as a column yet wants the
+   * escape — so before it existed a layout container (a card, a `steps` block)
+   * had to hijack the editor-global `config.onEnter` and re-derive containment.
+   *
+   * `toolbox` and `isReadOnlySupported` are owned by the factory and cannot be
+   * overridden here (see {@link BlockToolStatics}).
+   */
+  statics?: BlockToolStatics;
+  /**
+   * The element the +/drag toolbar should vertically center on — core's
+   * `getToolbarAnchorElement` hook, resolved against this block's host element
+   * on every call (never cached, so it tracks re-renders).
+   *
+   * A container block whose own chrome is not editable needs it: with no anchor,
+   * core centers the toolbar on the first `[contenteditable]` under the host,
+   * which for a container is its FIRST CHILD BLOCK. Return `null`/`undefined`
+   * (or omit the field) to keep core's default.
+   * @param host - this block's mutation-free host element
+   * @param block - this block's per-block API
+   */
+  getToolbarAnchorElement?: (host: HTMLElement, block: BlockAPI) => HTMLElement | null | undefined;
+  /**
+   * Enter (or Cmd/Ctrl+Enter) on this block while it is the keyboard
+   * navigation target — core's `onNavigationEnter` hook. Return true when the
+   * block handled it (e.g. opened a link); omit it, or return false, to let
+   * core put the caret in the block.
+   * @param event - the Enter keydown
+   * @param block - this block's per-block API
+   */
+  onNavigationEnter?: (event: KeyboardEvent, block: BlockAPI) => boolean;
+  /** Optional lifecycle callbacks mapped from Blok's block hooks. */
+  onRendered?: (block: BlockAPI) => void;
+  /**
+   * Fired ONCE per block instance, once the component's DOM (and, for a
+   * container, the child holders its `ctx.mountChildren` adopted) exists.
+   * Angular mounts the block synchronously while core is still inside
+   * `render()`, so this lands with `rendered()` — the first hook at which the
+   * host is also in the document. The React and Vue adapters spell the same
+   * contract; there it is genuinely LATER than `onRendered`, because their
+   * portals commit a frame after core returns.
+   *
+   * It is also the create-vs-restore signal: `context.origin` says whether the
+   * author just made this block (`user`/`api`/`convert`) or the document is
+   * being re-materialised (`load`/`replay`/`paste`) — so a container can seed
+   * its default children here exactly once, without the "children are
+   * transiently empty during a replay" trap.
+   * @example
+   * ```ts
+   * onMounted: (block, { origin, api }) => {
+   *   if (origin === 'user' && block.getChildren().length === 0) {
+   *     api.blocks.insertInsideParent(block.id);
+   *   }
+   * }
+   * ```
+   */
+  onMounted?: (block: BlockAPI, context: AngularBlockMountedContext) => void;
+  /**
+   * The SEEDING hook: `onMounted`, narrowed to a genuine creation. Fired ONCE
+   * per block instance, once the component's DOM exists, and only when this
+   * instance is the author making a new block (`origin` of `user`, `api` or
+   * `convert`) — never for a `load`/`replay`/`paste` restore, and never for the
+   * off-tree `probe` instance core builds to read a tool's default data.
+   *
+   * That predicate is why the hook exists rather than leaving every block to
+   * read `context.origin` in `onMounted`: the intuitive `origin === 'user'` test
+   * is wrong. It drops `api.blocks.insert('steps')` and turn-into, so a
+   * container seeded that way comes up empty for every path except a keystroke.
+   * Core refused to ship that axis into its own `column`/`column_list`; this
+   * encodes the correct one once, here.
+   *
+   * The `context` is the same object {@link CreateAngularBlockSpec.onMounted}
+   * receives, so a block that only seeds can read `origin` for finer decisions.
+   * @example
+   * ```ts
+   * onCreated: (block, { api }) => {
+   *   if (block.getChildren().length === 0) {
+   *     api.blocks.insertInsideParent(block.id);
+   *   }
+   * }
+   * ```
+   */
+  onCreated?: (block: BlockAPI, context: AngularBlockMountedContext) => void;
+  onMoved?: (block: BlockAPI) => void;
+  onRemoved?: (block: BlockAPI) => void;
 }
 /**
  * Author a first-party Angular block. Returns a `BlockToolConstructable`
@@ -822,43 +1694,43 @@ interface CreateAngularBlockSpec<Data = BlockToolData> {
  * - `setReadOnly()` flips a reactive flag and flushes CD (in-place, no remount).
  * - `removed()`/`destroy()` unregister the portal (deterministic unmount).
  */
-declare function createAngularBlock<Data = BlockToolData>(spec: CreateAngularBlockSpec<Data>): (new (options: BlockToolConstructorOptions) => {
-    render(): HTMLElement;
-    save(): BlockToolData;
-    setData(newData: BlockToolData): Promise<boolean>;
-    setReadOnly(state: boolean): void;
-    getToolbarAnchorElement(): HTMLElement | undefined;
-    rendered(): void;
-    moved(): void;
-    removed(): void;
-    destroy(): void;
+export declare function createAngularBlock<Data = BlockToolData>(spec: CreateAngularBlockSpec<Data>): (new (options: BlockToolConstructorOptions) => {
+  render(): HTMLElement;
+  save(): BlockToolData;
+  setData(newData: BlockToolData): Promise<boolean>;
+  setReadOnly(state: boolean): void;
+  getToolbarAnchorElement(): HTMLElement | undefined;
+  onNavigationEnter(event: KeyboardEvent): boolean;
+  rendered(): void;
+  moved(): void;
+  removed(): void;
+  destroy(): void;
 }) & BlockToolStatics & {
-    readonly __isBlokAngularBlock: true;
-    readonly toolbox: ToolboxConfig | undefined;
-    readonly isReadOnlySupported: boolean;
+  readonly __isBlokAngularBlock: true;
+  readonly toolbox: ToolboxConfig | undefined;
+  readonly isReadOnlySupported: boolean;
 };
-
 /** Options for {@link injectBlocks}. */
 interface InjectBlocksOptions {
-    /**
-     * Invalidate reads only for changes inside the subtree rooted at this block id
-     * (the block itself or any descendant). Omit — or pass `null` — for the
-     * document-wide default.
-     *
-     * This bounds REACTIVITY, not reads: the returned API still sees the whole
-     * tree, so a scoped consumer can still `getById` anything. Reach for it in a
-     * container block that renders only its own children — unscoped, such a block
-     * invalidates on every keystroke anywhere in the document, and a page of N
-     * containers turns one keystroke into N re-renders.
-     *
-     * Accepted as a plain value or a signal (like `editor`) and read at EMIT time,
-     * so changing it takes effect immediately with no re-subscription.
-     *
-     * A change whose block cannot be placed in the tree (a removal that emits
-     * after the block is gone) counts as in-scope: skipping it would leave a
-     * container rendering a child that no longer exists.
-     */
-    within?: Signal<string | null> | string | null;
+  /**
+   * Invalidate reads only for changes inside the subtree rooted at this block id
+   * (the block itself or any descendant). Omit — or pass `null` — for the
+   * document-wide default.
+   *
+   * This bounds REACTIVITY, not reads: the returned API still sees the whole
+   * tree, so a scoped consumer can still `getById` anything. Reach for it in a
+   * container block that renders only its own children — unscoped, such a block
+   * invalidates on every keystroke anywhere in the document, and a page of N
+   * containers turns one keystroke into N re-renders.
+   *
+   * Accepted as a plain value or a signal (like `editor`) and read at EMIT time,
+   * so changing it takes effect immediately with no re-subscription.
+   *
+   * A change whose block cannot be placed in the tree (a removal that emits
+   * after the block is gone) counts as in-scope: skipping it would leave a
+   * container rendering a child that no longer exists.
+   */
+  within?: Signal<string | null> | string | null;
 }
 /**
  * Angular factory exposing an id/parentId-relative, reactive view of the block
@@ -896,30 +1768,29 @@ interface InjectBlocksOptions {
  * @param options - reactivity options; see {@link InjectBlocksOptions.within} to
  *   scope invalidation to one block's subtree
  */
-declare function injectBlocks(editor: Signal<Blok | null>, options?: InjectBlocksOptions): UseBlocksApi;
-
+export declare function injectBlocks(editor: Signal<Blok | null>, options?: InjectBlocksOptions): UseBlocksApi;
 /** How the caller names the DOM scope to observe. */
 type BlokReadyScope = (() => Element | ElementRef<Element> | null | undefined) | ElementRef<Element> | Element | null;
 /** Options accepted by {@link injectBlokReady}. */
 interface InjectBlokReadyOptions {
-    /**
-     * Restrict the wait to editors mounted inside this element. Accepts an
-     * element, an `ElementRef`, or a getter/signal returning either — the getter
-     * form lets you pass `() => this.scopeRef?.nativeElement` from a field
-     * initializer, before the view exists. It is re-read on every readiness
-     * change.
-     *
-     * Omit it to observe every editor on the page. Passing it while it still
-     * resolves to null reports NOT ready — an unresolved scope must never fall
-     * back to the page-global one.
-     */
-    within?: BlokReadyScope;
-    /**
-     * `'ready'` (default) settles when each editor has finished booting.
-     * `'rendered'` also waits for its content to be in the DOM and re-arms on
-     * every post-boot re-render.
-     */
-    settleOn?: 'ready' | 'rendered';
+  /**
+   * Restrict the wait to editors mounted inside this element. Accepts an
+   * element, an `ElementRef`, or a getter/signal returning either — the getter
+   * form lets you pass `() => this.scopeRef?.nativeElement` from a field
+   * initializer, before the view exists. It is re-read on every readiness
+   * change.
+   *
+   * Omit it to observe every editor on the page. Passing it while it still
+   * resolves to null reports NOT ready — an unresolved scope must never fall
+   * back to the page-global one.
+   */
+  within?: BlokReadyScope;
+  /**
+   * `'ready'` (default) settles when each editor has finished booting.
+   * `'rendered'` also waits for its content to be in the DOM and re-arms on
+   * every post-boot re-render.
+   */
+  settleOn?: 'ready' | 'rendered';
 }
 /**
  * Angular factory exposing the live readiness of the Blok editors in a DOM
@@ -937,8 +1808,7 @@ interface InjectBlokReadyOptions {
  * `@ViewChild` scope to exist. Over-waiting is safe; under-waiting is a bug.
  * @param options - scope and readiness depth
  */
-declare function injectBlokReady(options?: InjectBlokReadyOptions): Signal<boolean>;
-
+export declare function injectBlokReady(options?: InjectBlokReadyOptions): Signal<boolean>;
 /**
  * One child's decoration: attribute name → value. `null`/`undefined` removes the
  * attribute; a boolean or number is stringified (so `false` writes
@@ -954,88 +1824,87 @@ type ChildAttributesFn = (child: BlockAPI, index: number) => ChildAttributes;
  * JIT test harness. The ONLY data write path is `commit`.
  */
 interface AngularBlockRenderContext<Data> {
-    /** Reactive, FROZEN snapshot of the block data. Read `data()`; never mutate. */
-    data: Signal<Readonly<Data>>;
-    /** The ONLY data write path: merge a partial patch and sync once. */
-    commit: (patch: Partial<Data>) => void;
-    /** This block's per-block API (id, getChildren, dispatchChange…). */
-    block: BlockAPI;
-    /**
-     * The EDITOR-level API this block belongs to (`api.blocks`, `api.caret`,
-     * `api.toolbar`…) — the same object a vanilla tool receives in its
-     * constructor. Reach for it when a block has to drive the document around it
-     * instead of routing everything through `block.call()` string dispatch.
-     *
-     * For the reactive, id/parentId-relative view of the tree (and to re-render
-     * when your own children change), pair `injectBlocks` with
-     * `injectBlokInstance()` instead — the api handle itself is not reactive.
-     */
-    api: API;
-    /**
-     * Reactive read-only flag. Read `readOnly()` in the template to disable
-     * editing (drop `contenteditable`, hide controls). Toggled IN PLACE by core's
-     * read-only switch — the component reacts without a remount, so ephemeral
-     * state survives. A block that ignores it stays interactive when the editor is
-     * read-only (same contract as a vanilla tool's `setReadOnly`).
-     */
-    readOnly: Signal<boolean>;
-    /**
-     * Container blocks only: append this block's real child holders into `host`
-     * (a `data-blok-nested` element the author owns). Call it once in
-     * `ngAfterViewInit`; the factory re-runs the same mount on every data change
-     * so late-added children appear. Angular must NOT manage these child holders.
-     *
-     * `childAttributes` decorates each child's HOLDER after the holders are
-     * mounted, and is REMEMBERED — every later remount re-applies it. Named hooks
-     * (`data-step-index`, `data-active`…) replace positional `:nth-child()` CSS
-     * over Blok's holders, which breaks the moment a child is inserted, removed or
-     * reordered. The holders stay DIRECT children of `host` — core requires that
-     * (hierarchy reparenting and caret navigation compare `holder.parentElement`
-     * by identity), so decoration is attributes, never wrapper elements.
-     * Attributes the callback stops producing are removed on the next pass.
-     *
-     * `childContentAttributes` is the same decoration applied one level IN — on
-     * each child's `[data-blok-element-content]` wrapper instead of its holder —
-     * and is remembered the same way. Core's decoration law blesses both, and a
-     * container needs both: the holder is the child's outer box (rails, indices,
-     * hover states), the content wrapper is where the child's own text box begins,
-     * which is what a numbered rail or a connector line has to align to. Reach for
-     * it instead of walking core's wrapper chain from a holder hook (`[data-step] >
-     * [data-blok-element-content] > …`) — those selectors encode engine DOM in host
-     * CSS and break when that structure changes. A child whose DOM has not
-     * committed yet has no wrapper to write to and is stamped on the next pass.
-     *
-     * Writing on a child's holder is inert by design: core's mutation filter drops
-     * a holder-targeted attribute record for the child block and suppresses it for
-     * the container. The guarantee stops at the holder and its
-     * `[data-blok-element-content]` wrapper — writing AT or BELOW a child's tool
-     * root DOES score as that child's edit.
-     */
-    mountChildren: (host: HTMLElement, childAttributes?: ChildAttributesFn, childContentAttributes?: ChildAttributesFn) => void;
-    /**
-     * Name the element the +/drag toolbar should vertically center on, from inside
-     * the component: `ctx.setToolbarAnchor(this.head().nativeElement)` in
-     * `ngAfterViewInit`. The Angular counterpart of React's/Vue's
-     * `toolbarAnchorRef` — core's `getToolbarAnchorElement` is otherwise a
-     * `(host, block) => Element` hook resolved OUTSIDE the component, so pointing
-     * at an element the template renders meant inventing a data attribute and
-     * `querySelector`-ing for it from
-     * `CreateAngularBlockSpec.getToolbarAnchorElement`.
-     *
-     * A container block whose own chrome is not editable needs an anchor: with
-     * none, core centers the toolbar on the first `[contenteditable]` under the
-     * host, which for a container is its FIRST CHILD BLOCK — parking the +/drag
-     * handles halfway down, beside content that has a toolbar of its own.
-     *
-     * The element set here outranks the declared hook while it is MOUNTED; once it
-     * detaches (or `null` is passed) the hook takes over again, so the toolbar is
-     * never positioned against a stale node. Never calling it keeps core's default.
-     */
-    setToolbarAnchor: (element: HTMLElement | null) => void;
+  /** Reactive, FROZEN snapshot of the block data. Read `data()`; never mutate. */
+  data: Signal<Readonly<Data>>;
+  /** The ONLY data write path: merge a partial patch and sync once. */
+  commit: (patch: Partial<Data>) => void;
+  /** This block's per-block API (id, getChildren, dispatchChange…). */
+  block: BlockAPI;
+  /**
+   * The EDITOR-level API this block belongs to (`api.blocks`, `api.caret`,
+   * `api.toolbar`…) — the same object a vanilla tool receives in its
+   * constructor. Reach for it when a block has to drive the document around it
+   * instead of routing everything through `block.call()` string dispatch.
+   *
+   * For the reactive, id/parentId-relative view of the tree (and to re-render
+   * when your own children change), pair `injectBlocks` with
+   * `injectBlokInstance()` instead — the api handle itself is not reactive.
+   */
+  api: API;
+  /**
+   * Reactive read-only flag. Read `readOnly()` in the template to disable
+   * editing (drop `contenteditable`, hide controls). Toggled IN PLACE by core's
+   * read-only switch — the component reacts without a remount, so ephemeral
+   * state survives. A block that ignores it stays interactive when the editor is
+   * read-only (same contract as a vanilla tool's `setReadOnly`).
+   */
+  readOnly: Signal<boolean>;
+  /**
+   * Container blocks only: append this block's real child holders into `host`
+   * (a `data-blok-nested` element the author owns). Call it once in
+   * `ngAfterViewInit`; the factory re-runs the same mount on every data change
+   * so late-added children appear. Angular must NOT manage these child holders.
+   *
+   * `childAttributes` decorates each child's HOLDER after the holders are
+   * mounted, and is REMEMBERED — every later remount re-applies it. Named hooks
+   * (`data-step-index`, `data-active`…) replace positional `:nth-child()` CSS
+   * over Blok's holders, which breaks the moment a child is inserted, removed or
+   * reordered. The holders stay DIRECT children of `host` — core requires that
+   * (hierarchy reparenting and caret navigation compare `holder.parentElement`
+   * by identity), so decoration is attributes, never wrapper elements.
+   * Attributes the callback stops producing are removed on the next pass.
+   *
+   * `childContentAttributes` is the same decoration applied one level IN — on
+   * each child's `[data-blok-element-content]` wrapper instead of its holder —
+   * and is remembered the same way. Core's decoration law blesses both, and a
+   * container needs both: the holder is the child's outer box (rails, indices,
+   * hover states), the content wrapper is where the child's own text box begins,
+   * which is what a numbered rail or a connector line has to align to. Reach for
+   * it instead of walking core's wrapper chain from a holder hook (`[data-step] >
+   * [data-blok-element-content] > …`) — those selectors encode engine DOM in host
+   * CSS and break when that structure changes. A child whose DOM has not
+   * committed yet has no wrapper to write to and is stamped on the next pass.
+   *
+   * Writing on a child's holder is inert by design: core's mutation filter drops
+   * a holder-targeted attribute record for the child block and suppresses it for
+   * the container. The guarantee stops at the holder and its
+   * `[data-blok-element-content]` wrapper — writing AT or BELOW a child's tool
+   * root DOES score as that child's edit.
+   */
+  mountChildren: (host: HTMLElement, childAttributes?: ChildAttributesFn, childContentAttributes?: ChildAttributesFn) => void;
+  /**
+   * Name the element the +/drag toolbar should vertically center on, from inside
+   * the component: `ctx.setToolbarAnchor(this.head().nativeElement)` in
+   * `ngAfterViewInit`. The Angular counterpart of React's/Vue's
+   * `toolbarAnchorRef` — core's `getToolbarAnchorElement` is otherwise a
+   * `(host, block) => Element` hook resolved OUTSIDE the component, so pointing
+   * at an element the template renders meant inventing a data attribute and
+   * `querySelector`-ing for it from
+   * `CreateAngularBlockSpec.getToolbarAnchorElement`.
+   *
+   * A container block whose own chrome is not editable needs an anchor: with
+   * none, core centers the toolbar on the first `[contenteditable]` under the
+   * host, which for a container is its FIRST CHILD BLOCK — parking the +/drag
+   * handles halfway down, beside content that has a toolbar of its own.
+   *
+   * The element set here outranks the declared hook while it is MOUNTED; once it
+   * detaches (or `null` is passed) the hook takes over again, so the toolbar is
+   * never positioned against a stale node. Never calling it keeps core's default.
+   */
+  setToolbarAnchor: (element: HTMLElement | null) => void;
 }
 /** DI token carrying the per-block render context into the authored component. */
-declare const BLOK_BLOCK_CONTEXT: InjectionToken<AngularBlockRenderContext<unknown>>;
-
+export declare const BLOK_BLOCK_CONTEXT: InjectionToken<AngularBlockRenderContext<unknown>>;
 /**
  * DI token carrying the LIVE editor instance (as a signal) into every block
  * mounted by `createAngularBlock`. `BlokContentDirective` publishes its own
@@ -1045,7 +1914,7 @@ declare const BLOK_BLOCK_CONTEXT: InjectionToken<AngularBlockRenderContext<unkno
  * Provided on the block's ELEMENT injector by the portal registry, so it is
  * per-EDITOR: two editors on one page each publish their own instance.
  */
-declare const BLOK_EDITOR_INSTANCE: InjectionToken<Signal<Blok | null>>;
+export declare const BLOK_EDITOR_INSTANCE: InjectionToken<Signal<Blok | null>>;
 /**
  * The live Blok instance the component is mounted inside, as a signal, or a
  * signal of null before it exists. Inside a `createAngularBlock` component this
@@ -1065,7 +1934,5 @@ declare const BLOK_EDITOR_INSTANCE: InjectionToken<Signal<Blok | null>>;
  * Call it in an injection context (a field initializer or the constructor).
  * Outside an editor it returns a signal of null.
  */
-declare function injectBlokInstance(): Signal<Blok | null>;
-
-export { BLOK_BLOCK_CONTEXT, BLOK_DEFAULT_CONFIG, BLOK_EDITOR_INSTANCE, BlokContentDirective, BlokEditorComponent, createAngularBlock, injectBlocks, injectBlokInstance, injectBlokReady, provideBlok };
-export type { AngularBlockMountedContext, AngularBlockRenderContext, BlockNode, BlockToolStatics, BlokAngularConfig, BlokReadyScope, CaretTarget, ChildAttributes, ChildAttributesFn, CreateAngularBlockSpec, InjectBlocksOptions, InjectBlokReadyOptions, InsertPosition, InsertSpec, MoveTarget, PropSchema, PropSchemaEntry, TreeInsertSpec, UseBlocksApi };
+export declare function injectBlokInstance(): Signal<Blok | null>;
+export type { AngularBlockMountedContext, AngularBlockRenderContext, BlockNode, BlockToolStatics, BlokAngularConfig, BlokReadyScope, CaretTarget, ChildAttributes, ChildAttributesFn, CreateAngularBlockSpec, InjectBlocksOptions, InjectBlokReadyOptions, InsertPosition, InsertSpec, MoveTarget, PropSchema, PropSchemaEntry, TreeInsertSpec, UseBlocksApi };