@damiro/stylo 0.4.0

package/dist/inplace/config.d.ts

@@ -0,0 +1,57 @@
+import { Facet } from "@codemirror/state";
+import type { InPlaceConfig, InPlaceDecorationToggles, MenuGroupId, RevealMode, SelectionUI, TableEditing, ToolbarCommandId } from "../types";
+/** `InPlaceDecorationToggles` with every key resolved to a concrete boolean. */
+export type ResolvedToggles = Required<InPlaceDecorationToggles>;
+export declare function resolveToggles(config?: InPlaceConfig): ResolvedToggles;
+/**
+ * Carries the resolved decoration toggles to every producer (the view plugin
+ * and the three state fields). Seeded once by `inPlaceExtension`; read, never
+ * written, by `decorate.ts`, `math.ts`, `frontmatter.ts`, and `tables.ts`.
+ */
+export declare const inPlaceConfigFacet: Facet<Required<InPlaceDecorationToggles>, Required<InPlaceDecorationToggles>>;
+/** Table editing mode, seeded once by `inPlaceExtension`; read by `tables.ts`. */
+export declare const tableEditingFacet: Facet<TableEditing, TableEditing>;
+/**
+ * Marker reveal behaviour (ADR-007). `"never"` makes `decorate.ts` hide every
+ * inline marker regardless of the caret line. Seeded once by `inPlaceExtension`.
+ */
+export declare const revealModeFacet: Facet<RevealMode, RevealMode>;
+/**
+ * The host's `onLinkClick` (the "Open link" action in the right-click link
+ * editor), or `null`. Seeded once by `inPlaceExtension`.
+ */
+export declare const linkOpenFacet: Facet<((href: string) => void) | null, ((href: string) => void) | null>;
+/**
+ * Whether the right-click menu takes over from the browser's own context menu
+ * in the canvas. Seeded once by `inPlaceExtension`; read by `menu-plugin.ts`.
+ */
+export declare const contextMenuEnabled: Facet<boolean, boolean>;
+/** The menu's groups in their default order. */
+export declare const DEFAULT_MENU_GROUPS: MenuGroupId[];
+/** The selection bar's buttons in their default order. */
+export declare const DEFAULT_SELECTION_BAR_ITEMS: ToolbarCommandId[];
+/** `enabled` false keeps the browser menu; `groups` is always a non-empty list. */
+export declare function resolveContextMenu(c: InPlaceConfig["contextMenu"]): {
+    enabled: boolean;
+    groups: MenuGroupId[];
+};
+/**
+ * Ordered right-click menu groups. Seeded once by `inPlaceExtension`; read by
+ * `context-menu-actions.ts`.
+ */
+export declare const menuGroupsFacet: Facet<MenuGroupId[], MenuGroupId[]>;
+/** Selection-bar buttons, resolved to the known inline ids in the given order. */
+export declare function resolveSelectionBarItems(ids?: ToolbarCommandId[]): ToolbarCommandId[];
+/**
+ * Ordered selection-bar button ids. Seeded once by `inPlaceExtension`; read by
+ * `selection-bar.ts`.
+ */
+export declare const selectionBarItemsFacet: Facet<ToolbarCommandId[], ToolbarCommandId[]>;
+/**
+ * What a non-empty selection offers (ADR-007). `"bar"` shows the floating
+ * formatting bar; `"menu"` (default) keeps the inline group in the right-click
+ * menu instead; `"none"` shows neither. Seeded once by `inPlaceExtension`; read
+ * by `selection-bar.ts` and `context-menu-actions.ts`.
+ */
+export declare const selectionUIFacet: Facet<SelectionUI, SelectionUI>;
+//# sourceMappingURL=config.d.ts.map

package/dist/inplace/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/inplace/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AACzC,OAAO,KAAK,EACV,aAAa,EACb,wBAAwB,EACxB,WAAW,EACX,UAAU,EACV,WAAW,EACX,YAAY,EACZ,gBAAgB,EACjB,MAAM,UAAU,CAAA;AAEjB,gFAAgF;AAChF,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC,wBAAwB,CAAC,CAAA;AAiBhE,wBAAgB,cAAc,CAAC,MAAM,CAAC,EAAE,aAAa,GAAG,eAAe,CAEtE;AAED;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,+EAE7B,CAAA;AAEF,kFAAkF;AAClF,eAAO,MAAM,iBAAiB,mCAE5B,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,eAAe,+BAE1B,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,aAAa,gBAChB,MAAM,KAAK,IAAI,kBACf,MAAM,KAAK,IAAI,SAGvB,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,yBAE7B,CAAA;AAEF,gDAAgD;AAChD,eAAO,MAAM,mBAAmB,EAAE,WAAW,EAM5C,CAAA;AAED,0DAA0D;AAC1D,eAAO,MAAM,2BAA2B,EAAE,gBAAgB,EAQzD,CAAA;AAED,mFAAmF;AACnF,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,aAAa,CAAC,aAAa,CAAC,GAAG;IACnE,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,EAAE,WAAW,EAAE,CAAA;CACtB,CAIA;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe,qCAE1B,CAAA;AAEF,kFAAkF;AAClF,wBAAgB,wBAAwB,CAAC,GAAG,CAAC,EAAE,gBAAgB,EAAE,GAAG,gBAAgB,EAAE,CAIrF;AAED;;;GAGG;AACH,eAAO,MAAM,sBAAsB,+CAEjC,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,iCAE3B,CAAA"}

package/dist/inplace/context-menu-actions.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Maps the shared toolbar command set onto rows for the in-place right-click
+ * menu. One shape everywhere (Obsidian style): the link rows, then Format /
+ * Paragraph / Insert submenus, then clipboard. Every command already carries
+ * its own `run` / `isActive` / `disabled`, so an item that can't apply where
+ * the caret sits is greyed, not hidden — the menu shape stays put.
+ */
+import type { EditorView } from "@codemirror/view";
+import type { MenuField, MenuRow } from "./context-menu";
+/**
+ * A non-empty text selection inside a focused editable table cell. The cell is a
+ * `contenteditable` surface, so this selection lives in the DOM, not in
+ * `state.selection` — but the inline commands route through `runInlineInCell`,
+ * so the Format group still applies.
+ */
+export declare function cellHasSelection(view: EditorView): boolean;
+/**
+ * The "Add external link" row — an editable `[text](url)` URL field. Prefilled,
+ * with Open / Remove and the label "Edit external link", when the caret sits in
+ * an existing `[text](url)`; otherwise an empty field that wraps the selection
+ * (or the word the menu just selected) on submit.
+ */
+export declare function linkRow(view: EditorView): MenuField;
+/**
+ * The "Add link" row — an editable `[[target]]` field for an internal link.
+ * Prefilled, with Remove and the label "Edit link", when the caret sits in an
+ * existing `[[target|label]]`; otherwise an empty field that wraps the
+ * selection (or the word the menu just selected) on submit.
+ */
+export declare function wikiLinkRow(view: EditorView): MenuField;
+/**
+ * The "Language" row shown when the caret is in a fenced code block: an
+ * editable info string (` ```ts `), plus **Remove code block** to unwrap it.
+ * The opening fence line is hidden in the seamless canvas, so this is the way
+ * to reach the language at all.
+ */
+export declare function codeBlockRow(view: EditorView): MenuField;
+/**
+ * Rows for a non-empty selection inside an editable table cell: the Format
+ * submenu (forced live — see `toAction`) and clipboard, gated by `menuGroups`.
+ * Shared by the canvas menu and the table widget's own structural menu, which
+ * appends these under its row / column / align actions.
+ */
+export declare function cellSelectionRows(view: EditorView): MenuRow[];
+/**
+ * The right-click menu. `menuGroupsFacet` picks and orders the top-level groups
+ * (`link` / `format` / `paragraph` / `insert` / `clipboard`); `selectionUI`
+ * independently decides whether `link` and `format` live here or on the floating
+ * bar. A table-cell selection and a fenced-code caret are focused contexts that
+ * ignore the ordering and offer only what applies.
+ */
+export declare function menuRows(view: EditorView): MenuRow[];
+//# sourceMappingURL=context-menu-actions.d.ts.map

package/dist/inplace/context-menu-actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-menu-actions.d.ts","sourceRoot":"","sources":["../../src/inplace/context-menu-actions.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAQlD,OAAO,KAAK,EAAc,SAAS,EAAE,OAAO,EAAe,MAAM,gBAAgB,CAAA;AAejF;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAK1D;AA+GD;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,UAAU,GAAG,SAAS,CAgEnD;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,UAAU,GAAG,SAAS,CA6DvD;AASD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,UAAU,GAAG,SAAS,CAsBxD;AASD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,EAAE,CAQ7D;AAyBD;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,EAAE,CA0CpD"}

package/dist/inplace/context-menu.d.ts

@@ -0,0 +1,50 @@
+/**
+ * A pointer-positioned menu shell for the in-place canvas. It owns the popup
+ * element, its placement, one level of flyout submenu, and dismissal (outside
+ * press, Escape, scroll). It knows nothing about editor commands; the caller
+ * passes plain rows with `onSelect` callbacks.
+ */
+export interface MenuAction {
+    label: string;
+    /** Stroke-path data for a leading glyph (see `toolbar/icon-paths`). */
+    icon?: string;
+    /** Rendered with emphasis when true. */
+    active?: boolean;
+    /** Shown greyed and not selectable. */
+    disabled?: boolean;
+    /** Native `title` tooltip — e.g. why a disabled row is disabled. */
+    title?: string;
+    onSelect: () => void;
+}
+export interface MenuSubmenu {
+    label: string;
+    icon?: string;
+    rows: MenuRow[];
+    /** Greyed, and its flyout never opens. */
+    disabled?: boolean;
+}
+/** A row whose flyout is a single text input plus optional action buttons. */
+export interface MenuField {
+    field: true;
+    label: string;
+    icon?: string;
+    value: string;
+    placeholder?: string;
+    onSubmit: (value: string) => void;
+    actions?: MenuAction[];
+}
+export type MenuRow = MenuAction | MenuSubmenu | MenuField | "separator";
+export interface ContextMenu {
+    /** Append once to a stable container (typically `document.body`). */
+    readonly el: HTMLElement;
+    readonly isOpen: boolean;
+    /** Render `rows` and show the menu at a viewport point, clamped on-screen. */
+    show: (rows: MenuRow[], x: number, y: number) => void;
+    /** Show a single field panel directly, with no wrapping menu row. */
+    showField: (field: MenuField, x: number, y: number) => void;
+    hide: () => void;
+    /** Remove the element and drop document listeners. */
+    destroy: () => void;
+}
+export declare function createContextMenu(doc: Document, className?: string): ContextMenu;
+//# sourceMappingURL=context-menu.d.ts.map

package/dist/inplace/context-menu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-menu.d.ts","sourceRoot":"","sources":["../../src/inplace/context-menu.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAA;IACb,uEAAuE;IACvE,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,wCAAwC;IACxC,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,uCAAuC;IACvC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,oEAAoE;IACpE,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,IAAI,CAAA;CACrB;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,OAAO,EAAE,CAAA;IACf,0CAA0C;IAC1C,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB;AAED,8EAA8E;AAC9E,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,IAAI,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IACjC,OAAO,CAAC,EAAE,UAAU,EAAE,CAAA;CACvB;AAED,MAAM,MAAM,OAAO,GAAG,UAAU,GAAG,WAAW,GAAG,SAAS,GAAG,WAAW,CAAA;AAExE,MAAM,WAAW,WAAW;IAC1B,qEAAqE;IACrE,QAAQ,CAAC,EAAE,EAAE,WAAW,CAAA;IACxB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;IACxB,8EAA8E;IAC9E,IAAI,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;IACrD,qEAAqE;IACrE,SAAS,EAAE,CAAC,KAAK,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;IAC3D,IAAI,EAAE,MAAM,IAAI,CAAA;IAChB,sDAAsD;IACtD,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB;AAKD,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,QAAQ,EAAE,SAAS,SAAoB,GAAG,WAAW,CA6O3F"}

package/dist/inplace/decorate.d.ts

@@ -0,0 +1,17 @@
+import { type DecorationSet, type EditorView } from "@codemirror/view";
+export interface InPlaceDecorations {
+    decorations: DecorationSet;
+    /** Every replacing decoration — the caret steps over these rather than into them. */
+    atomic: DecorationSet;
+}
+/**
+ * Build the in-place decoration set for the visible viewport only — the syntax
+ * tree is walked across `view.visibleRanges`, never the whole document, so the
+ * cost stays bounded on long notes. Decorations are collected unordered and
+ * sorted by `Decoration.set`, which tolerates the overlaps that nested emphasis
+ * and marker-inside-styled-span produce. Multi-line `$$` blocks and the
+ * frontmatter block are handled by their own state fields (a plugin may not
+ * replace line breaks).
+ */
+export declare function buildDecorations(view: EditorView): InPlaceDecorations;
+//# sourceMappingURL=decorate.d.ts.map

package/dist/inplace/decorate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorate.d.ts","sourceRoot":"","sources":["../../src/inplace/decorate.ts"],"names":[],"mappings":"AAEA,OAAO,EAAc,KAAK,aAAa,EAAE,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAelF,MAAM,WAAW,kBAAkB;IACjC,WAAW,EAAE,aAAa,CAAA;IAC1B,qFAAqF;IACrF,MAAM,EAAE,aAAa,CAAA;CACtB;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,kBAAkB,CAiErE"}

package/dist/inplace/edit-boundaries.d.ts

@@ -0,0 +1,59 @@
+/**
+ * ADR-007 Stage 2 (first slice): editing at a hidden marker's edge.
+ *
+ * Under `reveal: "never"` (or off-caret under `"caret"`) an inline construct's
+ * markers are hidden and atomic. The stock Backspace/Delete skips the whole
+ * atomic range and eats the marker itself, stranding its partner — and for a
+ * nested `***word***` it strips a level of formatting per keypress.
+ *
+ * Here the key steps *over* the run of hidden markers and removes the real
+ * character beyond them instead: Backspace at the front of a bold word deletes
+ * the space before it, the bold stays. The one exception is deleting the last
+ * character *inside* a wrapper — the now-empty markers go with it.
+ *
+ * Arrow keys get the same treatment: `atomicRanges` leaves both edges of a
+ * hidden run as caret stops that render at the same point, so a press can look
+ * like it did nothing — when a step only crossed hidden markers, take one more.
+ * This covers both a plain caret move and `Shift`-extending a selection, which
+ * the stock `select*` commands park on the near edge just the same.
+ */
+import { type EditorState, type Extension } from "@codemirror/state";
+import { type Command } from "@codemirror/view";
+export interface Wrap {
+    from: number;
+    to: number;
+    contentFrom: number;
+    contentTo: number;
+    /** `"mark"` — a paired inline mark (`**`, `*`, `~~`, `` ` ``); `"link"` — a
+     *  link or wikilink, whose label is not itself a Markdown context, so a
+     *  right-click formats the *whole* construct rather than the label. */
+    kind: "mark" | "link";
+}
+/** Are inline markers on this line hidden right now? */
+export declare function markersHidden(state: EditorState, lineNumber: number): boolean;
+/**
+ * The hidden-marker inline construct enclosing `pos`, or `null`. With
+ * `emphasisOnly`, only the paired-mark constructs whose *both* delimiters are
+ * hidden count (strong / emphasis / strike / inline code) — links and wikilinks
+ * keep a directly editable label, so their edges are not boundary-escaped.
+ *
+ * By default the construct's markers must be hidden right now (boundary editing
+ * only applies then); `ignoreReveal` drops that check for callers that just want
+ * the span — the right-click menu selecting the whole phrase, which should work
+ * whether or not the caret has revealed the line.
+ */
+export declare function wrapAt(state: EditorState, pos: number, emphasisOnly?: boolean, ignoreReveal?: boolean): Wrap | null;
+/** Backspace that steps over a hidden marker rather than stranding it. */
+export declare const deleteAcrossMarkerBackward: Command;
+/** Delete — the forward mirror. */
+export declare const deleteAcrossMarkerForward: Command;
+/** Plain caret step across a hidden marker run (leftward). */
+export declare const arrowAcrossMarkerLeft: Command;
+/** Plain caret step — the forward mirror. */
+export declare const arrowAcrossMarkerRight: Command;
+/** `Shift`-extend the selection head across a hidden marker run (leftward). */
+export declare const selectAcrossMarkerLeft: Command;
+/** `Shift`-extend — the forward mirror. */
+export declare const selectAcrossMarkerRight: Command;
+export declare const inPlaceEditBoundaries: Extension;
+//# sourceMappingURL=edit-boundaries.d.ts.map

package/dist/inplace/edit-boundaries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit-boundaries.d.ts","sourceRoot":"","sources":["../../src/inplace/edit-boundaries.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,EAAmB,KAAK,WAAW,EAAQ,KAAK,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAC3F,OAAO,EAAE,KAAK,OAAO,EAA2B,MAAM,kBAAkB,CAAA;AAgBxE,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,MAAM,CAAA;IACZ,EAAE,EAAE,MAAM,CAAA;IACV,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;IACjB;;2EAEuE;IACvE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;CACtB;AAED,wDAAwD;AACxD,wBAAgB,aAAa,CAAC,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAE7E;AAyBD;;;;;;;;;;GAUG;AACH,wBAAgB,MAAM,CACpB,KAAK,EAAE,WAAW,EAClB,GAAG,EAAE,MAAM,EACX,YAAY,UAAQ,EACpB,YAAY,UAAQ,GACnB,IAAI,GAAG,IAAI,CA0Db;AA6CD,0EAA0E;AAC1E,eAAO,MAAM,0BAA0B,EAAE,OAAiC,CAAA;AAC1E,mCAAmC;AACnC,eAAO,MAAM,yBAAyB,EAAE,OAAgC,CAAA;AAiDxE,8DAA8D;AAC9D,eAAO,MAAM,qBAAqB,EAAE,OAA0C,CAAA;AAC9E,6CAA6C;AAC7C,eAAO,MAAM,sBAAsB,EAAE,OAAyC,CAAA;AAC9E,+EAA+E;AAC/E,eAAO,MAAM,sBAAsB,EAAE,OAAyC,CAAA;AAC9E,2CAA2C;AAC3C,eAAO,MAAM,uBAAuB,EAAE,OAAwC,CAAA;AAE9E,eAAO,MAAM,qBAAqB,EAAE,SASnC,CAAA"}

package/dist/inplace/edit-insert-assoc.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ADR-007 Stage 2 — insertion association at a hidden marker's edge.
+ *
+ * With a construct's markers hidden and atomic, the caret at the visual end of a
+ * bold word actually sits *before* the hidden `**`, so a keystroke there lands
+ * inside the markup: `**bold**` + "x" → `**boldx**`. This transaction filter
+ * moves a single boundary insertion to the outer edge of the marker run, so it
+ * lands on the side the user perceives: `**bold**x`. The mirror case at the
+ * front of the word is handled the same way (`x**bold**`, never `**xbold**`).
+ *
+ * Scope: the paired-mark inline constructs whose *both* delimiters are hidden —
+ * strong / emphasis / strikethrough / inline code. Links and wikilinks keep a
+ * directly editable label, so typing at a label edge is left alone.
+ */
+import { type Extension } from "@codemirror/state";
+export declare const inPlaceInsertAssociation: Extension;
+//# sourceMappingURL=edit-insert-assoc.d.ts.map

package/dist/inplace/edit-insert-assoc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit-insert-assoc.d.ts","sourceRoot":"","sources":["../../src/inplace/edit-insert-assoc.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,EAAe,KAAK,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAmC/D,eAAO,MAAM,wBAAwB,EAAE,SA8BrC,CAAA"}

package/dist/inplace/edit-line-prefix.d.ts

@@ -0,0 +1,23 @@
+/**
+ * ADR-007 Stage 3 — line-prefix backspace.
+ *
+ * With `## `, `> `, `- ` and friends hidden and atomic, the caret at the visual
+ * start of a heading / quote / list line sits just past the hidden prefix.
+ * Backspace there removes one level of prefix instead of joining the line to the
+ * one above — the Notion "backspace to unstyle" gesture:
+ *
+ * - heading  → paragraph (the whole `#{1,6} ` goes)
+ * - quote    → one `> ` level out (nested quotes step out one at a time)
+ * - list     → outdent one step, or drop the marker when already flush
+ * - task     → paragraph (`- [ ] ` goes)
+ *
+ * Only fires while that prefix is actually hidden (so `reveal: "caret"` with the
+ * caret on the line is untouched — the prefix is visible there and a normal
+ * backspace edits it).
+ */
+import { type Extension } from "@codemirror/state";
+import { type Command } from "@codemirror/view";
+/** Backspace at visual column 0 of a hidden-prefix line — one level out. */
+export declare const unwrapLinePrefix: Command;
+export declare const inPlaceLinePrefixEdit: Extension;
+//# sourceMappingURL=edit-line-prefix.d.ts.map

package/dist/inplace/edit-line-prefix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit-line-prefix.d.ts","sourceRoot":"","sources":["../../src/inplace/edit-line-prefix.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAQ,KAAK,SAAS,EAAE,MAAM,mBAAmB,CAAA;AACxD,OAAO,EAAE,KAAK,OAAO,EAA2B,MAAM,kBAAkB,CAAA;AAoCxE,4EAA4E;AAC5E,eAAO,MAAM,gBAAgB,EAAE,OAwB9B,CAAA;AAED,eAAO,MAAM,qBAAqB,EAAE,SAEnC,CAAA"}

package/dist/inplace/extension.d.ts

@@ -0,0 +1,21 @@
+import { type Extension } from "@codemirror/state";
+import type { InPlaceConfig } from "../types";
+export interface InPlaceOptions {
+    /** Fired when a collapsed `[[wikilink]]` is clicked in the canvas. */
+    onWikiLinkClick?: (target: string) => void;
+    /** Fired by the link editor's "Open link" action with the link's href. */
+    onLinkClick?: (href: string) => void;
+    /** Which decoration types render; see ADR-005. Applied once, at construction. */
+    inPlace?: InPlaceConfig;
+}
+/**
+ * The complete in-place canvas layer: decoration plugin, display theme, a
+ * reveal-on-click fallback for rendered widgets, and a delegated click handler
+ * for wikilinks.
+ *
+ * The theme is raised with `Prec.high` so its `.cm-content` font rule overrides
+ * the base editor theme (which sets the source surface to monospace) for
+ * in-place editors only.
+ */
+export declare function inPlaceExtension(opts?: InPlaceOptions): Extension;
+//# sourceMappingURL=extension.d.ts.map

package/dist/inplace/extension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extension.d.ts","sourceRoot":"","sources":["../../src/inplace/extension.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAGxD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AA6B7C,MAAM,WAAW,cAAc;IAC7B,sEAAsE;IACtE,eAAe,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;IAC1C,0EAA0E;IAC1E,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;IACpC,iFAAiF;IACjF,OAAO,CAAC,EAAE,aAAa,CAAA;CACxB;AAuCD;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,GAAE,cAAmB,GAAG,SAAS,CA8DrE"}

package/dist/inplace/frontmatter.d.ts

@@ -0,0 +1,13 @@
+import { StateField } from "@codemirror/state";
+import { type DecorationSet } from "@codemirror/view";
+import { frontmatterRange } from "../frontmatter";
+export { frontmatterRange };
+/**
+ * Recesses the leading YAML block — muted, monospace, with a "Frontmatter"
+ * label on the first line — without collapsing it. Line decorations only: the rows
+ * keep their height, so click-to-position stays accurate (an earlier `block`
+ * widget that folded the block to a one-line chip desynced it). A state field,
+ * not the plugin, only because the region has no grammar node to hang off.
+ */
+export declare const frontmatterField: StateField<DecorationSet>;
+//# sourceMappingURL=frontmatter.d.ts.map

package/dist/inplace/frontmatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frontmatter.d.ts","sourceRoot":"","sources":["../../src/inplace/frontmatter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAChE,OAAO,EAAc,KAAK,aAAa,EAAc,MAAM,kBAAkB,CAAA;AAC7E,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAGjD,OAAO,EAAE,gBAAgB,EAAE,CAAA;AA2B3B;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,2BAI3B,CAAA"}

package/dist/inplace/inline-md.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Render a single line of inline Markdown to DOM nodes — the subset that can
+ * appear in a table cell: `` `code` ``, `$math$`, `[[wiki]]`, `[text](url)`,
+ * `***both***`, `**bold**`, `*em*`, `~~strike~~`. Block constructs are out of
+ * scope (a cell is one line). Reuses the `.cm-inplace-*` classes so cell text
+ * matches the rest of the canvas, and tags wikilinks with `data-stylo-wikilink`
+ * so the existing delegated click handler picks them up.
+ *
+ * `code` and `math` win first and keep their contents literal; everything else
+ * recurses so `**a `code` b**` styles the bold and the code.
+ */
+export declare function renderInline(text: string): DocumentFragment;
+//# sourceMappingURL=inline-md.d.ts.map

package/dist/inplace/inline-md.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-md.d.ts","sourceRoot":"","sources":["../../src/inplace/inline-md.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,CAI3D"}

package/dist/inplace/lazyInPlace.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The in-place canvas carries the decoration plugin (and, in later increments,
+ * its KaTeX widgets). It loads only when `mode` resolves to `in-place`, so
+ * `source` consumers never fetch it.
+ */
+export declare const LazyInPlaceView: import("react").LazyExoticComponent<typeof import("./InPlaceView").InPlaceView>;
+//# sourceMappingURL=lazyInPlace.d.ts.map

package/dist/inplace/lazyInPlace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazyInPlace.d.ts","sourceRoot":"","sources":["../../src/inplace/lazyInPlace.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,eAAO,MAAM,eAAe,iFAEzB,CAAA"}

package/dist/inplace/link-click.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Click a collapsed `[text](url)` in the seamless canvas and its URL editor
+ * opens at the pointer — the same field the right-click menu and the selection
+ * bar use. Under `reveal: "never"` the `(url)` is never on screen as text, so a
+ * plain click otherwise has nowhere to go for an edit. The read side is
+ * `link-hover.ts`; this is the write side (ADR-007 Stage 5, the click half).
+ *
+ * Scope:
+ * - Only under `reveal: "never"`. In `"caret"` mode a click already reveals the
+ *   source on that line, so inline editing is the path there.
+ * - External links only. A wikilink click is navigation (`onWikiLinkClick`);
+ *   its target stays editable through hover + the right-click menu.
+ */
+import { ViewPlugin, type EditorView, type PluginValue } from "@codemirror/view";
+declare class LinkClickEditor implements PluginValue {
+    private menu;
+    private contentDOM;
+    private onClick;
+    constructor(view: EditorView);
+    destroy(): void;
+}
+export declare const linkClickEditor: ViewPlugin<LinkClickEditor, undefined>;
+export {};
+//# sourceMappingURL=link-click.d.ts.map

package/dist/inplace/link-click.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"link-click.d.ts","sourceRoot":"","sources":["../../src/inplace/link-click.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,UAAU,EAAE,KAAK,UAAU,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAKhF,cAAM,eAAgB,YAAW,WAAW;IAC1C,OAAO,CAAC,IAAI,CAAa;IACzB,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,OAAO,CAAyB;IAExC,YAAY,IAAI,EAAE,UAAU,EAsB3B;IAED,OAAO,SAGN;CACF;AAED,eAAO,MAAM,eAAe,wCAAwC,CAAA"}

package/dist/inplace/link-hover.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Hover a link or wikilink in the in-place canvas and a small bubble shows where
+ * it points — the raw `(url)` of a `[text](url)`, or the `[[target]]`. Under
+ * `reveal: "never"` the destination is otherwise never on screen, so this is the
+ * read affordance for it (ADR-007 Stage 5, the hover half).
+ */
+import { type Tooltip } from "@codemirror/view";
+export declare const linkHoverTooltip: import("@codemirror/state").Extension & {
+    active: import("@codemirror/state").StateField<readonly Tooltip[]>;
+};
+//# sourceMappingURL=link-hover.d.ts.map

package/dist/inplace/link-hover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"link-hover.d.ts","sourceRoot":"","sources":["../../src/inplace/link-hover.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAiC,KAAK,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAoD9E,eAAO,MAAM,gBAAgB;;CAM3B,CAAA"}

package/dist/inplace/list-guides.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Vertical indent guides for nested lists on the in-place canvas — one faint
+ * rule per nesting level, drawn from the list's left padding (Obsidian /
+ * Notion). Purely decorative: a `.cm-inplace-li` line decoration carrying the
+ * nesting depth in `--sl-li-depth`, which the theme turns into that many guide
+ * rules via a background gradient.
+ *
+ * Only a list item's *own* lines are decorated — the range stops before its
+ * first nested list — so each line's depth is its innermost item's.
+ */
+import type { Range, Text } from "@codemirror/state";
+import { Decoration } from "@codemirror/view";
+import type { ResolvedToggles } from "./config";
+import type { Tree } from "./scan";
+export declare function scanListGuides(from: number, to: number, tree: Tree, doc: Text, toggles: ResolvedToggles, out: Range<Decoration>[]): void;
+//# sourceMappingURL=list-guides.d.ts.map

package/dist/inplace/list-guides.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-guides.d.ts","sourceRoot":"","sources":["../../src/inplace/list-guides.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAA;AACpD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAE7C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAC/C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAWlC,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,IAAI,EACV,GAAG,EAAE,IAAI,EACT,OAAO,EAAE,eAAe,EACxB,GAAG,EAAE,KAAK,CAAC,UAAU,CAAC,EAAE,GACvB,IAAI,CA4BN"}

package/dist/inplace/long-press.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Touch / pen long-press detection.
+ *
+ * A mouse gets the context menu from the native `contextmenu` event on
+ * right-click. A touch device has no dependable equivalent — iOS Safari in
+ * particular races its own selection callout on a long-press and usually wins,
+ * so `contextmenu` never arrives. This runs a plain timer instead: pointer
+ * down, hold still for `delay` ms, and `onLongPress` fires with the contact
+ * point.
+ *
+ * Mouse pointers are ignored — they already have `contextmenu`. Moving past
+ * `slop` pixels, or lifting / cancelling before the timer, aborts the press.
+ * `cancel()` aborts a pending press without detaching — the caller uses it when
+ * a real `contextmenu` lands first (Android synthesises one from the same
+ * gesture) so the two paths can't both open the menu.
+ *
+ * The defaults are tuned for a fingertip, not a stylus: a finger cannot hold a
+ * contact point to within a few pixels for half a second, so `slop` is generous
+ * and `delay` sits just under the ~500 ms where iOS Safari commits to its own
+ * long-press selection.
+ */
+export interface LongPressOptions {
+    /** Hold time before the press completes. Default 450 ms. */
+    delay?: number;
+    /** Movement (from the contact point, on either axis) that aborts it. Default 20 px. */
+    slop?: number;
+    /** Fired when the hold completes: viewport coordinates and the element the
+     *  finger first landed on. */
+    onLongPress: (x: number, y: number, target: EventTarget | null) => void;
+}
+export interface LongPressHandle {
+    /** Abort a press in progress; keeps the listeners attached. */
+    cancel: () => void;
+    /** Abort and detach every listener. */
+    dispose: () => void;
+}
+/** Attach long-press detection to `el`. */
+export declare function attachLongPress(el: HTMLElement, opts: LongPressOptions): LongPressHandle;
+//# sourceMappingURL=long-press.d.ts.map

package/dist/inplace/long-press.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"long-press.d.ts","sourceRoot":"","sources":["../../src/inplace/long-press.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,MAAM,WAAW,gBAAgB;IAC/B,4DAA4D;IAC5D,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,uFAAuF;IACvF,IAAI,CAAC,EAAE,MAAM,CAAA;IACb;kCAC8B;IAC9B,WAAW,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,IAAI,KAAK,IAAI,CAAA;CACxE;AAED,MAAM,WAAW,eAAe;IAC9B,+DAA+D;IAC/D,MAAM,EAAE,MAAM,IAAI,CAAA;IAClB,uCAAuC;IACvC,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB;AAED,2CAA2C;AAC3C,wBAAgB,eAAe,CAAC,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,gBAAgB,GAAG,eAAe,CA8CxF"}

package/dist/inplace/math.d.ts

@@ -0,0 +1,16 @@
+import { type Range, StateField } from "@codemirror/state";
+import { Decoration, type DecorationSet, EditorView } from "@codemirror/view";
+import { type Tree } from "./scan";
+/**
+ * Viewport pass for `$…$` and single-line `$$…$$` — the CodeMirror grammar has
+ * no math node. Off-caret matches become KaTeX widgets. Multi-line `$$` blocks
+ * are handled by `blockMathField` instead (a plugin may not replace line breaks).
+ */
+export declare function scanInlineMath(view: EditorView, from: number, to: number, revealed: Set<number>, tree: Tree, out: Range<Decoration>[]): void;
+/**
+ * Multi-line `$$…$$` blocks, whose delimiters sit alone on their own lines.
+ * A state field (not a plugin) because the replacement spans line breaks. Not
+ * viewport-scoped — the whole document is scanned — but `$$` blocks are few.
+ */
+export declare const blockMathField: StateField<DecorationSet>;
+//# sourceMappingURL=math.d.ts.map

package/dist/inplace/math.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"math.d.ts","sourceRoot":"","sources":["../../src/inplace/math.ts"],"names":[],"mappings":"AACA,OAAO,EAAoB,KAAK,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAC5E,OAAO,EAAE,UAAU,EAAE,KAAK,aAAa,EAAE,UAAU,EAAc,MAAM,kBAAkB,CAAA;AAIzF,OAAO,EAAgC,KAAK,IAAI,EAAE,MAAM,QAAQ,CAAA;AAmChE;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,EACrB,IAAI,EAAE,IAAI,EACV,GAAG,EAAE,KAAK,CAAC,UAAU,CAAC,EAAE,GACvB,IAAI,CAyBN;AAED;;;;GAIG;AACH,eAAO,MAAM,cAAc,2BASzB,CAAA"}

package/dist/inplace/menu-plugin.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Owns the in-place right-click menu: one `ContextMenu` per editor, a
+ * `contextmenu` listener on the content DOM, and the rule for when Stylo takes
+ * over from the browser's own menu (see the 2026-09-03 journal note). On touch
+ * there is no `contextmenu` event, so a long-press opens the same menu.
+ */
+import { ViewPlugin, type EditorView, type PluginValue } from "@codemirror/view";
+declare class ContextMenuController implements PluginValue {
+    private view;
+    private menu;
+    private onContextMenu;
+    private onPointerDown;
+    private longPress;
+    private contentDOM;
+    /** Selection captured at pointer-down — a right-click can collapse it before
+     *  `contextmenu` fires, which would drop the selection-aware menu rows. */
+    private stashed;
+    /** When a long-press last opened the menu. Android also synthesises a
+     *  `contextmenu` from the same gesture; one that lands within the window is
+     *  swallowed so the menu does not re-open on top of itself. */
+    private longPressAt;
+    constructor(view: EditorView);
+    /** Open the canvas menu at a screen point, from a right-click or a long-press.
+     *  Reconciles the selection first so the menu offers the right rows. */
+    private openMenuAt;
+    destroy(): void;
+}
+export declare const contextMenuLayer: ViewPlugin<ContextMenuController, undefined>;
+export {};
+//# sourceMappingURL=menu-plugin.d.ts.map

package/dist/inplace/menu-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-plugin.d.ts","sourceRoot":"","sources":["../../src/inplace/menu-plugin.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,UAAU,EAAE,KAAK,UAAU,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAOhF,cAAM,qBAAsB,YAAW,WAAW;IAChD,OAAO,CAAC,IAAI,CAAY;IACxB,OAAO,CAAC,IAAI,CAAa;IACzB,OAAO,CAAC,aAAa,CAAyB;IAC9C,OAAO,CAAC,aAAa,CAAY;IACjC,OAAO,CAAC,SAAS,CAAiB;IAClC,OAAO,CAAC,UAAU,CAAa;IAC/B;+EAC2E;IAC3E,OAAO,CAAC,OAAO,CAAgD;IAC/D;;mEAE+D;IAC/D,OAAO,CAAC,WAAW,CAAI;IAEvB,YAAY,IAAI,EAAE,UAAU,EA4C3B;IAED;4EACwE;IACxE,OAAO,CAAC,UAAU;IAiClB,OAAO,SAKN;CACF;AAED,eAAO,MAAM,gBAAgB,8CAA8C,CAAA"}

package/dist/inplace/nodes.d.ts

@@ -0,0 +1,24 @@
+import type { Range, Text } from "@codemirror/state";
+import { Decoration } from "@codemirror/view";
+import type { SyntaxNodeRef } from "@lezer/common";
+import type { ResolvedToggles } from "./config";
+export interface NodeCtx {
+    doc: Text;
+    revealed: Set<number>;
+    /** Lines the caret actually touches. Equals `revealed` except under
+     *  `reveal: "never"`, where `revealed` is empty but this is not — a few
+     *  constructs (fenced code) still reveal their delimiters on caret entry
+     *  because there is no other way to see or remove them. */
+    caretRevealed: Set<number>;
+    out: Range<Decoration>[];
+    toggles: ResolvedToggles;
+    /** End of the frontmatter block, or -1. Nodes within are left to `frontmatterField`. */
+    fmEnd: number;
+    /** Lines of a blockquote / callout whose block the caret is in — its `> ` and
+     *  `[!type]` markers show raw, like a fenced code / `$$` block. Filled by the
+     *  `Blockquote` handler before its `QuoteMark` children are visited. */
+    quoteRevealed: Set<number>;
+}
+/** Decorate one syntax node. Returns `false` to stop descent, `undefined` to continue. */
+export declare function decorateNode(node: SyntaxNodeRef, ctx: NodeCtx): boolean | undefined;
+//# sourceMappingURL=nodes.d.ts.map

package/dist/inplace/nodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodes.d.ts","sourceRoot":"","sources":["../../src/inplace/nodes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAA;AACpD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC7C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAElD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAgB/C,MAAM,WAAW,OAAO;IACtB,GAAG,EAAE,IAAI,CAAA;IACT,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IACrB;;;+DAG2D;IAC3D,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAC1B,GAAG,EAAE,KAAK,CAAC,UAAU,CAAC,EAAE,CAAA;IACxB,OAAO,EAAE,eAAe,CAAA;IACxB,wFAAwF;IACxF,KAAK,EAAE,MAAM,CAAA;IACb;;4EAEwE;IACxE,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CAC3B;AAED,0FAA0F;AAC1F,wBAAgB,YAAY,CAAC,IAAI,EAAE,aAAa,EAAE,GAAG,EAAE,OAAO,GAAG,OAAO,GAAG,SAAS,CAgPnF"}

package/dist/inplace/plugin.d.ts

@@ -0,0 +1,21 @@
+import type { Extension } from "@codemirror/state";
+import { type DecorationSet, ViewPlugin, type ViewUpdate } from "@codemirror/view";
+/**
+ * Owns the in-place decoration set and rebuilds it when the document, the
+ * viewport, or the selection changes. Selection is a trigger because the
+ * cursor-reveal behaviour depends on where the caret sits.
+ *
+ * Also provides `EditorView.atomicRanges` covering every replacing decoration —
+ * hidden markers and widgets alike — so the caret steps over hidden syntax
+ * instead of into invisible positions.
+ *
+ * Exported (not just the factory) so tests can read the live sets via
+ * `view.plugin(inPlacePlugin)`.
+ */
+export declare const inPlacePlugin: ViewPlugin<{
+    decorations: DecorationSet;
+    atomic: DecorationSet;
+    update(update: ViewUpdate): void;
+}, undefined>;
+export declare function inPlaceDecorations(): Extension;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/inplace/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../src/inplace/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAClD,OAAO,EAEL,KAAK,aAAa,EAElB,UAAU,EACV,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAGzB;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,aAAa;iBAET,aAAa;YAClB,aAAa;mBAQN,UAAU;aAa5B,CAAA;AAED,wBAAgB,kBAAkB,IAAI,SAAS,CAE9C"}

package/dist/inplace/reveal.d.ts

@@ -0,0 +1,8 @@
+import type { EditorState } from "@codemirror/state";
+/**
+ * Line numbers (1-based) that a selection range currently touches. A node whose
+ * line is in this set keeps its raw Markdown markers visible for editing;
+ * elsewhere the decoration builder hides them.
+ */
+export declare function revealedLines(state: EditorState): Set<number>;
+//# sourceMappingURL=reveal.d.ts.map