@markless/runtime 0.3.2 → 0.3.3

package/dist/graph-DAwgoMQ1.js

@@ -1,941 +0,0 @@
-//#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-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-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);
-}
-//#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;
-	for (const path of asyncCommitPaths(input.node, previous, snapshot)) input.markDirtyPath(input.node.graphNodeId, path);
-	input.scheduleFlush();
-}
-/**
-* 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
-//#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,
-		invalidated: false,
-		baselineStale: false,
-		value: void 0
-	});
-	return computedNodes;
-}
-function readComputedNode(computed, readGraph, path, reconcile) {
-	const { compute } = computed;
-	if (computed.dirty && compute) {
-		const previous = computed.value;
-		const next = compute(readGraph);
-		const changed = computed.invalidated && reconcile ? diffDerivedValue({
-			previous,
-			next,
-			keyed: computed.reconcile?.keyed,
-			touched: reconcile.touched,
-			baselineStale: computed.baselineStale
-		}) : [];
-		computed.value = next;
-		computed.dirty = false;
-		computed.invalidated = false;
-		computed.baselineStale = false;
-		if (reconcile && changed.length > 0) {
-			for (const changedPath of changed) reconcile.dirtyPaths.push({
-				graphNodeId: computed.graphNodeId,
-				path: changedPath
-			});
-			reconcile.scheduleFlush();
-		}
-	}
-	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;
-	computed.invalidated = true;
-	input.dirtyComputedIds.add(input.graphNodeId);
-	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 dirtyComputedIds = /* @__PURE__ */ new Set();
-	const writeTouched = /* @__PURE__ */ new Map();
-	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 reconcileContext = {
-		dirtyPaths,
-		touched: writeTouched,
-		scheduleFlush: () => {
-			scheduleFlush();
-		}
-	};
-	const readGraph = (graphNodeId, path = []) => {
-		const computed = computedNodes.get(graphNodeId);
-		if (computed?.compute) return readComputedNode(computed, readGraph, path, reconcileContext);
-		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 recordWriteTouched = (graphNodeId, path) => {
-		if (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]]);
-		}
-	};
-	const markDirtyPath = (graphNodeId, path) => {
-		dirtyPaths.push({
-			graphNodeId,
-			path
-		});
-		recordWriteTouched(graphNodeId, path);
-		markDirtyComputedDependencies({
-			graphNodeId,
-			path,
-			computedNodes,
-			asyncComputedNodes,
-			dirtyComputedIds,
-			invalidateAsyncComputed: invalidateAsyncComputed$1
-		});
-	};
-	const scheduleFlush = () => {
-		if (flushScheduled || flushing) return;
-		flushScheduled = true;
-		scheduleMicrotask(() => {
-			flush();
-		});
-	};
-	const asyncComputedInput = () => ({
-		computedNodes,
-		asyncComputedNodes,
-		demandAsyncComputed: demandAsyncComputed$1,
-		readGraph,
-		markDirtyPath,
-		scheduleFlush
-	});
-	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 recomputeSubscribedComputeds = () => {
-		for (const graphNodeId of Array.from(dirtyComputedIds)) {
-			if (!computedNodes.get(graphNodeId)?.dirty) {
-				dirtyComputedIds.delete(graphNodeId);
-				continue;
-			}
-			if (!subscriptions.some((subscription) => subscription.graphNodeId === graphNodeId)) continue;
-			dirtyComputedIds.delete(graphNodeId);
-			readGraph(graphNodeId);
-		}
-	};
-	const settleReconcileBaselines = () => {
-		for (const graphNodeId of dirtyComputedIds) {
-			const computed = computedNodes.get(graphNodeId);
-			if (computed?.dirty) computed.baselineStale = true;
-		}
-		dirtyComputedIds.clear();
-		writeTouched.clear();
-	};
-	const runFlush = async () => {
-		flushScheduled = false;
-		flushing = true;
-		try {
-			try {
-				while (dirtyPaths.length > 0) {
-					recomputeSubscribedComputeds();
-					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 {
-				settleReconcileBaselines();
-				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);
-			const computed = computedNodes.get(write.graphNodeId);
-			if (computed && !computed.compute && path.length === 0) {
-				const changed = diffDerivedValue({
-					previous: current,
-					next: write.value,
-					keyed: computed.reconcile?.keyed,
-					touched: writeTouched,
-					baselineStale: computed.baselineStale
-				});
-				cells.set(write.graphNodeId, write.value);
-				computed.baselineStale = false;
-				if (changed.length === 0) return;
-				for (const changedPath of changed) markDirtyPath(write.graphNodeId, changedPath);
-				scheduleFlush();
-				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 { diffDerivedValue as n, createRuntimeGraph as t };