@octane-xplat/tiptap 0.10.0 → 0.11.0

package/dist/native/index3.js

@@ -2,7 +2,7 @@ import { ensureJSONBridge, htmlToJSON, jsonBridgeReady, jsonToHTML } from "./ind
 import { defineUniversalComponent, hookSlots, universalComponent, universalPlan, universalProps, universalValue, useCallback, useEffect, useImperativeHandle, useRef, useState } from "@nativescript-community/octane";
 import { RichTextEditor, supported } from "@octane-xplat/richtext";
 //#region src/TiptapEditor.tsrx
-var _hs$ = /* @__PURE__ */ hookSlots(8);
+var _hs$ = /* @__PURE__ */ hookSlots(9);
 var _h$0 = /* @__PURE__ */ Symbol(_hs$);
 var _h$1 = /* @__PURE__ */ Symbol(_hs$ + 1);
 var _h$2 = /* @__PURE__ */ Symbol(_hs$ + 2);
@@ -11,6 +11,7 @@ var _h$4 = /* @__PURE__ */ Symbol(_hs$ + 4);
 var _h$5 = /* @__PURE__ */ Symbol(_hs$ + 5);
 var _h$6 = /* @__PURE__ */ Symbol(_hs$ + 6);
 var _h$7 = /* @__PURE__ */ Symbol(_hs$ + 7);
+var _h$8 = /* @__PURE__ */ Symbol(_hs$ + 8);
 var __octaneUniversalPlan0 = universalPlan("nativescript", {
 	"kind": "slot",
 	"slot": 0
@@ -20,20 +21,32 @@ var TiptapEditor = defineUniversalComponent("nativescript", function TiptapEdito
 	const inner = useRef(null, _h$0);
 	const [exposedHandle, setHandle] = useState(null, _h$1);
 	useImperativeHandle(props.ref, () => exposedHandle, [exposedHandle], _h$2);
-	const jsonReady = useRef(false, _h$3);
-	const lastJSON = useRef(void 0, _h$4);
+	const lastJSON = useRef(void 0, _h$3);
+	const appliedHost = useRef(null, _h$4);
+	const desiredDoc = useRef(void 0, _h$5);
+	const applyDoc = () => {
+		const host = inner.current;
+		const doc = desiredDoc.current;
+		if (!host || doc === void 0 || !jsonBridgeReady()) return;
+		const stamp = JSON.stringify(doc);
+		if (stamp === lastJSON.current && appliedHost.current === host) return;
+		const html = jsonToHTML(doc);
+		if (html != null) {
+			lastJSON.current = stamp;
+			appliedHost.current = host;
+			host.setHTML(html);
+		}
+	};
 	const bindHost = useCallback((h) => {
 		inner.current = h;
+		if (h) queueMicrotask(applyDoc);
 		setHandle((previous) => previous?.native === h?.native ? previous : h ? {
 			getHTML: () => h.getHTML(),
 			setHTML: (html) => h.setHTML(html),
 			getJSON: () => jsonBridgeReady() ? htmlToJSON(h.getHTML()) : null,
 			setJSON: (doc) => {
-				const html = jsonBridgeReady() ? jsonToHTML(doc) : null;
-				if (html != null) {
-					lastJSON.current = JSON.stringify(doc);
-					h.setHTML(html);
-				}
+				desiredDoc.current = doc;
+				applyDoc();
 			},
 			apply: (format) => h.apply(format),
 			linkTo: (url, anchor) => h.linkTo(url, anchor),
@@ -46,28 +59,29 @@ var TiptapEditor = defineUniversalComponent("nativescript", function TiptapEdito
 			isFocused: () => h.isFocused(),
 			native: h.native
 		} : null);
-	}, [], _h$5);
+	}, [], _h$6);
 	useEffect(() => {
+		let alive = true;
 		ensureJSONBridge().then((ok) => {
-			jsonReady.current = ok;
+			if (!alive) return;
 			props.onJSONReady?.(ok);
+			applyDoc();
 		});
-	}, [], _h$6);
+		return () => {
+			alive = false;
+		};
+	}, [], _h$7);
 	useEffect(() => {
-		if (!props.json || !jsonBridgeReady() || !inner.current) return;
-		const stamp = JSON.stringify(props.json);
-		if (stamp === lastJSON.current) return;
-		const html = jsonToHTML(props.json);
-		if (html != null) {
-			lastJSON.current = stamp;
-			inner.current.setHTML(html);
-		}
-	}, [props.json], _h$7);
+		if (!props.json) return;
+		desiredDoc.current = props.json;
+		applyDoc();
+	}, [props.json], _h$8);
 	const emitJSON = () => {
 		if (!inner.current || !jsonBridgeReady()) return;
 		const doc = htmlToJSON(inner.current.getHTML());
 		if (doc) {
 			lastJSON.current = JSON.stringify(doc);
+			appliedHost.current = inner.current;
 			props.onJSONChange?.(doc);
 		}
 	};
@@ -110,7 +124,10 @@ var TiptapEditor = defineUniversalComponent("nativescript", function TiptapEdito
 		[
 			"set",
 			"onReady",
-			props.onReady
+			() => {
+				applyDoc();
+				props.onReady?.();
+			}
 		],
 		[
 			"set",

package/dist/native/octane-client-build.json

@@ -1,6 +1,6 @@
 {
   "version": 1,
-  "buildId": "3880e698-2b9a-436f-af5a-a7ec180643bf",
+  "buildId": "17348370-95cd-416a-8890-a13f83eea059",
   "mode": "production",
   "capabilities": {
     "independentHydration": false

package/dist/web/index2.js

@@ -1,5 +1,5 @@
 import { __s, bag3, clone, componentSlot, hookSlots, setStyle, template, useEffect, useImperativeHandle, useRef, withSlot } from "octane";
-import { updateFreshClassName } from "octane/internal/client";
+import { compilerMemoRegion, hookMemoCreate, hookMemoEqual, hookMemoPublish2, updateFreshClassName } from "octane/internal/client";
 import { EditorContent, useEditor } from "@octanejs/tiptap";
 import StarterKit from "@tiptap/starter-kit";
 //#region src/TiptapEditor.web.tsrx
@@ -74,14 +74,24 @@ function activeFormats(editor) {
 	for (const [name, kind, attrs] of ACTIVE_OF) if (editor.isActive(kind, attrs)) out.push(name);
 	return out;
 }
+function resolveExtensions(web) {
+	const extras = web?.extensions ?? [];
+	if (web?.starterKit === false || extras.some((ext) => ext?.name === "starterKit")) return extras;
+	return [web?.starterKit ? StarterKit.configure(web.starterKit) : StarterKit, ...extras];
+}
 var TiptapEditor = /* @__PURE__ */ __s(function TiptapEditor(props, __s, __extra) {
+	const __memoRegion = compilerMemoRegion(__s, _hs$ + 0);
+	let __hk = __memoRegion.hooks;
+	if (__hk === void 0) __memoRegion.hooks = __hk = hookMemoCreate(4);
+	let __hkd0, __hkd1;
 	const lastEmitted = useRef(void 0, _hs$ + 0);
 	const lastJSON = useRef(void 0, _hs$ + 1);
 	const lastHTMLInput = useRef(JSON.stringify([props.json !== void 0, props.value]), _hs$ + 2);
 	const lastJSONInput = useRef(JSON.stringify(props.json), _hs$ + 3);
 	const bound = useRef(void 0, _hs$ + 4);
+	const extensions = (__hkd0 = props.web?.extensions, __hkd1 = props.web?.starterKit, __hk[0] !== true || !hookMemoEqual(__hk[1], __hkd0) || !hookMemoEqual(__hk[2], __hkd1) ? hookMemoPublish2(__hk, 0, resolveExtensions(props.web), __hkd0, __hkd1) : __hk[3]);
 	const editor = withSlot(_h$5, useEditor, {
-		extensions: [StarterKit],
+		extensions,
 		content: props.json ?? props.value ?? "",
 		editable: props.editable !== false,
 		autofocus: props.autofocus ?? false,
@@ -177,7 +187,7 @@ var TiptapEditor = /* @__PURE__ */ __s(function TiptapEditor(props, __s, __extra
 			_b.c = _v;
 		}
 	}
-	componentSlot(__s, 1, _b.b, EditorContent, { "editor": editor }, void 0, void 0, 2, void 0, void 0, "c:e9be3bbb");
+	componentSlot(__s, 1, _b.b, EditorContent, { "editor": editor }, void 0, void 0, 2, void 0, void 0, "c:95ead9de");
 });
 //#endregion
 export { TiptapEditor, supported };

package/dist/web/octane-client-build.json

@@ -1,6 +1,6 @@
 {
   "version": 1,
-  "buildId": "e01adeb4-b2cd-4b21-9fdd-57831df35c5b",
+  "buildId": "1f4559d1-3518-4733-bde1-7ae4be559663",
   "mode": "production",
   "capabilities": {
     "independentHydration": false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@octane-xplat/tiptap",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "Unified rich-text editor facade for Octane xplat — live tiptap on web/AppKit, Aztec + tiptap document model on Android",
   "keywords": [
     "cross-platform",
@@ -48,7 +48,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@octane-xplat/richtext": "0.10.0",
+    "@octane-xplat/richtext": "0.11.0",
     "@octanejs/tiptap": "0.0.51",
     "@tiptap/core": "3.28.0",
     "@tiptap/pm": "3.28.0",
@@ -59,11 +59,12 @@
   "devDependencies": {
     "@nativescript-community/octane": "0.2.4",
     "@nativescript/core": "9.1.2",
-    "@octane-xplat/macos-renderer": "0.10.0",
+    "@octane-xplat/macos-renderer": "0.11.0",
     "@octanejs/vite-plugin": "0.1.61",
     "octane": "0.6.3",
     "typescript": "5.9.3",
-    "vite": "8.3.0"
+    "vite": "8.3.0",
+    "vitest": "5.0.1"
   },
   "peerDependencies": {
     "@nativescript-community/octane": ">=0.2.1 <1",
@@ -88,6 +89,7 @@
     }
   },
   "scripts": {
-    "build": "vite build && vite build --mode native && tsc -p tsconfig.types.json && node ../../scripts/check-native-dist.mjs && node ../richtext/build-browser.mjs"
+    "build": "vite build && vite build --mode native && tsc -p tsconfig.types.json && node ../../scripts/check-native-dist.mjs && node ../richtext/build-browser.mjs",
+    "test:native": "vitest run --config vitest.native.config.mts"
   }
 }

package/src/TiptapEditor.mobile.test.ts

@@ -0,0 +1,229 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import {
+	createObjectContainer,
+	createObjectDriver,
+	createUniversalRoot,
+	flushUniversalSync,
+} from 'octane/universal/native'
+
+import type { TiptapJSON } from './types'
+
+// Controlled fake for the lazy JSON bridge — the real module's dynamic
+// imports aren't needed to test facade timing. `resolved`/`ready` model the
+// bridge settling; docs carry `html` so conversions stay deterministic.
+const bridge = vi.hoisted(() => ({
+	ready: false,
+	resolved: undefined as boolean | undefined,
+	waiters: [] as Array<(ok: boolean) => void>,
+}))
+
+vi.mock('./json-bridge', () => ({
+	ensureJSONBridge: () =>
+		bridge.resolved !== undefined
+			? Promise.resolve(bridge.resolved)
+			: new Promise<boolean>((resolve) => bridge.waiters.push(resolve)),
+	jsonBridgeReady: () => bridge.ready,
+	jsonToHTML: (doc: any) =>
+		doc && typeof doc === 'object' && typeof doc.html === 'string' ? doc.html : null,
+	htmlToJSON: (html: string) => ({ type: 'doc', html }),
+}))
+
+vi.mock('@octane-xplat/richtext', async () => {
+	return await import('../tests/fake-richtext.fixture.mobile.tsrx')
+})
+
+import { TiptapEditor } from './TiptapEditor.tsrx'
+import { hosts, resetFakeRichtext, setDefer } from '../tests/fake-richtext.fixture.mobile.tsrx'
+
+const docA = { type: 'doc', html: '<p>alpha</p>' } as unknown as TiptapJSON
+const docB = { type: 'doc', html: '<p>bravo</p>' } as unknown as TiptapJSON
+
+const roots: ReturnType<typeof createUniversalRoot>[] = []
+
+function mount(props: any) {
+	const container = createObjectContainer('nativescript')
+	const root = createUniversalRoot(container, createObjectDriver('nativescript'))
+	roots.push(root)
+	let handle: any = null
+	root.render(TiptapEditor, {
+		...props,
+		ref: (next: any) => {
+			handle = next
+		},
+	})
+
+	return {
+		root,
+		container,
+		get handle() {
+			return handle
+		},
+	}
+}
+
+function settleBridge(ok: boolean) {
+	bridge.ready = ok
+	bridge.resolved = ok
+	for (const resolve of bridge.waiters.splice(0)) {
+		resolve(ok)
+	}
+}
+
+async function settle() {
+	for (let i = 0; i < 12; i++) {
+		await Promise.resolve()
+	}
+
+	flushUniversalSync(() => {})
+}
+
+beforeEach(() => {
+	bridge.ready = false
+	bridge.resolved = undefined
+	bridge.waiters.length = 0
+	resetFakeRichtext()
+})
+
+afterEach(() => {
+	for (const root of roots.splice(0)) {
+		root.unmount()
+	}
+})
+
+describe('TiptapEditor native JSON readiness', () => {
+	it('applies an initial props.json once when the bridge settles after mount', async () => {
+		const onJSONReady = vi.fn()
+		mount({ json: docA, onJSONReady })
+		await settle()
+		expect(hosts[0].setCalls).toEqual([])
+
+		settleBridge(true)
+		await settle()
+		expect(onJSONReady).toHaveBeenCalledWith(true)
+		expect(hosts[0].html).toBe('<p>alpha</p>')
+		expect(hosts[0].setCalls).toEqual(['<p>alpha</p>'])
+	})
+
+	it('applies an initial props.json when the host readies after the bridge', async () => {
+		bridge.ready = true
+		bridge.resolved = true
+		setDefer(true)
+		mount({ json: docA })
+		await settle()
+		expect(hosts[0].setCalls).toEqual([])
+
+		hosts[0].ready()
+		await settle()
+		expect(hosts[0].html).toBe('<p>alpha</p>')
+		expect(hosts[0].setCalls).toEqual(['<p>alpha</p>'])
+	})
+
+	it('applies an initial props.json once when host and bridge are both late', async () => {
+		setDefer(true)
+		mount({ json: docA })
+		await settle()
+		hosts[0].ready()
+		await settle()
+		expect(hosts[0].setCalls).toEqual([])
+
+		settleBridge(true)
+		await settle()
+		expect(hosts[0].setCalls).toEqual(['<p>alpha</p>'])
+	})
+
+	it('keeps json precedence over value once readiness lands', async () => {
+		mount({ value: '<p>value</p>', json: docA })
+		await settle()
+		settleBridge(true)
+		await settle()
+		expect(hosts[0].html).toBe('<p>alpha</p>')
+	})
+
+	it('applies later props.json updates and skips identical docs', async () => {
+		const view = mount({ json: docA })
+		settleBridge(true)
+		await settle()
+		expect(hosts[0].setCalls).toEqual(['<p>alpha</p>'])
+
+		view.root.render(TiptapEditor, { json: docB } as any)
+		await settle()
+		expect(hosts[0].setCalls).toEqual(['<p>alpha</p>', '<p>bravo</p>'])
+
+		view.root.render(TiptapEditor, { json: docB } as any)
+		await settle()
+		expect(hosts[0].setCalls).toEqual(['<p>alpha</p>', '<p>bravo</p>'])
+	})
+
+	it('does not push a doc the editor itself emitted back at it', async () => {
+		const onJSONChange = vi.fn()
+		const view = mount({ onJSONChange })
+		settleBridge(true)
+		await settle()
+
+		const rig = hosts[0]
+		rig.html = '<p>typed</p>'
+		// The leaf calls props.onChange(html); the facade wraps it to emit JSON.
+		rig.props.onChange('<p>typed</p>')
+		await settle()
+		const emitted = onJSONChange.mock.calls[0][0]
+		expect(emitted).toEqual({ type: 'doc', html: '<p>typed</p>' })
+
+		view.root.render(TiptapEditor, { json: emitted, onJSONChange } as any)
+		await settle()
+		expect(rig.setCalls).toEqual([])
+	})
+
+	it('defers an imperative setJSON issued before the bridge settles', async () => {
+		const view = mount({})
+		await settle()
+		expect(view.handle).not.toBeNull()
+
+		view.handle.setJSON(docB)
+		expect(hosts[0].setCalls).toEqual([])
+		settleBridge(true)
+		await settle()
+		expect(hosts[0].setCalls).toEqual(['<p>bravo</p>'])
+	})
+
+	it('re-applies the current doc when the host rebinds', async () => {
+		mount({ json: docA })
+		settleBridge(true)
+		await settle()
+		expect(hosts[0].setCalls).toEqual(['<p>alpha</p>'])
+
+		hosts[0].rebind()
+		await settle()
+		expect(hosts[0].html).toBe('<p>alpha</p>')
+		expect(hosts[0].setCalls).toEqual(['<p>alpha</p>'])
+	})
+
+	it('ignores a bridge that settles after unmount', async () => {
+		const onJSONReady = vi.fn()
+		const view = mount({ json: docA, onJSONReady })
+		await settle()
+		view.root.unmount()
+
+		settleBridge(true)
+		await settle()
+		expect(onJSONReady).not.toHaveBeenCalled()
+		expect(hosts[0].setCalls).toEqual([])
+	})
+
+	it('reports bridge failure through onJSONReady without touching the host', async () => {
+		const onJSONReady = vi.fn()
+		const view = mount({ json: docA, onJSONReady })
+		await settle()
+		settleBridge(false)
+		await settle()
+		expect(onJSONReady).toHaveBeenCalledWith(false)
+		expect(hosts[0].setCalls).toEqual([])
+		expect(view.handle.getJSON()).toBeNull()
+	})
+
+	it('drops a doc the converter rejects instead of writing null HTML', async () => {
+		mount({ json: { type: 'doc', content: [{ type: 'mystery' }] } as any })
+		settleBridge(true)
+		await settle()
+		expect(hosts[0].setCalls).toEqual([])
+	})
+})

package/src/TiptapEditor.tsrx

@@ -2,7 +2,7 @@
 import { useState, useImperativeHandle, useCallback, useEffect, useRef } from 'octane'
 import { RichTextEditor, supported as leafSupported } from '@octane-xplat/richtext'
 import type { RichTextEditorHandle } from '@octane-xplat/richtext'
-import type { TiptapEditorHandle, TiptapEditorProps } from './types'
+import type { TiptapEditorHandle, TiptapEditorProps, TiptapJSON } from './types'
 import { ensureJSONBridge, htmlToJSON, jsonBridgeReady, jsonToHTML } from './json-bridge'
 
 export const supported = leafSupported
@@ -14,22 +14,45 @@ export function TiptapEditor(props: TiptapEditorProps) @{
 	const inner = useRef<RichTextEditorHandle | null>(null)
 	const [exposedHandle, setHandle] = useState<TiptapEditorHandle | null>(null)
 	useImperativeHandle<TiptapEditorHandle | null>(props.ref, () => exposedHandle, [exposedHandle])
-	const jsonReady = useRef(false)
 	const lastJSON = useRef<string | undefined>(undefined)
+	const appliedHost = useRef<RichTextEditorHandle | null>(null)
+	// Latest doc requested for the host — by `json` prop or `setJSON`. Kept
+	// after a successful push so a rebound (recreated) host still gets it.
+	const desiredDoc = useRef<TiptapJSON | undefined>(undefined)
+
+	// Push the requested doc once both halves are up — the JSON bridge
+	// (async module load) and the bound host (ref/onReady timing). Skips the
+	// stamp the host already shows, so editor-emitted echoes and repeat props
+	// never reach setHTML; a different host always gets its own copy.
+	const applyDoc = () => {
+		const host = inner.current
+		const doc = desiredDoc.current
+		if (!host || doc === undefined || !jsonBridgeReady()) return
+		const stamp = JSON.stringify(doc)
+		if (stamp === lastJSON.current && appliedHost.current === host) return
+		const html = jsonToHTML(doc)
+		if (html != null) {
+			lastJSON.current = stamp
+			appliedHost.current = host
+			host.setHTML(html)
+		}
+	}
 
 	const bindHost = useCallback((h: RichTextEditorHandle | null) => {
 		inner.current = h
+		if (h) {
+			// The ref binds inside the leaf's commit, before its own `value`
+			// seed — defer so `json` keeps precedence over `value`.
+			queueMicrotask(applyDoc)
+		}
 
 		setHandle((previous) => previous?.native === h?.native ? previous : h ? ({
 			getHTML: () => h.getHTML(),
 			setHTML: (html: string) => h.setHTML(html),
 			getJSON: () => (jsonBridgeReady() ? htmlToJSON(h.getHTML()) : null),
 			setJSON: (doc) => {
-				const html = jsonBridgeReady() ? jsonToHTML(doc) : null
-				if (html != null) {
-					lastJSON.current = JSON.stringify(doc)
-					h.setHTML(html)
-				}
+				desiredDoc.current = doc
+				applyDoc()
 			},
 			apply: (format) => h.apply(format),
 			linkTo: (url, anchor) => h.linkTo(url, anchor),
@@ -45,25 +68,28 @@ export function TiptapEditor(props: TiptapEditorProps) @{
 	}, [])
 
 	// The bridge loads once per process — dynamic imports of the DOM-free
-	// tiptap slices, plus the zeed-dom parse shim.
+	// tiptap slices, plus the zeed-dom parse shim. A doc that arrived before
+	// it settles is applied here, not dropped.
 	useEffect(() => {
+		let alive = true
 		ensureJSONBridge().then((ok) => {
-			jsonReady.current = ok
+			if (!alive) return
 			props.onJSONReady?.(ok)
+			applyDoc()
 		})
+
+		return () => {
+			alive = false
+		}
 	}, [])
 
-	// `json` prop → editor content, when the bridge is up and the doc wasn't
-	// emitted by the editor itself.
+	// `json` prop → editor content. It may land before the bridge settles or
+	// before the host binds — park it in desiredDoc and let the readiness
+	// flushes apply it.
 	useEffect(() => {
-		if (!props.json || !jsonBridgeReady() || !inner.current) return
-		const stamp = JSON.stringify(props.json)
-		if (stamp === lastJSON.current) return
-		const html = jsonToHTML(props.json)
-		if (html != null) {
-			lastJSON.current = stamp
-			inner.current.setHTML(html)
-		}
+		if (!props.json) return
+		desiredDoc.current = props.json
+		applyDoc()
 	}, [props.json])
 
 	const emitJSON = () => {
@@ -71,6 +97,7 @@ export function TiptapEditor(props: TiptapEditorProps) @{
 		const doc = htmlToJSON(inner.current.getHTML())
 		if (doc) {
 			lastJSON.current = JSON.stringify(doc)
+			appliedHost.current = inner.current
 			props.onJSONChange?.(doc)
 		}
 	}
@@ -83,7 +110,12 @@ export function TiptapEditor(props: TiptapEditorProps) @{
 		placeholder={props.placeholder}
 		editable={props.editable}
 		autofocus={props.autofocus}
-		onReady={props.onReady}
+		onReady={() => {
+			// Host signalled ready after the leaf's own initial content seed —
+			// the last apply point that still outranks a `value` prop.
+			applyDoc()
+			props.onReady?.()
+		}}
 		onChange={(html) => {
 			props.onChange?.(html)
 			emitJSON()

package/src/TiptapEditor.web.test.tsrx

@@ -0,0 +1,129 @@
+// @vitest-environment jsdom
+import { afterEach, expect, it, vi } from 'vitest'
+import { act, createRoot } from 'octane'
+import { Extension, Mark, Node } from '@tiptap/core'
+import StarterKit from '@tiptap/starter-kit'
+import { TiptapEditor } from './TiptapEditor.web.tsrx'
+import type { TiptapEditorHandle } from './types'
+
+const Spoiler = Mark.create({
+	name: 'spoiler',
+	parseHTML: () => [{ tag: 'span[data-spoiler]' }],
+	renderHTML: () => ['span', { 'data-spoiler': '' }, 0],
+})
+
+const Shout = Extension.create({
+	name: 'shout',
+	addCommands() {
+		return {
+			shout: () => ({ commands }: any) => commands.setContent('<p>SHOUT</p>'),
+		}
+	},
+})
+
+// Minimal schema for the starterKit:false path — callers dropping the
+// built-in kit supply the base nodes themselves.
+const Doc = Node.create({ name: 'doc', topNode: true, content: 'block+' })
+const Paragraph = Node.create({
+	name: 'paragraph',
+	group: 'block',
+	content: 'inline*',
+	parseHTML: () => [{ tag: 'p' }],
+	renderHTML: () => ['p', 0],
+})
+
+const Text = Node.create({ name: 'text', group: 'inline' })
+
+const roots: any[] = []
+
+function mount(props: any = {}) {
+	const el = document.createElement('div')
+	document.body.append(el)
+	const root = createRoot(el)
+	roots.push(root)
+	let handle: TiptapEditorHandle | null = null
+	act(() =>
+		root.render(
+			<TiptapEditor
+				{...props}
+				ref={(next: TiptapEditorHandle | null) => {
+					handle = next
+				}}
+			/>,
+		),
+	)
+
+	return { el, root, get handle() { return handle } }
+}
+
+afterEach(() => {
+	for (const root of roots.splice(0)) act(() => root.unmount())
+	document.body.innerHTML = ''
+	vi.restoreAllMocks()
+})
+
+it('mounts StarterKit by default', () => {
+	const { handle } = mount({ value: '<p>Travel notes</p>' })
+	const editor = handle!.native
+	expect(editor.schema.marks.bold).toBeTruthy()
+	expect(editor.schema.nodes.heading).toBeTruthy()
+	expect(handle!.getHTML()).toContain('<p>Travel notes</p>')
+})
+
+it('registers caller mark extensions alongside StarterKit', () => {
+	const { handle } = mount({
+		value: '<p>shh <span data-spoiler>secret</span></p>',
+		web: { extensions: [Spoiler] },
+	})
+
+	const editor = handle!.native
+	expect(editor.schema.marks.spoiler).toBeTruthy()
+	expect(editor.schema.marks.bold).toBeTruthy()
+
+	const doc = handle!.getJSON()!
+	const marks = JSON.stringify(doc)
+	expect(marks).toContain('"spoiler"')
+	expect(handle!.getHTML()).toContain('data-spoiler')
+})
+
+it('exposes commands added by caller extensions', () => {
+	const { handle } = mount({ web: { extensions: [Shout] } })
+	handle!.native.commands.shout()
+	expect(handle!.getHTML()).toContain('SHOUT')
+})
+
+it('passes starterKit options to the built-in kit', () => {
+	const { handle } = mount({ web: { starterKit: { link: false } } })
+	const editor = handle!.native
+	expect(editor.schema.marks.link).toBeUndefined()
+	expect(editor.schema.marks.bold).toBeTruthy()
+})
+
+it('hands the schema to caller extensions when starterKit is false', () => {
+	const { handle } = mount({
+		web: { starterKit: false, extensions: [Doc, Paragraph, Text, Spoiler] },
+	})
+
+	const editor = handle!.native
+	expect(editor.schema.marks.spoiler).toBeTruthy()
+	expect(editor.schema.marks.bold).toBeUndefined()
+	expect(editor.schema.nodes.heading).toBeUndefined()
+})
+
+it('never registers StarterKit twice', () => {
+	const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+
+	const { handle } = mount({
+		web: { extensions: [StarterKit.configure({ link: false })] },
+	})
+
+	const kits = handle!.native.extensionManager.extensions.filter(
+		(extension: any) => extension.name === 'starterKit',
+	)
+
+	expect(kits).toHaveLength(1)
+	expect(handle!.native.schema.marks.link).toBeUndefined()
+	expect(warn).not.toHaveBeenCalledWith(
+		expect.stringContaining('Duplicate extension names'),
+	)
+})