@markput/react 0.14.1 → 0.14.2

package/index.d.ts

@@ -38,6 +38,35 @@ declare const GAP_TYPE: {
 };
 type GapType = (typeof GAP_TYPE)[keyof typeof GAP_TYPE];
 //#endregion
+//#region ../../core/src/features/parsing/parser/core/SegmentMatcher.d.ts
+/**
+ * Segment definition - can be a static string or a dynamic pattern
+ * For dynamic patterns: [before, after, exclusions]
+ */
+type SegmentDefinition = string | readonly [before: string, after: string, exclusions: string];
+//#endregion
+//#region ../../core/src/features/parsing/parser/core/MarkupDescriptor.d.ts
+/**
+ * Descriptor for segment-based markup parsing
+ * Converts markup templates into arrays of static or dynamic segments
+ */
+interface MarkupDescriptor {
+  /** Original markup template string */
+  markup: Markup;
+  /** Index of this markup in the original markups array */
+  index: number;
+  /** Array of segment definitions (can be static strings or dynamic patterns) */
+  segments: SegmentDefinition[];
+  /** Type of content in each gap between segments */
+  gapTypes: GapType[];
+  /** True if this markup contains a __slot__ placeholder */
+  hasSlot: boolean;
+  /** True if this markup contains exactly two __value__ placeholders */
+  hasTwoValues: boolean;
+  /** Global indices of segments in registry segments array (parallel to segments array) */
+  segmentGlobalIndices: number[];
+}
+//#endregion
 //#region ../../core/src/features/parsing/parser/types.d.ts
 type Token = TextToken | MarkToken;
 interface TextToken {
@@ -65,12 +94,6 @@ interface MarkToken {
   };
   children: Token[];
 }
-interface ParseOptions {
-  /** Return only MarkTokens, drop all TextTokens */
-  marksOnly?: boolean;
-  /** Drop zero-length TextTokens (where start === end) */
-  skipEmptyText?: boolean;
-}
 /**
  * Template literal types for markup placeholders
  */
@@ -89,62 +112,59 @@ type SlotMarkup = `${string}${typeof PLACEHOLDER.Slot}${string}`;
  */
 type Markup = ValueMarkup | `${ValueMarkup}${MetaMarkup}` | `${ValueMarkup}${MetaMarkup}${SlotMarkup}` | `${ValueMarkup}${SlotMarkup}` | `${ValueMarkup}${SlotMarkup}${MetaMarkup}` | SlotMarkup | `${SlotMarkup}${MetaMarkup}` | `${SlotMarkup}${MetaMarkup}${ValueMarkup}` | `${SlotMarkup}${ValueMarkup}` | `${SlotMarkup}${ValueMarkup}${MetaMarkup}` | `${MetaMarkup}${ValueMarkup}` | `${MetaMarkup}${ValueMarkup}${SlotMarkup}` | `${MetaMarkup}${SlotMarkup}` | `${MetaMarkup}${SlotMarkup}${ValueMarkup}`;
 //#endregion
-//#region ../../core/src/features/parsing/parser/core/SegmentMatcher.d.ts
-/**
- * Segment definition - can be a static string or a dynamic pattern
- * For dynamic patterns: [before, after, exclusions]
- */
-type SegmentDefinition = string | readonly [before: string, after: string, exclusions: string];
-//#endregion
-//#region ../../core/src/features/parsing/parser/core/MarkupDescriptor.d.ts
-/**
- * Descriptor for segment-based markup parsing
- * Converts markup templates into arrays of static or dynamic segments
- */
-interface MarkupDescriptor {
-  /** Original markup template string */
-  markup: Markup;
-  /** Index of this markup in the original markups array */
-  index: number;
-  /** Array of segment definitions (can be static strings or dynamic patterns) */
-  segments: SegmentDefinition[];
-  /** Type of content in each gap between segments */
-  gapTypes: GapType[];
-  /** True if this markup contains a __slot__ placeholder */
-  hasSlot: boolean;
-  /** True if this markup contains exactly two __value__ placeholders */
-  hasTwoValues: boolean;
-  /** Global indices of segments in registry segments array (parallel to segments array) */
-  segmentGlobalIndices: number[];
-}
-//#endregion
-//#region ../../core/src/shared/signals/signal.d.ts
-interface Signal<T> {
-  (): T;
-  (value: T | undefined): void;
-}
-type SignalValues<T> = { [K in keyof T]: T[K] extends Signal<infer V> | Computed<infer V> ? V : T[K] };
-interface Computed<T> {
-  (): T;
-}
-interface Event<T = void> {
-  (payload: T): void;
-  read(): T | undefined;
-}
-//#endregion
-//#region ../../core/src/features/lifecycle/Lifecycle.d.ts
-declare class Lifecycle {
-  readonly mounted: Event<void>;
-  readonly unmounted: Event<void>;
-  readonly rendered: Event<void>;
-  /**
-   * Run `setup` when the editor is mounted. Any reactive subscription
-   * created inside `setup` (`watch`, `listen`, `effect`, nested
-   * `effectScope`) is automatically disposed on `unmounted` and re-created
-   * on the next `mounted`.
-   */
-  onMounted(setup: () => void): void;
-}
+//#region ../../core/src/shared/editorContracts.d.ts
+type TokenPath = readonly number[];
+type TokenAddress = {
+  readonly path: TokenPath;
+  readonly token: Token;
+};
+type Result<T, Reason extends string> = {
+  ok: true;
+  value: T;
+} | {
+  ok: false;
+  reason: Reason;
+};
+type DomRef = (element: HTMLElement | null) => void;
+type Range$1 = {
+  readonly start: number;
+  readonly end: number;
+};
+type RawSelection = {
+  readonly range: Range$1;
+  readonly direction?: 'forward' | 'backward';
+};
+type NodeLocationResult = Result<{
+  readonly address: TokenAddress;
+  readonly tokenElement: HTMLElement;
+  readonly textElement?: HTMLElement;
+  readonly rowElement?: HTMLElement;
+}, 'notIndexed' | 'outsideEditor' | 'control'>;
+type RawSelectionResult = Result<RawSelection, 'notIndexed' | 'outsideEditor' | 'control' | 'mixedBoundary' | 'invalidBoundary'>;
+type BoundaryPositionResult = Result<number, 'notIndexed' | 'outsideEditor' | 'control' | 'invalidBoundary' | 'composing'>;
+type OptionalMarkFieldPatch = {
+  readonly kind: 'set';
+  readonly value: string;
+} | {
+  readonly kind: 'clear';
+};
+type MarkPatch = {
+  readonly value?: string;
+  readonly meta?: OptionalMarkFieldPatch;
+  readonly slot?: OptionalMarkFieldPatch;
+};
+type MarkSnapshot = {
+  readonly value: string;
+  readonly meta: string | undefined;
+  readonly slot: string | undefined;
+  readonly readOnly: boolean;
+};
+type MarkInfo = {
+  readonly address: TokenAddress;
+  readonly depth: number;
+  readonly hasNestedMarks: boolean;
+  readonly key: string;
+};
 //#endregion
 //#region ../../../node_modules/.pnpm/csstype@3.2.3/node_modules/csstype/index.d.ts
 interface StandardLonghandProperties<TLength = (string & {}) | 0, TTime = string & {}> {
@@ -10599,7 +10619,7 @@ type Slot = keyof SlotRegistry extends never ? unknown : SlotRegistry[keyof Slot
  * Architecture:
  * - CoreOption: Contains only markup pattern (framework-independent)
  * - trigger configuration: Handled by framework layer via getTrigger function in TriggerFinder
- * - Separation of concerns: Core focuses on markup parsing, framework handles overlay triggers
+ * - Separation of concerns: Core focuses on markup tokens, framework handles overlay triggers
  */
 interface CoreOption {
   /**
@@ -10657,7 +10677,6 @@ type DataAttributes = Record<`data${Capitalize<string>}`, string | number | bool
 interface CoreSlots {
   container?: Slot;
   block?: Slot;
-  span?: Slot;
 }
 interface CoreSlotProps {
   container?: Record<string, unknown> & {
@@ -10668,10 +10687,6 @@ interface CoreSlotProps {
     className?: string;
     style?: CSSProperties$1;
   };
-  span?: Record<string, unknown> & {
-    className?: string;
-    style?: CSSProperties$1;
-  };
 }
 interface DraggableConfig {
   alwaysShowHandle?: boolean;
@@ -10696,14 +10711,31 @@ interface DragActions {
   };
 }
 //#endregion
-//#region ../../core/src/features/props/PropsModel.d.ts
+//#region ../../core/src/shared/signals/signal.d.ts
+interface Signal<T> {
+  (): T;
+  (value: T | undefined): boolean;
+}
+type SignalValues<T> = { [K in keyof T]: T[K] extends Signal<infer V> | Computed<infer V> ? V : T[K] };
+type ComputedRecord<C> = { readonly [K in keyof C]: C[K] extends (() => infer R) ? Computed<R> : never };
+interface Computed<T> {
+  (): T;
+}
+interface Event<T = void> {
+  (payload: T): void;
+  read(): T | undefined;
+}
+//#endregion
+//#region ../../core/src/features/state/PropsModel.d.ts
 declare class PropsModel {
   readonly value: Signal<string | undefined>;
   readonly defaultValue: Signal<string | undefined>;
   readonly onChange: Signal<((value: string) => void) | undefined>;
   readonly options: Signal<CoreOption[]>;
   readonly readOnly: Signal<boolean>;
-  readonly layout: Signal<"inline" | "block">;
+  readonly layout: Signal<"inline" | "block"> & ComputedRecord<{
+    isBlock: () => boolean;
+  }>;
   readonly draggable: Signal<boolean | DraggableConfig>;
   readonly showOverlayOn: Signal<OverlayTrigger>;
   readonly Span: Signal<_$react.ElementType | undefined>;
@@ -10716,347 +10748,111 @@ declare class PropsModel {
   set(values: Partial<SignalValues<typeof this>>): void;
 }
 //#endregion
-//#region ../../core/src/features/parsing/parser/Parser.d.ts
-/**
- * Parser - High-performance tree-based markup parser
- *
- * Parses text with markup patterns into a nested token tree structure.
- * Supports complex patterns with metadata, nesting, and HTML-like constructs.
- *
- * @example
- * ```typescript
- * const parser = new Parser(['@[__value__](__meta__)', '#[__slot__]'])
- * const tokens = parser.parse('Hello @[world](test) and #[tag]')
- * const text = parser.stringify(tokens)
- * ```
- */
-declare class Parser {
-  private readonly registry;
-  private readonly segmentMatcher;
-  private readonly patternMatcher;
-  private readonly treeBuilder;
-  private readonly parseOptions;
-  /**
-   * Creates a new Parser instance with the specified markup patterns
-   *
-   * @param markups - Array of markup pattern strings with placeholders (can include undefined values):
-   *   - `__value__` - main content (plain text, no nesting)
-   *   - `__meta__` - metadata (plain text, no nesting)
-   *   - `__slot__` - content supporting nested structures
-   *   - `undefined` - skipped, but original array indices are preserved for descriptor matching
-   * @param options - Optional parse options to control token output:
-   *   - `marksOnly` - return only MarkTokens, drop all TextTokens
-   *   - `skipEmptyText` - drop zero-length TextTokens (where start === end)
-   *
-   * @example
-   * ```typescript
-   * const parser = new Parser([
-   *   '@[__value__](__meta__)',  // @[label](value) - descriptor.index = 0
-   *   undefined,                 // skipped
-   *   '#[__slot__]',           // #[nested content] - descriptor.index = 2
-   *   '**__slot__**'           // **bold text** - descriptor.index = 3
-   * ])
-   * ```
-   */
-  constructor(markups: (Markup | undefined)[], options?: ParseOptions);
-  /**
-   * Parses text into tokens (static convenience method)
-   *
-   * @param value - Text to parse
-   * @param options - Options with markup patterns and token filtering
-   * @returns Array of tokens (TextToken and MarkToken)
-   *
-   * @example
-   * ```typescript
-   * const tokens = Parser.parse('Hello @[world]', {
-   *   markup: ['@[__value__]']
-   * })
-   * ```
-   */
-  static parse(value: string, options?: {
-    markup: Markup[];
-  } & ParseOptions): Token[];
-  /**
-   * Converts tokens back to text (static convenience method)
-   *
-   * @param tokens - Array of tokens to convert
-   * @returns Reconstructed text string
-   *
-   * @example
-   * ```typescript
-   * const text = Parser.stringify(tokens)
-   * ```
-   */
-  static stringify(tokens: Token[]): string;
-  /**
-   * Parses text into a nested token tree
-   *
-   * This is the main parsing method. It processes the input text through
-   * three stages:
-   * 1. Segment matching - finds all markup segments (O(N + M))
-   * 2. Pattern matching - builds complete patterns from segments (O(M))
-   * 3. Tree building - constructs nested token tree (O(M·D))
-   *
-   * @param value - Text to parse
-   * @returns Array of tokens representing the parsed structure
-   *
-   * @example
-   * ```typescript
-   * const parser = new Parser(['@[__value__](__meta__)'])
-   * const tokens = parser.parse('Hello @[world](test)')
-   * // Returns: [
-   * //   TextToken('Hello '),
-   * //   MarkToken('@[world](test)', value='world', meta='test'),
-   * //   TextToken('')
-   * // ]
-   * ```
-   */
-  parse(value: string): Token[];
-  /**
-   * Converts tokens back to the original text
-   *
-   * This is the inverse operation of parse(). It reconstructs the original
-   * text from a token tree, preserving all markup and structure.
-   *
-   * @param tokens - Array of tokens to convert
-   * @returns Reconstructed text string
-   *
-   * @example
-   * ```typescript
-   * const text = 'Hello @[world](test)'
-   * const tokens = parser.parse(text)
-   * const reconstructed = parser.stringify(tokens)
-   * console.log(reconstructed === text) // true
-   * ```
-   */
-  stringify(tokens: Token[]): string;
-  /**
-   * Transforms annotated text by processing all mark tokens with a callback
-   *
-   * This method parses the text, recursively processes all MarkTokens
-   * (including nested ones) with the provided callback, and returns
-   * the transformed text.
-   *
-   * @param value - Annotated text to process
-   * @param callback - Function to transform each MarkToken
-   * @returns Transformed text
-   *
-   * @example
-   * ```typescript
-   * // Extract all values
-   * const text = '@[Hello](world) and #[tag]'
-   * const result = parser.transform(text, mark => mark.value)
-   * // Returns: 'Hello and tag'
-   *
-   * // Custom transformation
-   * const result = parser.transform(text, mark =>
-   *   mark.meta ? `${mark.value}:${mark.meta}` : mark.value
-   * )
-   * // Returns: 'Hello:world and tag'
-   * ```
-   */
-  transform(value: string, callback: (mark: MarkToken) => string): string;
-  /**
-   * Escapes markup segments in the given text using backslash
-   *
-   * This method uses the registry's unique segments and escapes them by adding
-   * a backslash before each character of each segment, preventing them from being
-   * parsed as markup when the text is processed again.
-   *
-   * @param text - Text to escape segments in
-   * @returns Text with escaped segments
-   *
-   * @example
-   * ```typescript
-   * const parser = new Parser(['**__slot__**', '@[__value__]'])
-   * const escaped = parser.escape('Hello **world** and @[user]')
-   * // Returns: 'Hello \*\*world\*\* and \@[user]'
-   * ```
-   */
-  escape(text: string): string;
+//#region ../../core/src/features/state/ValueModel.d.ts
+declare class ValueModel {
+  private readonly props;
+  readonly current: Signal<string>;
+  constructor(props: PropsModel);
   /**
-   * Unescapes markup patterns in the given text
-   *
-   * This method removes escape characters from segments that were previously
-   * escaped using escape(), allowing the patterns to be parsed normally.
-   *
-   * @param text - Text to unescape patterns in
-   * @returns Text with unescaped patterns
-   *
-   * @example
-   * ```typescript
-   * const parser = new Parser(['**__slot__**', '@[__value__]'])
-   * const unescaped = parser.unescape('Hello \*\*world\*\* and \@[user]')
-   * // Returns: 'Hello **world** and @[user]'
-   * ```
+   * Attempts to replace `range` with `replacement`. Returns `true` when the
+   * edit was accepted (range valid and not read-only), `false` otherwise.
+   * Callers use the return value to gate downstream side effects such as
+   * caret placement.
    */
-  unescape(text: string): string;
+  replace(range: Range$1, replacement: string): boolean;
 }
 //#endregion
-//#region ../../core/src/features/parsing/parser/utils/annotate.d.ts
-/**
- * Make annotation from the markup for ParserV2
- *
- * @param markup - Markup pattern with __value__, __meta__, and/or __slot__ placeholders
- * @param params - Object with optional value, meta, and slot strings
- * @returns Annotated string with placeholders replaced
- *
- * @example
- * ```typescript
- * annotate('@[__value__]', { value: 'Hello' }) // '@[Hello]'
- * annotate('@[__value__](__meta__)', { value: 'Hello', meta: 'world' }) // '@[Hello](world)'
- * annotate('@[__slot__]', { slot: 'content' }) // '@[content]'
- * ```
- */
-declare function annotate(markup: Markup, params: {
-  value?: string;
-  meta?: string;
-  slot?: string;
-}): string;
-//#endregion
-//#region ../../core/src/features/parsing/parser/utils/denote.d.ts
-/**
- * Transform annotated text to another text by recursively processing all tokens
- *
- * @param value - Annotated text to process
- * @param callback - Function to transform each MarkToken
- * @param markups - Array of markup patterns to parse
- * @returns Transformed text
- *
- * @example
- * ```typescript
- * const text = '@[Hello](world) and #[nested @[content]]'
- * const result = denote(text, mark => mark.value, ['@[__value__](__meta__)', '#[__slot__]'])
- * // Returns: 'Hello and nested content'
- * ```
- */
-declare function denote(value: string, callback: (mark: MarkToken) => string, markups: Markup[]): string;
-//#endregion
 //#region ../../core/src/features/parsing/tokenIndex.d.ts
 type TokenIndex = {
-  readonly generation: number;
   pathFor(token: Token): TokenPath | undefined;
   addressFor(path: TokenPath): TokenAddress | undefined;
   resolve(path: TokenPath): Token | undefined;
-  resolveAddress(address: TokenAddress, expected?: TokenShapeSnapshot): Result<Token, 'stale'>;
+  resolveAddress(address: TokenAddress): Result<Token, 'stale'>;
   key(path: TokenPath): string;
-  equals(a: TokenPath, b: TokenPath): boolean;
 };
 //#endregion
-//#region ../../core/src/features/slots/types.d.ts
-interface MarkSlot {
-  (): (token: Token) => readonly [Slot, Record<string, unknown>];
-}
-interface OverlaySlot {
-  (): (option?: CoreOption, defaultComponent?: Slot) => readonly [Slot, Record<string, unknown>];
-}
-//#endregion
-//#region ../../core/src/features/slots/SlotsFeature.d.ts
-declare class SlotsFeature {
-  private readonly props;
-  readonly isBlock: Computed<boolean>;
-  readonly isDraggable: Computed<boolean>;
-  readonly containerComponent: Computed<Slot>;
-  readonly containerProps: Computed<{
-    className: string | undefined;
-    style?: CSSProperties$1;
-    [key: string]: unknown;
-  }>;
-  readonly blockComponent: Computed<Slot>;
-  readonly blockProps: Computed<Record<string, unknown> | undefined>;
-  readonly spanComponent: Computed<Slot>;
-  readonly spanProps: Computed<Record<string, unknown> | undefined>;
-  constructor(props: PropsModel);
-}
-//#endregion
-//#region ../../core/src/features/mark/MarkFeature.d.ts
-declare class MarkFeature {
+//#region ../../core/src/features/parsing/TokenModel.d.ts
+declare class TokenModel {
+  #private;
+  private readonly value;
   private readonly props;
-  readonly enabled: Computed<boolean>;
-  readonly slot: MarkSlot;
-  constructor(props: PropsModel);
+  readonly current: Computed<Token[]>;
+  readonly index: Computed<TokenIndex>;
+  constructor(value: ValueModel, props: PropsModel);
 }
 //#endregion
-//#region ../../core/src/features/value/ValueModel.d.ts
-declare class ValueModel {
-  private readonly props;
-  readonly isControlledMode: Computed<boolean>;
-  readonly current: Signal<string>;
-  constructor(props: PropsModel);
+//#region ../../core/src/features/state/Lifecycle.d.ts
+declare class Lifecycle {
+  readonly mounted: Event<void>;
+  readonly unmounted: Event<void>;
+  readonly rendered: Event<void>;
   /**
-   * Attempts to replace `range` with `replacement`. Returns `true` when the
-   * edit was accepted (range valid and not read-only), `false` otherwise.
-   * Callers use the return value to gate downstream side effects such as
-   * caret placement.
+   * Run `setup` when the editor is mounted. Any reactive subscription
+   * created inside `setup` (`watch`, `listen`, `effect`, nested
+   * `effectScope`) is automatically disposed on `unmounted` and re-created
+   * on the next `mounted`.
    */
-  replace(range: Range$1, replacement: string): boolean;
+  onMounted(setup: () => void): void;
 }
 //#endregion
-//#region ../../core/src/features/parsing/ParseController.d.ts
-declare class ParseController {
-  #private;
-  private readonly lifecycle;
-  private readonly value;
-  private readonly mark;
-  private readonly props;
-  private readonly slots;
-  readonly tokens: Signal<Token[]>;
-  readonly index: Computed<TokenIndex>;
-  readonly parser: Computed<Parser | undefined>;
-  readonly reparse: Event<void>;
-  constructor(lifecycle: Lifecycle, value: ValueModel, mark: MarkFeature, props: PropsModel, slots: SlotsFeature);
-  acceptTokens(tokens: Token[]): void;
-}
+//#region ../../core/src/features/dom/DomIndexer.d.ts
+type PathElements = {
+  path: TokenPath;
+  address: TokenAddress;
+  rowElement?: HTMLElement;
+  tokenElement: HTMLElement;
+  textElement?: HTMLElement;
+};
 //#endregion
-//#region ../../core/src/features/dom/DomController.d.ts
-declare class DomController {
+//#region ../../core/src/features/dom/DomModel.d.ts
+declare class DomModel {
   #private;
-  private readonly lifecycle;
-  private readonly props;
-  private readonly parsing;
-  private readonly value;
-  readonly index: Computed<DomIndex | undefined>;
   readonly container: Signal<HTMLElement | null>;
-  readonly diagnostics: Event<DomDiagnostic>;
   readonly indexed: Event<void>;
-  readonly readOnly: Computed<boolean>;
-  constructor(lifecycle: Lifecycle, props: PropsModel, parsing: ParseController, value: ValueModel);
+  readonly isUserSelecting: Signal<boolean>;
+  readonly isIndexed: Signal<boolean>;
+  constructor(lifecycle: Lifecycle, props: PropsModel, tokens: TokenModel);
   compositionStarted(): void;
   compositionEnded(): void;
   controlFor(ownerPath?: TokenPath): DomRef;
   childrenFor(ownerPath: TokenPath): DomRef;
-  reconcile(opts?: {
-    isUserSelecting?: boolean;
-  }): void;
+  reconcile(): void;
   locateNode(node: Node): NodeLocationResult;
-  placeAt(rawPosition: number, affinity?: 'before' | 'after'): Result<{
-    applied: number;
-  }, 'notIndexed' | 'invalidBoundary'>;
-  placeRange(range: Range$1): Result<{
-    applied: Range$1;
-  }, 'notIndexed' | 'invalidBoundary'>;
-  focusAddress(address: TokenAddress, boundary?: 'start' | 'end'): Result<void, 'notIndexed' | 'stale'>;
+  pathElements(): IterableIterator<PathElements>;
+  pathElementsFor(address: TokenAddress): PathElements | undefined;
   rawPositionFromBoundary(node: Node, offset: number, affinity?: 'before' | 'after'): BoundaryPositionResult;
   readRawSelection(): RawSelectionResult;
+  readSelectedContent(): {
+    html: string;
+    text: string;
+  } | undefined;
 }
 //#endregion
-//#region ../../core/src/features/caret/CaretModel.d.ts
-declare class CaretModel {
+//#region ../../core/src/features/selection/SelectionController.d.ts
+declare class SelectionController {
   #private;
   private readonly lifecycle;
   private readonly dom;
+  private readonly parsing;
   private readonly value;
-  readonly selection: Signal<Range$1 | undefined>;
+  private readonly props;
+  readonly range: Signal<Range$1 | undefined>;
   readonly position: Signal<number | undefined>;
-  /**
-   * Whether the user is actively selecting text (mouse drag, keyboard
-   * Shift+Arrow, etc.). Drives {@link DomController.reconcile} to freeze
-   * structural text surfaces (contenteditable=false) while selecting.
-   */
-  readonly isUserSelecting: Signal<boolean>;
   readonly isAllSelected: Computed<boolean>;
-  constructor(lifecycle: Lifecycle, dom: DomController, value: ValueModel);
+  constructor(lifecycle: Lifecycle, dom: DomModel, parsing: TokenModel, value: ValueModel, props: PropsModel);
+  focusFirst(): void;
   selectAll(): void;
+  /**
+   * Place the caret at a known token address. Use this when the caller already
+   * has a {@link TokenAddress} and needs to disambiguate which token owns a
+   * shared boundary position (e.g. a text-token ending at N and a mark-token
+   * starting at N both "own" position N). Position-only callers should write
+   * to `range` instead — the auto-apply effect handles the common case.
+   *
+   * Returns `true` when the address could be resolved and focused, `false`
+   * when the DOM is not yet indexed or the address is stale.
+   */
+  placeAtAddress(address: TokenAddress, boundary?: 'start' | 'end'): boolean;
 }
 //#endregion
 //#region ../../core/src/features/edit/EditController.d.ts
@@ -11067,38 +10863,62 @@ declare class CaretModel {
  */
 declare class EditController {
   private readonly value;
-  private readonly caret;
-  constructor(value: ValueModel, caret: CaretModel);
+  private readonly selection;
+  constructor(value: ValueModel, selection: SelectionController);
   replace(range: Range$1, replacement: string): void;
 }
 //#endregion
-//#region ../../core/src/features/clipboard/ClipboardController.d.ts
-declare class ClipboardController {
-  #private;
-  private readonly lifecycle;
-  private readonly edit;
-  private readonly dom;
-  private readonly parsing;
-  constructor(lifecycle: Lifecycle, edit: EditController, dom: DomController, parsing: ParseController);
-}
+//#region ../../core/src/features/parsing/parser/utils/annotate.d.ts
+/**
+ * Make annotation from the markup for ParserV2
+ *
+ * @param markup - Markup pattern with __value__, __meta__, and/or __slot__ placeholders
+ * @param params - Object with optional value, meta, and slot strings
+ * @returns Annotated string with placeholders replaced
+ *
+ * @example
+ * ```typescript
+ * annotate('@[__value__]', { value: 'Hello' }) // '@[Hello]'
+ * annotate('@[__value__](__meta__)', { value: 'Hello', meta: 'world' }) // '@[Hello](world)'
+ * annotate('@[__slot__]', { slot: 'content' }) // '@[content]'
+ * ```
+ */
+declare function annotate(markup: Markup, params: {
+  value?: string;
+  meta?: string;
+  slot?: string;
+}): string;
+//#endregion
+//#region ../../core/src/features/parsing/parser/utils/denote.d.ts
+/**
+ * Transform annotated text to another text by recursively processing all tokens
+ *
+ * @param value - Annotated text to process
+ * @param callback - Function to transform each MarkToken
+ * @param markups - Array of markup patterns to parse
+ * @returns Transformed text
+ *
+ * @example
+ * ```typescript
+ * const text = '@[Hello](world) and #[nested @[content]]'
+ * const result = denote(text, mark => mark.value, ['@[__value__](__meta__)', '#[__slot__]'])
+ * // Returns: 'Hello and nested content'
+ * ```
+ */
+declare function denote(value: string, callback: (mark: MarkToken) => string, markups: Markup[]): string;
 //#endregion
-//#region ../../core/src/features/drag/DragController.d.ts
-declare class DragController {
+//#region ../../core/src/features/block/BlockController.d.ts
+declare class BlockController {
   #private;
   private readonly props;
   private readonly value;
-  private readonly parsing;
-  private readonly caret;
+  private readonly tokens;
+  private readonly selection;
   readonly action: Event<DragAction>;
-  constructor(props: PropsModel, value: ValueModel, parsing: ParseController, caret: CaretModel);
-}
-//#endregion
-//#region ../../core/src/features/keyboard/KeyboardController.d.ts
-declare class KeyboardController {
-  constructor(lifecycle: Lifecycle, dom: DomController, value: ValueModel, caret: CaretModel, edit: EditController, slots: SlotsFeature, parsing: ParseController, props: PropsModel);
+  constructor(props: PropsModel, value: ValueModel, tokens: TokenModel, selection: SelectionController);
 }
 //#endregion
-//#region ../../core/src/store/BlockStore.d.ts
+//#region ../../core/src/features/block/BlockStore.d.ts
 type DropPosition = 'before' | 'after' | null;
 declare class BlockStore {
   #private;
@@ -11118,25 +10938,88 @@ declare class BlockStore {
   attachContainer(el: HTMLElement | null, blockIndex: number, actions: DragActions): void;
   attachGrip(el: HTMLButtonElement | null, blockIndex: number, actions: DragActions): void;
   attachMenu(el: HTMLElement | null): void;
-  closeMenu: () => void;
+  closeMenu: () => boolean;
   addBlock: () => void;
   deleteBlock: () => void;
   duplicateBlock: () => void;
 }
 //#endregion
-//#region ../../core/src/store/BlockRegistry.d.ts
+//#region ../../core/src/features/block/BlockRegistry.d.ts
 declare class BlockRegistry {
   #private;
   get(token: object): BlockStore;
 }
 //#endregion
-//#region ../../core/src/features/mark/MarkController.d.ts
+//#region ../../core/src/features/clipboard/ClipboardController.d.ts
+declare class ClipboardController {
+  #private;
+  private readonly lifecycle;
+  private readonly edit;
+  private readonly dom;
+  private readonly tokens;
+  constructor(lifecycle: Lifecycle, edit: EditController, dom: DomModel, tokens: TokenModel);
+}
+//#endregion
+//#region ../../core/src/features/keyboard/KeyboardController.d.ts
+declare class KeyboardController {
+  constructor(lifecycle: Lifecycle, dom: DomModel, value: ValueModel, selection: SelectionController, edit: EditController, tokens: TokenModel, props: PropsModel);
+}
+//#endregion
+//#region ../../core/src/features/slots/types.d.ts
+interface MarkSlot {
+  (): (token: Token) => readonly [Slot, Record<string, unknown>];
+}
+interface OverlaySlot {
+  (): (option?: CoreOption, defaultComponent?: Slot) => readonly [Slot, Record<string, unknown>];
+}
+//#endregion
+//#region ../../core/src/features/slots/SlotsFeature.d.ts
+declare class SlotsFeature {
+  private readonly props;
+  readonly containerComponent: Computed<Slot>;
+  readonly containerProps: Computed<{
+    className: string | undefined;
+    style?: CSSProperties$1;
+    [key: string]: unknown;
+  }>;
+  readonly blockComponent: Computed<Slot>;
+  readonly blockProps: Computed<Record<string, unknown> | undefined>;
+  readonly mark: MarkSlot;
+  constructor(props: PropsModel);
+}
+//#endregion
+//#region ../../core/src/shared/classes/KeyGenerator.d.ts
+declare class KeyGenerator {
+  #private;
+  get(object: object): number | undefined;
+}
+//#endregion
+//#region ../../core/src/store/Store.d.ts
+declare class Store {
+  readonly key: KeyGenerator;
+  readonly blocks: BlockRegistry;
+  readonly lifecycle: Lifecycle;
+  readonly props: PropsModel;
+  readonly value: ValueModel;
+  readonly tokens: TokenModel;
+  readonly slots: SlotsFeature;
+  readonly dom: DomModel;
+  readonly selection: SelectionController;
+  readonly edit: EditController;
+  readonly overlay: OverlayController;
+  readonly keyboard: KeyboardController;
+  readonly block: BlockController;
+  readonly clipboard: ClipboardController;
+  readonly handler: MarkputHandler;
+}
+//#endregion
+//#region ../../core/src/features/parsing/MarkController.d.ts
 declare class MarkController {
   #private;
   private readonly store;
   private readonly address;
   private readonly snapshot;
-  constructor(store: Store, address: TokenAddress, snapshot: MarkSnapshot, shape: TokenShapeSnapshot);
+  constructor(store: Store, address: TokenAddress, snapshot: MarkSnapshot);
   static fromToken(store: Store, token: MarkToken): MarkController;
   get value(): string;
   get meta(): string | undefined;
@@ -11153,9 +11036,9 @@ declare class OverlayController {
   private readonly props;
   private readonly value;
   private readonly dom;
-  private readonly caret;
+  private readonly selection;
   private readonly edit;
-  private readonly parsing;
+  private readonly tokens;
   readonly match: Signal<OverlayMatch | undefined>;
   readonly element: Signal<HTMLElement | null>;
   readonly slot: OverlaySlot;
@@ -11168,115 +11051,20 @@ declare class OverlayController {
     left: number;
     top: number;
   }>;
-  constructor(lifecycle: Lifecycle, props: PropsModel, value: ValueModel, dom: DomController, caret: CaretModel, edit: EditController, parsing: ParseController);
+  constructor(lifecycle: Lifecycle, props: PropsModel, value: ValueModel, dom: DomModel, selection: SelectionController, edit: EditController, tokens: TokenModel);
 }
 //#endregion
-//#region ../../core/src/shared/classes/MarkputHandler.d.ts
+//#region ../../core/src/store/MarkputHandler.d.ts
 declare class MarkputHandler {
   private readonly dom;
   private readonly overlayFeature;
-  private readonly parsing;
-  constructor(dom: DomController, overlayFeature: OverlayController, parsing: ParseController);
+  private readonly selection;
+  constructor(dom: DomModel, overlayFeature: OverlayController, selection: SelectionController);
   get container(): HTMLElement | null;
   get overlay(): HTMLElement | null;
   focus(): void;
 }
 //#endregion
-//#region ../../core/src/shared/classes/KeyGenerator.d.ts
-declare class KeyGenerator {
-  #private;
-  get(object: object): number | undefined;
-}
-//#endregion
-//#region ../../core/src/store/Store.d.ts
-declare class Store {
-  readonly key: KeyGenerator;
-  readonly blocks: BlockRegistry;
-  readonly lifecycle: Lifecycle;
-  readonly props: PropsModel;
-  readonly value: ValueModel;
-  readonly mark: MarkFeature;
-  readonly slots: SlotsFeature;
-  readonly parsing: ParseController;
-  readonly dom: DomController;
-  readonly caret: CaretModel;
-  readonly edit: EditController;
-  readonly overlay: OverlayController;
-  readonly keyboard: KeyboardController;
-  readonly drag: DragController;
-  readonly clipboard: ClipboardController;
-  readonly handler: MarkputHandler;
-}
-//#endregion
-//#region ../../core/src/shared/editorContracts.d.ts
-type TokenPath = readonly number[];
-type TokenAddress = {
-  readonly path: TokenPath;
-  readonly parseGeneration: number;
-};
-type Result<T, Reason extends string> = {
-  ok: true;
-  value: T;
-} | {
-  ok: false;
-  reason: Reason;
-};
-type DomRef = (element: HTMLElement | null) => void;
-type Range$1 = {
-  readonly start: number;
-  readonly end: number;
-};
-type RawSelection = {
-  readonly range: Range$1;
-  readonly direction?: 'forward' | 'backward';
-};
-type NodeLocationResult = Result<{
-  readonly address: TokenAddress;
-  readonly tokenElement: HTMLElement;
-  readonly textElement?: HTMLElement;
-  readonly rowElement?: HTMLElement;
-}, 'notIndexed' | 'outsideEditor' | 'control'>;
-type RawSelectionResult = Result<RawSelection, 'notIndexed' | 'outsideEditor' | 'control' | 'mixedBoundary' | 'invalidBoundary'>;
-type BoundaryPositionResult = Result<number, 'notIndexed' | 'outsideEditor' | 'control' | 'invalidBoundary' | 'composing'>;
-type OptionalMarkFieldPatch = {
-  readonly kind: 'set';
-  readonly value: string;
-} | {
-  readonly kind: 'clear';
-};
-type MarkPatch = {
-  readonly value?: string;
-  readonly meta?: OptionalMarkFieldPatch;
-  readonly slot?: OptionalMarkFieldPatch;
-};
-type MarkSnapshot = {
-  readonly value: string;
-  readonly meta: string | undefined;
-  readonly slot: string | undefined;
-  readonly readOnly: boolean;
-};
-type MarkInfo = {
-  readonly address: TokenAddress;
-  readonly depth: number;
-  readonly hasNestedMarks: boolean;
-  readonly key: string;
-};
-type TokenShapeSnapshot = {
-  readonly kind: 'text';
-} | {
-  readonly kind: 'mark';
-  readonly descriptor: MarkupDescriptor;
-  readonly descriptorIndex: number;
-};
-type DomIndex = {
-  readonly generation: number;
-};
-type DomDiagnostic = {
-  readonly kind: 'missingRole' | 'stalePath' | 'outsideEditor' | 'controlBoundary' | 'mixedBoundary' | 'invalidBoundary' | 'renderReentry' | 'recoveryFailed' | 'missingContainer' | 'ambiguousStructure';
-  readonly path?: TokenPath;
-  readonly reason: string;
-};
-//#endregion
 //#region src/types.d.ts
 /**
  * Props passed to Mark components.
@@ -11375,12 +11163,12 @@ interface MarkedInputProps<TMarkProps = MarkProps, TOverlayProps extends CoreOpt
   style?: CSSProperties;
   /**
    * Override internal components using slots
-   * @example slots={{ container: 'div', span: 'span' }}
+   * @example slots={{ container: 'div' }}
    */
   slots?: Slots;
   /**
    * Props to pass to slot components
-   * @example slotProps={{ container: { onKeyDown: handler }, span: { className: 'custom' } }}
+   * @example slotProps={{ container: { onKeyDown: handler } }}
    */
   slotProps?: SlotProps;
   /**