@ripple-ui/svelte 0.0.0-stage → 0.8.2

package/dist/editor/core/editor-ops.js

@@ -0,0 +1,60 @@
+/**
+ * @file editor/core/editor-ops.ts
+ * @description L1 (PURE TS, zero Svelte/rune imports) one-op apply SEAM for the
+ *   Ripple visual editor (SP-1b). This is the single choke point every editor
+ *   mutation flows through — inline text edit AND inspector prop edit both call
+ *   `setNodeProp`, which builds one wire-shaped `node_prop_set` payload and runs
+ *   it through `spec-mutator`'s `applyOp` against the host's live root.
+ *
+ *   The host owns the spec in Svelte `$state` (a deep proxy) and passes a
+ *   `getRoot` accessor; `applyOp` mutates that proxy IN PLACE, so the canvas
+ *   repaints reactively (SP-0 §3). After a successful op, `onApplied(op)` fires —
+ *   that is the documented interception point SP-1c (persistence / Branch) hangs
+ *   off to `saveDraft(root)` without any change to the call sites. Keeping the
+ *   op stream behind one function means undo/redo (a later slice) can also wrap
+ *   it (capture the inverse `applyOp` returns) in exactly one place.
+ *
+ *   Pure: no Svelte, no DOM. The only reactivity is in the host's `$state` root;
+ *   this module just routes payloads, so it is fully unit-testable over a plain
+ *   object tree.
+ * @created 2026-06-27 (SP-1b — branch spike/editor-domid-overlay)
+ */
+import { applyOp } from '@ripple-ui/core';
+/**
+ * Build a wire-shaped `node_prop_set` payload — the one op SP-1b emits. `prop`
+ * may be a top-level field (`text` is in `props`; `class`/`show`/… are top-level
+ * — `applySetNodeProp` routes them) or a dotted path into `props`.
+ */
+export function nodePropSet(node_id, prop, value) {
+    return { action: 'node_prop_set', node_id, prop, value };
+}
+/**
+ * Create the editor op seam bound to a host's live root accessor. Every editor
+ * entry point (inline edit, inspector) goes through the returned `apply` /
+ * `setNodeProp`, so `onApplied` is the one place to wire persistence/undo later.
+ */
+export function createEditorOps(opts) {
+    function apply(op) {
+        const root = opts.getRoot();
+        if (!root)
+            return false;
+        let ok = false;
+        try {
+            ok = applyOp(root, op);
+        }
+        catch (err) {
+            if (opts.onError) {
+                opts.onError(err, op);
+                return false;
+            }
+            throw err;
+        }
+        if (ok)
+            opts.onApplied?.(op);
+        return ok;
+    }
+    function setNodeProp(node_id, prop, value) {
+        return apply(nodePropSet(node_id, prop, value));
+    }
+    return { apply, setNodeProp };
+}

package/dist/editor/core/geometry.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @file editor/core/geometry.ts
+ * @description L1 (PURE TS, zero Svelte/rune imports) rect math for the Ripple
+ *   visual-editor overlay. `pointInRect` and `rectToStyle` are lifted from
+ *   svelte-visual-builder's `editor-svelte/src/lib/canvas.ts` and re-typed onto
+ *   a plain `Rect` ({left,top,right,bottom,width,height}) so a future React/Vue
+ *   L2 can reuse them unchanged (Decision 6). No DOM is queried here — callers
+ *   pass rects in; the thin DOM-reading boundary lives in `bounds-index.ts`.
+ * @created 2026-06-27 (SP-1a — branch spike/editor-domid-overlay)
+ */
+/** A plain axis-aligned rectangle. A browser `DOMRect` is structurally assignable. */
+export interface Rect {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+    width: number;
+    height: number;
+}
+/** True when (x, y) falls within `rect` (edges inclusive). */
+export declare function pointInRect(rect: Rect, x: number, y: number): boolean;
+/** Absolutely-positioned CSS for a box matching `rect` (left/top/width/height). */
+export declare function rectToStyle(rect: Rect): string;
+/** Area of a rect — used to pick the innermost (smallest) hit in a point test. */
+export declare function rectArea(rect: Rect): number;
+/**
+ * Re-base an absolute (viewport) rect onto an origin — typically a render
+ * container's top-left — so the overlay can position boxes relative to that
+ * container instead of the viewport. Pure arithmetic; `input` may be a `DOMRect`
+ * the caller read via getBoundingClientRect (structurally a `Rect`).
+ */
+export declare function relativeRect(input: Rect, origin: {
+    left: number;
+    top: number;
+}): Rect;

package/dist/editor/core/geometry.js

@@ -0,0 +1,38 @@
+/**
+ * @file editor/core/geometry.ts
+ * @description L1 (PURE TS, zero Svelte/rune imports) rect math for the Ripple
+ *   visual-editor overlay. `pointInRect` and `rectToStyle` are lifted from
+ *   svelte-visual-builder's `editor-svelte/src/lib/canvas.ts` and re-typed onto
+ *   a plain `Rect` ({left,top,right,bottom,width,height}) so a future React/Vue
+ *   L2 can reuse them unchanged (Decision 6). No DOM is queried here — callers
+ *   pass rects in; the thin DOM-reading boundary lives in `bounds-index.ts`.
+ * @created 2026-06-27 (SP-1a — branch spike/editor-domid-overlay)
+ */
+/** True when (x, y) falls within `rect` (edges inclusive). */
+export function pointInRect(rect, x, y) {
+    return x >= rect.left && x <= rect.right && y >= rect.top && y <= rect.bottom;
+}
+/** Absolutely-positioned CSS for a box matching `rect` (left/top/width/height). */
+export function rectToStyle(rect) {
+    return `left:${rect.left}px;top:${rect.top}px;width:${rect.width}px;height:${rect.height}px;`;
+}
+/** Area of a rect — used to pick the innermost (smallest) hit in a point test. */
+export function rectArea(rect) {
+    return Math.max(0, rect.width) * Math.max(0, rect.height);
+}
+/**
+ * Re-base an absolute (viewport) rect onto an origin — typically a render
+ * container's top-left — so the overlay can position boxes relative to that
+ * container instead of the viewport. Pure arithmetic; `input` may be a `DOMRect`
+ * the caller read via getBoundingClientRect (structurally a `Rect`).
+ */
+export function relativeRect(input, origin) {
+    return {
+        left: input.left - origin.left,
+        top: input.top - origin.top,
+        right: input.right - origin.left,
+        bottom: input.bottom - origin.top,
+        width: input.width,
+        height: input.height
+    };
+}

package/dist/editor/core/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @file editor/core/index.ts
+ * @description Barrel for the editor L1 core (PURE TS, zero Svelte/rune imports):
+ *   geometry math, the DOM-id `BoundsIndex` + element resolver, the
+ *   framework-agnostic `SelectionModel`, the catalog-derived editable-prop
+ *   policy (`editable.ts`), and the one-op apply seam (`editor-ops.ts`).
+ *   Re-exported by the editor L2 barrel (`../index.ts`) under the
+ *   `@ripple-ui/svelte/editor` package entry.
+ * @created 2026-06-27 (SP-1a — branch spike/editor-domid-overlay)
+ * @changes 2026-06-27 (SP-1b): export findNodeElement, editable.ts, editor-ops.ts.
+ * @changes 2026-06-27 (SP-1c-a): export ports.ts (host-boundary interfaces) +
+ *   MemoryPersistenceAdapter (in-memory reference stub).
+ * @changes 2026-06-30 (EP-1): export the LaneAdapter port (lane-adapter.ts) + the
+ *   ripple implementation (RippleLaneAdapter).
+ * @changes 2026-06-30 (EP-3): export the pluggable InlineEditor slot (inline-editor.ts:
+ *   the interface, registry, and the two ripple impls — ContentEditable + TipTap).
+ * @changes 2026-06-30 (EP-4): export the SOURCE-FIDELITY InlineEditor impl
+ *   (inline-editor-source.ts) — the no-dep, byte-stable, in-place editor registered
+ *   under the 'overlay' kind for the future svelte source lane. The re-export
+ *   evaluates the module, so its self-registration side effect runs for any barrel
+ *   consumer (`resolveInlineEditor('overlay')`).
+ */
+export { pointInRect, rectToStyle, rectArea, relativeRect, type Rect } from './geometry.js';
+export { BoundsIndex, buildBoundsIndex, findNodeElement, resolveElementToNodeId, nodeIdOf, RIPPLE_NODE_ATTR, NODE_ID_SELECTOR, type ResolveOptions } from './bounds-index.js';
+export { SelectionModel, createSelectionModel, type SelectionState, type SelectionListener } from './selection-model.js';
+export { TEXT_PROP_PRIORITY, resolvePrimaryTextProp, resolveEditableTextProps, primaryTextProp, editableTextProps, catalogEntry, INLINE_TEXT_WIDGETS, isInlineTextWidget, normalizeInlineText, RICH_TEXT_PROP, RICH_TEXT_WIDGETS, isRichTextWidget, type CatalogPropSpec, type CatalogEntryLike } from './editable.js';
+export { createEditorOps, nodePropSet, type EditorOp, type EditorOps, type EditorOpsOptions } from './editor-ops.js';
+export { type PersistenceAdapter, type DataSourceAdapter, type ExportStorageAdapter, type AuthoringAgentAdapter, type ScopeId, type DraftRef, type Revision } from './ports.js';
+export { MemoryPersistenceAdapter } from './memory-persistence-adapter.js';
+export { inferFields, inferFieldKind, parseEnumOptions, coerceFieldValue, inspectorCatalogEntry, type InspectorField, type FieldKind } from './inspector-fields.js';
+export { resolveSiblingDrop, siblingResolverFromRoot, nodeMovedOp, type ParentAndSiblings, type SiblingResolver, type DropTarget } from './drag-reorder.js';
+export { type LaneAdapter, type TargetRef, type EditableNode, type EditOp } from './lane-adapter.js';
+export { RippleLaneAdapter, type RippleLaneAdapterOptions } from './ripple-lane-adapter.js';
+export { registerInlineEditor, resolveInlineEditor, type InlineEditor, type InlineEditorHandle, type InlineEditorMountOpts } from './inline-editor.js';
+export { ContentEditableInlineEditor } from './inline-editor-contenteditable.js';
+export { TipTapInlineEditor } from './inline-editor-tiptap.js';
+export { SourceFidelityInlineEditor } from './inline-editor-source.js';

package/dist/editor/core/index.js

@@ -0,0 +1,37 @@
+/**
+ * @file editor/core/index.ts
+ * @description Barrel for the editor L1 core (PURE TS, zero Svelte/rune imports):
+ *   geometry math, the DOM-id `BoundsIndex` + element resolver, the
+ *   framework-agnostic `SelectionModel`, the catalog-derived editable-prop
+ *   policy (`editable.ts`), and the one-op apply seam (`editor-ops.ts`).
+ *   Re-exported by the editor L2 barrel (`../index.ts`) under the
+ *   `@ripple-ui/svelte/editor` package entry.
+ * @created 2026-06-27 (SP-1a — branch spike/editor-domid-overlay)
+ * @changes 2026-06-27 (SP-1b): export findNodeElement, editable.ts, editor-ops.ts.
+ * @changes 2026-06-27 (SP-1c-a): export ports.ts (host-boundary interfaces) +
+ *   MemoryPersistenceAdapter (in-memory reference stub).
+ * @changes 2026-06-30 (EP-1): export the LaneAdapter port (lane-adapter.ts) + the
+ *   ripple implementation (RippleLaneAdapter).
+ * @changes 2026-06-30 (EP-3): export the pluggable InlineEditor slot (inline-editor.ts:
+ *   the interface, registry, and the two ripple impls — ContentEditable + TipTap).
+ * @changes 2026-06-30 (EP-4): export the SOURCE-FIDELITY InlineEditor impl
+ *   (inline-editor-source.ts) — the no-dep, byte-stable, in-place editor registered
+ *   under the 'overlay' kind for the future svelte source lane. The re-export
+ *   evaluates the module, so its self-registration side effect runs for any barrel
+ *   consumer (`resolveInlineEditor('overlay')`).
+ */
+export { pointInRect, rectToStyle, rectArea, relativeRect } from './geometry.js';
+export { BoundsIndex, buildBoundsIndex, findNodeElement, resolveElementToNodeId, nodeIdOf, RIPPLE_NODE_ATTR, NODE_ID_SELECTOR } from './bounds-index.js';
+export { SelectionModel, createSelectionModel } from './selection-model.js';
+export { TEXT_PROP_PRIORITY, resolvePrimaryTextProp, resolveEditableTextProps, primaryTextProp, editableTextProps, catalogEntry, INLINE_TEXT_WIDGETS, isInlineTextWidget, normalizeInlineText, RICH_TEXT_PROP, RICH_TEXT_WIDGETS, isRichTextWidget } from './editable.js';
+export { createEditorOps, nodePropSet } from './editor-ops.js';
+export {} from './ports.js';
+export { MemoryPersistenceAdapter } from './memory-persistence-adapter.js';
+export { inferFields, inferFieldKind, parseEnumOptions, coerceFieldValue, inspectorCatalogEntry } from './inspector-fields.js';
+export { resolveSiblingDrop, siblingResolverFromRoot, nodeMovedOp } from './drag-reorder.js';
+export {} from './lane-adapter.js';
+export { RippleLaneAdapter } from './ripple-lane-adapter.js';
+export { registerInlineEditor, resolveInlineEditor } from './inline-editor.js';
+export { ContentEditableInlineEditor } from './inline-editor-contenteditable.js';
+export { TipTapInlineEditor } from './inline-editor-tiptap.js';
+export { SourceFidelityInlineEditor } from './inline-editor-source.js';

package/dist/editor/core/inline-editor-contenteditable.d.ts

@@ -0,0 +1,3 @@
+import type { InlineEditor } from './inline-editor.js';
+/** The plain single-text contenteditable editor — the fixed path for text widgets. */
+export declare const ContentEditableInlineEditor: InlineEditor;

package/dist/editor/core/inline-editor-contenteditable.js

@@ -0,0 +1,94 @@
+/**
+ * @file editor/core/inline-editor-contenteditable.ts
+ * @description L1 (PURE TS / DOM, zero Svelte/rune imports) the PLAIN single-text
+ *   `InlineEditor` impl (EP-3) — the contenteditable path lifted VERBATIM out of
+ *   `RippleInlineEditor.svelte`. Used for heading / text / button / badge, whose
+ *   rendered textContent equals their primary text prop, so the edit round-trips
+ *   `textContent` -> the prop.
+ *
+ *   LIFECYCLE (per the `InlineEditor` slot contract): `mount` makes `el`
+ *   contenteditable, wires Enter (commit) / Escape (cancel) / blur (commit), focuses
+ *   it and selects all so typing replaces. A commit harvests `normalizeInlineText
+ *   (textContent)` and fires `onCommit(value)` ONLY when it differs from the seed
+ *   (an unchanged Enter / blur emits nothing — the pre-EP-3 behavior). Escape
+ *   restores the seed text and fires `onCancel`. `destroy` tears the DOM down
+ *   silently. EVERY teardown path removes the host's `data-ripple-editing`
+ *   attribute and the contenteditable listeners + flag. Interaction FEEL (caret,
+ *   IME, select-all) is out of jsdom's reach; all Selection calls are guarded.
+ * @created 2026-06-30 (EP-3 — pluggable InlineEditor slot)
+ */
+import { normalizeInlineText } from './editable.js';
+/** Caret across the whole text so typing replaces it. Guarded — jsdom Selection is partial. */
+function selectAll(el) {
+    try {
+        const sel = window.getSelection?.();
+        const range = document.createRange();
+        range.selectNodeContents(el);
+        sel?.removeAllRanges();
+        sel?.addRange(range);
+    }
+    catch {
+        /* selection is a nicety, not required for correctness */
+    }
+}
+/** The plain single-text contenteditable editor — the fixed path for text widgets. */
+export const ContentEditableInlineEditor = {
+    mount(el, opts) {
+        const seed = opts.content;
+        let done = false; // re-entrancy guard: a blur after Enter must not re-commit.
+        function teardownDom() {
+            el.removeEventListener('keydown', onKey);
+            el.removeEventListener('blur', onBlur);
+            el.removeAttribute('contenteditable');
+            el.removeAttribute('data-ripple-editing'); // clear the editing outline (the EP-1 fix)
+        }
+        function commit() {
+            if (done)
+                return;
+            done = true;
+            const value = normalizeInlineText(el.textContent);
+            teardownDom();
+            // Only emit when the text actually changed — keeps the op / undo stream clean.
+            // (No DOM restore: the host's reactive re-render rewrites the text from the prop.)
+            if (value !== normalizeInlineText(seed))
+                opts.onCommit(value);
+        }
+        function cancel() {
+            if (done)
+                return;
+            done = true;
+            teardownDom();
+            // The model was never mutated, so restoring the DOM text matches it.
+            el.textContent = seed;
+            opts.onCancel();
+        }
+        const onKey = (e) => {
+            if (e.key === 'Enter' && !e.shiftKey) {
+                e.preventDefault();
+                commit();
+            }
+            else if (e.key === 'Escape') {
+                e.preventDefault();
+                cancel();
+            }
+        };
+        const onBlur = () => commit();
+        el.setAttribute('contenteditable', 'true');
+        el.addEventListener('keydown', onKey);
+        el.addEventListener('blur', onBlur);
+        el.focus();
+        selectAll(el);
+        return {
+            destroy() {
+                if (done)
+                    return; // already committed / cancelled / torn down
+                done = true;
+                teardownDom();
+            },
+            focus() {
+                el.focus();
+                selectAll(el);
+            }
+        };
+    }
+};

package/dist/editor/core/inline-editor-source.d.ts

@@ -0,0 +1,6 @@
+import type { InlineEditor } from './inline-editor.js';
+/**
+ * The source-fidelity rich editor — no dependency, edits the live element in place,
+ * keeps its markup byte-stable. Registered as the ripple 'overlay' built-in.
+ */
+export declare const SourceFidelityInlineEditor: InlineEditor;

package/dist/editor/core/inline-editor-source.js

@@ -0,0 +1,178 @@
+/**
+ * @file editor/core/inline-editor-source.ts
+ * @description L1 (PURE TS / DOM, zero Svelte/rune imports) the SOURCE-FIDELITY
+ *   `InlineEditor` impl (EP-4) — a no-dependency, in-place contenteditable editor
+ *   registered under the 'overlay' kind. It is the rich slot for the future svelte
+ *   SOURCE lane (EP-6), which edits hand-authored .svelte / html markup where a
+ *   parser/schema round-trip is DESTRUCTIVE.
+ *
+ *   WHY NOT TIPTAP / SQUIRE (the EP-4 spike decision — see the design doc's open
+ *   question). TipTap parses HTML into a ProseMirror schema and re-serializes on
+ *   `getHTML()`, so it reorders/drops attributes and rewrites whitespace + non-schema
+ *   markup. Squire (the prior-art candidate) was spiked and REJECTED on the decisive
+ *   fidelity criterion: even with a passthrough sanitizer it rewrites inline tags
+ *   (`<strong>` -> `<b>`) and its `setHTML` requires a second dependency (DOMPurify),
+ *   so it is no more source-stable than TipTap and adds ~60KB + a jsdom-hostile
+ *   construction path. This editor instead keeps the LIVE DOM as the source of truth:
+ *   it never re-parses or re-serializes through a schema, so attribute order, child
+ *   markup, and whitespace stay BYTE-STABLE — only the text node the user actually
+ *   edits changes. The 'overlay' kind name is the lane key the svelte lane will set
+ *   as `adapter.inlineEditor`; the no-dep win can later grow a floating visual layer
+ *   (a clone-based overlay) WITHOUT changing this contract or the byte-stability
+ *   guarantee.
+ *
+ *   MECHANISM. `mount` snapshots the element's current `innerHTML` (the authoritative
+ *   seed — `opts.content` is accepted but the LIVE element wins, because re-parsing a
+ *   passed-in string would itself be a normalizing round-trip), marks the element
+ *   contenteditable, and places the caret at the end (NOT select-all — that would nuke
+ *   child markup like `<strong>`). The user edits text in place; contenteditable
+ *   mutates only the touched text node(s), leaving every other DOM node identical.
+ *
+ *   COMMIT / CANCEL. Enter (no shift) and blur commit; Escape cancels. A commit FIRST
+ *   strips the editor scaffolding (`contenteditable` + the host's `data-ripple-editing`)
+ *   so they never leak into the serialization, then reads `el.outerHTML` — the full,
+ *   byte-stable element markup — and fires `onCommit(value)` ONLY when the content
+ *   changed from the seed. Cancel and the silent `destroy` restore the seed `innerHTML`
+ *   (the model was never mutated). EVERY teardown path clears `data-ripple-editing`
+ *   (the EP-1 stuck-outline fix). `destroy` is idempotent. All focus / Selection calls
+ *   are guarded so the jsdom unit path never throws.
+ *
+ *   XSS POSTURE — DELIBERATELY NOT SANITIZED (unlike the TipTap impl). The sibling
+ *   `inline-editor-tiptap` sanitizes its seed because that seed is the RAW SPEC PROP:
+ *   model content that was never rendered, so writing it to `innerHTML` grants the
+ *   page a capability it did not have. This impl is the opposite case — its seed is
+ *   `el.innerHTML`, a snapshot of the LIVE element. Whatever is in there was already
+ *   parsed and rendered by the host (in the ripple lane, by RichTextDisplay, which
+ *   sanitizes before `{@html}`), so restoring it re-creates the status quo and grants
+ *   nothing new. Running the seed through `sanitizeHtml` here would therefore add no
+ *   security while DESTROYING the contract this file exists for: the sanitizer's
+ *   profile FORBIDS `style` and drops non-schema markup, so hand-authored source in
+ *   the EP-6 svelte lane would silently lose legitimate attributes on every cancel —
+ *   the exact round-trip damage that got TipTap and Squire rejected above. The
+ *   invariant is "faithful to what the host rendered", and the host owns sanitizing
+ *   what it renders. If a future lane ever renders UNSANITIZED model HTML into the
+ *   element this mounts on, that lane's RENDER path is the bug, not this restore.
+ *   Guarded by a test in `editor/inline-editor.security.test.ts`.
+ *
+ *   REAL-BROWSER NOTE. Native contenteditable can inject `<br>` / normalize whitespace
+ *   on certain edits; that is a browser concern (not exercised by the jsdom suite). If
+ *   EP-6 sees spurious diffs in a live browser, add a normalization guard at the lane's
+ *   `applyEdit` seam — the byte-stability contract proven here stays unchanged.
+ * @created 2026-06-30 (EP-4 — source-fidelity inline editor)
+ */
+import { registerInlineEditor } from './inline-editor.js';
+/** Collapse the caret to the end of `el`'s content. Guarded — jsdom Selection is partial. */
+function caretToEnd(el) {
+    try {
+        const sel = window.getSelection?.();
+        const range = document.createRange();
+        range.selectNodeContents(el);
+        range.collapse(false); // to the END — preserve child markup, don't select-all
+        sel?.removeAllRanges();
+        sel?.addRange(range);
+    }
+    catch {
+        /* caret placement is a nicety, not required for correctness */
+    }
+}
+/**
+ * Restore the element's content to its seed markup. NOT sanitized on purpose — the
+ * seed is a snapshot of this element's own live content, so this restores the status
+ * quo rather than introducing model HTML, and sanitizing would break byte-stability
+ * (see the XSS POSTURE section in the header). Guarded for jsdom.
+ */
+function restoreInner(el, inner) {
+    try {
+        el.innerHTML = inner;
+    }
+    catch {
+        /* jsdom */
+    }
+}
+/**
+ * The source-fidelity rich editor — no dependency, edits the live element in place,
+ * keeps its markup byte-stable. Registered as the ripple 'overlay' built-in.
+ */
+export const SourceFidelityInlineEditor = {
+    mount(el, opts) {
+        // The LIVE element is the source of truth (see header) — snapshot its current
+        // inner markup as the seed; `opts.content` is intentionally not re-parsed into el.
+        const seedInner = el.innerHTML;
+        let done = false; // re-entrancy guard: a blur after Enter must not re-commit.
+        function teardownDom() {
+            el.removeEventListener('keydown', onKey);
+            el.removeEventListener('blur', onBlur);
+            // Strip the editor scaffolding BEFORE any serialization so it never leaks into
+            // the committed markup: contenteditable (ours) + data-ripple-editing (the host's,
+            // the EP-1 stuck-outline fix).
+            el.removeAttribute('contenteditable');
+            el.removeAttribute('data-ripple-editing');
+        }
+        function commit() {
+            if (done)
+                return;
+            done = true;
+            teardownDom();
+            // outerHTML AFTER teardown = the clean, byte-stable whole-element markup.
+            const value = el.outerHTML;
+            // Compare INNER markup (text edits live inside el; attrs can't change via typing).
+            if (el.innerHTML !== seedInner)
+                opts.onCommit(value);
+            // No restore: the live DOM already holds the result, and the host re-renders
+            // from the model after applyEdit (matches the other impls).
+        }
+        function cancel() {
+            if (done)
+                return;
+            done = true;
+            teardownDom();
+            // The model was never mutated, so restore the live DOM to the seed.
+            restoreInner(el, seedInner);
+            opts.onCancel();
+        }
+        const onKey = (e) => {
+            if (e.key === 'Enter' && !e.shiftKey) {
+                e.preventDefault();
+                commit();
+            }
+            else if (e.key === 'Escape') {
+                e.preventDefault();
+                cancel();
+            }
+        };
+        const onBlur = () => commit();
+        el.setAttribute('contenteditable', 'true');
+        el.addEventListener('keydown', onKey);
+        el.addEventListener('blur', onBlur);
+        try {
+            el.focus();
+        }
+        catch {
+            /* jsdom — focus is a nicety */
+        }
+        caretToEnd(el);
+        return {
+            destroy() {
+                if (done)
+                    return; // already committed / cancelled / torn down (idempotent)
+                done = true;
+                teardownDom();
+                // Silent teardown (no onCommit / onCancel): the model was never mutated, so
+                // restore the seed markup to keep the live DOM consistent with the model.
+                restoreInner(el, seedInner);
+            },
+            focus() {
+                try {
+                    el.focus();
+                }
+                catch {
+                    /* jsdom */
+                }
+                caretToEnd(el);
+            }
+        };
+    }
+};
+// Self-register the ripple source-fidelity built-in so `resolveInlineEditor('overlay')`
+// works for the svelte lane (EP-6), which sets `adapter.inlineEditor = 'overlay'`.
+registerInlineEditor('overlay', SourceFidelityInlineEditor);

package/dist/editor/core/inline-editor-tiptap.d.ts

@@ -0,0 +1,3 @@
+import type { InlineEditor } from './inline-editor.js';
+/** The rich-HTML editor backed by TipTap StarterKit — the ripple 'tiptap' built-in. */
+export declare const TipTapInlineEditor: InlineEditor;