@dxos/graph 0.12.0-next-73daef452f1464b62efdbca75fb0067c1066f264 → 0.13.0

package/dist/lib/GraphBuilder.mjs

@@ -1,515 +1,4 @@
-import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
-import { createId } from "./GraphEdge.mjs";
-import { RootId, qualifyId, validateSegmentId } from "./GraphNode.mjs";
-import { make as make$1 } from "./GraphModel.mjs";
-import * as Atom from "effect/unstable/reactivity/Atom";
-import * as Registry from "effect/unstable/reactivity/AtomRegistry";
-import * as Array from "effect/Array";
-import * as Function from "effect/Function";
-import * as Option from "effect/Option";
-import * as Pipeable from "effect/Pipeable";
-import * as Record from "effect/Record";
-import { log } from "@dxos/log";
-import { Position, getDebugName, isNonNullable } from "@dxos/util";
-//#region src/GraphBuilder.ts
-var GraphBuilder_exports = /* @__PURE__ */ __exportAll({
-	GraphBuilder: () => GraphBuilder,
-	ModelGraphBuilder: () => ModelGraphBuilder,
-	TypeId: () => TypeId,
-	addExtension: () => addExtension,
-	createConnector: () => createConnector,
-	destroy: () => destroy,
-	explore: () => explore,
-	flattenExtensions: () => flattenExtensions,
-	flush: () => flush,
-	make: () => make,
-	makeModel: () => makeModel,
-	release: () => release,
-	removeExtension: () => removeExtension
-});
-var __dxlog_file = "/__w/dxos/dxos/packages/common/graph/src/GraphBuilder.ts";
-var PRIMARY = "
";
-var primaryKey = (...parts) => parts.join(PRIMARY);
-var primaryParts = (key) => key.split(PRIMARY);
-/** {@link Atom.withLabel}, reduced to a pass-through wherever labels are not collected. */
-var withLabel = () => (self) => self;
-var defaultInline = {
-	children: () => [],
-	map: (node) => node
-};
-/**
-* Identifier denoting a GraphBuilder.
-*/
-var TypeId = Symbol.for("@dxos/graph/GraphBuilder");
-/**
-* Composes the construction of a graph out of independently registered extensions: each expansion of a
-* node's relation subscribes to every connector declared for it, and the difference between successive
-* reads is flushed into the store as node and edge changes.
-*
-* Subclass to layer a vocabulary on top (see `@dxos/app-graph`'s `AppGraphBuilder`); the generic engine
-* is unaware of what the nodes mean.
-*/
-var GraphBuilder = class {
-	[TypeId] = TypeId;
-	pipe() {
-		return Pipeable.pipeArguments(this, arguments);
-	}
-	/**
-	* Expansion subscriptions, keyed by the node they belong to and then by relation key. Nested
-	* rather than flat: removal cancels a node's subscriptions, and a flat map makes that a scan of
-	* every subscription in the graph per removed node.
-	*/
-	_subscriptions = /* @__PURE__ */ new Map();
-	/** Connector updates pending flush, keyed by connector key. */
-	_dirtyConnectors = /* @__PURE__ */ new Map();
-	/** Last-flushed node IDs per connector key, used for edge removal on update. */
-	_connectorPrevious = /* @__PURE__ */ new Map();
-	/** All inline-descendant IDs per connector key, used to remove stale inline nodes on update. */
-	_connectorPreviousInlineIds = /* @__PURE__ */ new Map();
-	/** Last-flushed node args per connector key, used for change detection. */
-	_connectorPreviousArgs = /* @__PURE__ */ new Map();
-	/** Whether a dirty-flush task is already scheduled. */
-	_flushScheduled = false;
-	/** Resolves when the current flush completes. */
-	_flushPromise = Promise.resolve();
-	/** Registered extensions keyed by extension ID. */
-	_extensions = Atom.make(Record.empty()).pipe(Atom.keepAlive, withLabel("graph-builder:extensions"));
-	/**
-	* Node id -> id of the extension whose connector produced it. Non-reactive: updated directly as
-	* connectors materialize/remove nodes, so a reverse mapping from a node back to its producer does not
-	* need a reactive read.
-	*/
-	_nodeExtensions = /* @__PURE__ */ new Map();
-	_registry;
-	_store;
-	_inline;
-	_relationKey;
-	_decorateNode;
-	_unchanged;
-	constructor({ registry, store, relationKey, inline, decorateNode, unchanged }) {
-		this._registry = registry ?? Registry.make();
-		this._relationKey = relationKey;
-		this._inline = inline ?? defaultInline;
-		this._decorateNode = decorateNode ?? ((node) => node);
-		this._unchanged = unchanged ?? (() => false);
-		this._store = store({
-			onExpand: (id, relation) => this._onExpand(id, relation),
-			onRemoveNode: (id) => this._onRemoveNode(id)
-		}, this._registry);
-	}
-	get graph() {
-		return this._store.graph;
-	}
-	get extensions() {
-		return this._extensions;
-	}
-	/** Read the currently registered extensions synchronously. */
-	getExtensions() {
-		return this._registry.get(this._extensions);
-	}
-	/**
-	* The id of the extension whose connector produced the given node, if known. Populated as connectors
-	* materialize nodes and cleared on removal.
-	*/
-	getNodeExtensionId(nodeId) {
-		return this._nodeExtensions.get(nodeId);
-	}
-	/** Every inline descendant of `node`, at every depth. */
-	_allInline(node) {
-		return this._inline.children(node).flatMap((child) => [child, ...this._allInline(child)]);
-	}
-	/** Qualify a node argument's id against its parent, recursively through its inline descendants. */
-	_qualify(parentId, node) {
-		validateSegmentId(node.id);
-		const id = qualifyId(parentId, node.id);
-		return this._inline.map({
-			...node,
-			id
-		}, (child) => this._qualify(id, child));
-	}
-	/** Record `extensionId` as the producer of a node and of the inline descendants that inherit it. */
-	_recordProvenance(node, extensionId) {
-		this._nodeExtensions.set(node.id, extensionId);
-		const owned = this._inline.owned ?? this._inline.children;
-		for (const child of owned(node)) this._recordProvenance(child, extensionId);
-	}
-	/** Apply a set of node changes for a single connector key. */
-	_applyConnectorUpdate(key, nodes, previous) {
-		const { id, relation } = relationFromConnectorKey(key);
-		const ids = nodes.map((node) => node.id);
-		const current = new Set(ids);
-		const removed = previous.filter((previousId) => !current.has(previousId));
-		this._connectorPrevious.set(key, ids);
-		this._connectorPreviousArgs.set(key, nodes);
-		const currentInlineIds = nodes.flatMap((node) => this._allInline(node).map((child) => child.id));
-		const currentInline = new Set(currentInlineIds);
-		const staleInlineIds = (this._connectorPreviousInlineIds.get(key) ?? []).filter((previousId) => !currentInline.has(previousId));
-		this._connectorPreviousInlineIds.set(key, currentInlineIds);
-		this._store.removeNodes(staleInlineIds, true);
-		this._store.removeEdges(removed.map((target) => ({
-			source: id,
-			target,
-			relation
-		})), true);
-		this._store.addNodes(nodes);
-		this._store.addEdges(nodes.map((node) => ({
-			source: id,
-			target: node.id,
-			relation
-		})));
-		if (ids.length > 0) {
-			const sortedIds = [...nodes].sort((a, b) => Position.compare({ position: a.properties?.position }, { position: b.properties?.position })).map((node) => node.id);
-			this._store.sortEdges(id, relation, sortedIds);
-		}
-	}
-	_scheduleDirtyFlush() {
-		if (!this._flushScheduled) {
-			this._flushScheduled = true;
-			this._flushPromise = this._schedule(() => {
-				this._flushScheduled = false;
-				while (this._dirtyConnectors.size > 0) {
-					const entries = [...this._dirtyConnectors.entries()];
-					this._dirtyConnectors.clear();
-					const apply = () => {
-						for (const [key, { nodes, previous }] of entries) this._applyConnectorUpdate(key, nodes, previous);
-					};
-					this._store.batch ? this._store.batch(apply) : apply();
-				}
-			});
-		}
-	}
-	/**
-	* When a flush runs. Defaults to the next microtask; override to hand the work to a scheduler that can
-	* yield to the main thread.
-	*/
-	_schedule(callback) {
-		return Promise.resolve().then(callback);
-	}
-	/** Where a traversal yields between nodes; overridden alongside {@link GraphBuilder._schedule}. */
-	_yield() {
-		return Promise.resolve();
-	}
-	/** A connector-produced node, tagged with the id of the extension that produced it (provenance). */
-	_connectors = Atom.family((key) => {
-		return Atom.make((get) => {
-			const { id, relation } = relationFromConnectorKey(key);
-			const node = this._store.node(id);
-			if (Option.isNone(get(node))) return [];
-			const extensions = Function.pipe(get(this._extensions), Record.values, Array.sortBy(Position.compare), Array.filter((extension) => this._relationKey(extension.relation) === relation && extension.connector != null));
-			const entries = [];
-			for (const extension of extensions) for (const node of get(extension.connector(this._store.node(id)))) entries.push({
-				extensionId: extension.id,
-				node
-			});
-			return entries;
-		}).pipe(withLabel(`graph-builder:connectors:${key}`));
-	});
-	/**
-	* A relation of a node was read for the first time; subscribe every connector declared for it.
-	* Override to expand additional relations alongside the requested one.
-	*/
-	_onExpand(id, relation) {
-		log("onExpand", {
-			id,
-			relation,
-			registry: getDebugName(this._registry)
-		}, {
-			"~LogMeta": "~LogMeta",
-			F: __dxlog_file,
-			L: 435,
-			S: this
-		});
-		this._expandRelation(id, relation);
-	}
-	_expandRelation(id, relation) {
-		const key = connectorKey(id, relation);
-		const cancel = this._registry.subscribe(this._connectors(key), (entries) => {
-			const extensions = this.getExtensions();
-			const nodes = entries.map((entry) => this._decorateNode(this._qualify(id, entry.node), extensions[entry.extensionId]));
-			entries.forEach((entry, index) => this._recordProvenance(nodes[index], entry.extensionId));
-			const previous = this._connectorPrevious.get(key) ?? [];
-			const ids = nodes.map((node) => node.id);
-			if (ids.length === previous.length && ids.every((nodeId, index) => nodeId === previous[index])) {
-				const previousArgs = this._connectorPreviousArgs.get(key);
-				if (previousArgs && this._unchanged(previousArgs, nodes)) return;
-			}
-			log("update", {
-				id,
-				relation,
-				ids
-			}, {
-				"~LogMeta": "~LogMeta",
-				F: __dxlog_file,
-				L: 463,
-				S: this
-			});
-			this._dirtyConnectors.set(key, {
-				nodes,
-				previous
-			});
-			this._scheduleDirtyFlush();
-		}, { immediate: true });
-		const forNode = this._subscriptions.get(id) ?? /* @__PURE__ */ new Map();
-		forNode.set(key, cancel);
-		this._subscriptions.set(id, forNode);
-	}
-	/**
-	* A relation is being torn down by {@link release}: drop its expansion subscription so the next
-	* read expands it again. Override to unwind whatever expansion bookkeeping the layer keeps.
-	*/
-	_onReleaseRelation({ id, relation }) {
-		const forNode = this._subscriptions.get(id);
-		const cancel = forNode?.get(connectorKey(id, relation));
-		if (cancel) {
-			cancel();
-			forNode.delete(connectorKey(id, relation));
-			if (forNode.size === 0) this._subscriptions.delete(id);
-		}
-	}
-	_onRemoveNode(id) {
-		this._nodeExtensions.delete(id);
-		const forNode = this._subscriptions.get(id);
-		if (forNode) {
-			this._subscriptions.delete(id);
-			forNode.forEach((cleanup) => cleanup());
-		}
-	}
-};
-/** A graph shaped for {@link ModelGraphBuilder} to build into. */
-var makeModel = (options) => make$1(options);
-/**
-* The builder over `@dxos/graph`'s own {@link GraphModel} — the default specialization, and the one to
-* reach for unless a layer needs its own node vocabulary (as `@dxos/app-graph` does).
-*
-* Relations are plain strings carried in the edge `type`, and sibling order in the edge `data.order`;
-* {@link ModelGraphBuilder.children} reads them back in that order.
-*/
-var ModelGraphBuilder = class extends GraphBuilder {
-	/** Relations already expanded, so a repeated read does not re-subscribe the same connectors. */
-	#expanded = /* @__PURE__ */ new Set();
-	/** Memoized {@link ModelGraphBuilder.children} views, so subscribers of a relation share one atom. */
-	#children = Atom.family((key) => {
-		const [id, relation] = primaryParts(key);
-		const model = this.graph;
-		return Atom.make((get) => {
-			get(model.version);
-			return model.outgoing(id, relation).toSorted((a, b) => a.data.order - b.data.order).map((edge) => model.findNode(edge.target)).filter(isNonNullable);
-		});
-	});
-	constructor({ model, rootId = RootId, ...props } = {}) {
-		super({
-			...props,
-			relationKey: (relation) => relation ?? "child",
-			inline: {
-				children: (node) => node.nodes ?? [],
-				map: (node, fn) => ({
-					...node,
-					nodes: node.nodes?.map(fn)
-				})
-			},
-			store: (hooks, registry) => modelStore(model ?? make$1({
-				registry,
-				retainAtoms: true
-			}), hooks)
-		});
-		if (!this.graph.findNode(rootId)) this.graph.addNode({ id: rootId });
-	}
-	/**
-	* The nodes a relation of `node` resolves to, in sibling order, expanding it on first read — the
-	* entry point that makes the graph grow.
-	*/
-	children(id, relation = "child") {
-		const key = primaryKey(id, relation);
-		if (!this.#expanded.has(key)) {
-			this.#expanded.add(key);
-			this._onExpand(id, relation);
-		}
-		return this.#children(key);
-	}
-	_onReleaseRelation(target) {
-		super._onReleaseRelation(target);
-		this.#expanded.delete(primaryKey(target.id, target.relation));
-	}
-	_onRemoveNode(id) {
-		super._onRemoveNode(id);
-		for (const key of this.#expanded) if (primaryParts(key)[0] === id) this.#expanded.delete(key);
-	}
-};
-/** Adapt a {@link GraphModel} to the store port. */
-var modelStore = (model, hooks) => {
-	const nodes = Atom.family((id) => Atom.make((get) => {
-		const node = get(model.nodeAtom(id));
-		return node ? Option.some(node) : Option.none();
-	}));
-	const edgeId = ({ source, target, relation }) => createId({
-		source,
-		target,
-		relation
-	});
-	const addEdge = (edge) => {
-		const id = edgeId(edge);
-		if (!model.findEdge(id)) model.addEdge({
-			id,
-			type: edge.relation,
-			source: edge.source,
-			target: edge.target,
-			data: { order: 0 }
-		});
-	};
-	const addNode = (node) => {
-		const { nodes: children, ...rest } = node;
-		model.setNode(rest);
-		children?.forEach((child) => {
-			addNode(child);
-			addEdge({
-				source: node.id,
-				target: child.id,
-				relation: "child"
-			});
-		});
-	};
-	return {
-		graph: model,
-		node: (id) => nodes(id),
-		nodeOrThrow: (id) => Atom.make((get) => Option.getOrThrowWith(get(nodes(id)), () => /* @__PURE__ */ new Error(`No node: ${id}`))),
-		addNodes: (args) => model.batch(() => args.forEach(addNode)),
-		removeNodes: (ids, edges) => model.batch(() => {
-			model.removeNodes([...ids], { detachEdges: edges });
-			ids.forEach((id) => hooks.onRemoveNode(id));
-		}),
-		addEdges: (edges) => model.batch(() => edges.forEach(addEdge)),
-		removeEdges: (edges, removeOrphans) => model.batch(() => {
-			const present = edges.filter((edge) => model.findEdge(edgeId(edge)) !== void 0);
-			model.removeEdges(present.map(edgeId));
-			if (removeOrphans) {
-				const orphans = [...new Set(present.flatMap(({ source, target }) => [source, target]))].filter((id) => id !== "root" && model.findNode(id) !== void 0 && !model.hasEdges(id));
-				if (orphans.length > 0) {
-					model.removeNodes(orphans);
-					orphans.forEach((id) => hooks.onRemoveNode(id));
-				}
-			}
-		}),
-		sortEdges: (id, relation, order) => model.batch(() => {
-			for (const edge of model.outgoing(id, relation)) {
-				const index = order.indexOf(edge.target);
-				if (index >= 0) edge.data.order = index;
-			}
-			model.touch();
-		}),
-		setNode: (id, node) => Option.match(node, {
-			onNone: () => model.removeNode(id),
-			onSome: (value) => model.setNode(value)
-		}),
-		constructNode: ({ nodes: _, ...node }) => Option.some(node),
-		batch: (fn) => model.batch(fn),
-		release: (ids) => model.release(ids)
-	};
-};
-/**
-* Creates a new GraphBuilder.
-*/
-var make = (props) => new GraphBuilder(props);
-/**
-* Add extensions to the builder.
-*/
-var addExtension = Function.dual(2, (builder, extensions) => {
-	flattenExtensions(extensions).forEach((extension) => {
-		builder._registry.set(builder._extensions, Record.set(builder.getExtensions(), extension.id, extension));
-	});
-	return builder;
-});
-/**
-* Remove an extension from the builder.
-*/
-var removeExtension = Function.dual(2, (builder, id) => {
-	builder._registry.set(builder._extensions, Record.remove(builder.getExtensions(), id));
-	return builder;
-});
-/**
-* Wait for all pending connector updates to be flushed.
-*/
-var flush = (builder) => builder._flushPromise;
-/**
-* Unloads the nodes and everything the builder remembers about them: expansion subscriptions, the
-* per-connector diff state, and provenance. The nodes leave the store outright rather than being
-* tombstoned, so reading a released relation again re-expands it from its connectors.
-*
-* Releasing a node does NOT release its descendants — the caller chooses the set, since what counts
-* as a releasable unit (a workspace, a collection, one node) is a policy the builder has no view of.
-* {@link explore} and the store's own traversal are how that set is collected.
-*/
-var release = (builder, ids) => {
-	const released = new Set(ids);
-	for (const [key, previous] of [...builder._connectorPrevious]) if (released.has(relationFromConnectorKey(key).id) || previous.some((id) => released.has(id))) {
-		builder._connectorPrevious.delete(key);
-		builder._connectorPreviousArgs.delete(key);
-		builder._connectorPreviousInlineIds.delete(key);
-		builder._dirtyConnectors.delete(key);
-		builder._onReleaseRelation(relationFromConnectorKey(key));
-	}
-	for (const [key, { nodes }] of [...builder._dirtyConnectors]) if (released.has(relationFromConnectorKey(key).id) || nodes.some((node) => released.has(node.id))) {
-		builder._dirtyConnectors.delete(key);
-		builder._onReleaseRelation(relationFromConnectorKey(key));
-	}
-	ids.forEach((id) => builder._onRemoveNode(id));
-	builder._store.release?.(ids);
-};
-/**
-* Release every expansion subscription the builder holds.
-*/
-var destroy = (builder) => {
-	builder._subscriptions.forEach((forNode) => forNode.forEach((unsubscribe) => unsubscribe()));
-	builder._subscriptions.clear();
-};
-/**
-* Traverse the graph, materializing the nodes reached along the way.
-*
-* The `registry` option scopes the connector reads, not the nodes themselves, which the store owns.
-*/
-var explore = async (builder, options, path = []) => {
-	const { registry = Registry.make(), source = RootId, relation, visitor } = options;
-	if (path.includes(source)) return;
-	await builder._yield();
-	const node = registry.get(builder._store.nodeOrThrow(source));
-	if (await visitor(node, [...path, node.id]) === false) return;
-	const nodes = Function.pipe(builder.getExtensions(), Record.values, Array.map((extension) => extension.connector), Array.filter(isNonNullable), Array.flatMap((connector) => registry.get(connector(builder._store.node(source)))), Array.map((node) => builder._qualify(source, node)));
-	await Promise.all(nodes.map((node) => {
-		builder._store.setNode(node.id, builder._store.constructNode(node));
-		return explore(builder, {
-			registry,
-			source: node.id,
-			relation,
-			visitor
-		}, [...path, source]);
-	}));
-	if (registry !== builder._registry) {
-		registry.reset();
-		registry.dispose();
-	}
-};
-/**
-* Create a connector from a matcher and a factory: the factory runs only for nodes the matcher accepts,
-* and its data type is inferred from the matcher's.
-*/
-var createConnector = (matcher, factory) => {
-	return (node) => Atom.make((get) => Function.pipe(get(node), Option.flatMap((matched) => matcher(matched, get)), Option.map((data) => factory(data, get)), Option.getOrElse(() => [])));
-};
-/**
-* Flatten arbitrarily nested extension groups into a single list.
-*/
-var flattenExtensions = (extensions, acc = []) => {
-	if (Array.isArray(extensions)) return [...acc, ...extensions.flatMap((extension) => flattenExtensions(extension, acc))];
-	else return [...acc, extensions];
-};
-var connectorKey = (id, relation) => primaryKey(id, relation);
-var relationFromConnectorKey = (key) => {
-	const [id, relation] = primaryParts(key);
-	return {
-		id,
-		relation
-	};
-};
-//#endregion
-export { GraphBuilder, ModelGraphBuilder, TypeId, addExtension, createConnector, destroy, explore, flattenExtensions, flush, make, makeModel, release, removeExtension, GraphBuilder_exports as t };
-
-//# sourceMappingURL=GraphBuilder.mjs.map
+import "./GraphNode.mjs";
+import "./GraphModel.mjs";
+import { a as addExtension, c as explore, d as make, f as makeModel, h as setRetention, i as TypeId, l as flattenExtensions, m as removeExtension, o as createConnector, p as release, r as ModelGraphBuilder, s as destroy, t as GraphBuilder, u as flush } from "./chunk-GraphBuilder.mjs";
+export { GraphBuilder, ModelGraphBuilder, TypeId, addExtension, createConnector, destroy, explore, flattenExtensions, flush, make, makeModel, release, removeExtension, setRetention };

package/dist/lib/GraphModel.mjs

@@ -1,13 +1,14 @@
 import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
 import { GraphEdge, createId } from "./GraphEdge.mjs";
 import { GraphNode } from "./GraphNode.mjs";
-import * as Atom from "effect/unstable/reactivity/Atom";
-import * as Registry from "effect/unstable/reactivity/AtomRegistry";
+import * as Atom from "effect/reactivity/Atom";
+import * as Registry from "effect/reactivity/AtomRegistry";
 import { failedInvariant, invariant } from "@dxos/invariant";
 import * as Function from "effect/Function";
 import * as Option from "effect/Option";
-import * as Schema from "effect/Schema";
+import * as AtomEx from "@dxos/effect/AtomEx";
 import * as EffectGraph from "effect/Graph";
+import * as Schema from "effect/Schema";
 import { inspectCustom } from "@dxos/debug";
 //#region src/GraphModel.ts
 var GraphModel_exports = /* @__PURE__ */ __exportAll({
@@ -37,7 +38,9 @@ var Data = Schema.Struct({
 * views read the working graph through that atom, so immutable snapshots are produced on demand
 * rather than on every write.
 */
-var AbstractGraphModel = class {
+var AbstractGraphModel = class AbstractGraphModel {
+	static #finalizer = new FinalizationRegistry((unmount) => unmount());
+	[AtomEx.OwnerId];
 	#registry;
 	#version;
 	#nodeIndex = /* @__PURE__ */ new Map();
@@ -55,13 +58,13 @@ var AbstractGraphModel = class {
 	#nodeAtoms;
 	#edgeAtoms;
 	#neighborAtoms;
-	/** One mount per node while it is in the graph; `undefined` when retention is off. See {@link Options.retainAtoms}. */
-	#pins;
-	constructor({ registry, graph, change, retainAtoms } = {}) {
+	constructor({ registry, graph, change } = {}) {
 		this.#registry = registry ?? Registry.make();
-		this.#pins = retainAtoms ? /* @__PURE__ */ new Map() : void 0;
-		this.#version = Atom.make(0).pipe(Atom.keepAlive);
-		this.#registry.get(this.#version);
+		this[AtomEx.OwnerId] = {
+			registry: this.#registry,
+			finalizer: AbstractGraphModel.#finalizer
+		};
+		this.#version = AtomEx.makeOwned(this, Atom.make(0));
 		this.#graph = EffectGraph.beginMutation(EffectGraph.directed());
 		this.#change = change;
 		this.#mirror = change ? graph : void 0;
@@ -107,15 +110,11 @@ var AbstractGraphModel = class {
 		return this.#version;
 	}
 	/**
-	* Immutable snapshot in the schema shape, recomputed only when the graph has changed.
+	* Immutable snapshot in the schema shape, recomputed on the first read after a change.
 	*/
 	get graph() {
-		const version = this.#registry.get(this.#version);
-		if (this.#snapshot?.version !== version) this.#snapshot = {
-			version,
-			graph: this.#encode()
-		};
-		return this.#snapshot.graph;
+		this.#snapshot ??= this.#encode();
+		return this.#snapshot;
 	}
 	get graphAtom() {
 		return this.#graphAtom;
@@ -137,7 +136,8 @@ var AbstractGraphModel = class {
 			this.#depth--;
 			if (this.#depth === 0 && this.#dirty) {
 				this.#dirty = false;
-				this.#registry.set(this.#version, this.#registry.get(this.#version) + 1);
+				this.#snapshot = void 0;
+				this.#registry.update(this.#version, (version) => version + 1);
 			}
 		}
 	}
@@ -201,14 +201,14 @@ var AbstractGraphModel = class {
 		invariant(node.id, "ID is required", {
 			"~LogMeta": "~LogMeta",
 			F: __dxlog_file,
-			L: 498,
+			L: 493,
 			S: this,
 			A: ["node.id", "'ID is required'"]
 		});
 		invariant(!this.findNode(node.id), `node already exists: ${node.id}`, {
 			"~LogMeta": "~LogMeta",
 			F: __dxlog_file,
-			L: 499,
+			L: 494,
 			S: this,
 			A: ["!this.findNode(node.id)", "`node already exists: ${node.id}`"]
 		});
@@ -232,7 +232,7 @@ var AbstractGraphModel = class {
 		invariant(node.id, "ID is required", {
 			"~LogMeta": "~LogMeta",
 			F: __dxlog_file,
-			L: 517,
+			L: 512,
 			S: this,
 			A: ["node.id", "'ID is required'"]
 		});
@@ -287,7 +287,6 @@ var AbstractGraphModel = class {
 				this.#nodeIndex.delete(id);
 				this.#outgoing.delete(id);
 				this.#incoming.delete(id);
-				this.#unpin(id);
 				this.#mirrorMutate((mirror) => removeInPlace(mirror.nodes, (candidate) => candidate.id === id));
 			}
 			this.#touch();
@@ -379,14 +378,14 @@ var AbstractGraphModel = class {
 		invariant(edge.source, void 0, {
 			"~LogMeta": "~LogMeta",
 			F: __dxlog_file,
-			L: 688,
+			L: 682,
 			S: this,
 			A: ["edge.source", ""]
 		});
 		invariant(edge.target, void 0, {
 			"~LogMeta": "~LogMeta",
 			F: __dxlog_file,
-			L: 689,
+			L: 683,
 			S: this,
 			A: ["edge.target", ""]
 		});
@@ -397,7 +396,7 @@ var AbstractGraphModel = class {
 		invariant(!this.findEdge(resolved.id), `edge already exists: ${resolved.id}`, {
 			"~LogMeta": "~LogMeta",
 			F: __dxlog_file,
-			L: 692,
+			L: 686,
 			S: this,
 			A: ["!this.findEdge(resolved.id)", "`edge already exists: ${resolved.id}`"]
 		});
@@ -641,17 +640,9 @@ var AbstractGraphModel = class {
 				value: Option.none()
 			});
 			this.#nodeIndex.set(id, index);
-			if (this.#pins && !this.#pins.has(id)) this.#pins.set(id, this.#registry.mount(this.#nodeAtoms(id)));
 		}
 		return index;
 	}
-	#unpin(id) {
-		const cancel = this.#pins?.get(id);
-		if (cancel) {
-			this.#pins.delete(id);
-			cancel();
-		}
-	}
 	#unlinkEdge(edge) {
 		const index = this.#edgeIndex.get(edge.id);
 		if (index === void 0) return;
@@ -665,8 +656,6 @@ var AbstractGraphModel = class {
 	* Discards the working graph wholesale, which also drops placeholders left by removals.
 	*/
 	#resetWorking() {
-		this.#pins?.forEach((cancel) => cancel());
-		this.#pins?.clear();
 		this.#graph = EffectGraph.beginMutation(EffectGraph.directed());
 		this.#nodeIndex.clear();
 		this.#edgeIndex.clear();
@@ -678,9 +667,8 @@ var AbstractGraphModel = class {
 		this.#dirty = true;
 	}
 	#mirrorMutate(fn) {
-		const mirror = this.#mirror;
-		if (!mirror || !this.#change) return;
-		this.#change(() => fn(mirror));
+		if (!this.#mirror || !this.#change) return;
+		this.#change((mirror) => fn(mirror));
 	}
 };
 var NEIGHBOR_SEPARATOR = "
";