@markless/runtime 0.3.1 → 0.3.3

package/dist/{graph-DoSjSC5T.js → graph-B77v_FUC.js}

@@ -1,69 +1,4 @@
-//#region src/graph-core.ts
-function findLastSharedReturnProperty(properties, propertyName) {
-	if (!properties) return void 0;
-	for (let index = properties.length - 1; index >= 0; index--) {
-		const property = properties[index];
-		if (property?.name === propertyName) return property;
-	}
-}
-function readPath(value, path) {
-	let current = value;
-	for (const segment of path) {
-		if (current == null) return void 0;
-		current = current[segment];
-	}
-	return current;
-}
-function writePath(value, path, nextValue) {
-	if (path.length === 0) return nextValue;
-	const root = isObject(value) ? value : {};
-	let current = root;
-	for (const segment of path.slice(0, -1)) {
-		const child = current[segment];
-		if (!isObject(child)) current[segment] = {};
-		current = current[segment];
-	}
-	current[path[path.length - 1]] = nextValue;
-	return root;
-}
-function dirtyPathForGraphWrite(value, path) {
-	if (path[path.length - 1] !== "length") return path;
-	const parentPath = path.slice(0, -1);
-	const parent = readPath(value, parentPath);
-	if (!Array.isArray(parent)) return path;
-	return parentPath;
-}
-function deletePath(value, path) {
-	if (path.length === 0) throw new TypeError("Cannot delete a graph node root. Delete a property path instead.");
-	let current = value;
-	for (const segment of path.slice(0, -1)) {
-		if (current == null) throw new TypeError(`Cannot delete graph path "${path.join(".")}".`);
-		current = current[segment];
-	}
-	if (current == null) throw new TypeError(`Cannot delete graph path "${path.join(".")}".`);
-	if (!isObject(current)) return {
-		result: true,
-		mutated: false
-	};
-	const key = path[path.length - 1];
-	const hadProperty = Object.prototype.hasOwnProperty.call(current, key);
-	const result = delete current[key];
-	return {
-		result,
-		mutated: hadProperty && result
-	};
-}
-function pathsIntersect(a, b) {
-	return isPrefix(a, b) || isPrefix(b, a);
-}
-function isPrefix(prefix, value) {
-	if (prefix.length > value.length) return false;
-	return prefix.every((segment, index) => value[index] === segment);
-}
-function isObject(value) {
-	return typeof value === "object" && value !== null;
-}
-//#endregion
+import { a as readAsyncComputedNode, c as findLastSharedReturnProperty, d as writePath, i as invalidateAsyncComputed, l as pathsIntersect, n as createRuntimeAsyncComputedNodes, o as deletePath, r as demandAsyncComputed, s as dirtyPathForGraphWrite, u as readPath } from "./graph-async-Db6SqB5x.js";
 //#region src/graph-collections.ts
 function applyCollectionCall(target, method, args) {
 	if (!isSupportedCollectionTarget(target)) throw new TypeError(`Cannot call collection method "${method}" because the graph path is not an Array, Map, Set, or Date.`);
@@ -144,134 +79,6 @@ function arraySlotsEqual(before, after) {
 	});
 }
 //#endregion
-//#region src/graph-async.ts
-const ASYNC_SNAPSHOT_META_KEYS = new Set([
-	"status",
-	"version",
-	"key",
-	"error",
-	"value"
-]);
-function createRuntimeAsyncComputedNodes(asyncComputedInput) {
-	const asyncComputedNodes = /* @__PURE__ */ new Map();
-	for (const asyncComputed of asyncComputedInput ?? []) {
-		const initialSnapshot = asyncComputed.initialSnapshot ?? {
-			status: "idle",
-			version: 0
-		};
-		asyncComputedNodes.set(asyncComputed.graphNodeId, {
-			...asyncComputed,
-			gate: initialSnapshot.status === "pending" ? 1 : 0,
-			snapshot: initialSnapshot,
-			version: initialSnapshot.version
-		});
-	}
-	return asyncComputedNodes;
-}
-function readAsyncComputedNode(node, path, demand) {
-	demand();
-	const head = path[0];
-	if (head === void 0 || ASYNC_SNAPSHOT_META_KEYS.has(head)) return readPath(node.snapshot, path);
-	return readPath(node.snapshot.value, path);
-}
-function demandAsyncComputed(input) {
-	if (input.node.gate !== 1 && input.node.snapshot.status !== "idle") return;
-	advanceAsyncComputed(input);
-}
-function invalidateAsyncComputed(input) {
-	if (input.node.snapshot.status === "idle") return;
-	advanceAsyncComputed(input);
-}
-function advanceAsyncComputed(input) {
-	const visited = new Set([input.node.graphNodeId]);
-	let blocked;
-	const visit = (graphNodeId) => {
-		if (visited.has(graphNodeId)) return;
-		visited.add(graphNodeId);
-		const dependency = input.asyncComputedNodes.get(graphNodeId);
-		if (dependency) {
-			if (dependency.snapshot.status === "idle" || dependency.snapshot.status === "pending") {
-				blocked = dependency;
-				input.demandAsyncComputed(dependency);
-			} else if (!blocked && dependency.snapshot.status === "rejected") blocked = dependency;
-			return;
-		}
-		for (const dependency of input.computedNodes.get(graphNodeId)?.dependencies ?? []) visit(dependency.graphNodeId);
-	};
-	for (const dependency of input.node.dependencies) visit(dependency.graphNodeId);
-	if (blocked) {
-		commitDependencyBlock(input, blocked.snapshot.status === "rejected" ? "rejected" : "pending", blocked.snapshot.error);
-		return;
-	}
-	const nextKey = input.node.key(input.readGraph);
-	if (!input.node.gate && input.node.snapshot.status !== "idle" && Object.is(input.node.snapshot.key, nextKey)) return;
-	startAsyncComputed({
-		...input,
-		key: nextKey
-	});
-}
-function commitDependencyBlock(input, status, error) {
-	if (input.node.gate === 2 && (status === "pending" || input.node.snapshot.status === "rejected" && Object.is(input.node.snapshot.error, error))) return;
-	input.node.controller?.abort();
-	input.node.controller = void 0;
-	input.node.gate = 2;
-	const version = ++input.node.version;
-	const key = input.node.snapshot.key;
-	publish(input, status === "pending" ? {
-		status,
-		version,
-		key,
-		value: input.node.snapshot.value
-	} : {
-		status,
-		version,
-		key,
-		error
-	});
-}
-function startAsyncComputed(input) {
-	input.node.controller?.abort();
-	input.node.gate = 0;
-	const controller = new AbortController();
-	const version = ++input.node.version;
-	input.node.controller = controller;
-	publish(input, {
-		status: "pending",
-		version,
-		key: input.key,
-		value: input.node.snapshot.value
-	});
-	const commit = (snapshot) => {
-		if (input.node.version !== version) return;
-		publish(input, snapshot);
-	};
-	const commitRejected = (error) => commit({
-		status: "rejected",
-		version,
-		key: input.key,
-		error
-	});
-	try {
-		Promise.resolve(input.node.run({
-			key: input.key,
-			signal: controller.signal,
-			read: input.readGraph
-		})).then((value) => commit({
-			status: "fulfilled",
-			version,
-			key: input.key,
-			value
-		}), commitRejected);
-	} catch (error) {
-		commitRejected(error);
-	}
-}
-function publish(input, snapshot) {
-	input.node.snapshot = snapshot;
-	input.markDirtyPath(input.node.graphNodeId, []);
-	input.scheduleFlush();
-}
-//#endregion
 //#region src/graph-computed.ts
 function createRuntimeComputedNodes(computedInput) {
 	const computedNodes = /* @__PURE__ */ new Map();
@@ -282,11 +89,13 @@ function createRuntimeComputedNodes(computedInput) {
 	});
 	return computedNodes;
 }
-function readComputedNode(computed, readGraph, path) {
+function readComputedNode(computed, readGraph, path, reconcile) {
 	const { compute } = computed;
 	if (computed.dirty && compute) {
+		const previous = computed.value;
 		computed.value = compute(readGraph);
 		computed.dirty = false;
+		reconcile?.(computed, previous);
 	}
 	return readPath(computed.value, path);
 }
@@ -296,7 +105,8 @@ function markComputedDirty(input) {
 	const computed = input.computedNodes.get(input.graphNodeId);
 	if (!computed?.compute) return;
 	computed.dirty = true;
-	input.dirtyPaths.push({
+	if (input.reconcile) input.reconcile.invalidateComputed(computed);
+	else input.dirtyPaths.push({
 		graphNodeId: input.graphNodeId,
 		path: []
 	});
@@ -447,7 +257,7 @@ function createRuntimeGraph(input) {
 	}
 	const readGraph = (graphNodeId, path = []) => {
 		const computed = computedNodes.get(graphNodeId);
-		if (computed?.compute) return readComputedNode(computed, readGraph, path);
+		if (computed?.compute) return readComputedNode(computed, readGraph, path, plane?.reconcileComputed);
 		const asyncComputed = asyncComputedNodes.get(graphNodeId);
 		if (asyncComputed) return readAsyncComputedNode(asyncComputed, path, () => demandAsyncComputed$1(asyncComputed));
 		const initialize = readInitializers.get(graphNodeId);
@@ -470,12 +280,14 @@ function createRuntimeGraph(input) {
 			graphNodeId,
 			path
 		});
+		plane?.recordWrite(graphNodeId, path);
 		markDirtyComputedDependencies({
 			graphNodeId,
 			path,
 			computedNodes,
 			asyncComputedNodes,
 			dirtyPaths,
+			reconcile: plane,
 			invalidateAsyncComputed: invalidateAsyncComputed$1
 		});
 	};
@@ -486,13 +298,23 @@ function createRuntimeGraph(input) {
 			flush();
 		});
 	};
+	const plane = input.reconcile?.({
+		cells,
+		computedNodes,
+		subscriptions,
+		dirtyPaths,
+		readGraph,
+		markDirtyPath,
+		scheduleFlush
+	});
 	const asyncComputedInput = () => ({
 		computedNodes,
 		asyncComputedNodes,
 		demandAsyncComputed: demandAsyncComputed$1,
 		readGraph,
 		markDirtyPath,
-		scheduleFlush
+		scheduleFlush,
+		reconcile: plane
 	});
 	const demandAsyncComputed$1 = (node) => demandAsyncComputed({
 		node,
@@ -520,6 +342,7 @@ function createRuntimeGraph(input) {
 		try {
 			try {
 				while (dirtyPaths.length > 0) {
+					plane?.recomputeSubscribed();
 					const pending = dirtyPaths.splice(0);
 					const ranSubscriptions = /* @__PURE__ */ new Set();
 					for (const subscription of subscriptions) {
@@ -530,6 +353,7 @@ function createRuntimeGraph(input) {
 					}
 				}
 			} finally {
+				plane?.settleBaselines();
 				flushing = false;
 			}
 			await notifyJournalListeners();
@@ -555,6 +379,7 @@ function createRuntimeGraph(input) {
 		write(write) {
 			const path = write.path ?? [];
 			const current = cells.get(write.graphNodeId);
+			if (plane?.commitDerived(write, path)) return;
 			if (Object.is(readPath(current, path), write.value)) return;
 			cells.set(write.graphNodeId, writePath(current, path, write.value));
 			markDirtyPath(write.graphNodeId, dirtyPathForGraphWrite(current, path));

package/dist/graph-async-Db6SqB5x.js

@@ -0,0 +1,197 @@
+//#region src/graph-core.ts
+function findLastSharedReturnProperty(properties, propertyName) {
+	if (!properties) return void 0;
+	for (let index = properties.length - 1; index >= 0; index--) {
+		const property = properties[index];
+		if (property?.name === propertyName) return property;
+	}
+}
+function readPath(value, path) {
+	let current = value;
+	for (const segment of path) {
+		if (current == null) return void 0;
+		current = current[segment];
+	}
+	return current;
+}
+function writePath(value, path, nextValue) {
+	if (path.length === 0) return nextValue;
+	const root = isObject(value) ? value : {};
+	let current = root;
+	for (const segment of path.slice(0, -1)) {
+		const child = current[segment];
+		if (!isObject(child)) current[segment] = {};
+		current = current[segment];
+	}
+	current[path[path.length - 1]] = nextValue;
+	return root;
+}
+function dirtyPathForGraphWrite(value, path) {
+	if (path[path.length - 1] !== "length") return path;
+	const parentPath = path.slice(0, -1);
+	const parent = readPath(value, parentPath);
+	if (!Array.isArray(parent)) return path;
+	return parentPath;
+}
+function deletePath(value, path) {
+	if (path.length === 0) throw new TypeError("Cannot delete a graph node root. Delete a property path instead.");
+	let current = value;
+	for (const segment of path.slice(0, -1)) {
+		if (current == null) throw new TypeError(`Cannot delete graph path "${path.join(".")}".`);
+		current = current[segment];
+	}
+	if (current == null) throw new TypeError(`Cannot delete graph path "${path.join(".")}".`);
+	if (!isObject(current)) return {
+		result: true,
+		mutated: false
+	};
+	const key = path[path.length - 1];
+	const hadProperty = Object.prototype.hasOwnProperty.call(current, key);
+	const result = delete current[key];
+	return {
+		result,
+		mutated: hadProperty && result
+	};
+}
+function pathsIntersect(a, b) {
+	return isPrefix(a, b) || isPrefix(b, a);
+}
+function isPrefix(prefix, value) {
+	if (prefix.length > value.length) return false;
+	return prefix.every((segment, index) => value[index] === segment);
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null;
+}
+//#endregion
+//#region src/graph-async.ts
+const ASYNC_SNAPSHOT_META_KEYS = new Set([
+	"status",
+	"version",
+	"key",
+	"error",
+	"value"
+]);
+function createRuntimeAsyncComputedNodes(asyncComputedInput) {
+	const asyncComputedNodes = /* @__PURE__ */ new Map();
+	for (const asyncComputed of asyncComputedInput ?? []) {
+		const initialSnapshot = asyncComputed.initialSnapshot ?? {
+			status: "idle",
+			version: 0
+		};
+		asyncComputedNodes.set(asyncComputed.graphNodeId, {
+			...asyncComputed,
+			gate: initialSnapshot.status === "pending" ? 1 : 0,
+			snapshot: initialSnapshot,
+			version: initialSnapshot.version
+		});
+	}
+	return asyncComputedNodes;
+}
+function readAsyncComputedNode(node, path, demand) {
+	demand();
+	const head = path[0];
+	if (head === void 0 || ASYNC_SNAPSHOT_META_KEYS.has(head)) return readPath(node.snapshot, path);
+	return readPath(node.snapshot.value, path);
+}
+function demandAsyncComputed(input) {
+	if (input.node.gate !== 1 && input.node.snapshot.status !== "idle") return;
+	advanceAsyncComputed(input);
+}
+function invalidateAsyncComputed(input) {
+	if (input.node.snapshot.status === "idle") return;
+	advanceAsyncComputed(input);
+}
+function advanceAsyncComputed(input) {
+	const visited = new Set([input.node.graphNodeId]);
+	let blocked;
+	const visit = (graphNodeId) => {
+		if (visited.has(graphNodeId)) return;
+		visited.add(graphNodeId);
+		const dependency = input.asyncComputedNodes.get(graphNodeId);
+		if (dependency) {
+			if (dependency.snapshot.status === "idle" || dependency.snapshot.status === "pending") {
+				blocked = dependency;
+				input.demandAsyncComputed(dependency);
+			} else if (!blocked && dependency.snapshot.status === "rejected") blocked = dependency;
+			return;
+		}
+		for (const dependency of input.computedNodes.get(graphNodeId)?.dependencies ?? []) visit(dependency.graphNodeId);
+	};
+	for (const dependency of input.node.dependencies) visit(dependency.graphNodeId);
+	if (blocked) {
+		commitDependencyBlock(input, blocked.snapshot.status === "rejected" ? "rejected" : "pending", blocked.snapshot.error);
+		return;
+	}
+	const nextKey = input.node.key(input.readGraph);
+	if (!input.node.gate && input.node.snapshot.status !== "idle" && Object.is(input.node.snapshot.key, nextKey)) return;
+	startAsyncComputed({
+		...input,
+		key: nextKey
+	});
+}
+function commitDependencyBlock(input, status, error) {
+	if (input.node.gate === 2 && (status === "pending" || input.node.snapshot.status === "rejected" && Object.is(input.node.snapshot.error, error))) return;
+	input.node.controller?.abort();
+	input.node.controller = void 0;
+	input.node.gate = 2;
+	const version = ++input.node.version;
+	const key = input.node.snapshot.key;
+	publish(input, status === "pending" ? {
+		status,
+		version,
+		key,
+		value: input.node.snapshot.value
+	} : {
+		status,
+		version,
+		key,
+		error
+	});
+}
+function startAsyncComputed(input) {
+	input.node.controller?.abort();
+	input.node.gate = 0;
+	const controller = new AbortController();
+	const version = ++input.node.version;
+	input.node.controller = controller;
+	publish(input, {
+		status: "pending",
+		version,
+		key: input.key,
+		value: input.node.snapshot.value
+	});
+	const commit = (snapshot) => {
+		if (input.node.version !== version) return;
+		publish(input, snapshot);
+	};
+	const commitRejected = (error) => commit({
+		status: "rejected",
+		version,
+		key: input.key,
+		error
+	});
+	try {
+		Promise.resolve(input.node.run({
+			key: input.key,
+			signal: controller.signal,
+			read: input.readGraph
+		})).then((value) => commit({
+			status: "fulfilled",
+			version,
+			key: input.key,
+			value
+		}), commitRejected);
+	} catch (error) {
+		commitRejected(error);
+	}
+}
+function publish(input, snapshot) {
+	const previous = input.node.snapshot;
+	input.node.snapshot = snapshot;
+	if (input.reconcile) input.reconcile.publishAsync(input.node, previous);
+	else input.markDirtyPath(input.node.graphNodeId, []);
+	input.scheduleFlush();
+}
+//#endregion
+export { readAsyncComputedNode as a, findLastSharedReturnProperty as c, writePath as d, invalidateAsyncComputed as i, pathsIntersect as l, createRuntimeAsyncComputedNodes as n, deletePath as o, demandAsyncComputed as r, dirtyPathForGraphWrite as s, ASYNC_SNAPSHOT_META_KEYS as t, readPath as u };

package/dist/graph-reconcile-DoBBfYsT.d.ts

@@ -0,0 +1,274 @@
+import { ProtocolStatePayload } from "@markless/serializer";
+
+//#region src/graph.d.ts
+type RuntimeGraphCell = {
+  readonly graphNodeId: string;
+  readonly value: unknown;
+  readonly readInitializer?: () => unknown;
+};
+type RuntimeGraphRead = (graphNodeId: string, path?: ReadonlyArray<string>) => unknown;
+type RuntimeGraphComputedDependency = {
+  readonly graphNodeId: string;
+  readonly path?: ReadonlyArray<string>;
+};
+type RuntimeGraphComputed = {
+  readonly graphNodeId: string;
+  readonly dependencies: ReadonlyArray<RuntimeGraphComputedDependency>;
+  readonly compute: (read: RuntimeGraphRead) => unknown; /** How re-derived values reconcile against the node's previous value. */
+  readonly reconcile?: RuntimeGraphReconcileOptions;
+};
+type RuntimeGraphComputedDependencyNode = Omit<RuntimeGraphComputed, 'compute'> & {
+  readonly compute?: never;
+};
+type RuntimeGraphAsyncSnapshot = {
+  readonly status: 'idle';
+  readonly version: 0;
+} | {
+  readonly status: 'pending';
+  readonly version: number;
+  readonly key: unknown;
+  readonly value?: unknown;
+} | {
+  readonly status: 'fulfilled';
+  readonly version: number;
+  readonly key: unknown;
+  readonly value: unknown;
+} | {
+  readonly status: 'rejected';
+  readonly version: number;
+  readonly key: unknown;
+  readonly error: unknown;
+};
+type RuntimeGraphAsyncComputed = {
+  readonly graphNodeId: string;
+  readonly dependencies: ReadonlyArray<RuntimeGraphComputedDependency>;
+  readonly initialSnapshot?: RuntimeGraphAsyncSnapshot;
+  readonly key: (read: RuntimeGraphRead) => unknown; /** How a fulfilled value reconciles against the previously published one. */
+  readonly reconcile?: RuntimeGraphReconcileOptions;
+  readonly run: (input: {
+    readonly key: unknown;
+    readonly signal: AbortSignal;
+    readonly read: RuntimeGraphRead;
+  }) => unknown | Promise<unknown>;
+};
+type DomJournalEntry = {
+  readonly type: 'setText';
+  readonly locator: string;
+  readonly value: unknown;
+} | {
+  readonly type: 'setAttr' | 'setProp';
+  readonly locator: string;
+  readonly name: string;
+  readonly value: unknown;
+} | {
+  readonly type: 'insertRange';
+  readonly locator: string;
+  readonly fragment: unknown;
+} | {
+  readonly type: 'removeRange';
+  readonly locator: string;
+} | {
+  readonly type: 'moveRange';
+  readonly locator: string;
+  readonly before: string;
+} | {
+  readonly type: 'runCleanup';
+  readonly locator: string;
+};
+type DomJournalResult = DomJournalEntry | ReadonlyArray<DomJournalEntry>;
+type DomJournalListener = (entries: ReadonlyArray<DomJournalEntry>) => void | Promise<void>;
+type RuntimeGraphInput = {
+  readonly cells: ReadonlyArray<RuntimeGraphCell>;
+  readonly computed?: ReadonlyArray<RuntimeGraphComputed | RuntimeGraphComputedDependencyNode>;
+  readonly asyncComputed?: ReadonlyArray<RuntimeGraphAsyncComputed>;
+  readonly sharedDefinitions?: ProtocolStatePayload['sharedDefinitions'];
+  /**
+   * Installs derived reconciliation, from
+   * `@markless/runtime/graph-reconcile`. Without it a computed invalidation
+   * dirties the whole node and an async commit dirties the whole snapshot.
+   */
+  readonly reconcile?: DerivedReconcilePlaneFactory;
+};
+type RuntimeGraphWrite = {
+  readonly graphNodeId: string;
+  readonly path?: ReadonlyArray<string>;
+  readonly value: unknown;
+};
+type RuntimeGraphSharedWrite = {
+  readonly definitionId: string;
+  readonly propertyName: string;
+  readonly path?: ReadonlyArray<string>;
+  readonly value: unknown;
+};
+type RuntimeGraphSharedPatchOperation = readonly [operation: 'set', path: ReadonlyArray<string>, value: unknown];
+type RuntimeGraphSharedPatch = {
+  readonly id: string;
+  readonly scope?: RuntimeSharedDefinition['scope'];
+  readonly version: number;
+  readonly patch: ReadonlyArray<RuntimeGraphSharedPatchOperation>;
+};
+type RuntimeGraphUpdate = {
+  readonly graphNodeId: string;
+  readonly path?: ReadonlyArray<string>;
+  readonly update: (value: unknown) => unknown;
+  readonly returnValue?: 'previous' | 'next';
+};
+type RuntimeGraphCall = {
+  readonly graphNodeId: string;
+  readonly path?: ReadonlyArray<string>;
+  readonly method: string;
+  readonly args?: ReadonlyArray<unknown>;
+};
+type RuntimeGraphDelete = {
+  readonly graphNodeId: string;
+  readonly path: ReadonlyArray<string>;
+};
+type RuntimeGraphSubscription = {
+  readonly id: string;
+  readonly graphNodeId: string;
+  readonly path?: ReadonlyArray<string>;
+  readonly run: (value: unknown) => DomJournalResult | void | Promise<DomJournalResult | void>;
+};
+type RuntimeGraph = {
+  readonly read: (graphNodeId: string, path?: ReadonlyArray<string>) => unknown; /** Available only in debug-enabled builds (`__MARKLESS_DEBUG_ENABLED__`). */
+  readonly peekAsyncSnapshot?: (graphNodeId: string) => RuntimeGraphAsyncSnapshot | undefined;
+  readonly readShared: (definitionId: string, propertyName: string, path?: ReadonlyArray<string>) => unknown;
+  readonly writeShared: (write: RuntimeGraphSharedWrite) => boolean;
+  readonly getSharedDefinition: (definitionId: string) => NonNullable<ProtocolStatePayload['sharedDefinitions']>[number] | undefined;
+  readonly listSharedDefinitions: () => NonNullable<ProtocolStatePayload['sharedDefinitions']>;
+  readonly takeSharedPatches: () => RuntimeGraphSharedPatch[];
+  readonly applySharedPatch: (patch: RuntimeGraphSharedPatch) => boolean;
+  readonly write: (write: RuntimeGraphWrite) => void;
+  readonly update: (update: RuntimeGraphUpdate) => unknown;
+  readonly call: (call: RuntimeGraphCall) => unknown;
+  readonly delete: (deletion: RuntimeGraphDelete) => boolean;
+  readonly subscribe: (subscription: RuntimeGraphSubscription) => () => void;
+  readonly subscribeJournal: (listener: DomJournalListener) => () => void;
+  readonly flush: () => Promise<void>;
+  readonly takeJournal: () => DomJournalEntry[];
+};
+type RuntimeSharedDefinition = NonNullable<ProtocolStatePayload['sharedDefinitions']>[number];
+declare function createRuntimeGraph(input: RuntimeGraphInput): RuntimeGraph;
+//#endregion
+//#region src/graph-scheduler.d.ts
+type DirtyPath = {
+  readonly graphNodeId: string;
+  readonly path: ReadonlyArray<string>;
+};
+//#endregion
+//#region src/graph-computed.d.ts
+type RuntimeComputedNode = Omit<RuntimeGraphComputed, 'compute'> & {
+  readonly compute?: RuntimeGraphComputed['compute'];
+  dirty: boolean;
+  value: unknown;
+};
+//#endregion
+//#region src/graph-async.d.ts
+type RuntimeAsyncComputedNode = RuntimeGraphAsyncComputed & {
+  controller?: AbortController;
+  gate: number;
+  snapshot: RuntimeGraphAsyncSnapshot;
+  version: number;
+};
+//#endregion
+//#region src/graph-reconcile.d.ts
+/**
+ * One array inside a derived value that reconciles by key instead of by
+ * element identity. `path` names the array (`[]` is the derived value itself)
+ * and `keyPath` is read on each element to get its identity.
+ */
+type RuntimeGraphReconcileKey = {
+  readonly path: ReadonlyArray<string>;
+  readonly keyPath: ReadonlyArray<string>;
+};
+/** Reconcile options carried by a computed or async computed graph node. */
+type RuntimeGraphReconcileOptions = {
+  readonly keyed?: ReadonlyArray<RuntimeGraphReconcileKey>;
+};
+/**
+ * Objects a state write touched during the current flush, mapped to the paths
+ * written beneath them. State writes mutate objects in place, so a derived
+ * value that still holds the same object reference is not unchanged when that
+ * object was written through. See `diffDerivedValue`.
+ */
+type WriteTouchedRecord = ReadonlyMap<object, ReadonlyArray<ReadonlyArray<string>>>;
+type DiffDerivedValueInput = {
+  readonly previous: unknown;
+  readonly next: unknown;
+  readonly keyed?: ReadonlyArray<RuntimeGraphReconcileKey>;
+  readonly touched?: WriteTouchedRecord;
+  readonly baselineStale?: boolean;
+  /**
+   * What an `Object.is`-identical plain object or array below the root means.
+   * `'unchanged'` (the default) trusts identity, which is sound for a caller
+   * that also supplies the write-touched record of the same flush.
+   * `'unknown'` is for a caller with no such record — the async commit — and
+   * reports every identical container at its own path instead.
+   */
+  readonly identicalContainers?: 'unchanged' | 'unknown';
+};
+/**
+ * Compares a derived value with the previous value of the same graph node and
+ * reports the graph paths that changed. It never mutates either value: the
+ * caller replaces the node's value pointer and invalidates the reported paths.
+ *
+ * Rules (specs/framework/03-state-graph.md "Derived reconciliation"):
+ * - identical references are unchanged, unless a write touched that object in
+ *   this flush, in which case the touched remainders are reported; the same
+ *   holds when only the previous value held the written object, because an
+ *   in-place write left that baseline already carrying the new field;
+ * - primitives, functions, `Map`, `Set`, `Date` and class instances are leaves;
+ * - plain objects reconcile field by field;
+ * - arrays reconcile by declared key, otherwise by element identity, and a
+ *   length or structural mismatch reports the array's own path;
+ * - a declared key that is missing or duplicated on either side falls back to
+ *   structural reconciliation for that array, which reports the array's own
+ *   path: keys are never matched partially and an index is never identity;
+ * - a missing baseline (first value, or a value whose write-touched record was
+ *   already cleared) reports the whole node.
+ *
+ * `identicalContainers: 'unknown'` is for a caller that has no write-touched
+ * record for the flush that produced the new value, so identity below the root
+ * proves nothing: every `Object.is`-identical plain object or array met below
+ * the root is reported at its own path and is not walked into. An identical
+ * root still reports nothing — nothing narrower is known about it, and the
+ * caller decides what a wholly identical value means — and identical
+ * primitives and other leaves stay unchanged. The default, `'unchanged'`,
+ * trusts identity as above.
+ */
+declare function diffDerivedValue(input: DiffDerivedValueInput): ReadonlyArray<ReadonlyArray<string>>;
+/** Plain objects and arrays are the only values reconciliation walks into. */
+declare function isDiffableContainer(value: unknown): value is object;
+declare function samePath(a: ReadonlyArray<string>, b: ReadonlyArray<string>): boolean;
+/**
+ * What the plane needs from the graph it is installed in. The graph passes its
+ * own internals; nothing here is part of the public runtime surface.
+ */
+type DerivedReconcileInternals = {
+  readonly cells: Map<string, unknown>;
+  readonly computedNodes: ReadonlyMap<string, RuntimeComputedNode>;
+  readonly subscriptions: ReadonlyArray<RuntimeGraphSubscription>;
+  readonly dirtyPaths: DirtyPath[];
+  readonly readGraph: RuntimeGraphRead;
+  readonly markDirtyPath: (graphNodeId: string, path: ReadonlyArray<string>) => void;
+  readonly scheduleFlush: () => void;
+};
+/**
+ * Derived reconciliation as a plug-in plane. The core graph carries the hook
+ * points and nothing else, so an app that never installs the plane does not
+ * load this module and its computed invalidations dirty the whole node the way
+ * they did before reconciliation existed.
+ */
+type DerivedReconcilePlane = {
+  /** Records the objects a state write mutated in place during this flush. */readonly recordWrite: (graphNodeId: string, path: ReadonlyArray<string>) => void; /** A dependency write invalidated this computed; its paths are not known yet. */
+  readonly invalidateComputed: (computed: RuntimeComputedNode) => void; /** Reports the paths a just-recomputed value moved, and wakes their subscribers. */
+  readonly reconcileComputed: (computed: RuntimeComputedNode, previous: unknown) => void; /** Commits a whole derived value onto a cell-backed computed node. */
+  readonly commitDerived: (write: RuntimeGraphWrite, path: ReadonlyArray<string>) => boolean; /** Dirties the paths an async snapshot commit changed. */
+  readonly publishAsync: (node: RuntimeAsyncComputedNode, previous: RuntimeGraphAsyncSnapshot) => void; /** Flush-pass start: recompute the dirty computeds something is subscribed to. */
+  readonly recomputeSubscribed: () => void; /** Flush end: drop the per-flush record and mark the baselines it leaves stale. */
+  readonly settleBaselines: () => void;
+};
+type DerivedReconcilePlaneFactory = (internals: DerivedReconcileInternals) => DerivedReconcilePlane;
+declare const createDerivedReconcilePlane: DerivedReconcilePlaneFactory;
+//#endregion
+export { RuntimeGraphUpdate as A, RuntimeGraphDelete as C, RuntimeGraphSharedPatchOperation as D, RuntimeGraphSharedPatch as E, createRuntimeGraph as M, RuntimeGraphSharedWrite as O, RuntimeGraphComputedDependencyNode as S, RuntimeGraphRead as T, RuntimeGraphAsyncSnapshot as _, RuntimeGraphReconcileKey as a, RuntimeGraphComputed as b, createDerivedReconcilePlane as c, samePath as d, DomJournalEntry as f, RuntimeGraphAsyncComputed as g, RuntimeGraph as h, DiffDerivedValueInput as i, RuntimeGraphWrite as j, RuntimeGraphSubscription as k, diffDerivedValue as l, DomJournalResult as m, DerivedReconcilePlane as n, RuntimeGraphReconcileOptions as o, DomJournalListener as p, DerivedReconcilePlaneFactory as r, WriteTouchedRecord as s, DerivedReconcileInternals as t, isDiffableContainer as u, RuntimeGraphCall as v, RuntimeGraphInput as w, RuntimeGraphComputedDependency as x, RuntimeGraphCell as y };

package/dist/graph-reconcile.d.ts

@@ -0,0 +1,2 @@
+import { a as RuntimeGraphReconcileKey, c as createDerivedReconcilePlane, d as samePath, i as DiffDerivedValueInput, l as diffDerivedValue, n as DerivedReconcilePlane, o as RuntimeGraphReconcileOptions, r as DerivedReconcilePlaneFactory, s as WriteTouchedRecord, t as DerivedReconcileInternals, u as isDiffableContainer } from "./graph-reconcile-DoBBfYsT.js";
+export { DerivedReconcileInternals, DerivedReconcilePlane, DerivedReconcilePlaneFactory, DiffDerivedValueInput, RuntimeGraphReconcileKey, RuntimeGraphReconcileOptions, WriteTouchedRecord, createDerivedReconcilePlane, diffDerivedValue, isDiffableContainer, samePath };

package/dist/graph-reconcile.js

@@ -0,0 +1,324 @@
+import { t as ASYNC_SNAPSHOT_META_KEYS, u as readPath } from "./graph-async-Db6SqB5x.js";
+//#region src/graph-reconcile.ts
+const WHOLE_NODE = Object.freeze([Object.freeze([])]);
+/**
+* Compares a derived value with the previous value of the same graph node and
+* reports the graph paths that changed. It never mutates either value: the
+* caller replaces the node's value pointer and invalidates the reported paths.
+*
+* Rules (specs/framework/03-state-graph.md "Derived reconciliation"):
+* - identical references are unchanged, unless a write touched that object in
+*   this flush, in which case the touched remainders are reported; the same
+*   holds when only the previous value held the written object, because an
+*   in-place write left that baseline already carrying the new field;
+* - primitives, functions, `Map`, `Set`, `Date` and class instances are leaves;
+* - plain objects reconcile field by field;
+* - arrays reconcile by declared key, otherwise by element identity, and a
+*   length or structural mismatch reports the array's own path;
+* - a declared key that is missing or duplicated on either side falls back to
+*   structural reconciliation for that array, which reports the array's own
+*   path: keys are never matched partially and an index is never identity;
+* - a missing baseline (first value, or a value whose write-touched record was
+*   already cleared) reports the whole node.
+*
+* `identicalContainers: 'unknown'` is for a caller that has no write-touched
+* record for the flush that produced the new value, so identity below the root
+* proves nothing: every `Object.is`-identical plain object or array met below
+* the root is reported at its own path and is not walked into. An identical
+* root still reports nothing — nothing narrower is known about it, and the
+* caller decides what a wholly identical value means — and identical
+* primitives and other leaves stay unchanged. The default, `'unchanged'`,
+* trusts identity as above.
+*/
+function diffDerivedValue(input) {
+	if (input.baselineStale) return WHOLE_NODE;
+	if (input.previous === void 0 && input.next !== void 0) return WHOLE_NODE;
+	const changed = [];
+	const active = /* @__PURE__ */ new Map();
+	function emitTouched(value, path) {
+		if (!input.touched || typeof value !== "object" || value === null) return;
+		const remainders = input.touched.get(value);
+		if (!remainders) return;
+		for (const remaining of remainders) {
+			const touchedPath = [...path, ...remaining];
+			if (changed.some((entry) => samePath(entry, touchedPath))) continue;
+			changed.push(touchedPath);
+		}
+	}
+	/**
+	* What an identical reference met at `path` reports. With a write-touched
+	* record identity means unchanged apart from the recorded remainders; in
+	* `'unknown'` mode there is no such record, so an identical container below
+	* the root is reported whole rather than trusted or walked into.
+	*/
+	function reportIdentical(value, path) {
+		if (input.identicalContainers === "unknown" && path.length > 0 && isDiffableContainer(value)) {
+			changed.push(path);
+			return;
+		}
+		emitTouched(value, path);
+	}
+	function keyedFor(path) {
+		return input.keyed?.find((entry) => samePath(entry.path, path));
+	}
+	function walkArray(previous, next, path) {
+		const mark = changed.length;
+		const fallBackToStructural = () => {
+			changed.length = mark;
+			changed.push(path);
+		};
+		if (previous.length !== next.length) {
+			fallBackToStructural();
+			return;
+		}
+		const keyed = keyedFor(path);
+		if (keyed) {
+			const fault = keyFault(previous, keyed) ?? keyFault(next, keyed);
+			if (fault) {
+				reportKeyFault(path, keyed, fault);
+				fallBackToStructural();
+				return;
+			}
+		}
+		for (let index = 0; index < next.length; index++) {
+			const previousItem = previous[index];
+			const nextItem = next[index];
+			const itemPath = [...path, String(index)];
+			if (Object.is(previousItem, nextItem)) {
+				reportIdentical(nextItem, itemPath);
+				continue;
+			}
+			if (keyed && isDiffableContainer(previousItem) && isDiffableContainer(nextItem)) {
+				const previousKey = readPath(previousItem, keyed.keyPath);
+				const nextKey = readPath(nextItem, keyed.keyPath);
+				if (!Object.is(previousKey, nextKey)) {
+					fallBackToStructural();
+					return;
+				}
+				walk(previousItem, nextItem, itemPath);
+				continue;
+			}
+			changed.push(itemPath);
+		}
+	}
+	function walkObject(previous, next, path) {
+		for (const key of new Set([...Object.keys(previous), ...Object.keys(next)])) {
+			const keyPath = [...path, key];
+			const inPrevious = Object.prototype.hasOwnProperty.call(previous, key);
+			const inNext = Object.prototype.hasOwnProperty.call(next, key);
+			if (!inPrevious || !inNext) {
+				changed.push(keyPath);
+				continue;
+			}
+			walk(previous[key], next[key], keyPath);
+		}
+	}
+	function walk(previous, next, path) {
+		if (Object.is(previous, next)) {
+			reportIdentical(next, path);
+			return;
+		}
+		if (!isDiffableContainer(previous) || !isDiffableContainer(next)) {
+			changed.push(path);
+			return;
+		}
+		const previousIsArray = Array.isArray(previous);
+		if (previousIsArray !== Array.isArray(next)) {
+			changed.push(path);
+			return;
+		}
+		let pairedWithPrevious = active.get(previous);
+		if (pairedWithPrevious?.has(next)) return;
+		if (!pairedWithPrevious) {
+			pairedWithPrevious = /* @__PURE__ */ new Set();
+			active.set(previous, pairedWithPrevious);
+		}
+		pairedWithPrevious.add(next);
+		try {
+			if (previousIsArray) walkArray(previous, next, path);
+			else walkObject(previous, next, path);
+		} finally {
+			pairedWithPrevious.delete(next);
+			if (pairedWithPrevious.size === 0) active.delete(previous);
+		}
+		emitTouched(previous, path);
+	}
+	walk(input.previous, input.next, []);
+	return changed;
+}
+/**
+* Reads the declared key of every element and reports the first element that
+* has no key or repeats one already used in the same array. Reads only; it
+* never touches the elements it inspects.
+*/
+function keyFault(items, keyed) {
+	const seen = /* @__PURE__ */ new Set();
+	for (let index = 0; index < items.length; index++) {
+		const key = readPath(items[index], keyed.keyPath);
+		if (key === void 0) return {
+			reason: "missing",
+			index,
+			key
+		};
+		if (seen.has(key)) return {
+			reason: "duplicate",
+			index,
+			key
+		};
+		seen.add(key);
+	}
+}
+/**
+* Names the array and the offending key in debug-enabled builds. Keyed
+* reconciliation degrading to structural reconciliation is silent in
+* production — the result is still correct, only coarser.
+*/
+function reportKeyFault(path, keyed, fault) {
+	if (typeof __MARKLESS_DEBUG_ENABLED__ === "undefined" || !__MARKLESS_DEBUG_ENABLED__) return;
+	const array = path.length === 0 ? "the derived value" : `derived path ${path.join(".")}`;
+	const keyPath = keyed.keyPath.length === 0 ? "the element itself" : keyed.keyPath.join(".");
+	const cause = fault.reason === "missing" ? `element ${fault.index} has no key at ${keyPath}` : `key ${describeKey(fault.key)} at ${keyPath} is used by more than one element (element ${fault.index})`;
+	console.warn(`markless: reconciling ${array} by key is not possible because ${cause}; falling back to structural reconciliation for that array.`);
+}
+function describeKey(key) {
+	return typeof key === "string" ? JSON.stringify(key) : String(key);
+}
+/** Plain objects and arrays are the only values reconciliation walks into. */
+function isDiffableContainer(value) {
+	if (typeof value !== "object" || value === null) return false;
+	if (Array.isArray(value)) return true;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+function samePath(a, b) {
+	return a.length === b.length && a.every((segment, index) => b[index] === segment);
+}
+const createDerivedReconcilePlane = (internals) => {
+	const { cells, computedNodes, subscriptions, dirtyPaths } = internals;
+	const { readGraph, markDirtyPath, scheduleFlush } = internals;
+	const writeTouched = /* @__PURE__ */ new Map();
+	const dirtyComputed = /* @__PURE__ */ new Set();
+	const invalidated = /* @__PURE__ */ new Set();
+	const baselineStale = /* @__PURE__ */ new Set();
+	const changedPaths = (computed, previous, next) => diffDerivedValue({
+		previous,
+		next,
+		keyed: computed.reconcile?.keyed,
+		touched: writeTouched,
+		baselineStale: baselineStale.has(computed)
+	});
+	return {
+		recordWrite(graphNodeId, path) {
+			if (computedNodes.size === 0 || computedNodes.has(graphNodeId)) return;
+			let container = cells.get(graphNodeId);
+			for (let depth = 0; depth <= path.length; depth++) {
+				if (typeof container === "object" && container !== null) {
+					const remainders = writeTouched.get(container) ?? [];
+					const remaining = path.slice(depth);
+					if (!remainders.some((entry) => samePath(entry, remaining))) {
+						remainders.push(remaining);
+						writeTouched.set(container, remainders);
+					}
+				}
+				if (depth === path.length) break;
+				container = readPath(container, [path[depth]]);
+			}
+		},
+		invalidateComputed(computed) {
+			invalidated.add(computed);
+			dirtyComputed.add(computed);
+		},
+		reconcileComputed(computed, previous) {
+			const changed = invalidated.has(computed) ? changedPaths(computed, previous, computed.value) : [];
+			invalidated.delete(computed);
+			baselineStale.delete(computed);
+			if (changed.length === 0) return;
+			for (const path of changed) dirtyPaths.push({
+				graphNodeId: computed.graphNodeId,
+				path
+			});
+			scheduleFlush();
+		},
+		commitDerived(write, path) {
+			const graphNodeId = write.graphNodeId;
+			const computed = computedNodes.get(graphNodeId);
+			if (!computed || computed.compute || path.length > 0) return false;
+			const changed = changedPaths(computed, cells.get(graphNodeId), write.value);
+			cells.set(graphNodeId, write.value);
+			baselineStale.delete(computed);
+			if (changed.length === 0) return true;
+			for (const changedPath of changed) markDirtyPath(graphNodeId, changedPath);
+			scheduleFlush();
+			return true;
+		},
+		publishAsync(node, previous) {
+			for (const path of asyncCommitPaths(node, previous, node.snapshot)) markDirtyPath(node.graphNodeId, path);
+		},
+		recomputeSubscribed() {
+			for (const computed of Array.from(dirtyComputed)) {
+				if (!computed.dirty) {
+					dirtyComputed.delete(computed);
+					continue;
+				}
+				if (!subscriptions.some((subscription) => subscription.graphNodeId === computed.graphNodeId)) continue;
+				dirtyComputed.delete(computed);
+				readGraph(computed.graphNodeId);
+			}
+		},
+		settleBaselines() {
+			for (const computed of dirtyComputed) if (computed.dirty) baselineStale.add(computed);
+			dirtyComputed.clear();
+			writeTouched.clear();
+		}
+	};
+};
+/**
+* The graph paths a snapshot commit changed. Snapshot metadata is addressed as
+* `status`/`version`/`key`/`error`; the fulfilled value is addressed both as
+* `value.<path>` and, for compiled reads, as the bare `<path>` (see
+* `readAsyncComputedNode`), so a changed value path is reported in both
+* coordinate systems.
+*
+* A value commit compares structurally only. Unlike a sync computed, an async
+* snapshot can land long after the flush that wrote the state it embeds, so the
+* per-flush write-touched record is already cleared by the time it publishes.
+* Identity below the root therefore proves nothing here: a runner that returns
+* live state objects publishes the very rows a later write mutated in place,
+* and treating them as unchanged would silently withhold that write from the
+* subscribers of those paths. The diff runs in `identicalContainers: 'unknown'`
+* mode, which reports each identical nested container at its path; a value
+* rebuilt from fresh objects still reconciles field by field, and an identical
+* root is handled by the whole-node rule below.
+*/
+function asyncCommitPaths(node, previous, next) {
+	const paths = [];
+	if (previous.status !== next.status) paths.push(["status"]);
+	if (previous.version !== next.version) paths.push(["version"]);
+	if (!Object.is(snapshotField(previous, "key"), snapshotField(next, "key"))) paths.push(["key"]);
+	if (!Object.is(snapshotField(previous, "error"), snapshotField(next, "error"))) paths.push(["error"]);
+	if (next.status === "pending") return paths;
+	const previousValue = snapshotField(previous, "value");
+	const nextValue = snapshotField(next, "value");
+	if (!Object.is(previousValue, nextValue) && isDiffableContainer(previousValue) && isDiffableContainer(nextValue)) {
+		const changed = diffDerivedValue({
+			previous: previousValue,
+			next: nextValue,
+			keyed: node.reconcile?.keyed,
+			identicalContainers: "unknown"
+		});
+		if (changed.every((path) => path.length > 0)) {
+			for (const path of changed) {
+				paths.push(["value", ...path]);
+				if (!ASYNC_SNAPSHOT_META_KEYS.has(path[0])) paths.push([...path]);
+			}
+			return paths;
+		}
+	}
+	paths.push([]);
+	return paths;
+}
+function snapshotField(snapshot, field) {
+	return snapshot[field];
+}
+//#endregion
+export { createDerivedReconcilePlane, diffDerivedValue, isDiffableContainer, samePath };

package/dist/graph.d.ts

@@ -1,145 +1,2 @@
-import { ProtocolStatePayload } from "@markless/serializer";
-
-//#region src/graph.d.ts
-type RuntimeGraphCell = {
-  readonly graphNodeId: string;
-  readonly value: unknown;
-  readonly readInitializer?: () => unknown;
-};
-type RuntimeGraphRead = (graphNodeId: string, path?: ReadonlyArray<string>) => unknown;
-type RuntimeGraphComputedDependency = {
-  readonly graphNodeId: string;
-  readonly path?: ReadonlyArray<string>;
-};
-type RuntimeGraphComputed = {
-  readonly graphNodeId: string;
-  readonly dependencies: ReadonlyArray<RuntimeGraphComputedDependency>;
-  readonly compute: (read: RuntimeGraphRead) => unknown;
-};
-type RuntimeGraphComputedDependencyNode = Omit<RuntimeGraphComputed, 'compute'> & {
-  readonly compute?: never;
-};
-type RuntimeGraphAsyncSnapshot = {
-  readonly status: 'idle';
-  readonly version: 0;
-} | {
-  readonly status: 'pending';
-  readonly version: number;
-  readonly key: unknown;
-  readonly value?: unknown;
-} | {
-  readonly status: 'fulfilled';
-  readonly version: number;
-  readonly key: unknown;
-  readonly value: unknown;
-} | {
-  readonly status: 'rejected';
-  readonly version: number;
-  readonly key: unknown;
-  readonly error: unknown;
-};
-type RuntimeGraphAsyncComputed = {
-  readonly graphNodeId: string;
-  readonly dependencies: ReadonlyArray<RuntimeGraphComputedDependency>;
-  readonly initialSnapshot?: RuntimeGraphAsyncSnapshot;
-  readonly key: (read: RuntimeGraphRead) => unknown;
-  readonly run: (input: {
-    readonly key: unknown;
-    readonly signal: AbortSignal;
-    readonly read: RuntimeGraphRead;
-  }) => unknown | Promise<unknown>;
-};
-type DomJournalEntry = {
-  readonly type: 'setText';
-  readonly locator: string;
-  readonly value: unknown;
-} | {
-  readonly type: 'setAttr' | 'setProp';
-  readonly locator: string;
-  readonly name: string;
-  readonly value: unknown;
-} | {
-  readonly type: 'insertRange';
-  readonly locator: string;
-  readonly fragment: unknown;
-} | {
-  readonly type: 'removeRange';
-  readonly locator: string;
-} | {
-  readonly type: 'moveRange';
-  readonly locator: string;
-  readonly before: string;
-} | {
-  readonly type: 'runCleanup';
-  readonly locator: string;
-};
-type DomJournalResult = DomJournalEntry | ReadonlyArray<DomJournalEntry>;
-type DomJournalListener = (entries: ReadonlyArray<DomJournalEntry>) => void | Promise<void>;
-type RuntimeGraphInput = {
-  readonly cells: ReadonlyArray<RuntimeGraphCell>;
-  readonly computed?: ReadonlyArray<RuntimeGraphComputed | RuntimeGraphComputedDependencyNode>;
-  readonly asyncComputed?: ReadonlyArray<RuntimeGraphAsyncComputed>;
-  readonly sharedDefinitions?: ProtocolStatePayload['sharedDefinitions'];
-};
-type RuntimeGraphWrite = {
-  readonly graphNodeId: string;
-  readonly path?: ReadonlyArray<string>;
-  readonly value: unknown;
-};
-type RuntimeGraphSharedWrite = {
-  readonly definitionId: string;
-  readonly propertyName: string;
-  readonly path?: ReadonlyArray<string>;
-  readonly value: unknown;
-};
-type RuntimeGraphSharedPatchOperation = readonly [operation: 'set', path: ReadonlyArray<string>, value: unknown];
-type RuntimeGraphSharedPatch = {
-  readonly id: string;
-  readonly scope?: RuntimeSharedDefinition['scope'];
-  readonly version: number;
-  readonly patch: ReadonlyArray<RuntimeGraphSharedPatchOperation>;
-};
-type RuntimeGraphUpdate = {
-  readonly graphNodeId: string;
-  readonly path?: ReadonlyArray<string>;
-  readonly update: (value: unknown) => unknown;
-  readonly returnValue?: 'previous' | 'next';
-};
-type RuntimeGraphCall = {
-  readonly graphNodeId: string;
-  readonly path?: ReadonlyArray<string>;
-  readonly method: string;
-  readonly args?: ReadonlyArray<unknown>;
-};
-type RuntimeGraphDelete = {
-  readonly graphNodeId: string;
-  readonly path: ReadonlyArray<string>;
-};
-type RuntimeGraphSubscription = {
-  readonly id: string;
-  readonly graphNodeId: string;
-  readonly path?: ReadonlyArray<string>;
-  readonly run: (value: unknown) => DomJournalResult | void | Promise<DomJournalResult | void>;
-};
-type RuntimeGraph = {
-  readonly read: (graphNodeId: string, path?: ReadonlyArray<string>) => unknown; /** Available only in debug-enabled builds (`__MARKLESS_DEBUG_ENABLED__`). */
-  readonly peekAsyncSnapshot?: (graphNodeId: string) => RuntimeGraphAsyncSnapshot | undefined;
-  readonly readShared: (definitionId: string, propertyName: string, path?: ReadonlyArray<string>) => unknown;
-  readonly writeShared: (write: RuntimeGraphSharedWrite) => boolean;
-  readonly getSharedDefinition: (definitionId: string) => NonNullable<ProtocolStatePayload['sharedDefinitions']>[number] | undefined;
-  readonly listSharedDefinitions: () => NonNullable<ProtocolStatePayload['sharedDefinitions']>;
-  readonly takeSharedPatches: () => RuntimeGraphSharedPatch[];
-  readonly applySharedPatch: (patch: RuntimeGraphSharedPatch) => boolean;
-  readonly write: (write: RuntimeGraphWrite) => void;
-  readonly update: (update: RuntimeGraphUpdate) => unknown;
-  readonly call: (call: RuntimeGraphCall) => unknown;
-  readonly delete: (deletion: RuntimeGraphDelete) => boolean;
-  readonly subscribe: (subscription: RuntimeGraphSubscription) => () => void;
-  readonly subscribeJournal: (listener: DomJournalListener) => () => void;
-  readonly flush: () => Promise<void>;
-  readonly takeJournal: () => DomJournalEntry[];
-};
-type RuntimeSharedDefinition = NonNullable<ProtocolStatePayload['sharedDefinitions']>[number];
-declare function createRuntimeGraph(input: RuntimeGraphInput): RuntimeGraph;
-//#endregion
-export { DomJournalEntry, DomJournalListener, DomJournalResult, RuntimeGraph, RuntimeGraphAsyncComputed, RuntimeGraphAsyncSnapshot, RuntimeGraphCall, RuntimeGraphCell, RuntimeGraphComputed, RuntimeGraphComputedDependency, RuntimeGraphComputedDependencyNode, RuntimeGraphDelete, RuntimeGraphInput, RuntimeGraphRead, RuntimeGraphSharedPatch, RuntimeGraphSharedPatchOperation, RuntimeGraphSharedWrite, RuntimeGraphSubscription, RuntimeGraphUpdate, RuntimeGraphWrite, createRuntimeGraph };
+import { A as RuntimeGraphUpdate, C as RuntimeGraphDelete, D as RuntimeGraphSharedPatchOperation, E as RuntimeGraphSharedPatch, M as createRuntimeGraph, O as RuntimeGraphSharedWrite, S as RuntimeGraphComputedDependencyNode, T as RuntimeGraphRead, _ as RuntimeGraphAsyncSnapshot, a as RuntimeGraphReconcileKey, b as RuntimeGraphComputed, f as DomJournalEntry, g as RuntimeGraphAsyncComputed, h as RuntimeGraph, i as DiffDerivedValueInput, j as RuntimeGraphWrite, k as RuntimeGraphSubscription, m as DomJournalResult, n as DerivedReconcilePlane, o as RuntimeGraphReconcileOptions, p as DomJournalListener, r as DerivedReconcilePlaneFactory, s as WriteTouchedRecord, t as DerivedReconcileInternals, v as RuntimeGraphCall, w as RuntimeGraphInput, x as RuntimeGraphComputedDependency, y as RuntimeGraphCell } from "./graph-reconcile-DoBBfYsT.js";
+export { DerivedReconcileInternals, DerivedReconcilePlane, DerivedReconcilePlaneFactory, DiffDerivedValueInput, DomJournalEntry, DomJournalListener, DomJournalResult, RuntimeGraph, RuntimeGraphAsyncComputed, RuntimeGraphAsyncSnapshot, RuntimeGraphCall, RuntimeGraphCell, RuntimeGraphComputed, RuntimeGraphComputedDependency, RuntimeGraphComputedDependencyNode, RuntimeGraphDelete, RuntimeGraphInput, RuntimeGraphRead, RuntimeGraphReconcileKey, RuntimeGraphReconcileOptions, RuntimeGraphSharedPatch, RuntimeGraphSharedPatchOperation, RuntimeGraphSharedWrite, RuntimeGraphSubscription, RuntimeGraphUpdate, RuntimeGraphWrite, WriteTouchedRecord, createRuntimeGraph };

package/dist/graph.js

@@ -1,2 +1,2 @@
-import { t as createRuntimeGraph } from "./graph-DoSjSC5T.js";
+import { t as createRuntimeGraph } from "./graph-B77v_FUC.js";
 export { createRuntimeGraph };

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-import { DomJournalEntry, DomJournalListener, DomJournalResult, RuntimeGraph, RuntimeGraphAsyncComputed, RuntimeGraphAsyncSnapshot, RuntimeGraphCall, RuntimeGraphCell, RuntimeGraphComputed, RuntimeGraphComputedDependency, RuntimeGraphComputedDependencyNode, RuntimeGraphDelete, RuntimeGraphInput, RuntimeGraphRead, RuntimeGraphSharedPatch, RuntimeGraphSharedPatchOperation, RuntimeGraphSharedWrite, RuntimeGraphSubscription, RuntimeGraphUpdate, RuntimeGraphWrite, createRuntimeGraph } from "./graph.js";
-export { DomJournalEntry, DomJournalListener, DomJournalResult, RuntimeGraph, RuntimeGraphAsyncComputed, RuntimeGraphAsyncSnapshot, RuntimeGraphCall, RuntimeGraphCell, RuntimeGraphComputed, RuntimeGraphComputedDependency, RuntimeGraphComputedDependencyNode, RuntimeGraphDelete, RuntimeGraphInput, RuntimeGraphRead, RuntimeGraphSharedPatch, RuntimeGraphSharedPatchOperation, RuntimeGraphSharedWrite, RuntimeGraphSubscription, RuntimeGraphUpdate, RuntimeGraphWrite, createRuntimeGraph };
+import { A as RuntimeGraphUpdate, C as RuntimeGraphDelete, D as RuntimeGraphSharedPatchOperation, E as RuntimeGraphSharedPatch, M as createRuntimeGraph, O as RuntimeGraphSharedWrite, S as RuntimeGraphComputedDependencyNode, T as RuntimeGraphRead, _ as RuntimeGraphAsyncSnapshot, a as RuntimeGraphReconcileKey, b as RuntimeGraphComputed, f as DomJournalEntry, g as RuntimeGraphAsyncComputed, h as RuntimeGraph, i as DiffDerivedValueInput, j as RuntimeGraphWrite, k as RuntimeGraphSubscription, m as DomJournalResult, n as DerivedReconcilePlane, o as RuntimeGraphReconcileOptions, p as DomJournalListener, r as DerivedReconcilePlaneFactory, s as WriteTouchedRecord, t as DerivedReconcileInternals, v as RuntimeGraphCall, w as RuntimeGraphInput, x as RuntimeGraphComputedDependency, y as RuntimeGraphCell } from "./graph-reconcile-DoBBfYsT.js";
+export { DerivedReconcileInternals, DerivedReconcilePlane, DerivedReconcilePlaneFactory, DiffDerivedValueInput, DomJournalEntry, DomJournalListener, DomJournalResult, RuntimeGraph, RuntimeGraphAsyncComputed, RuntimeGraphAsyncSnapshot, RuntimeGraphCall, RuntimeGraphCell, RuntimeGraphComputed, RuntimeGraphComputedDependency, RuntimeGraphComputedDependencyNode, RuntimeGraphDelete, RuntimeGraphInput, RuntimeGraphRead, RuntimeGraphReconcileKey, RuntimeGraphReconcileOptions, RuntimeGraphSharedPatch, RuntimeGraphSharedPatchOperation, RuntimeGraphSharedWrite, RuntimeGraphSubscription, RuntimeGraphUpdate, RuntimeGraphWrite, WriteTouchedRecord, createRuntimeGraph };

package/dist/index.js

@@ -1,2 +1,2 @@
-import { t as createRuntimeGraph } from "./graph-DoSjSC5T.js";
+import { t as createRuntimeGraph } from "./graph-B77v_FUC.js";
 export { createRuntimeGraph };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markless/runtime",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Markless state graph runtime: reads, writes, computed invalidation, flush journal.",
   "license": "MIT",
   "repository": {
@@ -22,10 +22,14 @@
     "./graph": {
       "types": "./dist/graph.d.ts",
       "default": "./dist/graph.js"
+    },
+    "./graph-reconcile": {
+      "types": "./dist/graph-reconcile.d.ts",
+      "default": "./dist/graph-reconcile.js"
     }
   },
   "dependencies": {
-    "@markless/serializer": "0.3.1"
+    "@markless/serializer": "0.3.3"
   },
   "files": [
     "dist"