@markless/runtime 0.9.0 → 0.10.0

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

@@ -99,56 +99,51 @@ function readComputedNode(computed, readGraph, path, reconcile) {
 	}
 	return readPath(computed.value, path);
 }
-function markComputedDirty(input) {
-	if (input.visited.has(input.graphNodeId)) return;
-	input.visited.add(input.graphNodeId);
-	const computed = input.computedNodes.get(input.graphNodeId);
-	if (!computed?.compute) return;
-	computed.dirty = true;
-	if (input.reconcile) input.reconcile.invalidateComputed(computed);
-	else input.dirtyPaths.push({
-		graphNodeId: input.graphNodeId,
-		path: []
-	});
-	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 indexRuntimeDependents(computedNodes, asyncComputedNodes) {
+	const index = /* @__PURE__ */ new Map();
+	const add = (node, isAsync) => {
+		for (const dependency of node.dependencies) {
+			let readers = index.get(dependency.graphNodeId);
+			if (!readers) index.set(dependency.graphNodeId, readers = []);
+			readers.push([
+				node,
+				dependency.path ?? [],
+				isAsync
+			]);
+		}
+	};
+	for (const computed of computedNodes.values()) if (computed.compute) add(computed, false);
+	for (const asyncComputed of asyncComputedNodes.values()) add(asyncComputed, true);
+	return index;
 }
-function markDirtyComputedDependencies(input) {
-	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);
+function markDirtyComputedDependencies(graphNodeId, path, dependents, dirtyPaths, reconcile, invalidateAsyncComputed) {
+	const visited = /* @__PURE__ */ new Set();
+	const invalidated = /* @__PURE__ */ new Set();
+	const mark = (sourceId, sourcePath) => {
+		for (const [node, dependencyPath, isAsync] of dependents.get(sourceId) ?? []) {
+			if (sourcePath && !pathsIntersect(sourcePath, dependencyPath)) continue;
+			if (isAsync) invalidated.add(node);
+			else if (!visited.has(node)) {
+				const computed = node;
+				visited.add(computed);
+				computed.dirty = true;
+				if (reconcile) reconcile.invalidateComputed(computed);
+				else dirtyPaths.push({
+					graphNodeId: computed.graphNodeId,
+					path: []
+				});
+				mark(computed.graphNodeId);
+			}
+		}
+	};
+	mark(graphNodeId, path);
+	for (const asyncComputed of invalidated) invalidateAsyncComputed(asyncComputed);
 }
 //#endregion
 //#region src/graph-scheduler.ts
 function appendJournalResult(journal, result) {
-	if (!result) return;
-	if (isDomJournalEntryArray(result)) {
-		journal.push(...result);
-		return;
-	}
-	journal.push(result);
-}
-function scheduleMicrotask(callback) {
-	if (typeof queueMicrotask === "function") {
-		queueMicrotask(callback);
-		return;
-	}
-	Promise.resolve().then(callback);
-}
-function isDomJournalEntryArray(result) {
-	return Array.isArray(result);
+	if (Array.isArray(result)) journal.push(...result);
+	else if (result) journal.push(result);
 }
 //#endregion
 //#region src/graph-shared.ts
@@ -250,7 +245,10 @@ function createRuntimeGraph(input) {
 	const readInitializers = /* @__PURE__ */ new Map();
 	const computedNodes = createRuntimeComputedNodes(input.computed);
 	const asyncComputedNodes = createRuntimeAsyncComputedNodes(input.asyncComputed);
-	const subscriptions = [];
+	let dependents = indexRuntimeDependents(computedNodes, asyncComputedNodes);
+	const subscriptionsByNode = /* @__PURE__ */ new Map();
+	const subscriptionOrder = /* @__PURE__ */ new Map();
+	let subscriptionSequence = 0;
 	const writeObservers = [];
 	const journalListeners = [];
 	const dirtyPaths = [];
@@ -275,11 +273,7 @@ function createRuntimeGraph(input) {
 			const current = cells.get(graphNodeId);
 			try {
 				const value = initialize();
-				if (!Object.is(current, value)) {
-					cells.set(graphNodeId, value);
-					markDirtyPath(graphNodeId, dirtyPathForGraphWrite(current, []));
-					scheduleFlush();
-				}
+				if (!Object.is(current, value)) commitCell(graphNodeId, [], value);
 			} catch {}
 		}
 		return readPath(cells.get(graphNodeId), path);
@@ -290,16 +284,14 @@ function createRuntimeGraph(input) {
 			path
 		});
 		plane?.recordWrite(graphNodeId, path);
-		markDirtyComputedDependencies({
-			graphNodeId,
-			path,
-			computedNodes,
-			asyncComputedNodes,
-			dirtyPaths,
-			reconcile: plane,
-			invalidateAsyncComputed: invalidateAsyncComputed$1
-		});
+		markDirtyComputedDependencies(graphNodeId, path, dependents, dirtyPaths, plane, invalidateAsyncComputed$1);
 		notifyWriteObservers(graphNodeId, path);
+		scheduleFlush();
+	};
+	const commitCell = (graphNodeId, path, value) => {
+		const current = cells.get(graphNodeId);
+		cells.set(graphNodeId, writePath(current, path, value));
+		markDirtyPath(graphNodeId, dirtyPathForGraphWrite(current, path));
 	};
 	/**
 	* Whether `graphNodeId` is derived, however deeply, from the written path.
@@ -326,6 +318,7 @@ function createRuntimeGraph(input) {
 			graphNodeId,
 			path
 		};
+		if (passWaitsOnCode()) return;
 		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();
@@ -333,23 +326,31 @@ function createRuntimeGraph(input) {
 			notifyingWrite = false;
 		}
 	};
+	const passWaitsOnCode = () => dirtyPaths.some(({ graphNodeId, path }) => subscriptionsByNode.get(graphNodeId)?.some((subscription) => subscription.ready?.() === false && pathsIntersect(path, subscription.path ?? [])));
 	const scheduleFlush = () => {
 		if (flushScheduled || flushing) return;
 		flushScheduled = true;
-		scheduleMicrotask(runScheduledFlush);
+		queueMicrotask(runScheduledFlush);
 	};
 	const runScheduledFlush = () => {
 		if (!flushHolds) flush();
 	};
-	const plane = input.reconcile?.({
+	const internals = {
 		cells,
 		computedNodes,
-		subscriptions,
 		dirtyPaths,
 		readGraph,
 		markDirtyPath,
-		scheduleFlush
-	});
+		scheduleFlush,
+		hasSubscription: (graphNodeId) => !!subscriptionsByNode.get(graphNodeId)?.length,
+		addSubscription(subscription) {
+			let bucket = subscriptionsByNode.get(subscription.graphNodeId);
+			if (!bucket) subscriptionsByNode.set(subscription.graphNodeId, bucket = []);
+			bucket.push(subscription);
+			subscriptionOrder.set(subscription, subscriptionSequence++);
+		}
+	};
+	const plane = input.reconcile?.(internals);
 	const asyncComputedInput = () => ({
 		computedNodes,
 		asyncComputedNodes,
@@ -376,7 +377,9 @@ function createRuntimeGraph(input) {
 	});
 	const flush = () => {
 		if (activeFlush) return activeFlush;
-		activeFlush = runFlush();
+		let settle;
+		activeFlush = new Promise((resolve) => settle = resolve);
+		settle(runFlush());
 		return activeFlush;
 	};
 	const runFlush = async () => {
@@ -389,11 +392,11 @@ function createRuntimeGraph(input) {
 					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;
+					for (let floor = 0, ceiling; floor < (ceiling = subscriptionSequence); floor = ceiling) for (const subscription of dueSubscriptions(pending, floor, ceiling)) {
+						if (!subscriptionOrder.has(subscription) || ranSubscriptions.has(subscription.id)) continue;
 						ranSubscriptions.add(subscription.id);
-						const entries = await subscription.run(readGraph(subscription.graphNodeId, subscriptionPath));
+						const ran = subscription.run(readGraph(subscription.graphNodeId, subscription.path ?? []));
+						const entries = typeof ran?.then === "function" ? await ran : ran;
 						if (typeof entries === "function") commits.push(entries);
 						else appendJournalResult(journal, entries);
 					}
@@ -414,6 +417,14 @@ function createRuntimeGraph(input) {
 			if (dirtyPaths.length > 0) scheduleFlush();
 		}
 	};
+	const dueSubscriptions = (pending, floor, ceiling) => {
+		const due = /* @__PURE__ */ new Set();
+		for (const { graphNodeId, path } of pending) for (const subscription of subscriptionsByNode.get(graphNodeId) ?? []) {
+			const order = subscriptionOrder.get(subscription);
+			if (order >= floor && order < ceiling && pathsIntersect(path, subscription.path ?? [])) due.add(subscription);
+		}
+		return [...due].sort((left, right) => subscriptionOrder.get(left) - subscriptionOrder.get(right));
+	};
 	const notifyJournalListeners = async () => {
 		if (journalListeners.length === 0 || journal.length === 0) return;
 		const entries = journal.splice(0);
@@ -431,23 +442,14 @@ function createRuntimeGraph(input) {
 		write(write) {
 			const path = write.path ?? [];
 			const current = cells.get(write.graphNodeId);
-			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();
+			if (!cells.has(write.graphNodeId) || !(plane?.commitDerived(write, path) || Object.is(readPath(current, path), write.value))) commitCell(write.graphNodeId, path, write.value);
+			return write.value;
 		},
 		update(update) {
 			const path = update.path ?? [];
 			const currentValue = readPath(cells.get(update.graphNodeId), path);
 			const nextValue = update.update(currentValue);
-			if (!Object.is(currentValue, nextValue)) {
-				const current = cells.get(update.graphNodeId);
-				cells.set(update.graphNodeId, writePath(current, path, nextValue));
-				markDirtyPath(update.graphNodeId, dirtyPathForGraphWrite(current, path));
-				scheduleFlush();
-			}
+			if (!Object.is(currentValue, nextValue)) commitCell(update.graphNodeId, path, nextValue);
 			if (update.returnValue === "previous") return currentValue;
 			if (update.returnValue === "next") return nextValue;
 		},
@@ -456,25 +458,29 @@ function createRuntimeGraph(input) {
 			const target = readPath(cells.get(call.graphNodeId), path);
 			const beforeMutation = collectionMutationSnapshot(target, call.method, call.args ?? []);
 			const result = applyCollectionCall(target, call.method, call.args ?? []);
-			if (collectionCallMutated(call.method, result, beforeMutation)) {
-				markDirtyPath(call.graphNodeId, path);
-				scheduleFlush();
-			}
+			if (collectionCallMutated(call.method, result, beforeMutation)) markDirtyPath(call.graphNodeId, path);
 			return result;
 		},
 		delete(deletion) {
 			const outcome = deletePath(cells.get(deletion.graphNodeId), deletion.path);
-			if (outcome.mutated) {
-				markDirtyPath(deletion.graphNodeId, deletion.path);
-				scheduleFlush();
-			}
+			if (outcome.mutated) markDirtyPath(deletion.graphNodeId, deletion.path);
 			return outcome.result;
 		},
+		defineAsyncComputed(asyncComputed) {
+			const id = asyncComputed.graphNodeId;
+			if (asyncComputedNodes.has(id) || cells.has(id)) return false;
+			asyncComputedNodes.set(id, createRuntimeAsyncComputedNodes([asyncComputed]).get(id));
+			dependents = indexRuntimeDependents(computedNodes, asyncComputedNodes);
+			return true;
+		},
 		subscribe(subscription) {
-			subscriptions.push(subscription);
+			internals.addSubscription(subscription);
 			return () => {
-				const index = subscriptions.indexOf(subscription);
-				if (index >= 0) subscriptions.splice(index, 1);
+				const bucket = subscriptionsByNode.get(subscription.graphNodeId);
+				const index = bucket.indexOf(subscription);
+				if (index < 0) return;
+				bucket.splice(index, 1);
+				subscriptionOrder.delete(subscription);
 			};
 		},
 		subscribeWrite(observer) {
@@ -488,7 +494,7 @@ function createRuntimeGraph(input) {
 		holdFlush() {
 			flushHolds++;
 			return () => {
-				if (!--flushHolds && flushScheduled) scheduleMicrotask(runScheduledFlush);
+				if (!--flushHolds && flushScheduled) queueMicrotask(runScheduledFlush);
 			};
 		},
 		settleWriteObservers() {

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

@@ -133,6 +133,8 @@ type RuntimeGraphSubscription = {
   readonly graphNodeId: string;
   readonly path?: ReadonlyArray<string>;
   readonly run: (value: unknown) => DomJournalResult | RuntimeGraphCommit | void | Promise<DomJournalResult | RuntimeGraphCommit | void>;
+  /** False while `run` still has code to load; a write observer then leaves its DOM to the pass, so the task's writes land together. */
+  readonly ready?: () => boolean;
 };
 /**
  * Told about a write the moment it lands, before the flush that write schedules.
@@ -175,11 +177,14 @@ type RuntimeGraph = {
   readonly listSharedDefinitions: () => NonNullable<ProtocolStatePayload['sharedDefinitions']>;
   readonly takeSharedPatches: () => RuntimeGraphSharedPatch[];
   readonly applySharedPatch: (patch: RuntimeGraphSharedPatch) => boolean;
-  readonly write: (write: RuntimeGraphWrite) => void;
+  /** Answers the value written, as the assignment it lowers from does. */
+  readonly write: (write: RuntimeGraphWrite) => unknown;
   readonly update: (update: RuntimeGraphUpdate) => unknown;
   readonly call: (call: RuntimeGraphCall) => unknown;
   readonly delete: (deletion: RuntimeGraphDelete) => boolean;
   readonly subscribe: (subscription: RuntimeGraphSubscription) => () => void;
+  /** Adds an async computed a component rendered after the graph was built; false when the node already exists. */
+  readonly defineAsyncComputed?: (asyncComputed: RuntimeGraphAsyncComputed) => boolean;
   /**
    * 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.
@@ -298,7 +303,9 @@ declare function samePath(a: ReadonlyArray<string>, b: ReadonlyArray<string>): b
 type DerivedReconcileInternals = {
   readonly cells: Map<string, unknown>;
   readonly computedNodes: ReadonlyMap<string, RuntimeComputedNode>;
-  readonly subscriptions: ReadonlyArray<RuntimeGraphSubscription>;
+  readonly hasSubscription: (graphNodeId: string) => boolean;
+  /** Registers a subscription; a wrapper installed before the first subscribe sees each one. */
+  addSubscription: (subscription: RuntimeGraphSubscription) => void;
   readonly dirtyPaths: DirtyPath[];
   readonly readGraph: RuntimeGraphRead;
   readonly markDirtyPath: (graphNodeId: string, path: ReadonlyArray<string>) => void;

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

package/dist/graph-reconcile.js

@@ -194,7 +194,7 @@ 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 { cells, computedNodes, hasSubscription, dirtyPaths } = internals;
 	const { readGraph, markDirtyPath, scheduleFlush } = internals;
 	const writeTouched = /* @__PURE__ */ new Map();
 	const dirtyComputed = /* @__PURE__ */ new Set();
@@ -260,7 +260,7 @@ const createDerivedReconcilePlane = (internals) => {
 					dirtyComputed.delete(computed);
 					continue;
 				}
-				if (!subscriptions.some((subscription) => subscription.graphNodeId === computed.graphNodeId)) continue;
+				if (!hasSubscription(computed.graphNodeId)) continue;
 				dirtyComputed.delete(computed);
 				readGraph(computed.graphNodeId);
 			}

package/dist/graph.d.ts

@@ -1,2 +1,2 @@
-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";
+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-DTpmb2VG.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 +1 @@
-export { t as createRuntimeGraph } from "./graph-B3y0SeX_.js";
+export { t as createRuntimeGraph } from "./graph-DO969AnQ.js";

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-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";
+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-DTpmb2VG.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 +1 @@
-export { t as createRuntimeGraph } from "./graph-B3y0SeX_.js";
+export { t as createRuntimeGraph } from "./graph-DO969AnQ.js";

package/package.json

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