@markless/runtime 0.3.2 → 0.3.3

package/dist/graph-B77v_FUC.js

@@ -0,0 +1,441 @@
+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.`);
+	if (!isSupportedCollectionMethod(method)) throw new TypeError(`Unsupported graph collection method "${method}".`);
+	const callable = target[method];
+	if (typeof callable !== "function") throw new TypeError(`Unsupported graph collection method "${method}".`);
+	return Reflect.apply(callable, target, [...args]);
+}
+function collectionCallMutated(method, result, beforeMutation) {
+	if (method === "delete") return result === true;
+	if (method === "clear") return beforeMutation?.type === "size" && beforeMutation.value > 0;
+	if (method === "pop") return beforeMutation?.type === "size" && beforeMutation.value > 0;
+	if (method === "shift") return beforeMutation?.type === "size" && beforeMutation.value > 0;
+	if (method === "push" || method === "unshift") return beforeMutation?.type !== "size" || result !== beforeMutation.value;
+	if (arrayContentMutationMethod(method)) return beforeMutation?.type !== "array" || !arraySlotsEqual(beforeMutation.slots, beforeMutation.target);
+	if (method === "add") return beforeMutation?.type !== "set-add" || !beforeMutation.hadValue;
+	if (method === "set") return beforeMutation?.type !== "map-set" || !beforeMutation.hadKey || beforeMutation.valueChanged;
+	if (dateMutationMethod(method)) return beforeMutation?.type !== "date" || !Object.is(beforeMutation.time, beforeMutation.target.getTime());
+	return true;
+}
+function collectionMutationSnapshot(target, method, args) {
+	if (method === "add" && target instanceof Set) return {
+		type: "set-add",
+		hadValue: target.has(args[0])
+	};
+	if (method === "set" && target instanceof Map) {
+		const hadKey = target.has(args[0]);
+		return {
+			type: "map-set",
+			hadKey,
+			valueChanged: !hadKey || !Object.is(target.get(args[0]), args[1])
+		};
+	}
+	if (target instanceof Date && dateMutationMethod(method)) return {
+		type: "date",
+		time: target.getTime(),
+		target
+	};
+	if (arrayContentMutationMethod(method) && Array.isArray(target)) return {
+		type: "array",
+		slots: arraySlotSnapshot(target),
+		target
+	};
+	if (Array.isArray(target)) return {
+		type: "size",
+		value: target.length
+	};
+	if (target instanceof Map || target instanceof Set) return {
+		type: "size",
+		value: target.size
+	};
+	return null;
+}
+function isSupportedCollectionMethod(name) {
+	return name === "add" || name === "clear" || name === "copyWithin" || name === "delete" || name === "fill" || name === "pop" || name === "push" || name === "reverse" || name === "set" || name === "shift" || name === "sort" || name === "splice" || name === "unshift" || dateMutationMethod(name);
+}
+function isSupportedCollectionTarget(target) {
+	return Array.isArray(target) || target instanceof Map || target instanceof Set || target instanceof Date;
+}
+function arrayContentMutationMethod(method) {
+	return method === "copyWithin" || method === "fill" || method === "reverse" || method === "sort" || method === "splice";
+}
+function dateMutationMethod(method) {
+	return method === "setDate" || method === "setFullYear" || method === "setHours" || method === "setMilliseconds" || method === "setMinutes" || method === "setMonth" || method === "setSeconds" || method === "setTime" || method === "setUTCDate" || method === "setUTCFullYear" || method === "setUTCHours" || method === "setUTCMilliseconds" || method === "setUTCMinutes" || method === "setUTCMonth" || method === "setUTCSeconds" || method === "setYear";
+}
+function arraySlotSnapshot(target) {
+	return Array.from({ length: target.length }, (_, index) => ({
+		exists: Object.prototype.hasOwnProperty.call(target, index),
+		value: target[index]
+	}));
+}
+function arraySlotsEqual(before, after) {
+	if (!Array.isArray(after)) return false;
+	if (before.length !== after.length) return false;
+	return before.every((slot, index) => {
+		const exists = Object.prototype.hasOwnProperty.call(after, index);
+		return slot.exists === exists && (!slot.exists || Object.is(slot.value, after[index]));
+	});
+}
+//#endregion
+//#region src/graph-computed.ts
+function createRuntimeComputedNodes(computedInput) {
+	const computedNodes = /* @__PURE__ */ new Map();
+	for (const computed of computedInput ?? []) computedNodes.set(computed.graphNodeId, {
+		...computed,
+		dirty: true,
+		value: void 0
+	});
+	return computedNodes;
+}
+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);
+}
+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.dependencies.some((dependency) => dependency.graphNodeId === input.graphNodeId) && dependent.compute) 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 asyncComputed of input.asyncComputedNodes.values()) if (asyncComputed.dependencies.some((dependency) => dependency.graphNodeId === input.graphNodeId && pathsIntersect(input.path, dependency.path ?? []))) input.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);
+}
+//#endregion
+//#region src/graph-shared.ts
+function createSharedGraphPlane(input) {
+	const sharedDefinitions = /* @__PURE__ */ new Map();
+	const sharedPatches = [];
+	for (const definition of input.sharedDefinitionsInput ?? []) sharedDefinitions.set(definition.id, definition);
+	const resolveSharedGraphPath = (definitionId, propertyName, path) => {
+		const definition = sharedDefinitions.get(definitionId);
+		if (!definition) return void 0;
+		const property = findLastSharedReturnProperty(definition.returnProperties, propertyName);
+		if (!property || property.kind !== "graph") return void 0;
+		return {
+			definition,
+			graphNodeId: property.graphNodeId,
+			graphPath: [...property.path, ...path],
+			exposedPath: [property.name, ...path]
+		};
+	};
+	const setSharedDefinitionVersion = (definition, version) => {
+		const nextDefinition = {
+			...definition,
+			version
+		};
+		sharedDefinitions.set(definition.id, nextDefinition);
+		return nextDefinition;
+	};
+	const nextSharedDefinitionVersion = (definition) => setSharedDefinitionVersion(definition, definition.version + 1);
+	const applySharedPatch = (patch) => {
+		const definition = sharedDefinitions.get(patch.id);
+		if (!definition) return false;
+		if (patch.version <= definition.version) return false;
+		if (patch.scope && definition.scope && patch.scope !== definition.scope) return false;
+		if (patch.patch.length === 0) return false;
+		const resolvedPatches = [];
+		for (const [operation, exposedPath, value] of patch.patch) {
+			if (operation !== "set") return false;
+			const [propertyName, ...path] = exposedPath;
+			if (!propertyName) return false;
+			const resolved = resolveSharedGraphPath(patch.id, propertyName, path);
+			if (!resolved) return false;
+			resolvedPatches.push({
+				graphNodeId: resolved.graphNodeId,
+				graphPath: resolved.graphPath,
+				value
+			});
+		}
+		for (const resolved of resolvedPatches) {
+			const current = input.cells.get(resolved.graphNodeId);
+			input.cells.set(resolved.graphNodeId, writePath(current, resolved.graphPath, resolved.value));
+			input.markDirtyPath(resolved.graphNodeId, dirtyPathForGraphWrite(current, resolved.graphPath));
+		}
+		setSharedDefinitionVersion(definition, patch.version);
+		input.scheduleFlush();
+		return true;
+	};
+	return {
+		readShared(definitionId, propertyName, path = []) {
+			const resolved = resolveSharedGraphPath(definitionId, propertyName, path);
+			if (!resolved) return void 0;
+			return input.readGraph(resolved.graphNodeId, resolved.graphPath);
+		},
+		writeShared(write) {
+			const target = resolveSharedGraphPath(write.definitionId, write.propertyName, write.path ?? []);
+			if (!target) return false;
+			const current = input.cells.get(target.graphNodeId);
+			input.cells.set(target.graphNodeId, writePath(current, target.graphPath, write.value));
+			const nextDefinition = nextSharedDefinitionVersion(target.definition);
+			sharedPatches.push({
+				id: nextDefinition.id,
+				...nextDefinition.scope ? { scope: nextDefinition.scope } : {},
+				version: nextDefinition.version,
+				patch: [[
+					"set",
+					target.exposedPath,
+					write.value
+				]]
+			});
+			input.markDirtyPath(target.graphNodeId, dirtyPathForGraphWrite(current, target.graphPath));
+			input.scheduleFlush();
+			return true;
+		},
+		getSharedDefinition(definitionId) {
+			return sharedDefinitions.get(definitionId);
+		},
+		listSharedDefinitions() {
+			return [...sharedDefinitions.values()];
+		},
+		takeSharedPatches() {
+			return sharedPatches.splice(0);
+		},
+		applySharedPatch
+	};
+}
+//#endregion
+//#region src/graph.ts
+function createRuntimeGraph(input) {
+	const cells = /* @__PURE__ */ new Map();
+	const readInitializers = /* @__PURE__ */ new Map();
+	const computedNodes = createRuntimeComputedNodes(input.computed);
+	const asyncComputedNodes = createRuntimeAsyncComputedNodes(input.asyncComputed);
+	const subscriptions = [];
+	const journalListeners = [];
+	const dirtyPaths = [];
+	const journal = [];
+	let flushScheduled = false;
+	let flushing = false;
+	let activeFlush;
+	for (const cell of input.cells) {
+		cells.set(cell.graphNodeId, cell.value);
+		if (cell.readInitializer) readInitializers.set(cell.graphNodeId, cell.readInitializer);
+	}
+	const readGraph = (graphNodeId, path = []) => {
+		const computed = computedNodes.get(graphNodeId);
+		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);
+		if (initialize) {
+			readInitializers.delete(graphNodeId);
+			const current = cells.get(graphNodeId);
+			try {
+				const value = initialize();
+				if (!Object.is(current, value)) {
+					cells.set(graphNodeId, value);
+					markDirtyPath(graphNodeId, dirtyPathForGraphWrite(current, []));
+					scheduleFlush();
+				}
+			} catch {}
+		}
+		return readPath(cells.get(graphNodeId), path);
+	};
+	const markDirtyPath = (graphNodeId, path) => {
+		dirtyPaths.push({
+			graphNodeId,
+			path
+		});
+		plane?.recordWrite(graphNodeId, path);
+		markDirtyComputedDependencies({
+			graphNodeId,
+			path,
+			computedNodes,
+			asyncComputedNodes,
+			dirtyPaths,
+			reconcile: plane,
+			invalidateAsyncComputed: invalidateAsyncComputed$1
+		});
+	};
+	const scheduleFlush = () => {
+		if (flushScheduled || flushing) return;
+		flushScheduled = true;
+		scheduleMicrotask(() => {
+			flush();
+		});
+	};
+	const plane = input.reconcile?.({
+		cells,
+		computedNodes,
+		subscriptions,
+		dirtyPaths,
+		readGraph,
+		markDirtyPath,
+		scheduleFlush
+	});
+	const asyncComputedInput = () => ({
+		computedNodes,
+		asyncComputedNodes,
+		demandAsyncComputed: demandAsyncComputed$1,
+		readGraph,
+		markDirtyPath,
+		scheduleFlush,
+		reconcile: plane
+	});
+	const demandAsyncComputed$1 = (node) => demandAsyncComputed({
+		node,
+		...asyncComputedInput()
+	});
+	const invalidateAsyncComputed$1 = (node) => invalidateAsyncComputed({
+		node,
+		...asyncComputedInput()
+	});
+	const sharedGraph = createSharedGraphPlane({
+		cells,
+		sharedDefinitionsInput: input.sharedDefinitions,
+		readGraph,
+		markDirtyPath,
+		scheduleFlush
+	});
+	const flush = () => {
+		if (activeFlush) return activeFlush;
+		activeFlush = runFlush();
+		return activeFlush;
+	};
+	const runFlush = async () => {
+		flushScheduled = false;
+		flushing = true;
+		try {
+			try {
+				while (dirtyPaths.length > 0) {
+					plane?.recomputeSubscribed();
+					const pending = dirtyPaths.splice(0);
+					const ranSubscriptions = /* @__PURE__ */ new Set();
+					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)));
+					}
+				}
+			} finally {
+				plane?.settleBaselines();
+				flushing = false;
+			}
+			await notifyJournalListeners();
+		} finally {
+			activeFlush = void 0;
+			if (dirtyPaths.length > 0) scheduleFlush();
+		}
+	};
+	const notifyJournalListeners = async () => {
+		if (journalListeners.length === 0 || journal.length === 0) return;
+		const entries = journal.splice(0);
+		for (const listener of journalListeners) await listener(entries);
+	};
+	return {
+		read: readGraph,
+		...typeof __MARKLESS_DEBUG_ENABLED__ !== "undefined" && __MARKLESS_DEBUG_ENABLED__ ? { peekAsyncSnapshot: (graphNodeId) => asyncComputedNodes.get(graphNodeId)?.snapshot } : {},
+		readShared: sharedGraph.readShared,
+		writeShared: sharedGraph.writeShared,
+		getSharedDefinition: sharedGraph.getSharedDefinition,
+		listSharedDefinitions: sharedGraph.listSharedDefinitions,
+		takeSharedPatches: sharedGraph.takeSharedPatches,
+		applySharedPatch: sharedGraph.applySharedPatch,
+		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));
+			scheduleFlush();
+		},
+		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 (update.returnValue === "previous") return currentValue;
+			if (update.returnValue === "next") return nextValue;
+		},
+		call(call) {
+			const path = call.path ?? [];
+			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();
+			}
+			return result;
+		},
+		delete(deletion) {
+			const outcome = deletePath(cells.get(deletion.graphNodeId), deletion.path);
+			if (outcome.mutated) {
+				markDirtyPath(deletion.graphNodeId, deletion.path);
+				scheduleFlush();
+			}
+			return outcome.result;
+		},
+		subscribe(subscription) {
+			subscriptions.push(subscription);
+			return () => {
+				const index = subscriptions.indexOf(subscription);
+				if (index >= 0) subscriptions.splice(index, 1);
+			};
+		},
+		subscribeJournal(listener) {
+			journalListeners.push(listener);
+			return () => {
+				const index = journalListeners.indexOf(listener);
+				if (index >= 0) journalListeners.splice(index, 1);
+			};
+		},
+		flush,
+		takeJournal() {
+			return journal.splice(0);
+		}
+	};
+}
+//#endregion
+export { createRuntimeGraph as t };

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 };