@markless/runtime 0.4.0 → 0.6.0

package/dist/{graph-Duhosz6u.js → graph-B3y0SeX_.js}

@@ -1,4 +1,4 @@
-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";
+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-BOuUUffx.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.`);
@@ -110,18 +110,24 @@ function markComputedDirty(input) {
 		graphNodeId: input.graphNodeId,
 		path: []
 	});
-	for (const dependent of input.computedNodes.values()) if (dependent.dependencies.some((dependency) => dependency.graphNodeId === input.graphNodeId) && dependent.compute) markComputedDirty({
-		...input,
-		graphNodeId: dependent.graphNodeId
-	});
+	for (const dependent of input.computedNodes.values()) {
+		if (!dependent.compute) continue;
+		if (dependent.dependencies.some((dependency) => dependency.graphNodeId === input.graphNodeId)) markComputedDirty({
+			...input,
+			graphNodeId: dependent.graphNodeId
+		});
+	}
 	for (const dependent of input.asyncComputedNodes.values()) if (dependent.dependencies.some((dependency) => dependency.graphNodeId === input.graphNodeId)) input.invalidateAsyncComputed(dependent);
 }
 function markDirtyComputedDependencies(input) {
-	for (const computed of input.computedNodes.values()) if (computed.dependencies.some((dependency) => dependency.graphNodeId === input.graphNodeId && pathsIntersect(input.path, dependency.path ?? [])) && computed.compute) markComputedDirty({
-		...input,
-		graphNodeId: computed.graphNodeId,
-		visited: /* @__PURE__ */ new Set()
-	});
+	for (const computed of input.computedNodes.values()) {
+		if (!computed.compute) continue;
+		if (computed.dependencies.some((dependency) => dependency.graphNodeId === input.graphNodeId && pathsIntersect(input.path, dependency.path ?? []))) markComputedDirty({
+			...input,
+			graphNodeId: computed.graphNodeId,
+			visited: /* @__PURE__ */ new Set()
+		});
+	}
 	for (const asyncComputed of input.asyncComputedNodes.values()) if (asyncComputed.dependencies.some((dependency) => dependency.graphNodeId === input.graphNodeId && pathsIntersect(input.path, dependency.path ?? []))) input.invalidateAsyncComputed(asyncComputed);
 }
 //#endregion
@@ -245,12 +251,15 @@ function createRuntimeGraph(input) {
 	const computedNodes = createRuntimeComputedNodes(input.computed);
 	const asyncComputedNodes = createRuntimeAsyncComputedNodes(input.asyncComputed);
 	const subscriptions = [];
+	const writeObservers = [];
 	const journalListeners = [];
 	const dirtyPaths = [];
 	const journal = [];
 	let flushScheduled = false;
 	let flushing = false;
+	let notifyingWrite = false;
 	let activeFlush;
+	let flushHolds = 0;
 	for (const cell of input.cells) {
 		cells.set(cell.graphNodeId, cell.value);
 		if (cell.readInitializer) readInitializers.set(cell.graphNodeId, cell.readInitializer);
@@ -290,13 +299,47 @@ function createRuntimeGraph(input) {
 			reconcile: plane,
 			invalidateAsyncComputed: invalidateAsyncComputed$1
 		});
+		notifyWriteObservers(graphNodeId, path);
+	};
+	/**
+	* Whether `graphNodeId` is derived, however deeply, from the written path.
+	*
+	* A computed collection carries no dependency of its own on the state a
+	* handler writes; the chain of `dependencies` is the only thing that says so,
+	* and with a reconcile plane installed the write dirties no path under the
+	* computed for a path test to find.
+	*/
+	const derivesFromWrite = (graphNodeId, write, seen) => {
+		if (seen.has(graphNodeId)) return false;
+		seen.add(graphNodeId);
+		const computed = computedNodes.get(graphNodeId);
+		if (!computed) return false;
+		for (const dependency of computed.dependencies) {
+			if (dependency.graphNodeId === write.graphNodeId && pathsIntersect(write.path, dependency.path ?? [])) return true;
+			if (derivesFromWrite(dependency.graphNodeId, write, seen)) return true;
+		}
+		return false;
+	};
+	const notifyWriteObservers = (graphNodeId, path) => {
+		if (writeObservers.length === 0 || flushing || notifyingWrite) return;
+		const write = {
+			graphNodeId,
+			path
+		};
+		notifyingWrite = true;
+		try {
+			for (const observer of writeObservers.slice()) if (observer.graphNodeId === graphNodeId ? pathsIntersect(path, observer.path ?? []) : derivesFromWrite(observer.graphNodeId, write, /* @__PURE__ */ new Set())) observer.run();
+		} finally {
+			notifyingWrite = false;
+		}
 	};
 	const scheduleFlush = () => {
 		if (flushScheduled || flushing) return;
 		flushScheduled = true;
-		scheduleMicrotask(() => {
-			flush();
-		});
+		scheduleMicrotask(runScheduledFlush);
+	};
+	const runScheduledFlush = () => {
+		if (!flushHolds) flush();
 	};
 	const plane = input.reconcile?.({
 		cells,
@@ -345,11 +388,19 @@ function createRuntimeGraph(input) {
 					plane?.recomputeSubscribed();
 					const pending = dirtyPaths.splice(0);
 					const ranSubscriptions = /* @__PURE__ */ new Set();
+					const commits = [];
 					for (const subscription of subscriptions) {
 						const subscriptionPath = subscription.path ?? [];
 						if (!pending.some((path) => path.graphNodeId === subscription.graphNodeId && pathsIntersect(path.path, subscriptionPath)) || ranSubscriptions.has(subscription.id)) continue;
 						ranSubscriptions.add(subscription.id);
-						appendJournalResult(journal, await subscription.run(readGraph(subscription.graphNodeId, subscriptionPath)));
+						const entries = await subscription.run(readGraph(subscription.graphNodeId, subscriptionPath));
+						if (typeof entries === "function") commits.push(entries);
+						else appendJournalResult(journal, entries);
+					}
+					if (commits.length > 0) {
+						const landing = commits.map((commit) => commit());
+						await notifyJournalListeners();
+						await Promise.all(landing);
 					}
 				}
 			} finally {
@@ -380,8 +431,9 @@ 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;
+			const seeded = cells.has(write.graphNodeId);
+			if (seeded && plane?.commitDerived(write, path)) return;
+			if (seeded && Object.is(readPath(current, path), write.value)) return;
 			cells.set(write.graphNodeId, writePath(current, path, write.value));
 			markDirtyPath(write.graphNodeId, dirtyPathForGraphWrite(current, path));
 			scheduleFlush();
@@ -425,6 +477,28 @@ function createRuntimeGraph(input) {
 				if (index >= 0) subscriptions.splice(index, 1);
 			};
 		},
+		subscribeWrite(observer) {
+			writeObservers.push(observer);
+			return () => {
+				const index = writeObservers.indexOf(observer);
+				if (index >= 0) writeObservers.splice(index, 1);
+			};
+		},
+		hasPendingFlush: () => flushScheduled || dirtyPaths.length > 0 || activeFlush !== void 0,
+		holdFlush() {
+			flushHolds++;
+			return () => {
+				if (!--flushHolds && flushScheduled) scheduleMicrotask(runScheduledFlush);
+			};
+		},
+		settleWriteObservers() {
+			let pending;
+			for (const observer of writeObservers) {
+				const settling = observer.settle?.();
+				if (settling) (pending ??= []).push(settling.catch(() => void 0));
+			}
+			return pending && Promise.all(pending).then(() => void 0);
+		},
 		subscribeJournal(listener) {
 			journalListeners.push(listener);
 			return () => {

package/dist/{graph-async-Db6SqB5x.js → graph-async-BOuUUffx.js}

@@ -65,7 +65,7 @@ function isObject(value) {
 }
 //#endregion
 //#region src/graph-async.ts
-const ASYNC_SNAPSHOT_META_KEYS = new Set([
+const ASYNC_SNAPSHOT_META_KEYS = /* @__PURE__ */ new Set([
 	"status",
 	"version",
 	"key",
@@ -103,7 +103,7 @@ function invalidateAsyncComputed(input) {
 	advanceAsyncComputed(input);
 }
 function advanceAsyncComputed(input) {
-	const visited = new Set([input.node.graphNodeId]);
+	const visited = /* @__PURE__ */ new Set([input.node.graphNodeId]);
 	let blocked;
 	const visit = (graphNodeId) => {
 		if (visited.has(graphNodeId)) return;

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

@@ -1,5 +1,4 @@
 import { ProtocolStatePayload } from "@markless/serializer";
-
 //#region src/graph.d.ts
 type RuntimeGraphCell = {
   readonly graphNodeId: string;
@@ -14,7 +13,8 @@ type RuntimeGraphComputedDependency = {
 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 compute: (read: RuntimeGraphRead) => unknown;
+  /** How re-derived values reconcile against the node's previous value. */
   readonly reconcile?: RuntimeGraphReconcileOptions;
 };
 type RuntimeGraphComputedDependencyNode = Omit<RuntimeGraphComputed, 'compute'> & {
@@ -43,7 +43,8 @@ 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 key: (read: RuntimeGraphRead) => unknown;
+  /** How a fulfilled value reconciles against the previously published one. */
   readonly reconcile?: RuntimeGraphReconcileOptions;
   readonly run: (input: {
     readonly key: unknown;
@@ -55,6 +56,8 @@ type DomJournalEntry = {
   readonly type: 'setText';
   readonly locator: string;
   readonly value: unknown;
+  /** The one child text node this write owns, when its element holds other children too. */
+  readonly node?: (host: unknown) => unknown;
 } | {
   readonly type: 'setAttr' | 'setProp';
   readonly locator: string;
@@ -123,14 +126,48 @@ type RuntimeGraphDelete = {
   readonly graphNodeId: string;
   readonly path: ReadonlyArray<string>;
 };
+/** DOM work a subscription holds back until its whole pass has run, so it lands in one task with that pass's journal. */
+type RuntimeGraphCommit = () => void | Promise<void>;
 type RuntimeGraphSubscription = {
   readonly id: string;
   readonly graphNodeId: string;
   readonly path?: ReadonlyArray<string>;
-  readonly run: (value: unknown) => DomJournalResult | void | Promise<DomJournalResult | void>;
+  readonly run: (value: unknown) => DomJournalResult | RuntimeGraphCommit | void | Promise<DomJournalResult | RuntimeGraphCommit | void>;
+};
+/**
+ * Told about a write the moment it lands, before the flush that write schedules.
+ *
+ * The flush is a microtask behind the statement that wrote, so a handler reading
+ * back what its own write produced - a keyed repeat's rows most of all - reads
+ * the pre-write answer. An observer runs synchronously inside the write instead,
+ * so the next statement of the same handler sees the result.
+ *
+ * It runs for a write to `graphNodeId` under an intersecting path, and for a
+ * write to anything `graphNodeId` derives from, so a computed-backed collection
+ * is reached through the state write behind it. It never runs during a flush -
+ * the flush's own subscription pass is the single answer there - and never
+ * re-enters: a write made from inside an observer notifies nobody.
+ *
+ * `run` is handed no value and answers with none: it is a place to react, not a
+ * second subscription channel, and reads whatever it needs off the graph. The
+ * graph does not catch what it throws.
+ */
+type RuntimeGraphWriteObserver = {
+  readonly graphNodeId: string;
+  readonly path?: ReadonlyArray<string>;
+  /**
+   * Work ALREADY in flight that this observer needs settled before it can
+   * answer a write synchronously - a demand-loaded module, above all. It starts
+   * nothing, so a caller awaiting it adds no fetch to the gesture; it only
+   * stops the gesture racing a load its own wiring began. `undefined` is
+   * nothing to wait for, and costs no microtask.
+   */
+  readonly settle?: () => Promise<void> | undefined;
+  readonly run: () => void;
 };
 type RuntimeGraph = {
-  readonly read: (graphNodeId: string, path?: ReadonlyArray<string>) => unknown; /** Available only in debug-enabled builds (`__MARKLESS_DEBUG_ENABLED__`). */
+  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;
@@ -143,6 +180,20 @@ type RuntimeGraph = {
   readonly call: (call: RuntimeGraphCall) => unknown;
   readonly delete: (deletion: RuntimeGraphDelete) => boolean;
   readonly subscribe: (subscription: RuntimeGraphSubscription) => () => void;
+  /**
+   * Optional so a facade over a subset of this contract stays a `RuntimeGraph`;
+   * a caller without it gets the flush-time answer it always had.
+   */
+  readonly subscribeWrite?: (observer: RuntimeGraphWriteObserver) => () => void;
+  /**
+   * Settles what the write observers are already loading, so a write made after
+   * it is answered synchronously. `undefined` when nothing is in flight.
+   */
+  readonly settleWriteObservers?: () => Promise<void> | undefined;
+  /** Whether a write is waiting on a flush that has not yet reached the journal. */
+  readonly hasPendingFlush?: () => boolean;
+  /** Keeps the scheduled flush back until each returned release has run once; `flush()` itself still runs. */
+  readonly holdFlush?: () => () => void;
   readonly subscribeJournal: (listener: DomJournalListener) => () => void;
   readonly flush: () => Promise<void>;
   readonly takeJournal: () => DomJournalEntry[];
@@ -260,15 +311,22 @@ type DerivedReconcileInternals = {
  * 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. */
+  /** 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 };
+export { RuntimeGraphSubscription as A, RuntimeGraphComputedDependencyNode as C, RuntimeGraphSharedPatch as D, RuntimeGraphRead as E, RuntimeGraphWrite as M, RuntimeGraphWriteObserver as N, RuntimeGraphSharedPatchOperation as O, createRuntimeGraph as P, RuntimeGraphComputedDependency as S, RuntimeGraphInput as T, RuntimeGraphAsyncSnapshot as _, RuntimeGraphReconcileKey as a, RuntimeGraphCommit as b, createDerivedReconcilePlane as c, samePath as d, DomJournalEntry as f, RuntimeGraphAsyncComputed as g, RuntimeGraph as h, DiffDerivedValueInput as i, RuntimeGraphUpdate as j, RuntimeGraphSharedWrite 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, RuntimeGraphDelete as w, RuntimeGraphComputed as x, RuntimeGraphCell as y };

package/dist/graph-reconcile.d.ts

@@ -1,2 +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";
+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-lpU0ZJNo.js";
 export { DerivedReconcileInternals, DerivedReconcilePlane, DerivedReconcilePlaneFactory, DiffDerivedValueInput, RuntimeGraphReconcileKey, RuntimeGraphReconcileOptions, WriteTouchedRecord, createDerivedReconcilePlane, diffDerivedValue, isDiffableContainer, samePath };

package/dist/graph-reconcile.js

@@ -1,4 +1,4 @@
-import { t as ASYNC_SNAPSHOT_META_KEYS, u as readPath } from "./graph-async-Db6SqB5x.js";
+import { t as ASYNC_SNAPSHOT_META_KEYS, u as readPath } from "./graph-async-BOuUUffx.js";
 //#region src/graph-reconcile.ts
 const WHOLE_NODE = Object.freeze([Object.freeze([])]);
 /**
@@ -102,7 +102,7 @@ function diffDerivedValue(input) {
 		}
 	}
 	function walkObject(previous, next, path) {
-		for (const key of new Set([...Object.keys(previous), ...Object.keys(next)])) {
+		for (const key of /* @__PURE__ */ 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);

package/dist/graph.d.ts

@@ -1,2 +1,2 @@
-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 };
+import { A as RuntimeGraphSubscription, C as RuntimeGraphComputedDependencyNode, D as RuntimeGraphSharedPatch, E as RuntimeGraphRead, M as RuntimeGraphWrite, N as RuntimeGraphWriteObserver, O as RuntimeGraphSharedPatchOperation, P as createRuntimeGraph, S as RuntimeGraphComputedDependency, T as RuntimeGraphInput, _ as RuntimeGraphAsyncSnapshot, a as RuntimeGraphReconcileKey, b as RuntimeGraphCommit, f as DomJournalEntry, g as RuntimeGraphAsyncComputed, h as RuntimeGraph, i as DiffDerivedValueInput, j as RuntimeGraphUpdate, k as RuntimeGraphSharedWrite, 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 RuntimeGraphDelete, x as RuntimeGraphComputed, y as RuntimeGraphCell } from "./graph-reconcile-lpU0ZJNo.js";
+export { type DerivedReconcileInternals, type DerivedReconcilePlane, type DerivedReconcilePlaneFactory, type DiffDerivedValueInput, DomJournalEntry, DomJournalListener, DomJournalResult, RuntimeGraph, RuntimeGraphAsyncComputed, RuntimeGraphAsyncSnapshot, RuntimeGraphCall, RuntimeGraphCell, RuntimeGraphCommit, RuntimeGraphComputed, RuntimeGraphComputedDependency, RuntimeGraphComputedDependencyNode, RuntimeGraphDelete, RuntimeGraphInput, RuntimeGraphRead, type RuntimeGraphReconcileKey, type RuntimeGraphReconcileOptions, RuntimeGraphSharedPatch, RuntimeGraphSharedPatchOperation, RuntimeGraphSharedWrite, RuntimeGraphSubscription, RuntimeGraphUpdate, RuntimeGraphWrite, RuntimeGraphWriteObserver, type WriteTouchedRecord, createRuntimeGraph };

package/dist/graph.js

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

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-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 };
+import { A as RuntimeGraphSubscription, C as RuntimeGraphComputedDependencyNode, D as RuntimeGraphSharedPatch, E as RuntimeGraphRead, M as RuntimeGraphWrite, N as RuntimeGraphWriteObserver, O as RuntimeGraphSharedPatchOperation, P as createRuntimeGraph, S as RuntimeGraphComputedDependency, T as RuntimeGraphInput, _ as RuntimeGraphAsyncSnapshot, a as RuntimeGraphReconcileKey, b as RuntimeGraphCommit, f as DomJournalEntry, g as RuntimeGraphAsyncComputed, h as RuntimeGraph, i as DiffDerivedValueInput, j as RuntimeGraphUpdate, k as RuntimeGraphSharedWrite, 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 RuntimeGraphDelete, x as RuntimeGraphComputed, y as RuntimeGraphCell } from "./graph-reconcile-lpU0ZJNo.js";
+export { type DerivedReconcileInternals, type DerivedReconcilePlane, type DerivedReconcilePlaneFactory, type DiffDerivedValueInput, DomJournalEntry, DomJournalListener, DomJournalResult, RuntimeGraph, RuntimeGraphAsyncComputed, RuntimeGraphAsyncSnapshot, RuntimeGraphCall, RuntimeGraphCell, RuntimeGraphCommit, RuntimeGraphComputed, RuntimeGraphComputedDependency, RuntimeGraphComputedDependencyNode, RuntimeGraphDelete, RuntimeGraphInput, RuntimeGraphRead, type RuntimeGraphReconcileKey, type RuntimeGraphReconcileOptions, RuntimeGraphSharedPatch, RuntimeGraphSharedPatchOperation, RuntimeGraphSharedWrite, RuntimeGraphSubscription, RuntimeGraphUpdate, RuntimeGraphWrite, RuntimeGraphWriteObserver, type WriteTouchedRecord, createRuntimeGraph };

package/dist/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markless/runtime",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Markless state graph runtime: reads, writes, computed invalidation, flush journal.",
   "license": "MIT",
   "repository": {
@@ -29,7 +29,7 @@
     }
   },
   "dependencies": {
-    "@markless/serializer": "0.4.0"
+    "@markless/serializer": "0.6.0"
   },
   "files": [
     "dist"