@markput/react 0.12.1 → 0.14.1

package/index.d.ts

@@ -38,35 +38,6 @@ 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 {
@@ -118,6 +89,63 @@ 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;
+}
+//#endregion
 //#region ../../../node_modules/.pnpm/csstype@3.2.3/node_modules/csstype/index.d.ts
 interface StandardLonghandProperties<TLength = (string & {}) | 0, TTime = string & {}> {
   /**
@@ -10547,6 +10575,147 @@ declare namespace DataType {
   type VisualBox = "border-box" | "content-box" | "padding-box";
 }
 //#endregion
+//#region ../../core/src/shared/types.d.ts
+/**
+ * Registry interface used as a module-augmentation target. Framework packages
+ * add a `default` property whose type is the framework's component type.
+ *
+ * @example React augmentation
+ * declare module '@markput/core' {
+ *   interface SlotRegistry {
+ *     default: import('react').ElementType
+ *   }
+ * }
+ *
+ * Without augmentation, `Slot` falls back to `unknown`.
+ */
+interface SlotRegistry {}
+/** Framework-provided component type. Resolves to `unknown` unless `SlotRegistry` is augmented. */
+type Slot = keyof SlotRegistry extends never ? unknown : SlotRegistry[keyof SlotRegistry];
+/**
+ * Core option for markups - Framework-agnostic configuration.
+ * Extended by framework-specific Option types (e.g., React Option).
+ *
+ * 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
+ */
+interface CoreOption {
+  /**
+   * Template string in which the mark is rendered.
+   * Must contain placeholders: `__value__`, `__meta__`, and/or `__slot__`
+   *
+   * Placeholder types:
+   * - `__value__` - main content (plain text, no nesting)
+   * - `__meta__` - additional metadata (plain text, no nesting)
+   * - `__slot__` - content supporting nested structures
+   *
+   * @example
+   * // Simple value
+   * "@[__value__]"
+   *
+   * @example
+   * // Value with metadata
+   * "@[__value__](__meta__)"
+   *
+   * @example
+   * // Nested content support
+   * "@[__slot__]"
+   */
+  markup?: Markup;
+  overlay?: {
+    trigger?: string;
+  };
+}
+type OverlayMatch<TOption = CoreOption> = {
+  /**
+   * Found value via a overlayMatch
+   */
+  value: string;
+  /**
+   * Triggered value
+   */
+  source: string;
+  /**
+   * Piece of text, in which was a overlayMatch
+   */
+  span: string;
+  /**
+   * Html element, in which was a overlayMatch
+   */
+  node: Node;
+  range: Range$1;
+  /**
+   * OverlayMatch's option
+   */
+  option: TOption;
+};
+type OverlayTrigger = Array<'change' | 'selectionChange'> | 'change' | 'selectionChange' | 'none';
+type CSSProperties$1 = Properties<string | number>;
+type DataAttributes = Record<`data${Capitalize<string>}`, string | number | boolean | undefined>;
+interface CoreSlots {
+  container?: Slot;
+  block?: Slot;
+  span?: Slot;
+}
+interface CoreSlotProps {
+  container?: Record<string, unknown> & {
+    className?: string;
+    style?: CSSProperties$1;
+  };
+  block?: Record<string, unknown> & {
+    className?: string;
+    style?: CSSProperties$1;
+  };
+  span?: Record<string, unknown> & {
+    className?: string;
+    style?: CSSProperties$1;
+  };
+}
+interface DraggableConfig {
+  alwaysShowHandle?: boolean;
+}
+type DragAction = {
+  type: 'reorder';
+  source: number;
+  target: number;
+} | {
+  type: 'add';
+  afterIndex: number;
+} | {
+  type: 'delete';
+  index: number;
+} | {
+  type: 'duplicate';
+  index: number;
+};
+interface DragActions {
+  action: {
+    (action: DragAction): void;
+  };
+}
+//#endregion
+//#region ../../core/src/features/props/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 draggable: Signal<boolean | DraggableConfig>;
+  readonly showOverlayOn: Signal<OverlayTrigger>;
+  readonly Span: Signal<_$react.ElementType | undefined>;
+  readonly Mark: Signal<_$react.ElementType | undefined>;
+  readonly Overlay: Signal<_$react.ElementType | undefined>;
+  readonly className: Signal<string | undefined>;
+  readonly style: Signal<CSSProperties$1 | undefined>;
+  readonly slots: Signal<CoreSlots | undefined>;
+  readonly slotProps: Signal<CoreSlotProps | undefined>;
+  set(values: Partial<SignalValues<typeof this>>): void;
+}
+//#endregion
 //#region ../../core/src/features/parsing/parser/Parser.d.ts
 /**
  * Parser - High-performance tree-based markup parser
@@ -10763,51 +10932,170 @@ declare function annotate(markup: Markup, params: {
  */
 declare function denote(value: string, callback: (mark: MarkToken) => string, markups: Markup[]): string;
 //#endregion
-//#region ../../core/src/features/caret/CaretFeature.d.ts
-declare class CaretFeature implements Feature {
+//#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'>;
+  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 {
+  private readonly props;
+  readonly enabled: Computed<boolean>;
+  readonly slot: MarkSlot;
+  constructor(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);
+  /**
+   * 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.
+   */
+  replace(range: Range$1, replacement: string): boolean;
+}
+//#endregion
+//#region ../../core/src/features/parsing/ParseController.d.ts
+declare class ParseController {
   #private;
-  private readonly _store;
-  readonly recovery: Signal<Recovery | undefined>;
-  readonly selecting: Signal<"drag" | "all" | undefined>;
-  constructor(_store: Store);
-  enable(): void;
-  disable(): void;
+  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;
 }
 //#endregion
-//#region ../../core/src/shared/signals/signal.d.ts
-interface Signal<T> {
-  (): T;
-  (value: T | undefined): void;
+//#region ../../core/src/features/dom/DomController.d.ts
+declare class DomController {
+  #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);
+  compositionStarted(): void;
+  compositionEnded(): void;
+  controlFor(ownerPath?: TokenPath): DomRef;
+  childrenFor(ownerPath: TokenPath): DomRef;
+  reconcile(opts?: {
+    isUserSelecting?: boolean;
+  }): 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'>;
+  rawPositionFromBoundary(node: Node, offset: number, affinity?: 'before' | 'after'): BoundaryPositionResult;
+  readRawSelection(): RawSelectionResult;
 }
-type SignalValues<T> = { [K in keyof T]: T[K] extends Signal<infer V> | Computed<infer V> ? V : T[K] };
-interface Computed<T> {
-  (): T;
+//#endregion
+//#region ../../core/src/features/caret/CaretModel.d.ts
+declare class CaretModel {
+  #private;
+  private readonly lifecycle;
+  private readonly dom;
+  private readonly value;
+  readonly selection: 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);
+  selectAll(): void;
 }
-interface Event<T = void> {
-  (payload: T): void;
-  read(): T | undefined;
+//#endregion
+//#region ../../core/src/features/edit/EditController.d.ts
+/**
+ * Single write path for text edits — delegates gating to {@link ValueModel.replace}
+ * and only moves the caret when the edit is accepted. Wrapped in {@link batch}
+ * so subscribers observe a consistent value/selection pair on one tick.
+ */
+declare class EditController {
+  private readonly value;
+  private readonly caret;
+  constructor(value: ValueModel, caret: CaretModel);
+  replace(range: Range$1, replacement: string): void;
 }
 //#endregion
-//#region ../../core/src/features/props/PropsFeature.d.ts
-declare class PropsFeature {
-  private readonly _store;
-  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 draggable: Signal<boolean | DraggableConfig>;
-  readonly showOverlayOn: Signal<OverlayTrigger>;
-  readonly Span: Signal<_$react.ElementType | undefined>;
-  readonly Mark: Signal<_$react.ElementType | undefined>;
-  readonly Overlay: Signal<_$react.ElementType | undefined>;
-  readonly className: Signal<string | undefined>;
-  readonly style: Signal<CSSProperties$1 | undefined>;
-  readonly slots: Signal<CoreSlots | undefined>;
-  readonly slotProps: Signal<CoreSlotProps | undefined>;
-  constructor(_store: Store);
-  set(values: Partial<SignalValues<typeof this>>): void;
+//#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);
+}
+//#endregion
+//#region ../../core/src/features/drag/DragController.d.ts
+declare class DragController {
+  #private;
+  private readonly props;
+  private readonly value;
+  private readonly parsing;
+  private readonly caret;
+  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);
 }
 //#endregion
 //#region ../../core/src/store/BlockStore.d.ts
@@ -10842,182 +11130,32 @@ declare class BlockRegistry {
   get(token: object): BlockStore;
 }
 //#endregion
-//#region ../../core/src/features/clipboard/ClipboardFeature.d.ts
-declare class ClipboardFeature {
-  #private;
-  private readonly store;
-  constructor(store: Store);
-  enable(): void;
-  disable(): void;
-}
-//#endregion
-//#region ../../core/src/features/dom/DomFeature.d.ts
-declare class DomFeature {
-  #private;
-  private readonly _store;
-  constructor(_store: Store);
-  enable(): void;
-  disable(): void;
-  reconcile(): void;
-}
-//#endregion
-//#region ../../core/src/features/drag/DragFeature.d.ts
-declare class DragFeature {
-  #private;
-  private readonly store;
-  readonly action: Event<DragAction>;
-  constructor(store: Store);
-  enable(): void;
-  disable(): void;
-}
-//#endregion
-//#region ../../core/src/features/keyboard/KeyboardFeature.d.ts
-declare class KeyboardFeature implements Feature {
+//#region ../../core/src/features/mark/MarkController.d.ts
+declare class MarkController {
   #private;
-  private readonly _store;
-  constructor(_store: Store);
-  enable(): void;
-  disable(): void;
-}
-//#endregion
-//#region ../../core/src/shared/classes/MarkputHandler.d.ts
-declare class MarkputHandler {
   private readonly store;
-  constructor(store: Store);
-  get container(): HTMLDivElement | 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/shared/classes/NodeProxy.d.ts
-declare class NodeProxy {
-  #private;
-  get target(): HTMLElement | undefined;
-  set target(value: Node | HTMLElement | EventTarget | undefined | null);
-  get next(): NodeProxy;
-  get prev(): NodeProxy;
-  get isSpan(): boolean;
-  get isMark(): boolean;
-  get isEditable(): boolean;
-  get isCaretAtBeginning(): boolean;
-  get isCaretAtEnd(): boolean;
-  get index(): number;
-  get caret(): number;
-  set caret(value: number);
-  get length(): number;
-  get content(): string;
-  set content(value: string | undefined);
-  get head(): HTMLElement | null;
-  get tail(): HTMLElement | null;
-  get isFocused(): boolean;
-  constructor(target: Node | EventTarget | null | undefined, store: Store);
-  setCaretToEnd(): void;
-  focus(): void;
-  clear(): void;
-}
-//#endregion
-//#region ../../core/src/features/lifecycle/LifecycleFeature.d.ts
-declare class LifecycleFeature implements Feature {
-  private readonly _store;
-  readonly mounted: Event<void>;
-  readonly unmounted: Event<void>;
-  readonly rendered: Event<void>;
-  constructor(_store: Store);
-  enable(): void;
-  disable(): void;
-}
-//#endregion
-//#region ../../core/src/features/mark/MarkHandler.d.ts
-interface RefAccessor<T> {
-  current: T | null;
-}
-declare class MarkHandler<T extends HTMLElement = HTMLElement> {
-  #private;
-  readonly ref: RefAccessor<T>;
-  constructor(param: {
-    ref: RefAccessor<T>;
-    store: Store;
-    token: MarkToken;
-  });
-  get readOnly(): boolean | undefined;
-  set readOnly(value: boolean | undefined);
-  get content(): string;
-  set content(value: string);
-  get value(): string | undefined;
-  set value(v: string | undefined);
+  private readonly address;
+  private readonly snapshot;
+  constructor(store: Store, address: TokenAddress, snapshot: MarkSnapshot, shape: TokenShapeSnapshot);
+  static fromToken(store: Store, token: MarkToken): MarkController;
+  get value(): string;
   get meta(): string | undefined;
-  set meta(v: string | undefined);
   get slot(): string | undefined;
-  get depth(): number;
-  get hasChildren(): boolean;
-  get parent(): MarkToken | undefined;
-  get tokens(): Token[];
-  change: (props: {
-    content: string;
-    value?: string;
-    meta?: string;
-  }) => void;
-  remove: () => void;
-}
-//#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>];
+  get readOnly(): boolean;
+  remove(): void;
+  update(patch: MarkPatch): void;
 }
 //#endregion
-//#region ../../core/src/features/slots/SlotsFeature.d.ts
-declare class SlotsFeature implements Feature {
-  private readonly _store;
-  readonly container: Signal<HTMLDivElement | null>;
-  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(_store: Store);
-  enable(): void;
-  disable(): void;
-}
-//#endregion
-//#region ../../core/src/features/mark/MarkFeature.d.ts
-declare class MarkFeature implements Feature {
-  #private;
-  private readonly _store;
-  readonly enabled: Computed<boolean>;
-  readonly slot: MarkSlot;
-  readonly remove: Event<{
-    token: Token;
-  }>;
-  constructor(_store: Store);
-  enable(): void;
-  disable(): void;
-}
-//#endregion
-//#region ../../core/src/features/mark/types.d.ts
-interface MarkOptions {
-  controlled?: boolean;
-}
-//#endregion
-//#region ../../core/src/features/overlay/OverlayFeature.d.ts
-declare class OverlayFeature implements Feature {
+//#region ../../core/src/features/overlay/OverlayController.d.ts
+declare class OverlayController {
   #private;
-  private readonly _store;
+  private readonly lifecycle;
+  private readonly props;
+  private readonly value;
+  private readonly dom;
+  private readonly caret;
+  private readonly edit;
+  private readonly parsing;
   readonly match: Signal<OverlayMatch | undefined>;
   readonly element: Signal<HTMLElement | null>;
   readonly slot: OverlaySlot;
@@ -11026,194 +11164,118 @@ declare class OverlayFeature implements Feature {
     match: OverlayMatch;
   }>;
   readonly close: Event<void>;
-  constructor(_store: Store);
-  enable(): void;
-  disable(): void;
+  readonly position: Computed<{
+    left: number;
+    top: number;
+  }>;
+  constructor(lifecycle: Lifecycle, props: PropsModel, value: ValueModel, dom: DomController, caret: CaretModel, edit: EditController, parsing: ParseController);
 }
 //#endregion
-//#region ../../core/src/features/parsing/ParseFeature.d.ts
-declare class ParsingFeature implements Feature {
-  #private;
-  private readonly _store;
-  readonly tokens: Signal<Token[]>;
-  readonly parser: Computed<Parser | undefined>;
-  readonly reparse: Event<void>;
-  constructor(_store: Store);
-  enable(): void;
-  disable(): void;
-  sync(): void;
+//#region ../../core/src/shared/classes/MarkputHandler.d.ts
+declare class MarkputHandler {
+  private readonly dom;
+  private readonly overlayFeature;
+  private readonly parsing;
+  constructor(dom: DomController, overlayFeature: OverlayController, parsing: ParseController);
+  get container(): HTMLElement | null;
+  get overlay(): HTMLElement | null;
+  focus(): void;
 }
 //#endregion
-//#region ../../core/src/features/value/ValueFeature.d.ts
-declare class ValueFeature implements Feature {
+//#region ../../core/src/shared/classes/KeyGenerator.d.ts
+declare class KeyGenerator {
   #private;
-  private readonly _store;
-  readonly last: Signal<string | undefined>;
-  readonly next: Signal<string | undefined>;
-  readonly current: Computed<string>;
-  readonly change: Event<void>;
-  constructor(_store: Store);
-  enable(): void;
-  disable(): void;
+  get(object: object): number | undefined;
 }
 //#endregion
 //#region ../../core/src/store/Store.d.ts
 declare class Store {
   readonly key: KeyGenerator;
   readonly blocks: BlockRegistry;
-  readonly nodes: {
-    focus: NodeProxy;
-    input: NodeProxy;
-  };
-  readonly props: PropsFeature;
-  readonly handler: MarkputHandler;
-  readonly lifecycle: LifecycleFeature;
-  readonly value: ValueFeature;
+  readonly lifecycle: Lifecycle;
+  readonly props: PropsModel;
+  readonly value: ValueModel;
   readonly mark: MarkFeature;
-  readonly overlay: OverlayFeature;
   readonly slots: SlotsFeature;
-  readonly caret: CaretFeature;
-  readonly keyboard: KeyboardFeature;
-  readonly dom: DomFeature;
-  readonly drag: DragFeature;
-  readonly clipboard: ClipboardFeature;
-  readonly parsing: ParsingFeature;
-  constructor();
+  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/types.d.ts
-/**
- * Registry interface used as a module-augmentation target. Framework packages
- * add a `default` property whose type is the framework's component type.
- *
- * @example React augmentation
- * declare module '@markput/core' {
- *   interface SlotRegistry {
- *     default: import('react').ElementType
- *   }
- * }
- *
- * Without augmentation, `Slot` falls back to `unknown`.
- */
-interface SlotRegistry {}
-/** Framework-provided component type. Resolves to `unknown` unless `SlotRegistry` is augmented. */
-type Slot = keyof SlotRegistry extends never ? unknown : SlotRegistry[keyof SlotRegistry];
-/**
- * Core option for markups - Framework-agnostic configuration.
- * Extended by framework-specific Option types (e.g., React Option).
- *
- * 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
- */
-interface CoreOption {
-  /**
-   * Template string in which the mark is rendered.
-   * Must contain placeholders: `__value__`, `__meta__`, and/or `__slot__`
-   *
-   * Placeholder types:
-   * - `__value__` - main content (plain text, no nesting)
-   * - `__meta__` - additional metadata (plain text, no nesting)
-   * - `__slot__` - content supporting nested structures
-   *
-   * @example
-   * // Simple value
-   * "@[__value__]"
-   *
-   * @example
-   * // Value with metadata
-   * "@[__value__](__meta__)"
-   *
-   * @example
-   * // Nested content support
-   * "@[__slot__]"
-   */
-  markup?: Markup;
-  overlay?: {
-    trigger?: string;
-  };
-}
-type OverlayMatch<TOption = CoreOption> = {
-  /**
-   * Found value via a overlayMatch
-   */
-  value: string;
-  /**
-   * Triggered value
-   */
-  source: string;
-  /**
-   * Piece of text, in which was a overlayMatch
-   */
-  span: string;
-  /**
-   * Html element, in which was a overlayMatch
-   */
-  node: Node;
-  /**
-   * Start position of a overlayMatch
-   */
-  index: number;
-  /**
-   * OverlayMatch's option
-   */
-  option: TOption;
-};
-type Recovery = {
-  anchor: NodeProxy;
-  isNext?: boolean;
-  caret: number;
-  childIndex?: number;
+//#region ../../core/src/shared/editorContracts.d.ts
+type TokenPath = readonly number[];
+type TokenAddress = {
+  readonly path: TokenPath;
+  readonly parseGeneration: number;
 };
-type OverlayTrigger = Array<'change' | 'selectionChange'> | 'change' | 'selectionChange' | 'none';
-type CSSProperties$1 = Properties<string | number>;
-type DataAttributes = Record<`data${Capitalize<string>}`, string | number | boolean | undefined>;
-interface CoreSlots {
-  container?: Slot;
-  block?: Slot;
-  span?: Slot;
-}
-interface CoreSlotProps {
-  container?: Record<string, unknown> & {
-    className?: string;
-    style?: CSSProperties$1;
-  };
-  block?: Record<string, unknown> & {
-    className?: string;
-    style?: CSSProperties$1;
-  };
-  span?: Record<string, unknown> & {
-    className?: string;
-    style?: CSSProperties$1;
-  };
-}
-interface DraggableConfig {
-  alwaysShowHandle?: boolean;
-}
-type DragAction = {
-  type: 'reorder';
-  source: number;
-  target: number;
+type Result<T, Reason extends string> = {
+  ok: true;
+  value: T;
 } | {
-  type: 'add';
-  afterIndex: number;
+  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;
 } | {
-  type: 'delete';
-  index: number;
+  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';
 } | {
-  type: 'duplicate';
-  index: number;
+  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;
 };
-interface DragActions {
-  action: {
-    (action: DragAction): void;
-  };
-}
-interface Feature {
-  enable(): void;
-  disable(): void;
-}
 //#endregion
 //#region src/types.d.ts
 /**
@@ -11346,7 +11408,10 @@ interface MarkedInputProps<TMarkProps = MarkProps, TOverlayProps extends CoreOpt
 declare function MarkedInput<TMarkProps = MarkProps, TOverlayProps extends CoreOption['overlay'] = OverlayProps>(props: MarkedInputProps<TMarkProps, TOverlayProps>): _$react_jsx_runtime0.JSX.Element;
 //#endregion
 //#region src/lib/hooks/useMark.d.ts
-declare const useMark: <T extends HTMLElement = HTMLElement>(options?: MarkOptions) => MarkHandler<T>;
+declare const useMark: () => MarkController;
+//#endregion
+//#region src/lib/hooks/useMarkInfo.d.ts
+declare const useMarkInfo: () => MarkInfo;
 //#endregion
 //#region src/lib/hooks/useOverlay.d.ts
 interface OverlayHandler {
@@ -11370,5 +11435,5 @@ type ObjectSelector = Record<string, Selectable<unknown> | unknown>;
 declare function useMarkput<T>(selector: (store: Store) => Selectable<T>): T;
 declare function useMarkput<R extends ObjectSelector>(selector: (store: Store) => R): SignalValues<R>;
 //#endregion
-export { MarkHandler, type MarkProps, type MarkToken, MarkedInput, type MarkedInputProps, MarkputHandler, type Markup, type Option, type OverlayHandler, type OverlayProps, type TextToken, type Token, annotate, denote, useMark, useMarkput, useOverlay };
+export { MarkController, type MarkProps, type MarkToken, MarkedInput, type MarkedInputProps, MarkputHandler, type Markup, type Option, type OverlayHandler, type OverlayProps, type TextToken, type Token, annotate, denote, useMark, useMarkInfo, useMarkput, useOverlay };
 //# sourceMappingURL=index.d.ts.map