@markless/runtime 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jack Shelton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,6 @@
+# @markless/runtime
+
+Markless state graph runtime: reads, writes, computed invalidation, and the
+flush journal. Internal implementation package of `@markless/core`.
+
+See the repository for documentation: https://github.com/markless-dev/markless

package/dist/graph-B7awrnzg.js

@@ -0,0 +1,561 @@
+//#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-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,
+			demanded: initialSnapshot.status !== "idle",
+			keyValue: "key" in initialSnapshot ? initialSnapshot.key : void 0,
+			pendingSnapshotNeedsRunner: initialSnapshot.status === "pending",
+			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.pendingSnapshotNeedsRunner && input.node.snapshot.status !== "idle") return;
+	input.node.demanded = true;
+	startAsyncComputed({
+		...input,
+		key: input.node.key(input.readGraph)
+	});
+}
+function invalidateAsyncComputed(input) {
+	if (!input.node.demanded) return;
+	const nextKey = input.node.key(input.readGraph);
+	if (input.node.snapshot.status !== "idle" && Object.is(input.node.keyValue, nextKey)) return;
+	startAsyncComputed({
+		...input,
+		key: nextKey
+	});
+}
+function startAsyncComputed(input) {
+	input.node.controller?.abort();
+	input.node.pendingSnapshotNeedsRunner = false;
+	const controller = new AbortController();
+	const version = input.node.version + 1;
+	input.node.controller = controller;
+	input.node.keyValue = input.key;
+	input.node.version = version;
+	input.node.snapshot = {
+		status: "pending",
+		version,
+		key: input.key,
+		value: input.node.snapshot.value
+	};
+	const commit = (snapshot) => {
+		if (input.node.version !== version || controller.signal.aborted) return;
+		input.node.snapshot = snapshot;
+		input.markDirtyPath(input.node.graphNodeId, []);
+		input.scheduleFlush();
+	};
+	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);
+	}
+	input.markDirtyPath(input.node.graphNodeId, []);
+	input.scheduleFlush();
+}
+//#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) {
+	if (computed.dirty) {
+		computed.value = computed.compute(readGraph);
+		computed.dirty = false;
+	}
+	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) computed.dirty = true;
+	input.dirtyPaths.push({
+		graphNodeId: input.graphNodeId,
+		path: []
+	});
+	for (const dependent of input.computedNodes.values()) 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 ?? []))) 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 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);
+	const readGraph = (graphNodeId, path = []) => {
+		const computed = computedNodes.get(graphNodeId);
+		if (computed) return readComputedNode(computed, readGraph, path);
+		const asyncComputed = asyncComputedNodes.get(graphNodeId);
+		if (asyncComputed) return readAsyncComputedNode(asyncComputed, path, () => demandAsyncComputed$1(asyncComputed));
+		return readPath(cells.get(graphNodeId), path);
+	};
+	const markDirtyPath = (graphNodeId, path) => {
+		dirtyPaths.push({
+			graphNodeId,
+			path
+		});
+		markDirtyComputedDependencies({
+			graphNodeId,
+			path,
+			computedNodes,
+			asyncComputedNodes,
+			dirtyPaths,
+			invalidateAsyncComputed: invalidateAsyncComputed$1
+		});
+	};
+	const scheduleFlush = () => {
+		if (flushScheduled || flushing) return;
+		flushScheduled = true;
+		scheduleMicrotask(() => {
+			flush();
+		});
+	};
+	const demandAsyncComputed$1 = (node) => {
+		demandAsyncComputed({
+			node,
+			readGraph,
+			markDirtyPath,
+			scheduleFlush
+		});
+	};
+	const invalidateAsyncComputed$1 = (node) => {
+		invalidateAsyncComputed({
+			node,
+			readGraph,
+			markDirtyPath,
+			scheduleFlush
+		});
+	};
+	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) {
+					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 {
+				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,
+		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 (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.d.ts

@@ -0,0 +1,140 @@
+import { ProtocolStatePayload } from "@markless/serializer";
+
+//#region src/graph.d.ts
+type RuntimeGraphCell = {
+  readonly graphNodeId: string;
+  readonly value: unknown;
+};
+type RuntimeGraphRead = (graphNodeId: string, path?: ReadonlyArray<string>) => unknown;
+type RuntimeGraphComputedDependency = {
+  readonly graphNodeId: string;
+  readonly path?: ReadonlyArray<string>;
+};
+type RuntimeGraphComputed = {
+  readonly graphNodeId: string;
+  readonly dependencies: ReadonlyArray<RuntimeGraphComputedDependency>;
+  readonly compute: (read: RuntimeGraphRead) => unknown;
+};
+type RuntimeGraphAsyncSnapshot = {
+  readonly status: 'idle';
+  readonly version: 0;
+} | {
+  readonly status: 'pending';
+  readonly version: number;
+  readonly key: unknown;
+  readonly value?: unknown;
+} | {
+  readonly status: 'fulfilled';
+  readonly version: number;
+  readonly key: unknown;
+  readonly value: unknown;
+} | {
+  readonly status: 'rejected';
+  readonly version: number;
+  readonly key: unknown;
+  readonly error: unknown;
+};
+type RuntimeGraphAsyncComputed = {
+  readonly graphNodeId: string;
+  readonly dependencies: ReadonlyArray<RuntimeGraphComputedDependency>;
+  readonly initialSnapshot?: RuntimeGraphAsyncSnapshot;
+  readonly key: (read: RuntimeGraphRead) => unknown;
+  readonly run: (input: {
+    readonly key: unknown;
+    readonly signal: AbortSignal;
+    readonly read: RuntimeGraphRead;
+  }) => unknown | Promise<unknown>;
+};
+type DomJournalEntry = {
+  readonly type: 'setText';
+  readonly locator: string;
+  readonly value: unknown;
+} | {
+  readonly type: 'setAttr' | 'setProp';
+  readonly locator: string;
+  readonly name: string;
+  readonly value: unknown;
+} | {
+  readonly type: 'insertRange';
+  readonly locator: string;
+  readonly fragment: unknown;
+} | {
+  readonly type: 'removeRange';
+  readonly locator: string;
+} | {
+  readonly type: 'moveRange';
+  readonly locator: string;
+  readonly before: string;
+} | {
+  readonly type: 'runCleanup';
+  readonly locator: string;
+};
+type DomJournalResult = DomJournalEntry | ReadonlyArray<DomJournalEntry>;
+type DomJournalListener = (entries: ReadonlyArray<DomJournalEntry>) => void | Promise<void>;
+type RuntimeGraphInput = {
+  readonly cells: ReadonlyArray<RuntimeGraphCell>;
+  readonly computed?: ReadonlyArray<RuntimeGraphComputed>;
+  readonly asyncComputed?: ReadonlyArray<RuntimeGraphAsyncComputed>;
+  readonly sharedDefinitions?: ProtocolStatePayload['sharedDefinitions'];
+};
+type RuntimeGraphWrite = {
+  readonly graphNodeId: string;
+  readonly path?: ReadonlyArray<string>;
+  readonly value: unknown;
+};
+type RuntimeGraphSharedWrite = {
+  readonly definitionId: string;
+  readonly propertyName: string;
+  readonly path?: ReadonlyArray<string>;
+  readonly value: unknown;
+};
+type RuntimeGraphSharedPatchOperation = readonly [operation: 'set', path: ReadonlyArray<string>, value: unknown];
+type RuntimeGraphSharedPatch = {
+  readonly id: string;
+  readonly scope?: RuntimeSharedDefinition['scope'];
+  readonly version: number;
+  readonly patch: ReadonlyArray<RuntimeGraphSharedPatchOperation>;
+};
+type RuntimeGraphUpdate = {
+  readonly graphNodeId: string;
+  readonly path?: ReadonlyArray<string>;
+  readonly update: (value: unknown) => unknown;
+  readonly returnValue?: 'previous' | 'next';
+};
+type RuntimeGraphCall = {
+  readonly graphNodeId: string;
+  readonly path?: ReadonlyArray<string>;
+  readonly method: string;
+  readonly args?: ReadonlyArray<unknown>;
+};
+type RuntimeGraphDelete = {
+  readonly graphNodeId: string;
+  readonly path: ReadonlyArray<string>;
+};
+type RuntimeGraphSubscription = {
+  readonly id: string;
+  readonly graphNodeId: string;
+  readonly path?: ReadonlyArray<string>;
+  readonly run: (value: unknown) => DomJournalResult | void | Promise<DomJournalResult | void>;
+};
+type RuntimeGraph = {
+  readonly read: (graphNodeId: string, path?: ReadonlyArray<string>) => unknown;
+  readonly readShared: (definitionId: string, propertyName: string, path?: ReadonlyArray<string>) => unknown;
+  readonly writeShared: (write: RuntimeGraphSharedWrite) => boolean;
+  readonly getSharedDefinition: (definitionId: string) => NonNullable<ProtocolStatePayload['sharedDefinitions']>[number] | undefined;
+  readonly listSharedDefinitions: () => NonNullable<ProtocolStatePayload['sharedDefinitions']>;
+  readonly takeSharedPatches: () => RuntimeGraphSharedPatch[];
+  readonly applySharedPatch: (patch: RuntimeGraphSharedPatch) => boolean;
+  readonly write: (write: RuntimeGraphWrite) => void;
+  readonly update: (update: RuntimeGraphUpdate) => unknown;
+  readonly call: (call: RuntimeGraphCall) => unknown;
+  readonly delete: (deletion: RuntimeGraphDelete) => boolean;
+  readonly subscribe: (subscription: RuntimeGraphSubscription) => () => void;
+  readonly subscribeJournal: (listener: DomJournalListener) => () => void;
+  readonly flush: () => Promise<void>;
+  readonly takeJournal: () => DomJournalEntry[];
+};
+type RuntimeSharedDefinition = NonNullable<ProtocolStatePayload['sharedDefinitions']>[number];
+declare function createRuntimeGraph(input: RuntimeGraphInput): RuntimeGraph;
+//#endregion
+export { DomJournalEntry, DomJournalListener, DomJournalResult, RuntimeGraph, RuntimeGraphAsyncComputed, RuntimeGraphAsyncSnapshot, RuntimeGraphCall, RuntimeGraphCell, RuntimeGraphComputed, RuntimeGraphComputedDependency, RuntimeGraphDelete, RuntimeGraphInput, RuntimeGraphRead, RuntimeGraphSharedPatch, RuntimeGraphSharedPatchOperation, RuntimeGraphSharedWrite, RuntimeGraphSubscription, RuntimeGraphUpdate, RuntimeGraphWrite, createRuntimeGraph };

package/dist/graph.js

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

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { DomJournalEntry, DomJournalListener, DomJournalResult, RuntimeGraph, RuntimeGraphAsyncComputed, RuntimeGraphAsyncSnapshot, RuntimeGraphCall, RuntimeGraphCell, RuntimeGraphComputed, RuntimeGraphComputedDependency, RuntimeGraphDelete, RuntimeGraphInput, RuntimeGraphRead, RuntimeGraphSharedPatch, RuntimeGraphSharedPatchOperation, RuntimeGraphSharedWrite, RuntimeGraphSubscription, RuntimeGraphUpdate, RuntimeGraphWrite, createRuntimeGraph } from "./graph.js";
+export { DomJournalEntry, DomJournalListener, DomJournalResult, RuntimeGraph, RuntimeGraphAsyncComputed, RuntimeGraphAsyncSnapshot, RuntimeGraphCall, RuntimeGraphCell, RuntimeGraphComputed, RuntimeGraphComputedDependency, RuntimeGraphDelete, RuntimeGraphInput, RuntimeGraphRead, RuntimeGraphSharedPatch, RuntimeGraphSharedPatchOperation, RuntimeGraphSharedWrite, RuntimeGraphSubscription, RuntimeGraphUpdate, RuntimeGraphWrite, createRuntimeGraph };

package/dist/index.js

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

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@markless/runtime",
+  "version": "0.1.0",
+  "description": "Markless state graph runtime: reads, writes, computed invalidation, flush journal.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/markless-dev/markless.git",
+    "directory": "packages/runtime"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./graph": {
+      "types": "./dist/graph.d.ts",
+      "default": "./dist/graph.js"
+    }
+  },
+  "dependencies": {
+    "@markless/serializer": "0.1.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {}
+}