@markless/runtime 0.3.2 → 0.4.0

package/dist/{graph-C1ACA8O1.d.ts → graph-reconcile-DoBBfYsT.d.ts}

@@ -1,72 +1,5 @@
 import { ProtocolStatePayload } from "@markless/serializer";
 
-//#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>>;
-//#endregion
 //#region src/graph.d.ts
 type RuntimeGraphCell = {
   readonly graphNodeId: string;
@@ -149,6 +82,12 @@ type RuntimeGraphInput = {
   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;
@@ -211,4 +150,125 @@ type RuntimeGraph = {
 type RuntimeSharedDefinition = NonNullable<ProtocolStatePayload['sharedDefinitions']>[number];
 declare function createRuntimeGraph(input: RuntimeGraphInput): RuntimeGraph;
 //#endregion
-export { RuntimeGraphReconcileKey as C, diffDerivedValue as E, DiffDerivedValueInput as S, WriteTouchedRecord as T, RuntimeGraphSharedWrite as _, RuntimeGraphAsyncComputed as a, RuntimeGraphWrite as b, RuntimeGraphCell as c, RuntimeGraphComputedDependencyNode as d, RuntimeGraphDelete as f, RuntimeGraphSharedPatchOperation as g, RuntimeGraphSharedPatch as h, RuntimeGraph as i, RuntimeGraphComputed as l, RuntimeGraphRead as m, DomJournalListener as n, RuntimeGraphAsyncSnapshot as o, RuntimeGraphInput as p, DomJournalResult as r, RuntimeGraphCall as s, DomJournalEntry as t, RuntimeGraphComputedDependency as u, RuntimeGraphSubscription as v, RuntimeGraphReconcileOptions as w, createRuntimeGraph as x, RuntimeGraphUpdate as y };
+//#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,2 +1,2 @@
-import { C as RuntimeGraphReconcileKey, E as diffDerivedValue, S as DiffDerivedValueInput, T as WriteTouchedRecord, _ as RuntimeGraphSharedWrite, a as RuntimeGraphAsyncComputed, b as RuntimeGraphWrite, c as RuntimeGraphCell, d as RuntimeGraphComputedDependencyNode, f as RuntimeGraphDelete, g as RuntimeGraphSharedPatchOperation, h as RuntimeGraphSharedPatch, i as RuntimeGraph, l as RuntimeGraphComputed, m as RuntimeGraphRead, n as DomJournalListener, o as RuntimeGraphAsyncSnapshot, p as RuntimeGraphInput, r as DomJournalResult, s as RuntimeGraphCall, t as DomJournalEntry, u as RuntimeGraphComputedDependency, v as RuntimeGraphSubscription, w as RuntimeGraphReconcileOptions, x as createRuntimeGraph, y as RuntimeGraphUpdate } from "./graph-C1ACA8O1.js";
-export { 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, diffDerivedValue };
+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 { n as diffDerivedValue, t as createRuntimeGraph } from "./graph-DAwgoMQ1.js";
-export { createRuntimeGraph, diffDerivedValue };
+import { t as createRuntimeGraph } from "./graph-Duhosz6u.js";
+export { createRuntimeGraph };

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-import { C as RuntimeGraphReconcileKey, E as diffDerivedValue, S as DiffDerivedValueInput, T as WriteTouchedRecord, _ as RuntimeGraphSharedWrite, a as RuntimeGraphAsyncComputed, b as RuntimeGraphWrite, c as RuntimeGraphCell, d as RuntimeGraphComputedDependencyNode, f as RuntimeGraphDelete, g as RuntimeGraphSharedPatchOperation, h as RuntimeGraphSharedPatch, i as RuntimeGraph, l as RuntimeGraphComputed, m as RuntimeGraphRead, n as DomJournalListener, o as RuntimeGraphAsyncSnapshot, p as RuntimeGraphInput, r as DomJournalResult, s as RuntimeGraphCall, t as DomJournalEntry, u as RuntimeGraphComputedDependency, v as RuntimeGraphSubscription, w as RuntimeGraphReconcileOptions, x as createRuntimeGraph, y as RuntimeGraphUpdate } from "./graph-C1ACA8O1.js";
-export { 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, diffDerivedValue };
+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 { n as diffDerivedValue, t as createRuntimeGraph } from "./graph-DAwgoMQ1.js";
-export { createRuntimeGraph, diffDerivedValue };
+import { t as createRuntimeGraph } from "./graph-Duhosz6u.js";
+export { createRuntimeGraph };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markless/runtime",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "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.2"
+    "@markless/serializer": "0.4.0"
   },
   "files": [
     "dist"