edytor 1.0.0 → 3.0.0

package/dist/selection/replaceSelection.js

@@ -340,7 +340,7 @@ export const deleteSelectedBlocks = (edytor, blocks = selectedMembers(edytor)) =
             ...beside(blocks[0], 'blockBefore', blocks),
             ...beside(blocks.at(-1), 'blockAfter', blocks)
         ];
-    const deleted = edytor.dispatcher.caret(at?.text, at?.offset ?? 0, () => edytor.deleteBlocks(blocks.map((block) => block.id)));
+    const deleted = edytor.dispatcher.caretIn(at?.text, at?.offset ?? 0, () => edytor.deleteBlocks(blocks.map((block) => block.id)));
     if (deleted?.status !== 'applied')
         return null;
     edytor.announcer.deleted(what);
@@ -354,7 +354,7 @@ export const deleteSelectedBlocks = (edytor, blocks = selectedMembers(edytor)) =
     const text = virtual ? edytor.idToBlock.get(virtual)?.firstText : undefined;
     const survivor = besides.find((block) => block.isInTree);
     if (text)
-        edytor.dispatcher.caret(text, 0);
+        edytor.dispatcher.caretIn(text, 0);
     else if (survivor)
         edytor.selection.select(blockSelection([survivor.id]));
     return text ?? null;

package/dist/selection/selection.svelte.d.ts

@@ -94,7 +94,7 @@ export declare class EdytorSelection {
      * the start binds right (boundary inserts stay outside), the end and a
      * caret bind left; `none` when the start text is not bound to the document.
      */
-    textValue: (startText: Text, yStart: number, endText?: Text, yEnd?: number, isReversed?: boolean, startAffinity?: "left" | "right", mint?: (text: Text, offset: number, affinity?: "left" | "right") => TextAnchor | null) => SelectionValue;
+    textValue: (startText: Text, yStart: number, endText?: Text, yEnd?: number, isReversed?: boolean, startAffinity?: "left" | "right") => SelectionValue;
     /**
      * A pointer drag is in progress (a press in the host, until its release):
      * the projector does not display under it, and the overlay chrome
@@ -123,9 +123,9 @@ export declare class EdytorSelection {
      * facade maps to the owning backing text — content routed from other
      * blocks' backing texts (merges/splits) anchors correctly.
      *
-     * `null` while the text isn't bound to a live block (mirrors the
-     * baseline where a non-integrated Y.Text couldn't produce an absolute
-     * position).
+     * Minted from the text's block record, live or not (the atoms of a text
+     * that died to a merge live on in the block that claimed them); `null`
+     * for the root's own text.
      */
     createTextAnchor: (text: Text, offset: number, affinity?: "left" | "right") => TextAnchor | null;
     /**
@@ -148,12 +148,6 @@ export declare class EdytorSelection {
      * never mounts.
      */
     displayable: (id: string) => boolean;
-    /** The view's visibility rule (`selection/visibility.ts`), for extensions: hidden by view state, and the shown neighbour. */
-    hidden: (block: Block, removed?: ReadonlySet<Block>) => boolean;
-    shown: (block: Block, step: "blockBefore" | "blockAfter", { sealed, removed }?: {
-        sealed?: boolean;
-        removed?: ReadonlySet<Block>;
-    }) => Block | null;
     /** The text's computed direction (a Surface fact): arrow and word keys are visual. */
     rtl: (text: Text) => boolean;
 }

package/dist/selection/selection.svelte.js

@@ -389,7 +389,8 @@ export class EdytorSelection {
      * the start binds right (boundary inserts stay outside), the end and a
      * caret bind left; `none` when the start text is not bound to the document.
      */
-    textValue = (startText, yStart, endText = startText, yEnd = yStart, isReversed = false, startAffinity, mint = this.createTextAnchor) => {
+    textValue = (startText, yStart, endText = startText, yEnd = yStart, isReversed = false, startAffinity) => {
+        const mint = this.createTextAnchor;
         const collapsed = startText === endText && yStart === yEnd;
         const start = mint(startText, yStart, startAffinity ?? (collapsed ? 'left' : 'right'));
         if (!start)
@@ -413,9 +414,7 @@ export class EdytorSelection {
         if (!startText || !endText)
             return;
         const at = (text, offset) => Math.min(Math.max(offset, 0), text.length);
-        const value = this.textValue(startText, at(startText, yStart), endText, at(endText, yEnd), isReversed, undefined, (text, offset, side) => text.parent.isRoot
-            ? null
-            : this.edytor.facade.anchorAt(text.blockId, text.segStart + offset, side));
+        const value = this.textValue(startText, at(startText, yStart), endText, at(endText, yEnd), isReversed);
         const target = project(value, this.edytor.facade).start
             ? value
             : this.#seamValue(startText.parent?.id ?? null);
@@ -652,12 +651,12 @@ export class EdytorSelection {
      * facade maps to the owning backing text — content routed from other
      * blocks' backing texts (merges/splits) anchors correctly.
      *
-     * `null` while the text isn't bound to a live block (mirrors the
-     * baseline where a non-integrated Y.Text couldn't produce an absolute
-     * position).
+     * Minted from the text's block record, live or not (the atoms of a text
+     * that died to a merge live on in the block that claimed them); `null`
+     * for the root's own text.
      */
     createTextAnchor = (text, offset, affinity = 'left') => {
-        if (text.parent.isRoot || !text.isInDocument)
+        if (text.parent.isRoot)
             return null;
         return this.edytor.facade.anchorAt(text.blockId, text.segStart + offset, affinity);
     };
@@ -688,9 +687,6 @@ export class EdytorSelection {
             ?.content.find((part) => part instanceof Text && part.node != null)?.node;
         return !!node && !node.closest(visibility.HIDDEN);
     };
-    /** The view's visibility rule (`selection/visibility.ts`), for extensions: hidden by view state, and the shown neighbour. */
-    hidden = visibility.hidden;
-    shown = visibility.shown;
     /** The text's computed direction (a Surface fact): arrow and word keys are visual. */
     rtl = (text) => !!text.node?.isConnected && getComputedStyle(text.node).direction === 'rtl';
     /** A caret at the seam `dead` vacated (`doc/anchors`); `null` when nothing displays. */

package/dist/session/attempt.d.ts

@@ -18,6 +18,7 @@
  */
 import type { Edytor } from '../edytor.svelte.js';
 import type { Text } from '../text/text.svelte.js';
+import type { BlockMovePosition } from './moves.js';
 type Kind = 'text' | 'composition' | 'payload' | 'break' | 'delete' | 'history';
 export type IntentRow = {
     kind: Kind;
@@ -63,10 +64,10 @@ export declare const untargeted: (edytor: Edytor) => boolean;
  * void's own field.
  */
 declare const facts: (edytor: Edytor) => {
-    projection: import("./selection").SelectionProjection;
+    projection: import("./selection.js").SelectionProjection;
     isCollapsed: boolean;
     /** The admitted mark-edge side of a caret. */
-    edge: import("./editing/text").EdgeSide | undefined;
+    edge: import("./editing/text.js").EdgeSide | undefined;
     isVoidEditableElement: boolean;
     startText: Text | null;
     endText: Text | null;
@@ -74,7 +75,7 @@ declare const facts: (edytor: Edytor) => {
     yEnd: number;
     texts: Text[];
     /** The anchored target, fixed at admission. */
-    target: import("./selection").SelectionValue;
+    target: import("./selection.js").SelectionValue;
 };
 /**
  * How DOM drift around a model-owned attempt is repaired: the observer
@@ -107,9 +108,16 @@ export type Occurrence = {
     dataTransfer?: DataTransfer | null;
     /** The range the browser declared (`getTargetRanges()`, a drop point). */
     declared?: StaticRange | null;
+    /** Where a file drop lands, the indicator's placement (`plugins/fileDrop.ts`). */
+    placement?: DropAt | null;
     cancelable: boolean;
     event?: InputEvent;
 };
+/** A drop's placement in block terms: beside, before, after or inside `block`. */
+export type DropAt = {
+    block: string;
+    position: BlockMovePosition;
+};
 export type Attempt = ReturnType<typeof facts> & {
     id: number;
     /** The intent, fixed at admission. */
@@ -121,6 +129,7 @@ export type Attempt = ReturnType<typeof facts> & {
     dataTransfer: DataTransfer | null;
     hasDataTransferTextPayload: boolean;
     declared: StaticRange | null;
+    placement: DropAt | null;
     /** Admitted from a keydown (the key's intent wins; the browser may never announce it). */
     isStructuralKeyFallback: boolean;
     owner: 'model' | 'browser';
@@ -135,10 +144,10 @@ export declare const intentSnapshot: (edytor: Edytor, inputType: string) => Atte
 export declare const caretAt: (edytor: Edytor, text: Text | null | undefined, offset: number) => void;
 /** Re-project an attempt's anchored target when it runs later than its admission. */
 export declare const reproject: (edytor: Edytor, attempt: Attempt) => {
-    projection: import("./selection").SelectionProjection;
+    projection: import("./selection.js").SelectionProjection;
     isCollapsed: boolean;
     /** The admitted mark-edge side of a caret. */
-    edge: import("./editing/text").EdgeSide | undefined;
+    edge: import("./editing/text.js").EdgeSide | undefined;
     isVoidEditableElement: boolean;
     startText: Text | null;
     endText: Text | null;
@@ -146,7 +155,7 @@ export declare const reproject: (edytor: Edytor, attempt: Attempt) => {
     yEnd: number;
     texts: Text[];
     /** The anchored target, fixed at admission. */
-    target: import("./selection").SelectionValue;
+    target: import("./selection.js").SelectionValue;
 } & {
     id: number;
     /** The intent, fixed at admission. */
@@ -158,6 +167,7 @@ export declare const reproject: (edytor: Edytor, attempt: Attempt) => {
     dataTransfer: DataTransfer | null;
     hasDataTransferTextPayload: boolean;
     declared: StaticRange | null;
+    placement: DropAt | null;
     /** Admitted from a keydown (the key's intent wins; the browser may never announce it). */
     isStructuralKeyFallback: boolean;
     owner: "model" | "browser";

package/dist/session/attempt.js

@@ -119,6 +119,7 @@ export const attemptOf = (edytor, occurrence, keyIntent) => {
         dataTransfer: occurrence.dataTransfer ?? null,
         hasDataTransferTextPayload: payload !== null,
         declared: occurrence.declared ?? null,
+        placement: occurrence.placement ?? null,
         isStructuralKeyFallback: Boolean(keyIntent),
         owner: 'model',
         expect: null,

package/dist/session/bindings.js

@@ -24,7 +24,7 @@ export const replaceSelectedAtom = (edytor, value = '') => {
     edytor.removeInline(parent.id, selected.id);
     if (value)
         edytor.insertText(parent.id, text.segStart + offset, value);
-    edytor.dispatcher.caret(text, offset + value.length);
+    edytor.dispatcher.caretIn(text, offset + value.length);
     return true;
 };
 /** The selection is the editor's own: an inline atom or blocks (no DOM range shows it). */
@@ -119,41 +119,44 @@ const moveRoots = (edytor, blocks, direction) => {
         .flatMap((moved) => moved ?? []);
 };
 /**
- * Tab / Shift+Tab: nest or unnest the selected block, or the caret's block.
+ * Tab / Shift+Tab, with `allowNesting`: nest or unnest the selected block, or the caret's block.
  * Selected blocks, or the blocks a text range spans, move one level per
  * group of siblings, a selected block's selected descendants with it, as
  * one command; the selection stays (its anchors moved with the blocks).
  */
-const nest = (operation) => ({ edytor, prevent }) => prevent(() => {
-    const { selection } = edytor;
-    const { value } = selection;
-    const direction = operation === 'nestBlock' ? 'in' : 'out';
-    const blocks = getSelectionBlocks(edytor);
-    if (blocks.length > 1) {
-        if (moveRoots(edytor, blocks, direction).length)
-            selection.select(value);
-        return;
-    }
-    const [selected] = selection.selectedBlocks;
-    const at = selection.textAt(selection.projection.start);
-    const block = selected ?? at?.text.parent;
-    if (!block)
-        return;
-    // Into the block before it; the view's move reveals a closed toggle it lands in or that adopts.
-    const into = block.previousBlock;
-    if (operation === 'nestBlock' && !into)
-        return edytor.dispatcher.record({ operation, status: 'refused' });
-    const result = operation === 'unNestBlock'
-        ? edytor.unNestBlock(block.id)
-        : edytor.nestBlock(block.id, into.id);
-    if (result.status !== 'applied')
-        return;
-    edytor.announcer.moved({ blocks: [block], direction }, [block]);
-    if (selected)
-        selection.select(blockSelection([block.id]));
-    else if (at)
-        caretAt(edytor, block.content[at.text.index], at.offset);
-});
+const nest = (operation) => ({ edytor, prevent }) => 
+// Nesting off (`allowNesting`, the default): the key is not the editor's, the browser moves the focus on.
+edytor.allowNesting &&
+    prevent(() => {
+        const { selection } = edytor;
+        const { value } = selection;
+        const direction = operation === 'nestBlock' ? 'in' : 'out';
+        const blocks = getSelectionBlocks(edytor);
+        if (blocks.length > 1) {
+            if (moveRoots(edytor, blocks, direction).length)
+                selection.select(value);
+            return;
+        }
+        const [selected] = selection.selectedBlocks;
+        const at = selection.textAt(selection.projection.start);
+        const block = selected ?? at?.text.parent;
+        if (!block)
+            return;
+        // Into the block before it; the view's move reveals a closed toggle it lands in or that adopts.
+        const into = block.previousBlock;
+        if (operation === 'nestBlock' && !into)
+            return edytor.dispatcher.record({ operation, status: 'refused' });
+        const result = operation === 'unNestBlock'
+            ? edytor.unNestBlock(block.id)
+            : edytor.nestBlock(block.id, into.id);
+        if (result.status !== 'applied')
+            return;
+        edytor.announcer.moved({ blocks: [block], direction }, [block]);
+        if (selected)
+            selection.select(blockSelection([block.id]));
+        else if (at)
+            caretAt(edytor, block.content[at.text.index], at.offset);
+    });
 /**
  * Backspace/Delete over an editor-owned selection: the selected atom, or
  * the selected blocks (the caret lands at the end of the block before them).

package/dist/session/commands.d.ts

@@ -128,18 +128,14 @@ export declare class Dispatcher {
         taken: boolean;
     };
     /**
-     * A command's result caret: selected once and recorded on the result;
-     * the projector displays it after the flush. With `ops`, the
-     * caret is declared before the command's operations run — minted while its
-     * text is live, so it survives them — and written only when they applied;
-     * meanwhile the seam repair leaves this view's endpoints to it. Takes a
-     * text segment and an offset in it, or a `{ block, offset }` caret in
-     * block offsets (an inline atom counting 1).
+     * A command's result caret, `{ block, offset }` in block offsets (an
+     * inline atom counting 1): selected once and recorded on the result;
+     * the projector displays it after the flush. With `ops`, the caret is
+     * declared before the command's operations run — minted while its text
+     * is live, so it survives them — and written only when they applied;
+     * meanwhile the seam repair leaves this view's endpoints to it.
      */
-    caret: {
-        (text: Text | null | undefined, offset: number, ops?: () => OpResult): OpResult | undefined;
-        (caret: Caret | DocPosition | null | undefined, ops?: () => OpResult): OpResult | undefined;
-    };
+    caret: (caret: Caret | DocPosition | null | undefined, ops?: () => OpResult) => OpResult | undefined;
     /**
      * The cut an operation applies as it writes. Inside a user command none
      * (the command cut); outside one, its bare policy. A led operation is a

package/dist/session/commands.js

@@ -458,6 +458,8 @@ export class Dispatcher {
      */
     operate = (operation, args) => {
         const { edytor } = this;
+        // The property writes queued in this task go first (`session/props`).
+        edytor.dataWrites.flush();
         const own = edytor.facade.prepare[operation];
         const prepare = (a) => {
             if (operation === 'insertText' && a[3] === undefined)
@@ -564,27 +566,20 @@ export class Dispatcher {
         return this.running ? this.kind : null;
     }
     /**
-     * A command's result caret: selected once and recorded on the result;
-     * the projector displays it after the flush. With `ops`, the
-     * caret is declared before the command's operations run — minted while its
-     * text is live, so it survives them — and written only when they applied;
-     * meanwhile the seam repair leaves this view's endpoints to it. Takes a
-     * text segment and an offset in it, or a `{ block, offset }` caret in
-     * block offsets (an inline atom counting 1).
+     * A command's result caret, `{ block, offset }` in block offsets (an
+     * inline atom counting 1): selected once and recorded on the result;
+     * the projector displays it after the flush. With `ops`, the caret is
+     * declared before the command's operations run — minted while its text
+     * is live, so it survives them — and written only when they applied;
+     * meanwhile the seam repair leaves this view's endpoints to it.
      */
-    caret = (target, ...rest) => {
-        // The form is the arguments', not the target's: a nullish caret still runs its `ops`.
-        if (typeof rest[0] === 'number') {
-            return this.#caret(target, rest[0], rest[1]);
-        }
-        const ops = rest[0];
-        const caret = target;
-        // `{ block, offset }`: block offsets (a handle or an id), mapped to the text segment that shows the offset.
+    caret = (caret, ops) => {
         const block = typeof caret?.block === 'string' ? this.edytor.idToBlock.get(caret.block) : caret?.block;
         const at = block?.textAtOffset(Math.max(0, caret.offset));
-        return this.#caret(at?.text, at?.offset ?? 0, ops);
+        return this.caretIn(at?.text, at?.offset ?? 0, ops);
     };
-    #caret = (text, offset, ops) => {
+    /** @internal `caret` at an offset inside a text segment. */
+    caretIn = (text, offset, ops) => {
         const selection = this.edytor.selection;
         const at = text ? Math.max(0, Math.min(offset, text.length)) : 0;
         const value = text ? selection.textValue(text, at) : null;
@@ -640,7 +635,8 @@ export class Dispatcher {
         try {
             for (let i = 0; i < this.queue.length; i++) {
                 if (i === 1000) {
-                    console.warn('[edytor] normalization is not converging; skipping further passes');
+                    if (DEV)
+                        console.warn('[edytor] normalization is not converging; skipping further passes');
                     break;
                 }
                 const entry = this.queue[i];
@@ -652,7 +648,7 @@ export class Dispatcher {
                 const count = (counts.get(id) ?? 0) + 1;
                 counts.set(id, count);
                 if (count > MAX_PASSES) {
-                    if (count === MAX_PASSES + 1)
+                    if (DEV && count === MAX_PASSES + 1)
                         console.warn(`edytor: ${normalize} on block "${id}" exceeded ${MAX_PASSES - 1} passes — a plugin normalizer is not converging; skipping further passes`);
                     continue;
                 }

package/dist/session/history.js

@@ -114,6 +114,7 @@ export class History {
     replay = (command) => !this.edytor.dispatcher.permits() ? 'refused' : this.#run(command) ? 'applied' : 'noop';
     #run(command) {
         const { undoManager: um, transaction: key, selection, facade } = this.edytor;
+        this.edytor.dataWrites.flush(); // this task's property writes are a step first
         this.#open = null;
         // Other writers (remote-apply and repair restores) stand aside while the
         // replay commits: this view's recorded value decides.

package/dist/session/inputRules.d.ts

@@ -3,9 +3,12 @@
  * (`## ` → a heading, `:smile:` → 😄). The one engine behind every
  * plugin's `inputRules`: it reads the typed text and the caret, finds the
  * first rule whose `find` ends at the typed text, and replaces the typed
- * `insertText` with the rule's replacement — a command of its own, the
- * matched text's removal leading its first operation (`dispatcher.lead`), so
- * a refusal of either writes neither and the typed text lands as typed.
+ * `insertText` with two steps: the typed text as typed (an insertion, which
+ * may continue the typing before it), then the rule's replacement, a command
+ * of its own whose first operation the matched text's removal leads
+ * (`dispatcher.lead`), so a refusal of either writes neither and the typed
+ * text stays as typed. The first undo gives the typed text back, the
+ * caret after it (as the autolink does).
  */
 import type { Block } from '../block/block.svelte.js';
 import type { Edytor } from '../edytor.svelte.js';

package/dist/session/inputRules.js

@@ -47,7 +47,7 @@ export const inputRulesHook = (edytor, rules) => {
         /** The typed text lands as typed, the caret after it. */
         const typeAsIs = () => {
             edytor.insertText(...payload);
-            dispatcher.caret(text, yStart + value.length);
+            dispatcher.caretIn(text, yStart + value.length);
         };
         /**
          * Run `rule` over `match`: whether it wrote, or `null` when it declined
@@ -57,7 +57,8 @@ export const inputRulesHook = (edytor, rules) => {
             /** The match's start in the segment; the match in the block, `from` to the caret. */
             const start = match.index;
             const from = text.segStart + start;
-            const to = text.segStart + yStart;
+            // The typed text is in the document: the match ends after it.
+            const to = text.segStart + yStart + value.length;
             let removed = null;
             /** Remove the match in the same plan as `then`'s first operation: `ctx.remove`. */
             const remove = (then) => {
@@ -104,12 +105,15 @@ export const inputRulesHook = (edytor, rules) => {
         prevent(() => {
             running = true;
             try {
+                // The typed text first, a step the replacement does not join.
+                const last = dispatcher.last;
+                typeAsIs();
+                if (dispatcher.last === last || dispatcher.last?.status !== 'applied')
+                    return;
                 for (const { rule, match } of matches) {
-                    const written = apply(rule, match);
-                    if (written !== null)
-                        return written || typeAsIs();
+                    if (apply(rule, match) !== null)
+                        return;
                 }
-                typeAsIs();
             }
             finally {
                 running = false;

package/dist/session/moves.d.ts

@@ -25,6 +25,17 @@ export type BlockMoveRequest = {
 } | {
     direction: BlockMoveDirection;
 });
+/**
+ * The view's nesting rule (`allowNesting`, off by default): whether a user
+ * gesture may place `blocks` under `parent`. With nesting off, blocks land
+ * only at the root or in a block made to hold children — a container (a
+ * list, a column, a toggle's or a callout's body: `isContainer`, the kind's
+ * `container`), an island (a code block's lines) — or stay under the parent
+ * they already have (a document holding nested blocks still edits them).
+ * Every move (`destination`: keys, drops, menus, `edytor.move`) and every
+ * new block a drop places (`canPlaceNew`) reads it.
+ */
+export declare const nestsInto: (edytor: Edytor, parent: Block, blocks?: readonly Block[]) => boolean;
 /** Whether the move is allowed: for runs (`parts`), whether one of them may move. */
 export declare const canMove: (edytor: Edytor, request: BlockMoveRequest) => boolean;
 /**
@@ -38,3 +49,25 @@ export declare const canMove: (edytor: Edytor, request: BlockMoveRequest) => boo
  * (`announcer.moved`).
  */
 export declare const move: (edytor: Edytor, request: BlockMoveRequest) => Block[];
+/** A new block a drop places (`placeNew`): its kind, and its id when the caller names it. */
+export type NewBlock = {
+    type: string;
+    id?: string;
+};
+/**
+ * Whether new blocks of `kinds` may land at `target`'s `position` (a file
+ * dropped there, `placeNew`): the move's places (`destination`) asked of
+ * blocks not yet in the document — the container rule (`fits`) of the
+ * parent they land in, never inside a void or an island; beside, a layout
+ * kind and a target outside any island (`placeBeside` takes any block a
+ * column holds).
+ */
+export declare const canPlaceNew: (edytor: Edytor, kinds: readonly string[], target: Block, position: BlockMovePosition) => boolean;
+/**
+ * Insert new blocks at `target`'s `position` (a file drop's placement):
+ * before or after it, inside it (its last children), or beside it — inserted
+ * after the block it stands beside (`besideAt`) and moved there by the one
+ * move path (`layout.place-beside`) — in one transaction. The caller's
+ * command makes it one undo step. Answers the ids placed (none: refused).
+ */
+export declare const placeNew: (edytor: Edytor, blocks: readonly NewBlock[], target: Block, position: BlockMovePosition) => string[];

package/dist/session/moves.js

@@ -24,6 +24,22 @@ const placement = (edytor, request) => {
     return step?.[0] ? { blocks, target: step[0], position: step[1] } : null;
 };
 const POSITIONS = ['before', 'after', 'inside', ...BESIDE];
+/**
+ * The view's nesting rule (`allowNesting`, off by default): whether a user
+ * gesture may place `blocks` under `parent`. With nesting off, blocks land
+ * only at the root or in a block made to hold children — a container (a
+ * list, a column, a toggle's or a callout's body: `isContainer`, the kind's
+ * `container`), an island (a code block's lines) — or stay under the parent
+ * they already have (a document holding nested blocks still edits them).
+ * Every move (`destination`: keys, drops, menus, `edytor.move`) and every
+ * new block a drop places (`canPlaceNew`) reads it.
+ */
+export const nestsInto = (edytor, parent, blocks = []) => edytor.allowNesting ||
+    parent.isRoot ||
+    parent.isContainer ||
+    !!parent.definition.container ||
+    edytor.facade.isIsland(parent.id) ||
+    (blocks.length > 0 && blocks.every((block) => block.parent === parent));
 /**
  * The document write a move request is, or `null` when refused: a
  * well-formed request, then the document's one structural answer
@@ -59,7 +75,7 @@ const destination = (edytor, request) => {
             ? { blocks, write: () => edytor.unNestBlocks(ids) }
             : null;
     const to = parent?.isRoot ? null : parent?.id;
-    if (!parent || !edytor.facade.canPlace(ids, to))
+    if (!parent || !nestsInto(edytor, parent, blocks) || !edytor.facade.canPlace(ids, to))
         return null;
     const at = position === 'inside' ? parent.children.length : target.index + (position === 'after' ? 1 : 0);
     // The document counts the destination's children without the moved blocks.
@@ -122,3 +138,57 @@ const place = (edytor, request) => {
     const result = move.write();
     return result.status === 'applied' ? move.blocks : [];
 };
+/**
+ * Whether new blocks of `kinds` may land at `target`'s `position` (a file
+ * dropped there, `placeNew`): the move's places (`destination`) asked of
+ * blocks not yet in the document — the container rule (`fits`) of the
+ * parent they land in, never inside a void or an island; beside, a layout
+ * kind and a target outside any island (`placeBeside` takes any block a
+ * column holds).
+ */
+export const canPlaceNew = (edytor, kinds, target, position) => {
+    const { facade } = edytor;
+    if (edytor.readonly || !kinds.length || !target.isInTree || target.isRoot)
+        return false;
+    if (!POSITIONS.includes(position) || facade.insideIsland(target.id))
+        return false;
+    if (isBeside(position))
+        return ([...edytor.blocks.values()].some((definition) => definition.layout) &&
+            !facade.isIsland(target.id));
+    const parent = position === 'inside' ? target : target.parent;
+    if (!parent || !nestsInto(edytor, parent))
+        return false;
+    const to = parent.isRoot ? null : parent.id;
+    if (to !== null && (facade.isVoid(to) || facade.isIsland(to)))
+        return false;
+    return kinds.every((kind) => facade.fits(to, kind));
+};
+/**
+ * Insert new blocks at `target`'s `position` (a file drop's placement):
+ * before or after it, inside it (its last children), or beside it — inserted
+ * after the block it stands beside (`besideAt`) and moved there by the one
+ * move path (`layout.place-beside`) — in one transaction. The caller's
+ * command makes it one undo step. Answers the ids placed (none: refused).
+ */
+export const placeNew = (edytor, blocks, target, position) => {
+    const kinds = blocks.map((block) => block.type);
+    if (!canPlaceNew(edytor, kinds, target, position))
+        return [];
+    const beside = isBeside(position);
+    const at = beside ? (edytor.idToBlock.get(edytor.facade.besideAt(target.id)) ?? target) : target;
+    const parent = position === 'inside' ? target : at.parent;
+    const destination = position === 'inside'
+        ? { parent: target.id, index: target.children.length }
+        : {
+            parent: !parent || parent.isRoot ? null : parent.id,
+            index: at.index + (position === 'before' ? 0 : 1)
+        };
+    return edytor.transact(() => {
+        const { ids } = edytor.insertBlocks(destination, blocks.map((block) => ({ ...block })));
+        if (!beside || !ids.length)
+            return [...ids];
+        const placed = ids.flatMap((id) => edytor.idToBlock.get(id) ?? []);
+        move(edytor, { blocks: placed, target, position });
+        return [...ids];
+    });
+};

package/dist/session/navigation.d.ts

@@ -23,6 +23,7 @@
  * lands it on no caret stop (`landed`).
  */
 import type { Edytor } from '../edytor.svelte.js';
+import type { Block } from '../block/block.svelte.js';
 import type { HotKey } from './keymap.js';
 /**
  * With no target (`untargeted`: the value is `none`, no gesture placed the
@@ -48,6 +49,12 @@ export declare const move: (edytor: Edytor, unit: Unit, key: Dir | "left" | "rig
  * moves keep the goal column. Answers whether a text selection moved.
  */
 export declare const extendVertically: (edytor: Edytor, dir: Dir) => boolean;
+/**
+ * The block a collapsed text caret sits on the last line of (a line box
+ * where the view lays one out, else a line break), if it does: where
+ * ArrowDown leaves the block (`nav.trailing.exit`, `body.down`).
+ */
+export declare const onLastLine: (edytor: Edytor) => Block | undefined;
 /**
  * The trailing paragraph (`nav.trailing`, Notion): the caret goes to an
  * empty top-level block of the root's default kind after the document's