svedit 0.11.1 → 0.12.0

package/src/lib/NodeArrayProperty.svelte

@@ -1,11 +1,11 @@
 <script>
 	import { getContext, setContext } from 'svelte';
 	import UnknownNode from './UnknownNode.svelte';
-	import { serialize_path } from './utils.js';
+	import { serialize_path, calculate_fragment_ranges } from './utils.js';
 	import DefaultNodeGap from './NodeGap.svelte';
 	import DefaultNodeGapMarkers from './NodeGapMarkers.svelte';
 
-	/** @import { NodeArrayPropertyProps } from './types.d.ts'; */
+	/** @import { NodeArrayPropertyProps, NodeArrayAttachmentContext } from './types.d.ts'; */
 
 	const svedit = getContext('svedit');
 	let NodeGap = $derived(svedit.session.config.system_components?.node_gap ?? DefaultNodeGap);
@@ -20,10 +20,85 @@
 	// NodeGap's should_position_gap call to avoid N+1 joins per render.
 	let path_str = $derived(serialize_path(path));
 
-	let node_ids = $derived(svedit.session.get(path));
-	let nodes = $derived(node_ids.map((id) => svedit.session.get(id)));
+	let raw_value = $derived(svedit.session.get(path));
+	let node_ids = $derived(raw_value.nodes);
+	let marks = $derived(raw_value.marks);
+	let annotations = $derived(raw_value.annotations);
 
-	// Mirrors the AnnotatedTextProperty pattern: a `focused` class follows
+	let fragments = $derived(get_fragments(node_ids, marks));
+
+	function get_fragments(node_ids, marks) {
+		const ranges = calculate_fragment_ranges(node_ids.length, marks);
+		let fragments = [];
+
+		for (const range of ranges) {
+			const nodes_slice = node_ids.slice(range.start_offset, range.end_offset);
+
+			if (range.type === 'mark') {
+				const node = svedit.session.get(range.node_id);
+				fragments.push({
+					type: 'mark',
+					node,
+					nodes: nodes_slice,
+					start_index: range.start_offset,
+					mark_index: range.mark_index
+				});
+			} else if (range.type === 'content') {
+				fragments.push({
+					type: 'nodes',
+					nodes: nodes_slice,
+					start_index: range.start_offset
+				});
+			}
+		}
+		return fragments;
+	}
+
+	function get_node_key(node_id, index) {
+		let occurrence = 0;
+		for (let current_index = 0; current_index < index; current_index++) {
+			if (node_ids[current_index] === node_id) occurrence += 1;
+		}
+		return `${node_id}:${occurrence}`;
+	}
+
+	/**
+	 * @returns {NodeArrayAttachmentContext}
+	 */
+	function get_range_context(range, index, node_index) {
+		const node = svedit.session.get(range.node_id);
+		const is_start = node_index === range.start_offset;
+		const is_end = node_index === range.end_offset - 1;
+
+		return {
+			...range,
+			index,
+			node,
+			is_start,
+			is_middle: !is_start && !is_end,
+			is_end
+		};
+	}
+
+	function get_covering_ranges(ranges, node_index) {
+		return ranges
+			.map((range, index) => ({ range, index }))
+			.filter(({ range }) => range.start_offset <= node_index && node_index < range.end_offset)
+			.map(({ range, index }) => get_range_context(range, index, node_index));
+	}
+
+	function get_annotation_contexts(node_index) {
+		return get_covering_ranges(annotations, node_index);
+	}
+
+	function get_mark(node_index) {
+		// The single mark wrapping this node, or null. Mark exclusivity
+		// guarantees at most one. Annotations never wrap and are exposed via
+		// `annotations` instead.
+		return get_covering_ranges(marks, node_index)[0] ?? null;
+	}
+
+	// Mirrors the TextProperty pattern: a `focused` class follows
 	// the model selection. Used by the CSS rule below to hide the empty-array
 	// NodeGap while the caret is in the placeholder, so its <br> isn't a
 	// second arrow-key stop (issue #260).
@@ -35,6 +110,15 @@
 	setContext('node_array_meta', {
 		get length() {
 			return node_ids.length;
+		},
+		// Lets Node self-serve the marks and annotations covering a child, so
+		// node wrappers can carry range classes without every node component
+		// having to thread the `mark`/`annotations` props through.
+		mark_for(node_index) {
+			return get_mark(node_index);
+		},
+		annotations_for(node_index) {
+			return get_annotation_contexts(node_index);
 		}
 	});
 </script>
@@ -48,6 +132,7 @@
 	data-path={path_str}
 	style="anchor-name: --{path_str};{style ? ` ${style}` : ''}"
 	{...rest}
+	{@attach svedit.visibility_registry.track_array(path_str)}
 >
 	{#if node_ids.length === 0 && svedit.editable}
 		<div
@@ -55,17 +140,39 @@
 			data-path={serialize_path([...path, 0])}
 			data-type="node"
 			style="anchor-name: --{serialize_path([...path, 0])};"
+			{@attach svedit.visibility_registry.track_node(serialize_path([...path, 0]))}
 		>
 			<NodeGap array_path={path} offset={0} count={0} empty />
 		</div>
 	{/if}
-	{#each nodes as node, index (index)}
-		<NodeGap array_path={path} offset={index} count={nodes.length} />
-		{@const Component = svedit.session.config.node_components[node.type]}
-		{#if Component}
-			<Component path={[...path, index]} />
-		{:else}
-			<UnknownNode path={[...path, index]} />
+	{#snippet render_nodes(nodes_slice, start_index)}
+		{#each nodes_slice as id, slice_index (get_node_key(id, start_index + slice_index))}
+			{@const index = start_index + slice_index}
+			{@const node = svedit.session.get(id)}
+			{@const mark = get_mark(index)}
+			{@const annotations = get_annotation_contexts(index)}
+			<NodeGap array_path={path} offset={index} count={node_ids.length} />
+			{@const Component = svedit.session.config.node_components[node.type]}
+			{#if Component}
+				<Component path={[...path, index]} {mark} {annotations} />
+			{:else}
+				<UnknownNode path={[...path, index]} />
+			{/if}
+		{/each}
+	{/snippet}
+
+	{#each fragments as fragment, fragment_index (fragment_index)}
+		{#if fragment.type === 'nodes'}
+			{@render render_nodes(fragment.nodes, fragment.start_index)}
+		{:else if fragment.type === 'mark'}
+			{@const MarkComponent = svedit.session.config.node_components[fragment.node.type]}
+			{#if MarkComponent}
+				<MarkComponent path={[...path, 'marks', fragment.mark_index, 'node_id']}>
+					{@render render_nodes(fragment.nodes, fragment.start_index)}
+				</MarkComponent>
+			{:else}
+				{@render render_nodes(fragment.nodes, fragment.start_index)}
+			{/if}
 		{/if}
 	{/each}
 	{#if node_ids.length > 0}

package/src/lib/NodeGap.svelte

@@ -13,6 +13,7 @@
 <script>
 	import { serialize_path } from './utils.js';
 	import { getContext } from 'svelte';
+	import { should_position_gap } from './node_visibility.svelte.js';
 
 	/**
 	 * ┌─────────────────────────────────────────────────────────────────┐
@@ -37,10 +38,13 @@
 	 *
 	 * Always present in the DOM when editable (stable structure for
 	 * selection anchoring, scrollTo, etc.). Anchor positioning is
-	 * activated lazily via the `.positioned` class, toggled imperatively
-	 * by the IO callback / MO / bootstrap in node_visibility — keeps
-	 * NodeGap allocation-free of per-instance Svelte signals, which
-	 * matters at 1000+ NodeGaps per scroll frame.
+	 * activated lazily via the `.positioned` class, derived reactively
+	 * from the visibility registry's array_indices / edge_map. Svelte's
+	 * reactive collections track reads at per-key granularity, so a
+	 * registry write only
+	 * re-evaluates the adjacent gaps. Applying the class declaratively
+	 * (instead of imperative classList toggles) means it survives DOM
+	 * recreation without a document change (e.g. dev-mode HMR).
 	 *
 	 * `position-visibility: anchors-visible` does NOT skip anchor
 	 * resolution — the browser resolves all anchor() then hides the
@@ -62,6 +66,22 @@
 	let is_last = $derived(offset === count);
 	let type = $derived(is_first ? 'gap-before' : 'gap-after');
 
+	let path_str = $derived(serialize_path(array_path));
+	// Two-derived split is load-bearing: get_array_indices lazily
+	// creates the set, and Svelte doesn't track deps on state created
+	// inside the reading derived — so acquire here, read in `positioned`.
+	let near_indices = $derived(svedit.visibility_registry.get_array_indices(path_str));
+	let positioned = $derived(
+		is_editable &&
+			should_position_gap(
+				near_indices,
+				svedit.visibility_registry.edge_map.get(path_str),
+				offset,
+				is_last,
+				empty
+			)
+	);
+
 	let gap_style = $derived.by(() => {
 		if (!is_editable) return '';
 		const prev_idx = offset - 1;
@@ -87,8 +107,9 @@
 		class:gap-after={!is_first}
 		class:empty
 		class:last={is_last}
+		class:positioned
 		data-type={type}
-		data-gap-array-path={serialize_path(array_path)}
+		data-gap-array-path={path_str}
 		data-gap-offset={offset}
 		style={gap_style}
 	>
@@ -111,9 +132,30 @@
 	}
 
 	/* ------------------------------------------------------------------ */
-	/* Un-positioned: minimal in-DOM presence, no anchor resolution        */
+	/* Un-positioned: no layout box at all                                 */
 	/* ------------------------------------------------------------------ */
 
+	/*
+	 * display: none is load-bearing for large documents. A zero-size
+	 * absolutely-positioned selectable still belongs to the containing
+	 * block's out-of-flow list, and the browser lays out EVERY such box
+	 * on EVERY layout pass — measured ~430ms per pass at 2000 nodes
+	 * (~3500 gaps) in Chrome vs ~23ms with the boxes removed. That cost
+	 * hits every keystroke (the per-change reconcile reads a rect for
+	 * every node, and selection rendering forces layout), every window
+	 * resize frame, and every scroll-triggered layout.
+	 *
+	 * Off-screen gaps therefore contribute no layout box. DOM structure
+	 * stays stable (the .node-gap wrapper and selectable elements remain),
+	 * and DOM Ranges may still point into display:none elements, so
+	 * programmatic node selections targeting off-screen gaps keep working.
+	 * Empty-array gaps are excluded: they must stay clickable/visible even
+	 * before reconcile positions them.
+	 */
+	:global(.node-gap:not(.positioned):not(.empty) .svedit-selectable) {
+		display: none;
+	}
+
 	:global(.node-gap:not(.positioned) .svedit-selectable) {
 		position: absolute;
 		pointer-events: none;

package/src/lib/Session.svelte.js

@@ -1,17 +1,21 @@
 import Transaction from './Transaction.svelte.js';
-import { char_slice, traverse } from './utils.js';
+import { char_slice, traverse, traverse_ids } from './utils.js';
 import {
 	get as doc_get,
 	property_type as doc_property_type,
 	kind as doc_kind,
 	inspect as doc_inspect,
-	apply_op,
+	create_document_draft,
+	apply_op_to_draft,
 	count_references as doc_count_references,
 	validate_document_schema,
 	validate_document,
+	validate_config_components,
 	validate_node,
+	is_id_valid,
 	get_referencing_node_ids,
-	get_active_annotation,
+	get_selected_marks,
+	get_selected_annotations,
 	validate_selection
 } from './doc_utils.js';
 
@@ -20,6 +24,8 @@ import {
  *   NodeId,
  *   DocumentPath,
  *   Selection,
+ *   Attachment,
+ *   Mark,
  *   Annotation,
  *   NodeKind,
  *   DocumentSchema,
@@ -63,8 +69,14 @@ export default class Session {
 
 	// Reactive variable for selected node
 	selected_node = $derived(this.get_selected_node());
+	available_mark_types = $derived(this.get_available_mark_types());
 	available_annotation_types = $derived(this.get_available_annotation_types());
-
+	selected_marks = $derived(get_selected_marks(this.schema, this.doc, this.selection));
+	active_mark = $derived(this.selected_marks.length === 1 ? this.selected_marks[0] : null);
+	selected_annotations = $derived(get_selected_annotations(this.schema, this.doc, this.selection));
+	active_annotation = $derived(
+		this.selected_annotations.length === 1 ? this.selected_annotations[0] : null
+	);
 
 	/**
 	 * @param {DocumentSchema} schema - The document schema
@@ -81,6 +93,7 @@ export default class Session {
 		this.doc = doc;
 		this.config = config;
 		validate_document(this.doc, this.schema);
+		validate_config_components(this.schema, this.config);
 
 		// Set selection after doc is initialized so validation can work properly
 		this.selection = options.selection ?? null;
@@ -136,23 +149,33 @@ export default class Session {
 	 */
 	validate_transaction_result(transaction) {
 		const doc = transaction.doc;
-		/** @type {NodeId[]} */
-		const affected_node_ids = [];
-
-		function add_node_id(node_id) {
-			if (!affected_node_ids.includes(node_id)) affected_node_ids.push(node_id);
-		}
-
-		for (const node_id of transaction.created_node_ids) add_node_id(node_id);
-		for (const node_id of transaction.modified_node_ids) add_node_id(node_id);
-		for (const node_id of get_referencing_node_ids(this.schema, doc, transaction.created_node_ids)) {
-			add_node_id(node_id);
-		}
-		for (const node_id of get_referencing_node_ids(this.schema, doc, transaction.modified_node_ids)) {
-			add_node_id(node_id);
-		}
-		for (const node_id of get_referencing_node_ids(this.schema, doc, transaction.deleted_node_ids)) {
-			add_node_id(node_id);
+		/** @type {Set<NodeId>} */
+		// eslint-disable-next-line svelte/prefer-svelte-reactivity -- Non-reactive local dedup set.
+		const affected_node_ids = new Set([
+			...transaction.created_node_ids,
+			...transaction.modified_node_ids
+		]);
+
+		// A full-document referrer scan is only needed when a reference held
+		// by an UNTOUCHED node can have become invalid:
+		// - deletions can leave dangling references behind
+		// - a 'type' change can violate a referrer's node/mark/annotation type
+		//   constraint
+		// References to created nodes can only live in nodes that were
+		// themselves created or modified in this transaction (the reference
+		// did not exist before), and modifying a node's other properties
+		// cannot invalidate its referrers — so those cases are already
+		// covered by the affected set and need no scan.
+		if (transaction.deleted_node_ids.length > 0 || transaction.changed_node_types) {
+			// eslint-disable-next-line svelte/prefer-svelte-reactivity -- Non-reactive local dedup set.
+			const scan_targets = new Set([
+				...transaction.created_node_ids,
+				...transaction.modified_node_ids,
+				...transaction.deleted_node_ids
+			]);
+			for (const node_id of get_referencing_node_ids(this.schema, doc, scan_targets)) {
+				affected_node_ids.add(node_id);
+			}
 		}
 
 		for (const node_id of affected_node_ids) {
@@ -162,11 +185,13 @@ export default class Session {
 	}
 
 	generate_id() {
-		if (this.config?.generate_id) {
-			return this.config.generate_id();
-		} else {
-			return crypto.randomUUID();
+		const id = this.config?.generate_id ? this.config.generate_id() : `node_${crypto.randomUUID()}`;
+		if (!is_id_valid(id)) {
+			throw new Error(
+				`Generated node id ${JSON.stringify(id)} is invalid. Node ids must be non-empty strings that start with a letter or underscore, contain only letters, numbers, underscores, or dashes, and must not contain "__".`
+			);
 		}
+		return id;
 	}
 
 	/**
@@ -187,11 +212,16 @@ export default class Session {
 		}
 	}
 
+	get_available_mark_types() {
+		if (this.selection?.type !== 'text' && this.selection?.type !== 'node') return [];
+		const property_definition = this.inspect(this.selection.path);
+		return property_definition.mark_types || [];
+	}
+
 	get_available_annotation_types() {
-		if (this.selection?.type !== 'text') return [];
-		const path = this.selection.path;
-		const property_definition = this.inspect(path);
-		return property_definition.node_types || [];
+		if (this.selection?.type !== 'text' && this.selection?.type !== 'node') return [];
+		const property_definition = this.inspect(this.selection.path);
+		return property_definition.annotation_types || [];
 	}
 
 	// Helper function to get the currently selected node
@@ -204,7 +234,7 @@ export default class Session {
 			// Only consider selection of a single node
 			if (end - start !== 1) return null;
 			const node_array = this.get(this.selection.path);
-			const node_id = node_array[start];
+			const node_id = node_array.nodes[start];
 			return node_id ? this.get(node_id) : null;
 		} else {
 			// we are assuming we are either in a text or property (=custom) selection
@@ -235,7 +265,13 @@ export default class Session {
 	 */
 	apply(transaction, { batch = false } = {}) {
 		this.validate_transaction_result(transaction);
-		this.doc = transaction.doc;
+		// Only swap the doc when something changed. The transaction draft is
+		// always a fresh object, and assigning it for an ops-less transaction
+		// (e.g. selection-only) would needlessly invalidate every doc-dependent
+		// derived in the component tree.
+		if (transaction.ops.length > 0) {
+			this.doc = transaction.doc;
+		}
 		// Make sure selection gets a new reference (is rerendered)
 		this.selection = structuredClone(transaction.selection);
 		if (this.history_index < this.history.length - 1) {
@@ -284,12 +320,14 @@ export default class Session {
 			return;
 		}
 		const change = this.history[this.history_index];
-		let doc = this.doc;
+		// One draft for the whole change set — ops mutate the draft with
+		// node-level copy-on-write instead of copying the nodes map per op.
+		const doc = create_document_draft(this.doc);
 		change.inverse_ops
 			.slice()
 			.reverse()
 			.forEach((op) => {
-				doc = apply_op(doc, op);
+				apply_op_to_draft(doc, op);
 			});
 		this.doc = doc;
 		this.selection = change.selection_before;
@@ -303,9 +341,9 @@ export default class Session {
 		}
 		this.history_index = this.history_index + 1;
 		const change = this.history[this.history_index];
-		let doc = this.doc;
+		const doc = create_document_draft(this.doc);
 		change.ops.forEach((op) => {
-			doc = apply_op(doc, op);
+			apply_op_to_draft(doc, op);
 		});
 		this.doc = doc;
 		this.selection = change.selection_after;
@@ -329,8 +367,8 @@ export default class Session {
 	 * session.get(['page_1', 'body', 3, 'list_items', 0]) // => { type: 'list_item', id: 'list_item_1', ... }
 	 *
 	 * @example
-	 * // Get an annotated text property
-	 * session.get(['page_1', 'cover', 'title']) // => {text: 'Hello world', annotations: []}
+	 * // Get a text property
+	 * session.get(['page_1', 'cover', 'title']) // => {content: 'Hello world', marks: [], annotations: []}
 	 */
 	get(path) {
 		return doc_get(this.schema, this.doc, path);
@@ -368,7 +406,7 @@ export default class Session {
 
 	/**
 	 * Determines the kind of a node ('block' for structured blocks, 'text' for pure
-	 * text nodes or 'annotation' for annotation nodes.
+	 * text nodes, 'mark' for mark nodes or 'annotation' for annotation nodes.
 	 * @param {any} node
 	 * @returns {NodeKind}
 	 */
@@ -417,46 +455,82 @@ export default class Session {
 		};
 	}
 
-	/**
-	 * Returns the annotation object that is currently "under the cursor".
-	 * NOTE: Annotations in Svedit are exclusive, so there can only be one active_annotation
-	 *
-	 * @param {string} [annotation_type] Optional annotation type to filter by
-	 * @returns {Annotation|null}
-	 */
-	active_annotation(annotation_type) {
-		return get_active_annotation(this.schema, this.doc, this.selection, annotation_type);
-	}
-
-	get_selected_annotated_text() {
+	get_selected_text() {
 		if (this.selection?.type !== 'text') return null;
 
 		const selection_start = Math.min(this.selection.anchor_offset, this.selection.focus_offset);
 		const selection_end = Math.max(this.selection.anchor_offset, this.selection.focus_offset);
-		const annotated_text = this.get(this.selection.path);
-		const text = char_slice(annotated_text.text, selection_start, selection_end);
+		const text_value = this.get(this.selection.path);
+		const selected_text = char_slice(text_value.content, selection_start, selection_end);
 		const nodes = {};
-		const annotations = annotated_text.annotations
-			.map((a) => {
-				if (selection_start < a.end_offset && selection_end > a.start_offset) {
-					const sub_graph = this.traverse(a.node_id);
-					for (const node of sub_graph) {
-						if (!nodes[node.id]) {
-							nodes[node.id] = node;
+
+		const clip_ranges = (ranges) =>
+			ranges
+				.map((range) => {
+					if (selection_start < range.end_offset && selection_end > range.start_offset) {
+						const sub_graph = this.traverse(range.node_id);
+						for (const node of sub_graph) {
+							if (!nodes[node.id]) {
+								nodes[node.id] = node;
+							}
 						}
+						return {
+							start_offset: Math.max(range.start_offset - selection_start, 0),
+							end_offset: Math.min(
+								range.end_offset - selection_start,
+								selection_end - selection_start
+							),
+							node_id: range.node_id
+						};
+					} else {
+						return null;
 					}
+				})
+				.filter(Boolean);
+
+		const marks = clip_ranges(text_value.marks);
+		const annotations = clip_ranges(text_value.annotations);
+
+		return { content: selected_text, marks, annotations, nodes };
+	}
+
+	get_selected_annotated_nodes() {
+		if (this.selection?.type !== 'node') return null;
+
+		const selection_start = Math.min(this.selection.anchor_offset, this.selection.focus_offset);
+		const selection_end = Math.max(this.selection.anchor_offset, this.selection.focus_offset);
+		const node_array = this.get(this.selection.path);
+		const main_nodes = node_array.nodes.slice(selection_start, selection_end);
+		const nodes = {};
+
+		const add_subgraph = (node_id) => {
+			for (const node of this.traverse(node_id)) {
+				if (!nodes[node.id]) nodes[node.id] = node;
+			}
+		};
+
+		for (const node_id of main_nodes) add_subgraph(node_id);
+
+		const clip_ranges = (ranges) =>
+			ranges
+				.map((range) => {
+					if (selection_start >= range.end_offset || selection_end <= range.start_offset) {
+						return null;
+					}
+
+					add_subgraph(range.node_id);
 					return {
-						start_offset: Math.max(a.start_offset - selection_start, 0),
-						end_offset: Math.min(a.end_offset - selection_start, selection_end - selection_start),
-						node_id: a.node_id
+						start_offset: Math.max(range.start_offset - selection_start, 0),
+						end_offset: Math.min(range.end_offset - selection_start, selection_end - selection_start),
+						node_id: range.node_id
 					};
-				} else {
-					return null;
-				}
-			})
-			.filter(Boolean);
+				})
+				.filter(Boolean);
 
-		return { text, annotations, nodes };
+		const marks = clip_ranges(node_array.marks);
+		const annotations = clip_ranges(node_array.annotations);
+
+		return { nodes, main_nodes, marks, annotations };
 	}
 
 	// TODO: think about ways how we can also turn a node selection into plain text.
@@ -465,8 +539,8 @@ export default class Session {
 
 		const start = Math.min(this.selection.anchor_offset, this.selection.focus_offset);
 		const end = Math.max(this.selection.anchor_offset, this.selection.focus_offset);
-		const annotated_text = this.get(this.selection.path);
-		return char_slice(annotated_text.text, start, end);
+		const text = this.get(this.selection.path);
+		return char_slice(text.content, start, end);
 	}
 
 	get_selected_nodes() {
@@ -475,7 +549,9 @@ export default class Session {
 		const start = Math.min(this.selection.anchor_offset, this.selection.focus_offset);
 		const end = Math.max(this.selection.anchor_offset, this.selection.focus_offset);
 		const node_array = this.get(this.selection.path);
-		return $state.snapshot(node_array.slice(start, end));
+		// node_array.nodes is a plain array of id strings (doc is $state.raw),
+		// so a slice is already a safe fresh copy.
+		return node_array.nodes.slice(start, end);
 	}
 
 	select_parent() {
@@ -528,7 +604,11 @@ export default class Session {
 	 * @note Nodes that are not reachable from the entry point node will not be included
 	 */
 	traverse(node_id) {
-		return traverse(node_id, this.schema, $state.snapshot(this.doc.nodes));
+		// doc is $state.raw, so doc.nodes is a plain (non-proxied) object —
+		// traverse() reads it directly and deep-clones each visited node.
+		// The previous $state.snapshot(this.doc.nodes) here deep-cloned the
+		// ENTIRE document per call, which made copying M nodes O(M·N).
+		return traverse(node_id, this.schema, this.doc.nodes);
 	}
 
 	/**
@@ -551,7 +631,7 @@ export default class Session {
 	}
 
 	// property_type('page', 'body') => 'node_array'
-	// property_type('paragraph', 'content') => 'annotated_text'
+	// property_type('paragraph', 'content') => 'text'
 	property_type(type, property) {
 		return doc_property_type(this.schema, type, property);
 	}
@@ -567,9 +647,7 @@ export default class Session {
 	 * @returns {NodeId[]}
 	 */
 	get_referenced_nodes(node_id) {
-		const traversed_nodes = this.traverse(node_id);
-
-		// Extract IDs and exclude the last element (root node)
-		return traversed_nodes.slice(0, -1).map((node) => node.id);
+		// Id-only traversal — no need to deep-clone the subgraph for ids.
+		return traverse_ids(node_id, this.schema, this.doc.nodes).slice(0, -1);
 	}
 }