@markless/runtime 0.1.1 → 0.2.1

package/dist/{graph-B7awrnzg.js → graph-P12yh-2u.js}

@@ -161,9 +161,7 @@ function createRuntimeAsyncComputedNodes(asyncComputedInput) {
 		};
 		asyncComputedNodes.set(asyncComputed.graphNodeId, {
 			...asyncComputed,
-			demanded: initialSnapshot.status !== "idle",
-			keyValue: "key" in initialSnapshot ? initialSnapshot.key : void 0,
-			pendingSnapshotNeedsRunner: initialSnapshot.status === "pending",
+			gate: initialSnapshot.status === "pending" ? 1 : 0,
 			snapshot: initialSnapshot,
 			version: initialSnapshot.version
 		});
@@ -177,41 +175,75 @@ function readAsyncComputedNode(node, path, demand) {
 	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)
-	});
+	if (input.node.gate !== 1 && input.node.snapshot.status !== "idle") return;
+	advanceAsyncComputed(input);
 }
 function invalidateAsyncComputed(input) {
-	if (!input.node.demanded) return;
+	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.snapshot.status !== "idle" && Object.is(input.node.keyValue, nextKey)) return;
+	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.pendingSnapshotNeedsRunner = false;
+	input.node.gate = 0;
 	const controller = new AbortController();
-	const version = input.node.version + 1;
+	const version = ++input.node.version;
 	input.node.controller = controller;
-	input.node.keyValue = input.key;
-	input.node.version = version;
-	input.node.snapshot = {
+	publish(input, {
 		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();
+		if (input.node.version !== version) return;
+		publish(input, snapshot);
 	};
 	const commitRejected = (error) => commit({
 		status: "rejected",
@@ -233,6 +265,9 @@ function startAsyncComputed(input) {
 	} catch (error) {
 		commitRejected(error);
 	}
+}
+function publish(input, snapshot) {
+	input.node.snapshot = snapshot;
 	input.markDirtyPath(input.node.graphNodeId, []);
 	input.scheduleFlush();
 }
@@ -258,19 +293,20 @@ 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;
+	if (!computed?.compute) return;
+	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({
+	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 ?? []))) markComputedDirty({
+	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()
@@ -394,6 +430,7 @@ function createSharedGraphPlane(input) {
 //#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 = [];
@@ -403,12 +440,28 @@ function createRuntimeGraph(input) {
 	let flushScheduled = false;
 	let flushing = false;
 	let activeFlush;
-	for (const cell of input.cells) cells.set(cell.graphNodeId, cell.value);
+	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) return readComputedNode(computed, readGraph, path);
+		if (computed?.compute) return readComputedNode(computed, readGraph, path);
 		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) => {
@@ -432,22 +485,22 @@ function createRuntimeGraph(input) {
 			flush();
 		});
 	};
-	const demandAsyncComputed$1 = (node) => {
-		demandAsyncComputed({
-			node,
-			readGraph,
-			markDirtyPath,
-			scheduleFlush
-		});
-	};
-	const invalidateAsyncComputed$1 = (node) => {
-		invalidateAsyncComputed({
-			node,
-			readGraph,
-			markDirtyPath,
-			scheduleFlush
-		});
-	};
+	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,
@@ -491,6 +544,7 @@ function createRuntimeGraph(input) {
 	};
 	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,

package/dist/graph.d.ts

@@ -4,6 +4,7 @@ import { ProtocolStatePayload } from "@markless/serializer";
 type RuntimeGraphCell = {
   readonly graphNodeId: string;
   readonly value: unknown;
+  readonly readInitializer?: () => unknown;
 };
 type RuntimeGraphRead = (graphNodeId: string, path?: ReadonlyArray<string>) => unknown;
 type RuntimeGraphComputedDependency = {
@@ -15,6 +16,9 @@ type RuntimeGraphComputed = {
   readonly dependencies: ReadonlyArray<RuntimeGraphComputedDependency>;
   readonly compute: (read: RuntimeGraphRead) => unknown;
 };
+type RuntimeGraphComputedDependencyNode = Omit<RuntimeGraphComputed, 'compute'> & {
+  readonly compute?: never;
+};
 type RuntimeGraphAsyncSnapshot = {
   readonly status: 'idle';
   readonly version: 0;
@@ -73,7 +77,7 @@ type DomJournalResult = DomJournalEntry | ReadonlyArray<DomJournalEntry>;
 type DomJournalListener = (entries: ReadonlyArray<DomJournalEntry>) => void | Promise<void>;
 type RuntimeGraphInput = {
   readonly cells: ReadonlyArray<RuntimeGraphCell>;
-  readonly computed?: ReadonlyArray<RuntimeGraphComputed>;
+  readonly computed?: ReadonlyArray<RuntimeGraphComputed | RuntimeGraphComputedDependencyNode>;
   readonly asyncComputed?: ReadonlyArray<RuntimeGraphAsyncComputed>;
   readonly sharedDefinitions?: ProtocolStatePayload['sharedDefinitions'];
 };
@@ -118,7 +122,8 @@ type RuntimeGraphSubscription = {
   readonly run: (value: unknown) => DomJournalResult | void | Promise<DomJournalResult | void>;
 };
 type RuntimeGraph = {
-  readonly read: (graphNodeId: string, path?: ReadonlyArray<string>) => unknown;
+  readonly read: (graphNodeId: string, path?: ReadonlyArray<string>) => unknown; /** Available only in debug-enabled builds (`__MARKLESS_DEBUG_ENABLED__`). */
+  readonly peekAsyncSnapshot?: (graphNodeId: string) => RuntimeGraphAsyncSnapshot | undefined;
   readonly readShared: (definitionId: string, propertyName: string, path?: ReadonlyArray<string>) => unknown;
   readonly writeShared: (write: RuntimeGraphSharedWrite) => boolean;
   readonly getSharedDefinition: (definitionId: string) => NonNullable<ProtocolStatePayload['sharedDefinitions']>[number] | undefined;
@@ -137,4 +142,4 @@ type RuntimeGraph = {
 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 };
+export { DomJournalEntry, DomJournalListener, DomJournalResult, RuntimeGraph, RuntimeGraphAsyncComputed, RuntimeGraphAsyncSnapshot, RuntimeGraphCall, RuntimeGraphCell, RuntimeGraphComputed, RuntimeGraphComputedDependency, RuntimeGraphComputedDependencyNode, RuntimeGraphDelete, RuntimeGraphInput, RuntimeGraphRead, RuntimeGraphSharedPatch, RuntimeGraphSharedPatchOperation, RuntimeGraphSharedWrite, RuntimeGraphSubscription, RuntimeGraphUpdate, RuntimeGraphWrite, createRuntimeGraph };

package/dist/graph.js

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

package/dist/index.d.ts

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

package/dist/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markless/runtime",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "Markless state graph runtime: reads, writes, computed invalidation, flush journal.",
   "license": "MIT",
   "repository": {
@@ -9,7 +9,8 @@
     "directory": "packages/runtime"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
   },
   "type": "module",
   "sideEffects": false,
@@ -24,7 +25,7 @@
     }
   },
   "dependencies": {
-    "@markless/serializer": "0.1.1"
+    "@markless/serializer": "0.2.1"
   },
   "files": [
     "dist"