@markput/react 0.14.0 → 0.14.2

package/index.d.ts

@@ -94,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
  */
@@ -118,6 +112,60 @@ 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/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 & {}> {
   /**
@@ -10547,181 +10595,277 @@ declare namespace DataType {
   type VisualBox = "border-box" | "content-box" | "padding-box";
 }
 //#endregion
-//#region ../../core/src/features/parsing/parser/Parser.d.ts
+//#region ../../core/src/shared/types.d.ts
 /**
- * Parser - High-performance tree-based markup parser
+ * Registry interface used as a module-augmentation target. Framework packages
+ * add a `default` property whose type is the framework's component type.
  *
- * Parses text with markup patterns into a nested token tree structure.
- * Supports complex patterns with metadata, nesting, and HTML-like constructs.
+ * @example React augmentation
+ * declare module '@markput/core' {
+ *   interface SlotRegistry {
+ *     default: import('react').ElementType
+ *   }
+ * }
  *
- * @example
- * ```typescript
- * const parser = new Parser(['@[__value__](__meta__)', '#[__slot__]'])
- * const tokens = parser.parse('Hello @[world](test) and #[tag]')
- * const text = parser.stringify(tokens)
- * ```
+ * Without augmentation, `Slot` falls back to `unknown`.
  */
-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);
+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 tokens, framework handles overlay triggers
+ */
+interface CoreOption {
   /**
-   * Parses text into tokens (static convenience method)
+   * Template string in which the mark is rendered.
+   * Must contain placeholders: `__value__`, `__meta__`, and/or `__slot__`
    *
-   * @param value - Text to parse
-   * @param options - Options with markup patterns and token filtering
-   * @returns Array of tokens (TextToken and MarkToken)
+   * Placeholder types:
+   * - `__value__` - main content (plain text, no nesting)
+   * - `__meta__` - additional metadata (plain text, no nesting)
+   * - `__slot__` - content supporting nested structures
    *
    * @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)
+   * // Simple value
+   * "@[__value__]"
    *
-   * @param tokens - Array of tokens to convert
-   * @returns Reconstructed text string
+   * @example
+   * // Value with metadata
+   * "@[__value__](__meta__)"
    *
    * @example
-   * ```typescript
-   * const text = Parser.stringify(tokens)
-   * ```
+   * // Nested content support
+   * "@[__slot__]"
    */
-  static stringify(tokens: Token[]): string;
+  markup?: Markup;
+  overlay?: {
+    trigger?: string;
+  };
+}
+type OverlayMatch<TOption = CoreOption> = {
   /**
-   * 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('')
-   * // ]
-   * ```
+   * Found value via a overlayMatch
    */
-  parse(value: string): Token[];
+  value: string;
   /**
-   * 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
-   * ```
+   * Triggered value
    */
-  stringify(tokens: Token[]): string;
+  source: 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'
-   * ```
+   * Piece of text, in which was a overlayMatch
    */
-  transform(value: string, callback: (mark: MarkToken) => string): string;
+  span: 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]'
-   * ```
+   * Html element, in which was a overlayMatch
    */
-  escape(text: string): string;
+  node: Node;
+  range: Range$1;
   /**
-   * 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]'
-   * ```
+   * 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;
+}
+interface CoreSlotProps {
+  container?: Record<string, unknown> & {
+    className?: string;
+    style?: CSSProperties$1;
+  };
+  block?: 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/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"> & ComputedRecord<{
+    isBlock: () => boolean;
+  }>;
+  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/state/ValueModel.d.ts
+declare class ValueModel {
+  private readonly props;
+  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/tokenIndex.d.ts
+type TokenIndex = {
+  pathFor(token: Token): TokenPath | undefined;
+  addressFor(path: TokenPath): TokenAddress | undefined;
+  resolve(path: TokenPath): Token | undefined;
+  resolveAddress(address: TokenAddress): Result<Token, 'stale'>;
+  key(path: TokenPath): string;
+};
+//#endregion
+//#region ../../core/src/features/parsing/TokenModel.d.ts
+declare class TokenModel {
+  #private;
+  private readonly value;
+  private readonly props;
+  readonly current: Computed<Token[]>;
+  readonly index: Computed<TokenIndex>;
+  constructor(value: ValueModel, props: PropsModel);
+}
+//#endregion
+//#region ../../core/src/features/state/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`.
    */
-  unescape(text: string): string;
+  onMounted(setup: () => void): void;
+}
+//#endregion
+//#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/DomModel.d.ts
+declare class DomModel {
+  #private;
+  readonly container: Signal<HTMLElement | null>;
+  readonly indexed: Event<void>;
+  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(): void;
+  locateNode(node: Node): NodeLocationResult;
+  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/selection/SelectionController.d.ts
+declare class SelectionController {
+  #private;
+  private readonly lifecycle;
+  private readonly dom;
+  private readonly parsing;
+  private readonly value;
+  private readonly props;
+  readonly range: Signal<Range$1 | undefined>;
+  readonly position: Signal<number | undefined>;
+  readonly isAllSelected: Computed<boolean>;
+  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
+/**
+ * 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 selection;
+  constructor(value: ValueModel, selection: SelectionController);
+  replace(range: Range$1, replacement: string): void;
 }
 //#endregion
 //#region ../../core/src/features/parsing/parser/utils/annotate.d.ts
@@ -10763,147 +10907,18 @@ declare function annotate(markup: Markup, params: {
  */
 declare function denote(value: string, callback: (mark: MarkToken) => string, markups: Markup[]): string;
 //#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 RawRange = {
-  readonly start: number;
-  readonly end: number;
-};
-type RawSelection = {
-  readonly range: RawRange;
-  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 EditResult = {
-  ok: true;
-  value: string;
-  accepted: 'immediate' | 'pendingControlledEcho';
-} | {
-  ok: false;
-  reason: 'readOnly' | 'invalidRange' | 'stale';
-};
-type CaretRecovery = {
-  readonly kind: 'caret';
-  readonly rawPosition: number;
-  readonly affinity?: 'before' | 'after';
-} | {
-  readonly kind: 'selection';
-  readonly selection: RawSelection;
-};
-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 CaretLocation = {
-  readonly address: TokenAddress;
-  readonly role: 'row' | 'token' | 'text' | 'markDescendant';
-};
-type DomDiagnostic = {
-  readonly kind: 'missingRole' | 'stalePath' | 'outsideEditor' | 'controlBoundary' | 'mixedBoundary' | 'invalidBoundary' | 'renderReentry' | 'recoveryFailed' | 'missingContainer' | 'ambiguousStructure';
-  readonly path?: TokenPath;
-  readonly reason: string;
-};
-type EditSource = 'input' | 'paste' | 'cut' | 'overlay' | 'mark' | 'block' | 'drag';
-//#endregion
-//#region ../../core/src/features/caret/CaretFeature.d.ts
-declare class CaretFeature implements Feature {
+//#region ../../core/src/features/block/BlockController.d.ts
+declare class BlockController {
   #private;
-  private readonly _store;
-  readonly recovery: Signal<CaretRecovery | undefined>;
-  readonly location: Signal<CaretLocation | undefined>;
-  readonly selecting: Signal<"drag" | "all" | undefined>;
-  constructor(_store: Store);
-  enable(): void;
-  disable(): void;
-  placeAt(rawPosition: number, affinity?: 'before' | 'after'): Result<void, 'notIndexed' | 'invalidBoundary'>;
-  focus(address: TokenAddress, boundary?: 'start' | 'end'): Result<void, 'notIndexed' | 'stale'>;
-}
-//#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/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;
+  private readonly props;
+  private readonly value;
+  private readonly tokens;
+  private readonly selection;
+  readonly action: Event<DragAction>;
+  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;
@@ -10923,91 +10938,31 @@ 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/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 {
+//#region ../../core/src/features/clipboard/ClipboardController.d.ts
+declare class ClipboardController {
   #private;
-  private readonly _store;
-  readonly index: Computed<DomIndex | undefined>;
-  readonly container: Signal<HTMLElement | null>;
-  readonly diagnostics: Event<DomDiagnostic>;
-  constructor(_store: Store);
-  enable(): void;
-  disable(): void;
-  compositionStarted(): void;
-  compositionEnded(): void;
-  controlFor(ownerPath?: TokenPath): DomRef;
-  childrenFor(ownerPath: TokenPath): DomRef;
-  reconcile(): void;
-  locateNode(node: Node): NodeLocationResult;
-  placeCaretAtRawPosition(rawPosition: number, affinity?: 'before' | 'after'): Result<void, 'notIndexed' | 'invalidBoundary'>;
-  focusAddress(address: TokenAddress, boundary?: 'start' | 'end'): Result<void, 'notIndexed' | 'stale'>;
-  rawPositionFromBoundary(node: Node, offset: number, affinity?: 'before' | 'after'): BoundaryPositionResult;
-  readRawSelection(): RawSelectionResult;
-}
-//#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 {
-  #private;
-  private readonly _store;
-  constructor(_store: Store);
-  enable(): void;
-  disable(): void;
-}
-//#endregion
-//#region ../../core/src/features/lifecycle/LifecycleFeature.d.ts
-declare class LifecycleFeature implements Feature {
-  readonly mounted: Event<void>;
-  readonly unmounted: Event<void>;
-  readonly rendered: Event<void>;
-  enable(): void;
-  disable(): void;
+  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/mark/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);
-  static fromToken(store: Store, token: MarkToken): MarkController;
-  get value(): string;
-  get meta(): string | undefined;
-  get slot(): string | undefined;
-  get readOnly(): boolean;
-  remove(): EditResult;
-  update(patch: MarkPatch): EditResult;
+//#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
@@ -11019,10 +10974,8 @@ interface OverlaySlot {
 }
 //#endregion
 //#region ../../core/src/features/slots/SlotsFeature.d.ts
-declare class SlotsFeature implements Feature {
-  private readonly _store;
-  readonly isBlock: Computed<boolean>;
-  readonly isDraggable: Computed<boolean>;
+declare class SlotsFeature {
+  private readonly props;
   readonly containerComponent: Computed<Slot>;
   readonly containerProps: Computed<{
     className: string | undefined;
@@ -11031,27 +10984,61 @@ declare class SlotsFeature implements Feature {
   }>;
   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;
+  readonly mark: MarkSlot;
+  constructor(props: PropsModel);
 }
 //#endregion
-//#region ../../core/src/features/mark/MarkFeature.d.ts
-declare class MarkFeature implements Feature {
-  private readonly _store;
-  readonly enabled: Computed<boolean>;
-  readonly slot: MarkSlot;
-  constructor(_store: Store);
-  enable(): void;
-  disable(): void;
+//#region ../../core/src/shared/classes/KeyGenerator.d.ts
+declare class KeyGenerator {
+  #private;
+  get(object: object): number | undefined;
 }
 //#endregion
-//#region ../../core/src/features/overlay/OverlayFeature.d.ts
-declare class OverlayFeature implements Feature {
+//#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);
+  static fromToken(store: Store, token: MarkToken): MarkController;
+  get value(): string;
+  get meta(): string | undefined;
+  get slot(): string | undefined;
+  get readOnly(): boolean;
+  remove(): void;
+  update(patch: MarkPatch): void;
+}
+//#endregion
+//#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 selection;
+  private readonly edit;
+  private readonly tokens;
   readonly match: Signal<OverlayMatch | undefined>;
   readonly element: Signal<HTMLElement | null>;
   readonly slot: OverlaySlot;
@@ -11060,218 +11047,24 @@ declare class OverlayFeature implements Feature {
     match: OverlayMatch;
   }>;
   readonly close: Event<void>;
-  constructor(_store: Store);
-  enable(): void;
-  disable(): void;
-}
-//#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'>;
-  key(path: TokenPath): string;
-  equals(a: TokenPath, b: TokenPath): boolean;
-};
-//#endregion
-//#region ../../core/src/features/parsing/ParseFeature.d.ts
-declare class ParsingFeature implements Feature {
-  #private;
-  private readonly _store;
-  readonly tokens: Signal<Token[]>;
-  readonly index: Computed<TokenIndex>;
-  readonly parser: Computed<Parser | undefined>;
-  readonly reparse: Event<void>;
-  constructor(_store: Store);
-  parseValue(value: string): Token[];
-  acceptTokens(tokens: Token[]): void;
-  enable(): void;
-  disable(): void;
-  sync(value?: string): void;
-}
-//#endregion
-//#region ../../core/src/features/value/ValueFeature.d.ts
-declare class ValueFeature implements Feature {
-  #private;
-  private readonly _store;
-  readonly current: Signal<string>;
-  readonly isControlledMode: Computed<boolean>;
-  readonly change: Event<void>;
-  constructor(_store: Store);
-  enable(): void;
-  disable(): void;
-  replaceRange(range: RawRange, replacement: string, options?: {
-    recover?: CaretRecovery;
-    source?: EditSource;
-  }): EditResult;
-  replaceAll(next: string, options?: {
-    recover?: CaretRecovery;
-    source?: EditSource;
-  }): EditResult;
+  readonly position: Computed<{
+    left: number;
+    top: number;
+  }>;
+  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 store;
-  constructor(store: Store);
+  private readonly dom;
+  private readonly overlayFeature;
+  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 props: PropsFeature;
-  readonly handler: MarkputHandler;
-  readonly lifecycle: LifecycleFeature;
-  readonly value: ValueFeature;
-  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();
-}
-//#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: RawRange;
-  /**
-   * 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;
-  };
-}
-interface Feature {
-  enable(): void;
-  disable(): void;
-}
-//#endregion
 //#region src/types.d.ts
 /**
  * Props passed to Mark components.
@@ -11370,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;
   /**