edytor 1.0.0-rc.2 → 1.0.0

package/dist/events/onBeforeInput.js

@@ -1,145 +1,101 @@
 import { vetoable } from '../utils.js';
-import { Text } from '../text/text.svelte.js';
 import { createDomRange, createDomSelectionSnapshotFromRange, getActiveElement, getDomSelection } from '../selection/domSelection.js';
 import { getYIndex } from '../selection/selection.utils.js';
 import { sameValue } from '../session/selection.js';
 import { INTENTS, attemptOf, intentOf, kindOf, reproject, targetless } from '../session/attempt.js';
 import { isAndroidChromeBrowser } from './events.utils.js';
 import { isNativeInteractiveControl, isNativeInteractiveEvent, ownsEvent } from './nativeInteractiveControl.js';
-import { observeInternalDragSources } from './onDrop.js';
-import { runBeforeInputCommand, runBeforeInputHotkeyBridge } from './beforeInputCommands.js';
+import { runBeforeInputCommand } from './beforeInputCommands.js';
+import { deleteInText } from './beforeInputDeleteCommands.js';
 import { readDomText } from './onInput.js';
-const isRangeInsideEditor = (edytor, range) => Boolean(edytor.node &&
-    edytor.node.contains(range.startContainer) &&
-    edytor.node.contains(range.endContainer));
-// Deletes whose extent the model computes itself (`deleteCollapsed*` in
-// beforeInputDeleteCommands): for a collapsed caret the browser's
-// targetRange is only used to locate the caret edge, never adopted
-// verbatim — Firefox delivers block-level end containers for word/line
-// deletes, which derive to a degenerate caret and no-op the delete.
-const deleteDir = (inputType) => INTENTS[inputType]?.dir;
-/** Insertions whose target is the caret the user placed (not a drop point). */
-const isTextInsertionInput = (inputType) => inputType.startsWith('insert') &&
-    inputType !== 'insertFromDrop' &&
-    ['text', 'composition', 'payload'].includes(kindOf(inputType) ?? '');
 /** The Android no-op-Backspace and model-owned drift deadlines (named, counted browser rules). */
 const NATIVE_INPUT_REPAIR_WINDOW_MS = 150;
-const getBeforeInputTextTargetRange = (edytor, range) => {
-    const startText = edytor.selection.getTextOfNode(range.startContainer);
-    const endText = edytor.selection.getTextOfNode(range.endContainer);
-    if (!startText || !endText) {
-        return null;
-    }
-    return {
-        startText,
-        endText,
-        yStart: getYIndex(startText, range.startContainer, range.startOffset),
-        yEnd: getYIndex(endText, range.endContainer, range.endOffset)
-    };
-};
-const isSafeDeleteTargetRange = (inputType, { startText, endText, yStart, yEnd }) => {
-    if (!deleteDir(inputType) || startText !== endText || yStart < 0 || yEnd < yStart)
-        return false;
-    if (yEnd > startText.length)
-        return false;
-    if (yStart !== yEnd)
-        return true;
-    return deleteDir(inputType) === 'back' ? yStart > 0 : yStart < startText.length;
+const dirOf = (inputType) => INTENTS[inputType]?.dir;
+/** An insertion at the caret the user placed (not a drop point, not a break). */
+const inserts = (inputType) => {
+    const kind = kindOf(inputType);
+    return (inputType.startsWith('insert') && inputType !== 'insertFromDrop' && !!kind && kind !== 'break');
 };
-const shouldSyncBeforeInputTargetRange = (edytor, reported, intent, targetRange) => {
-    if (kindOf(reported) === 'history') {
-        return false;
-    }
-    const { isCollapsed } = edytor.selection.state;
-    if (isTextInsertionInput(intent) &&
-        edytor.selection.consumeModelSelectionPreservationForTextInsertion()) {
-        return false;
-    }
-    if (isTextInsertionInput(intent) && intent !== 'insertReplacementText' && !isCollapsed) {
+/**
+ * Whether the range the browser declared, not the model selection, is where
+ * the attempt acts: never for history, nor for an insertion the model keeps
+ * its selection for, nor over a model range (but for a replacement or a
+ * drop); an insertion at the admitted caret keeps its edge side (Chromium
+ * re-reports ` tail`@0 as `Link`@4); a delete whose extent the model
+ * computes takes only a caret edge inside one text (Firefox declares
+ * block-level containers for word and line deletes).
+ */
+const declares = (edytor, a, range) => {
+    const { reported, inputType: intent, isCollapsed } = a;
+    const insertion = inserts(intent);
+    if (kindOf(reported) === 'history')
         return false;
-    }
-    if ((kindOf(intent) === 'break' || deleteDir(intent)) && !isCollapsed) {
+    if (!isCollapsed &&
+        (insertion ? intent !== 'insertReplacementText' : kindOf(intent) === 'break' || dirOf(intent)))
         return false;
-    }
-    const targetTextRange = getBeforeInputTextTargetRange(edytor, targetRange);
-    const { startText, yStart } = edytor.selection.state;
-    if (isTextInsertionInput(intent) &&
+    const start = edytor.selection.getTextOfNode(range.startContainer);
+    const end = edytor.selection.getTextOfNode(range.endContainer);
+    const from = getYIndex(start, range.startContainer, range.startOffset);
+    const to = getYIndex(end, range.endContainer, range.endOffset);
+    if (insertion &&
         isCollapsed &&
-        targetTextRange?.startText === startText &&
-        targetTextRange.endText === startText &&
-        targetTextRange.yStart === yStart &&
-        targetTextRange.yEnd === yStart) {
-        // The engine re-reports the admitted caret, canonicalized (Chromium moves
-        // ` tail`@0 into `Link`@4): the caret keeps its admitted edge side.
+        start === a.startText &&
+        end === start &&
+        from === a.yStart &&
+        to === from)
         return false;
-    }
-    if (!deleteDir(reported)) {
-        return true;
-    }
-    return targetTextRange ? isSafeDeleteTargetRange(reported, targetTextRange) : false;
+    const dir = dirOf(reported);
+    return (!dir ||
+        (!!start &&
+            start === end &&
+            from >= 0 &&
+            from <= to &&
+            to <= start.length &&
+            (from !== to || (dir === 'back' ? from > 0 : from < start.length))));
 };
-/** Resolve the declared target range into the selection the attempt is admitted at. */
-const syncSelectionFromDeclaredRange = (edytor, occurrence, intent) => {
-    const targetRange = occurrence.declared;
-    const reported = occurrence.inputType;
-    if (!targetRange ||
-        !isRangeInsideEditor(edytor, targetRange) ||
-        !shouldSyncBeforeInputTargetRange(edytor, reported, intent, targetRange)) {
-        return;
-    }
-    // The declared range becomes the model selection directly: the DOM
-    // selection is not a transport (a delete's caret edge for a collapsed caret).
-    const range = createDomRange(targetRange.startContainer);
-    const dir = deleteDir(reported);
-    if (dir && edytor.selection.state.isCollapsed) {
-        const [container, offset] = dir === 'back'
-            ? [targetRange.endContainer, targetRange.endOffset]
-            : [targetRange.startContainer, targetRange.startOffset];
-        range.setStart(container, offset);
+/** The declared range becomes the model selection: the DOM selection is not a transport. */
+const adoptDeclared = (edytor, a, declared) => {
+    const range = createDomRange(declared.startContainer);
+    const { startContainer, startOffset, endContainer, endOffset } = declared;
+    const dir = dirOf(a.reported);
+    if (dir && a.isCollapsed) {
+        // A collapsed caret's delete: the declared range only locates its edge.
+        if (dir === 'back')
+            range.setStart(endContainer, endOffset);
+        else
+            range.setStart(startContainer, startOffset);
         range.collapse(true);
     }
     else {
-        range.setStart(targetRange.startContainer, targetRange.startOffset);
-        range.setEnd(targetRange.endContainer, targetRange.endOffset);
+        range.setStart(startContainer, startOffset);
+        range.setEnd(endContainer, endOffset);
     }
     edytor.selection.applySelectionSnapshot(createDomSelectionSnapshotFromRange(range), {
         restoreNormalizedDomRange: false
     });
+    reproject(edytor, a);
 };
 /**
  * Undo-scope walk (Lexical #6714): when a control OUTSIDE the editor exhausts
  * its own undo stack, Chromium/WebKit re-dispatch `historyUndo`/`historyRedo`
- * at the contenteditable root with no selection. Those events are not
- * editor-owned — bail without `preventDefault` so the owning scope can handle
- * the command and the document's undo history is never consumed on a foreign
- * intent.
+ * at the contenteditable root. Those are not the editor's: no
+ * `preventDefault`, the owning scope handles them. A focused element outside
+ * owns the command; with nothing focused (the body, the document, the shadow
+ * host that retargets inner focus) the DOM selection decides.
  */
-const isForeignHistoryBeforeInput = (edytor, event) => {
-    if (kindOf(event.inputType) !== 'history') {
-        return false;
-    }
+const isForeignHistory = (edytor) => {
     const node = edytor.node;
-    if (!node) {
+    if (!node)
         return true;
-    }
-    const activeElement = getActiveElement(node);
-    if (activeElement === node || (activeElement && node.contains(activeElement))) {
+    const active = getActiveElement(node);
+    if (active && node.contains(active))
         return false;
-    }
-    // A focused element outside the editor owns the command. When nothing is
-    // focused (null/body/html, or the shadow host that retargets inner focus),
-    // the DOM selection decides whether the editor still holds editing scope.
-    const rootNode = node.getRootNode();
-    const shadowHost = typeof ShadowRoot !== 'undefined' && rootNode instanceof ShadowRoot ? rootNode.host : null;
-    const ownerDocument = node.ownerDocument;
-    if (activeElement &&
-        activeElement !== shadowHost &&
-        activeElement !== ownerDocument.body &&
-        activeElement !== ownerDocument.documentElement) {
-        return true;
-    }
-    const selection = getDomSelection(node);
-    return !selection?.anchorNode || !node.contains(selection.anchorNode);
+    const { body, documentElement } = node.ownerDocument;
+    const anchor = getDomSelection(node)?.anchorNode;
+    return ((!!active &&
+        ![body, documentElement, node.getRootNode().host].includes(active)) ||
+        !anchor ||
+        !node.contains(anchor));
 };
 /**
  * An input the browser performs alone: any in a kind's own control (a field
@@ -152,94 +108,64 @@ const isBrowserOwnedNativeInput = (edytor, event) => ownsEvent(edytor.node, even
     (isNativeInteractiveEvent(event) &&
         edytor.selection.selectedBlocks.size === 0 &&
         edytor.selection.selectedInlineBlock.size === 0);
-const shouldIgnoreBeforeInput = (edytor, attempt) => edytor.readonly ||
-    attempt.isVoidEditableElement ||
-    (attempt.event &&
-        (isBrowserOwnedNativeInput(edytor, attempt.event) ||
-            isNativeInteractiveControl(attempt.event.target)));
-/** One text, nothing spanning, no block selection: a change the browser can make alone. */
-const isTextLocal = (edytor, attempt) => edytor.selection.selectedBlocks.size === 0 &&
-    Boolean(attempt.startText) &&
-    attempt.startText === attempt.endText &&
-    !attempt.isTextSpanning &&
-    !attempt.isBlockSpanning;
-const isTextLocalDeletion = (edytor, attempt) => {
-    if (attempt.isStructuralKeyFallback ||
-        attempt.cancelable ||
-        isTrailingSoftBreakBackward(attempt) ||
-        (attempt.inputType !== 'deleteContentBackward' &&
-            attempt.inputType !== 'deleteContentForward') ||
-        !isTextLocal(edytor, attempt)) {
-        return false;
-    }
-    if (!attempt.isCollapsed) {
-        return true;
-    }
-    return attempt.inputType === 'deleteContentBackward'
-        ? !attempt.isAtStartOfText
-        : !attempt.isAtEndOfText;
-};
-const isTextLocalReplacement = (edytor, attempt) => attempt.inputType === 'insertReplacementText' &&
-    attempt.isCollapsed &&
-    isTextLocal(edytor, attempt);
-const isSafeTextLocalInsertion = (edytor, attempt) => !attempt.cancelable &&
-    attempt.inputType === 'insertText' &&
-    attempt.data !== '\t' &&
-    !(attempt.data === '@' && edytor.inlineBlocks.has('mention')) &&
-    attempt.isCollapsed &&
-    isTextLocal(edytor, attempt);
-/** A non-cancelable insertion the model must perform: the browser's own write is drift. */
-const isUnsafeNativeTextInsertion = (edytor, attempt) => !attempt.cancelable &&
-    ((attempt.inputType === 'insertText' && !isSafeTextLocalInsertion(edytor, attempt)) ||
-        (attempt.inputType === 'insertReplacementText' && !isTextLocalReplacement(edytor, attempt)) ||
-        kindOf(attempt.inputType) === 'payload');
-/**
- * `insertTranspose` (macOS Ctrl+T) and `insertFromYank` (Emacs yank)
- * carry no `data` and usually no `dataTransfer` — the model cannot know
- * what to insert, so the only correct handling is letting the browser
- * perform the mutation natively and reconciling it. Restricted to a
- * single text: a spanning range would let the browser clobber structure
- * the model cannot recover.
- */
-const isTextLocalRearrangeInput = (edytor, attempt) => (attempt.inputType === 'insertTranspose' || attempt.inputType === 'insertFromYank') &&
-    !attempt.data &&
-    !attempt.hasDataTransferTextPayload &&
-    edytor.selection.selectedInlineBlock.size === 0 &&
-    isTextLocal(edytor, attempt);
 /**
- * The owner rule: the browser performs a text-local insertion, replacement,
- * rearrangement or deletion (and composition-text deletion); the model
- * performs everything else. Answers the change a browser-owned attempt
- * expects, or `undefined` when the model owns it.
+ * The owner rule, one answer per attempt: the browser performs a text-local
+ * change — an insertion it reports without letting the model take it (but a
+ * tab or a mention trigger), a replacement or rearrangement (transpose, yank:
+ * no data the model could insert), a character delete inside the text (not a
+ * trailing soft break's, whose `<br>` it mishandles) — and the attempt
+ * expects that change on its host (`deleteCompositionText`: none to check).
+ * The model performs everything else; the answer is then how it repairs
+ * the DOM drift around it and for how long: a browser write it could not
+ * prevent (text, payloads, breaks) is inverted for the window, a delete's
+ * also has its caret restored.
  */
-const browserExpectation = (edytor, attempt) => {
-    const text = attempt.startText;
-    const change = (after = null) => text && edytor.selection.selectedBlocks.size === 0
-        ? { kind: 'change', host: text, after }
-        : null;
-    if (isSafeTextLocalInsertion(edytor, attempt)) {
-        const before = text.stringContent;
-        return change(before.slice(0, attempt.yStart) + attempt.data + before.slice(attempt.yStart));
-    }
-    if ((!attempt.hasDataTransferTextPayload && isTextLocalReplacement(edytor, attempt)) ||
-        // Transpose/yank: the browser rearranges; the model adopts it.
-        isTextLocalRearrangeInput(edytor, attempt) ||
-        isTextLocalDeletion(edytor, attempt))
-        return change();
-    if (attempt.inputType === 'deleteCompositionText')
+const nativeOf = (edytor, a) => {
+    const { inputType: type, startText: text, cancelable, isCollapsed } = a;
+    const kind = kindOf(type);
+    const plain = !a.hasDataTransferTextPayload;
+    const local = !edytor.selection.selectedBlocks.size &&
+        !!text &&
+        text === a.endText &&
+        !a.projection.isTextSpanning &&
+        !a.projection.isBlockSpanning;
+    const change = (after = null) => ({ kind: 'change', host: text, after });
+    if (local) {
+        if (isCollapsed &&
+            !cancelable &&
+            type === 'insertText' &&
+            a.data !== '\t' &&
+            !(a.data === '@' && edytor.inlineBlocks.has('mention'))) {
+            const before = text.stringContent;
+            return change(before.slice(0, a.yStart) + a.data + before.slice(a.yStart));
+        }
+        if (isCollapsed && plain && type === 'insertReplacementText')
+            return change();
+        if (plain &&
+            !a.data &&
+            /^insert(Transpose|FromYank)$/.test(type) &&
+            !edytor.selection.selectedInlineBlock.size)
+            return change();
+        if (!cancelable &&
+            !a.isStructuralKeyFallback &&
+            /^deleteContent(Back|For)ward$/.test(type) &&
+            !isTrailingSoftBreakBackward(a) &&
+            !(isCollapsed &&
+                (dirOf(type) === 'back' ? a.projection.isAtStartOfText : a.projection.isAtEndOfText)))
+            return change();
+    }
+    if (type === 'deleteCompositionText')
         return null;
-    return undefined;
-};
-/** How the browser's own mutation around a model-owned attempt is handled, for how long. */
-const driftOf = (edytor, attempt) => {
-    const kind = kindOf(attempt.inputType);
-    if (attempt.cancelable || kind === 'history')
+    if (cancelable)
         return ['refresh', 0];
-    if (isUnsafeNativeTextInsertion(edytor, attempt) || kind === 'break')
-        return ['discard', NATIVE_INPUT_REPAIR_WINDOW_MS];
-    if (kind === 'delete' && !isTextLocalDeletion(edytor, attempt))
+    if (kind === 'delete')
         return ['restore', NATIVE_INPUT_REPAIR_WINDOW_MS];
-    return ['refresh', 0];
+    return [
+        'refresh',
+        kind === 'break' || kind === 'payload' || /^insert(Text|ReplacementText)$/.test(type)
+            ? NATIVE_INPUT_REPAIR_WINDOW_MS
+            : 0
+    ];
 };
 /**
  * Android can announce a non-cancelable Backspace it never performs. At the
@@ -250,83 +176,64 @@ const androidNoOpBackspaceDeadline = (edytor, attempt) => {
     const text = attempt.startText;
     if (!isAndroidChromeBrowser() ||
         attempt.inputType !== 'deleteContentBackward' ||
-        !text ||
-        !attempt.isCollapsed ||
-        attempt.isAtStartOfText ||
-        attempt.isTextSpanning ||
-        attempt.isBlockSpanning) {
+        !attempt.isCollapsed)
         return;
-    }
     setTimeout(() => {
         // Did this attempt's adoption apply (or refuse) a deletion?
         if (attempt.phase === 'applied' ||
             attempt.phase === 'failed' ||
             !text.isInDocument ||
             !sameValue(edytor.selection.value, attempt.target) ||
-            readDomText(text) !== text.stringContent) {
+            readDomText(text) !== text.stringContent)
             return;
-        }
         attempt.phase = 'applied';
         edytor.attempts.drift(attempt, 'refresh', 0);
-        const deletion = text.deleteText({ direction: 'BACKWARD', length: 1 });
-        edytor.selection.setAtTextOffset(text, deletion?.start ?? attempt.yStart - 1);
+        deleteInText(edytor, text, attempt.yStart, true, false);
     }, NATIVE_INPUT_REPAIR_WINDOW_MS);
 };
 /**
  * Backspace right after a trailing soft break: the browser mishandles the
  * `<br>` it renders, so the model deletes the break (a command hooks see).
  */
-const isTrailingSoftBreakBackward = ({ inputType, isCollapsed, yStart, yEnd, startText }) => inputType === 'deleteContentBackward' &&
-    (isCollapsed || yStart === yEnd) &&
-    Boolean(startText?.stringContent.endsWith('\n')) &&
+export const isTrailingSoftBreakBackward = ({ inputType, yStart, yEnd, startText }) => inputType === 'deleteContentBackward' &&
+    yStart === yEnd &&
+    !!startText?.stringContent.endsWith('\n') &&
     yStart === startText.length;
-/** The pre-admission extension hook: an extension may claim a browser `beforeinput`. */
-const runBeforeInputPlugins = (edytor, event) => {
-    edytor.plugins.forEach((plugin) => {
-        vetoable((prevent) => plugin.onBeforeInput?.({ prevent, e: event }));
-    });
-};
 /**
  * Perform a model-owned attempt as one user command (undo policy, prevention
- * scope): the key's bindings first (offered once per occurrence), then its
- * drift expectation, the extension hook and the intent's command.
+ * scope): the key's bindings first (offered once per occurrence: the key it
+ * stands for when no keydown offered it — Android, virtual keyboards; a
+ * non-cancelable intent too, its attempt owns the browser's drift either
+ * way), then its drift expectation, the extension hook and the intent's
+ * command.
  */
-const perform = (edytor, attempt, offered) => edytor.dispatcher.run(attempt.inputType, async () => {
-    const { event } = attempt;
-    const kind = kindOf(attempt.inputType);
+const perform = (edytor, attempt, offered, [mode, window]) => edytor.dispatcher.run(attempt.inputType, async () => {
+    const { event, inputType, data } = attempt;
+    const kind = kindOf(inputType);
     attempt.phase = 'applied';
     event?.preventDefault();
-    if (kind === 'history') {
-        edytor.attempts.drift(attempt, 'refresh', 0);
-        if (attempt.inputType === 'historyUndo')
-            edytor.historyUndo();
-        else
-            edytor.historyRedo();
-        return;
-    }
+    const key = inputType === 'insertText' && data === '\t' ? 'tab' : INTENTS[inputType]?.key;
     // A binding claimed the intent: its command owns the result, the
     // observer repairs what the browser did around it.
-    if (runBeforeInputHotkeyBridge(edytor, attempt, offered))
+    if (key && key !== offered && edytor.keymap.run(key))
         return;
-    const [mode, window] = driftOf(edytor, attempt);
     // The live composition host is the session's: no drift expectation on it.
     if (kind !== 'composition')
         edytor.attempts.drift(attempt, mode, window);
+    if (kind === 'history')
+        return edytor[inputType]();
     try {
         if (event)
-            runBeforeInputPlugins(edytor, event);
+            for (const plugin of edytor.plugins)
+                vetoable((prevent) => plugin.onBeforeInput?.({ prevent, e: event }));
         await runBeforeInputCommand(edytor, attempt);
     }
     catch (error) {
         attempt.phase = 'failed';
         throw error;
     }
-    if (mode !== 'refresh')
+    if (window)
         edytor.attempts.arm(attempt, window);
-    // The command selected its caret; a paste re-renders the text it landed in.
-    const text = edytor.selection.state.startText;
-    if (attempt.inputType === 'insertFromPaste' && text?.node?.isConnected)
-        text.refreshFromModel();
     if (kind !== 'composition')
         edytor.composition.interrupt();
 });
@@ -336,69 +243,61 @@ const perform = (edytor, attempt, offered) => edytor.dispatcher.run(attempt.inpu
  * `key` is the keydown's attempt when that keydown announced the intent;
  * `reuse` is that attempt itself when its `beforeinput` never came.
  */
-const occur = (edytor, occurrence, key = null, offered = null, reuse) => {
-    observeInternalDragSources(edytor.node?.getRootNode());
+const occur = (edytor, occurrence, key, offered, reuse) => {
+    const { event, declared } = occurrence;
     const intent = intentOf(occurrence.inputType, occurrence.data ?? null, key?.inputType);
     if (kindOf(intent) !== 'composition')
         edytor.composition.occurred(intent);
+    const drop = () => reuse && edytor.attempts.close(reuse);
     // Admission: an intent with no target is refused before the declared range
-    // (where the browser parked its own caret) could become one.
-    if (targetless(edytor, intent))
-        return refuseTargetless(edytor, occurrence, key, reuse);
-    if (!reuse)
-        syncSelectionFromDeclaredRange(edytor, occurrence, intent);
-    const attempt = reuse ? reproject(edytor, reuse) : attemptOf(edytor, occurrence, key?.inputType);
-    if (shouldIgnoreBeforeInput(edytor, attempt)) {
-        if (reuse)
-            edytor.attempts.close(reuse);
-        return;
+    // (where the browser parked its own caret) could become one. Nothing is
+    // written; a browser write that cannot be prevented is drift the model
+    // owns until the deadline (a composition's is its session's: the tail
+    // restores its pinned host).
+    if (targetless(edytor, intent)) {
+        drop();
+        edytor.dispatcher.record({ operation: occurrence.inputType, status: 'refused' });
+        // The caret the browser placed for this key is its own, never adopted.
+        edytor.projector.parked();
+        if (occurrence.cancelable || !event)
+            return event?.preventDefault();
+        if (kindOf(occurrence.inputType) === 'composition')
+            return;
+        const attempt = edytor.attempts.admit(attemptOf(edytor, occurrence, key?.inputType), 'model');
+        attempt.phase = 'failed';
+        return edytor.attempts.drift(attempt, 'refresh', NATIVE_INPUT_REPAIR_WINDOW_MS);
     }
-    const expect = browserExpectation(edytor, attempt);
-    if (expect !== undefined) {
+    const attempt = reuse ? reproject(edytor, reuse) : attemptOf(edytor, occurrence, key?.inputType);
+    if (!reuse && declared && declares(edytor, attempt, declared))
+        adoptDeclared(edytor, attempt, declared);
+    // A native control's input over a block or atom selection (the others are
+    // the browser's, before any admission) writes nothing either.
+    if (edytor.readonly ||
+        attempt.isVoidEditableElement ||
+        (event && isNativeInteractiveControl(event.target)))
+        return drop();
+    const native = nativeOf(edytor, attempt);
+    if (!Array.isArray(native)) {
         edytor.dispatcher.cut(attempt.inputType);
-        edytor.attempts.admit(attempt, 'browser', expect);
-        androidNoOpBackspaceDeadline(edytor, attempt);
-        return;
+        edytor.attempts.admit(attempt, 'browser', native);
+        return androidNoOpBackspaceDeadline(edytor, attempt);
     }
     if (!edytor.dispatcher.permits()) {
-        occurrence.event?.preventDefault();
-        if (reuse)
-            edytor.attempts.close(reuse);
-        return;
+        event?.preventDefault();
+        return drop();
     }
     if (!reuse)
         edytor.attempts.admit(attempt, 'model');
-    return perform(edytor, attempt, offered);
-};
-/**
- * Refuse an occurrence with no target (`targetless`): nothing is written. A
- * cancelable one is prevented; a browser write that cannot be is drift the
- * model owns until the deadline (restored from the model, as an unsafe
- * native insertion's).
- */
-const refuseTargetless = (edytor, occurrence, key, reuse) => {
-    if (reuse)
-        edytor.attempts.close(reuse);
-    edytor.dispatcher.record({ operation: occurrence.inputType, status: 'refused' });
-    // The caret the browser placed for this key is its own, never adopted.
-    edytor.projector.parked();
-    if (occurrence.cancelable || !occurrence.event) {
-        occurrence.event?.preventDefault();
-        return;
-    }
-    // A composition's writes are its session's: the tail restores its pinned host.
-    if (kindOf(occurrence.inputType) === 'composition')
-        return;
-    const attempt = edytor.attempts.admit(attemptOf(edytor, occurrence, key?.inputType), 'model');
-    attempt.phase = 'failed';
-    edytor.attempts.drift(attempt, 'discard', NATIVE_INPUT_REPAIR_WINDOW_MS);
+    return perform(edytor, attempt, offered, native);
 };
-/** An occurrence with no `beforeinput` of its own (paste, drop, a line break found in the DOM). */
-export const runOccurrence = (edytor, occurrence) => {
+/** The keydown's attempt this occurrence confirms, and the chord it offered the bindings. */
+const keyed = (edytor) => {
     const offered = edytor.keymap.offered;
     edytor.keymap.offered = null;
-    return occur(edytor, occurrence, edytor.attempts.confirm(), offered);
+    return [edytor.attempts.confirm(), offered];
 };
+/** An occurrence with no `beforeinput` of its own (paste, drop, a line break found in the DOM). */
+export const runOccurrence = (edytor, occurrence) => occur(edytor, occurrence, ...keyed(edytor));
 /**
  * A keydown whose intent some engines never announce (structural keys): an
  * attempt at the keydown's anchored target, run at the missing-`beforeinput`
@@ -416,22 +315,10 @@ const runKeyAttempt = async (edytor, attempt) => {
     edytor.attempts.arm(attempt, NATIVE_INPUT_REPAIR_WINDOW_MS);
     // The browser may have moved the selection since the keydown: the key
     // acts on its anchored target, which followed any concurrent edit.
-    edytor.selection.commit(attempt.target, 'repair');
-    const { state, selectedBlocks } = edytor.selection;
-    if (selectedBlocks.size > 0) {
-        edytor.selection.selectBlocks(...selectedBlocks);
-    }
-    else if (state.startText && state.endText) {
-        if (state.isCollapsed)
-            edytor.selection.setAtTextOffset(state.startText, state.yStart);
-        else
-            edytor.selection.setAtRange(state.startText, state.yStart, state.endText, state.yEnd);
-    }
-    else {
-        // Its target is gone (a remote delete): a named no-op.
-        edytor.attempts.close(attempt);
-        return;
-    }
+    edytor.selection.select(attempt.target);
+    // Its target is gone (a remote delete): a named no-op.
+    if (!edytor.selection.projection.start)
+        return edytor.attempts.close(attempt);
     // A real `beforeinput` or a newer key may have taken over meanwhile.
     if (edytor.attempts.key !== attempt)
         return;
@@ -439,42 +326,31 @@ const runKeyAttempt = async (edytor, attempt) => {
 };
 export async function onBeforeInput(event) {
     // The keydown of this occurrence may have admitted its attempt and offered its key.
-    const key = this.attempts.confirm();
-    const offered = this.keymap.offered;
-    this.keymap.offered = null;
-    if (event.inputType === 'deleteByDrag' && event.isTrusted) {
-        event.preventDefault();
-        this.selection.pointer.release();
-        return;
-    }
-    if (isBrowserOwnedNativeInput(this, event)) {
-        this.attempts.clear((attempt) => attempt.owner === 'browser');
-        return;
-    }
-    const declared = typeof event.getTargetRanges === 'function' ? (event.getTargetRanges()[0] ?? null) : null;
-    if (declared && !isRangeInsideEditor(this, declared)) {
-        event.preventDefault();
-        return;
-    }
-    if (isForeignHistoryBeforeInput(this, event)) {
-        return;
-    }
-    if (this.isComposing && kindOf(event.inputType) === 'history') {
-        // A history command landing mid-composition would consume capture
-        // groups (and the preview's own model writes) while the IME still
-        // owns the DOM node; the commit would then resolve against a moved
-        // document. Swallow it — undo applies cleanly after the commit.
+    const [key, offered] = keyed(this);
+    const { inputType } = event;
+    const kind = kindOf(inputType);
+    if (inputType === 'deleteByDrag' && event.isTrusted) {
         event.preventDefault();
+        return this.selection.pointer.release();
+    }
+    if (isBrowserOwnedNativeInput(this, event))
+        return this.attempts.clear((attempt) => attempt.owner === 'browser');
+    const declared = event.getTargetRanges?.()[0] ?? null;
+    const node = this.node;
+    if (declared &&
+        !(node?.contains(declared.startContainer) && node.contains(declared.endContainer)))
+        return event.preventDefault();
+    if (kind === 'history' && isForeignHistory(this))
         return;
-    }
-    // Mid-composition paste/drop is left to the browser (PM input.ts:656-660):
-    // the composition preview owns the write path and the deferred observer
-    // reconciles whatever the native insertion produced after compositionend.
-    if (this.isComposing && kindOf(event.inputType) === 'payload') {
-        return;
-    }
+    // A history command landing mid-composition would consume capture groups
+    // (and the preview's own model writes) while the IME still owns the DOM
+    // node: swallowed, undo applies cleanly after the commit. A paste or drop
+    // mid-composition is left to the browser (PM input.ts:656-660): the
+    // preview owns the write path, the observer reconciles it after the end.
+    if (this.isComposing && (kind === 'history' || kind === 'payload'))
+        return kind === 'history' ? event.preventDefault() : undefined;
     return occur(this, {
-        inputType: event.inputType,
+        inputType,
         data: event.data,
         dataTransfer: event.dataTransfer,
         declared,