@mark1russell7/render-node 0.0.0-bootstrap.0 → 0.1.0

package/build/index.js

@@ -0,0 +1,846 @@
+import { isSome, none, some } from "@mark1russell7/render-optional";
+import { deps, evaluate, lit, ref } from "@mark1russell7/render-dsl";
+//#region src/equality.ts
+/**
+* Structural equality for node values.
+*
+* With reference equality only, each expression that makes an object is always dirty: each evaluation
+* gives a new object, and each epoch propagates it. Node values are plain data, thus the default is structural:
+*
+* - `Object.is` for primitives, thus `NaN` is equal to `NaN`.
+* - Element by element for arrays, own key by own key for plain objects.
+* - An exotic object (a class instance, a function, a React element) is equal only to itself.
+* - Below `MAX_DEPTH` levels, two values are not equal. This limit also stops a cyclic value.
+*/
+const MAX_DEPTH = 32;
+const hasOwn$1 = (o, key) => Object.prototype.hasOwnProperty.call(o, key);
+/** This function tells if a value is a plain object: its prototype is `Object.prototype` or `null`. */
+const isPlainObject = (v) => {
+	if (v === null || typeof v !== "object") return false;
+	const proto = Object.getPrototypeOf(v);
+	return proto === Object.prototype || proto === null;
+};
+const eq = (a, b, depth) => {
+	if (Object.is(a, b)) return true;
+	if (depth >= MAX_DEPTH) return false;
+	if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+	if (Array.isArray(a) || Array.isArray(b)) {
+		if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+		for (let i = 0; i < a.length; i++) if (!eq(a[i], b[i], depth + 1)) return false;
+		return true;
+	}
+	if (!isPlainObject(a) || !isPlainObject(b)) return false;
+	const keysA = Object.keys(a);
+	if (keysA.length !== Object.keys(b).length) return false;
+	for (const k of keysA) if (!hasOwn$1(b, k) || !eq(a[k], b[k], depth + 1)) return false;
+	return true;
+};
+/** This function compares two node values structurally. The module comment gives the rules. */
+const valueEquals = (a, b) => eq(a, b, 0);
+//#endregion
+//#region src/ops.ts
+const hasOwn = (o, key) => Object.prototype.hasOwnProperty.call(o, key);
+/**
+* The default write. It keeps the old value when the new result is structurally equal, thus an equal
+* object keeps its old reference. A change from a value to `none`, or from `none` to a value, is a change.
+*/
+const defaultSplash = (value, target) => {
+	const prev = target.value;
+	if (isSome(prev) ? isSome(value) && valueEquals(prev.value, value.value) : !isSome(value)) return false;
+	target.value = value;
+	return true;
+};
+/** The default propagation. A change of a node makes its value readers dirty. */
+const defaultFlow = (target) => target.seats;
+/**
+* The default resolution. It goes through slots as far as they exist, then through the own fields of the value.
+* A path that ends on a node gives the value of that node. For a container, this value is the record of its slots.
+* A path that stops at a container before its end reads a missing slot, thus it gives `none`.
+*/
+const defaultDeref = (root, path, store) => {
+	let current = root;
+	let i = 0;
+	while (i < path.length) {
+		const slotId = current.slots.get(path[i]);
+		if (slotId === void 0) break;
+		const next = store.nodes.get(slotId);
+		if (!next) break;
+		current = next;
+		i++;
+	}
+	if (i < path.length && current.slots.size > 0) return none;
+	if (!isSome(current.value)) return none;
+	let value = current.value.value;
+	for (; i < path.length; i++) {
+		const segment = path[i];
+		if (value === null || typeof value !== "object" || !hasOwn(value, segment)) return none;
+		value = value[segment];
+	}
+	return some(value);
+};
+/**
+* The default dependencies of a path, which agree with `defaultDeref`. The nodes that the path goes through are
+* structural targets, and the node where it ends is the terminal. A path that stops at a container before its end
+* reads a missing slot: it has no terminal, and the container is a structural target.
+*/
+const defaultTargets = (root, path, store) => {
+	const through = [];
+	let current = root;
+	let i = 0;
+	for (; i < path.length; i++) {
+		const slotId = current.slots.get(path[i]);
+		const next = slotId === void 0 ? void 0 : store.nodes.get(slotId);
+		if (!next) break;
+		through.push(current);
+		current = next;
+	}
+	if (i < path.length && current.slots.size > 0) return {
+		through: [...through, current],
+		terminal: void 0
+	};
+	return {
+		through,
+		terminal: current
+	};
+};
+/** The default semantics of a store. */
+const defaultOps = {
+	splash: defaultSplash,
+	flow: defaultFlow,
+	deref: defaultDeref,
+	targets: defaultTargets
+};
+//#endregion
+//#region src/engine.ts
+/** This function gives the internal state of a store. All stores come from `makeState`. */
+const state = (store) => store;
+/** This function gives the public view of a state. */
+const publicStore = (s) => s;
+/** This function makes the state of an empty store. */
+const makeState = (nodeOps, ops) => ({
+	nodes: /* @__PURE__ */ new Map(),
+	nodeOps,
+	ops,
+	epochStats: null,
+	nextId: 0,
+	dangling: /* @__PURE__ */ new Map(),
+	pending: null,
+	batchDepth: 0,
+	epoch: 0
+});
+/** This function makes a node that is not in a store yet. */
+const makeNode = (id, expr) => ({
+	id,
+	expr,
+	value: none,
+	reads: deps(expr),
+	seats: /* @__PURE__ */ new Set(),
+	seatsStructural: /* @__PURE__ */ new Set(),
+	seatedOn: /* @__PURE__ */ new Set(),
+	parent: void 0,
+	heldBy: /* @__PURE__ */ new Set(),
+	slots: /* @__PURE__ */ new Map(),
+	dangles: false,
+	mark: 0,
+	dirty: 0,
+	index: -1,
+	low: -1,
+	onStack: false,
+	next: null
+});
+/**
+* This function gives an ID that no node of the store has. It uses the hint when the hint is free.
+* Without a hint, the IDs have the form `n_<number>`, with a counter for each store.
+*/
+const freshId = (s, hint) => {
+	if (hint !== void 0 && !s.nodes.has(hint)) return hint;
+	const base = hint ?? "n";
+	for (;;) {
+		const id = `${base}${hint === void 0 ? "_" : "~"}${String(s.nextId++)}`;
+		if (!s.nodes.has(id)) return id;
+	}
+};
+/** This function makes the `record` expression of a container: one field for each slot. */
+const recordOf = (n) => {
+	const args = [];
+	for (const name of n.slots.keys()) args.push(lit(name), ref(n.id, name));
+	return {
+		tag: "app",
+		op: "record",
+		args
+	};
+};
+/** This function tells if the expression of a container is the record of its current slots. */
+const isRecordOf = (n) => {
+	const e = n.expr;
+	if (e.tag !== "app" || e.op !== "record" || e.args.length !== 2 * n.slots.size) return false;
+	let i = 0;
+	for (const name of n.slots.keys()) {
+		const k = e.args[i++];
+		const r = e.args[i++];
+		if (k.tag !== "lit" || k.value !== name) return false;
+		if (r.tag !== "ref" || r.path.length !== 2 || r.path[0] !== n.id || r.path[1] !== name) return false;
+	}
+	return true;
+};
+/** This function points a slot at a node and records the container in `heldBy` of the node. */
+const linkSlot = (container, name, child) => {
+	container.slots.set(name, child.id);
+	child.heldBy.add(container.id);
+};
+/** This function removes a slot. The target forgets the container when no other slot of the container points at it. */
+const unlinkSlot = (s, container, name) => {
+	const target = container.slots.get(name);
+	container.slots.delete(name);
+	if (target === void 0) return;
+	for (const other of container.slots.values()) if (other === target) return;
+	s.nodes.get(target)?.heldBy.delete(container.id);
+};
+/**
+* This function gives the chain of nodes that a read path goes through. The chain starts at the root
+* (`path[0]`, a node ID) and follows slots as far as they exist. The last node is the terminal: the path
+* reads its value. The function gives an empty chain when the root is not in the store.
+*/
+const readTargets = (nodes, path) => {
+	const rootId = path[0];
+	const root = rootId === void 0 ? void 0 : nodes.get(rootId);
+	if (!root) return [];
+	const out = [root];
+	let current = root;
+	for (let i = 1; i < path.length; i++) {
+		const slotId = current.slots.get(path[i]);
+		const next = slotId === void 0 ? void 0 : nodes.get(slotId);
+		if (!next) break;
+		current = next;
+		out.push(current);
+	}
+	return out;
+};
+/**
+* This function seats a node on the targets of its reads (the `targets` op of the store). The terminal gets a
+* value seat, and each node that the path goes through gets a structural seat. A read whose root is not in the
+* store waits in `dangling`. A missing slot of a container has no terminal. Thus a container cannot be on a
+* false cycle with a reader of one of its missing slots.
+*/
+const wireNode = (s, n) => {
+	for (const path of n.reads) {
+		const rootId = path[0];
+		const root = rootId === void 0 ? void 0 : s.nodes.get(rootId);
+		if (!root) {
+			if (rootId !== void 0) {
+				let waiting = s.dangling.get(rootId);
+				if (!waiting) s.dangling.set(rootId, waiting = /* @__PURE__ */ new Set());
+				waiting.add(n.id);
+				n.dangles = true;
+			}
+			continue;
+		}
+		const targets = s.nodeOps.targets(root, path.slice(1), publicStore(s));
+		for (const t of targets.through) {
+			const m = s.nodes.get(t.id);
+			if (!m || m === n) continue;
+			m.seatsStructural.add(n.id);
+			n.seatedOn.add(m.id);
+		}
+		const terminal = targets.terminal === void 0 ? void 0 : s.nodes.get(targets.terminal.id);
+		if (terminal && terminal !== n) {
+			terminal.seats.add(n.id);
+			n.seatedOn.add(terminal.id);
+		}
+	}
+};
+/** This function removes a node from each seat set that holds it, and from `dangling`. */
+const unwireNode = (s, n) => {
+	if (n.seatedOn.size > 0) {
+		for (const otherId of n.seatedOn) {
+			const other = s.nodes.get(otherId);
+			if (other) {
+				other.seats.delete(n.id);
+				other.seatsStructural.delete(n.id);
+			}
+		}
+		n.seatedOn.clear();
+	}
+	if (n.dangles) {
+		for (const path of n.reads) {
+			const head = path[0];
+			const waiting = head === void 0 ? void 0 : s.dangling.get(head);
+			if (waiting) {
+				waiting.delete(n.id);
+				if (waiting.size === 0) s.dangling.delete(head);
+			}
+		}
+		n.dangles = false;
+	}
+};
+/** This function changes the expression of a node and keeps its reads correct. The caller touches the node. */
+const replaceExpr = (s, n, expr) => {
+	unwireNode(s, n);
+	n.expr = expr;
+	n.reads = deps(expr);
+};
+const pending = (s) => s.pending ??= {
+	touched: /* @__PURE__ */ new Set(),
+	records: /* @__PURE__ */ new Set(),
+	expansions: /* @__PURE__ */ new Set()
+};
+/** This function marks a node for the next flush: rewire and evaluate. */
+const touch = (s, id) => {
+	pending(s).touched.add(id);
+};
+/** This function marks a container: the next flush makes its record expression again. */
+const touchRecord = (s, id) => {
+	pending(s).records.add(id);
+};
+/** This function marks a node for an expansion after the next epoch, when its value is settled. */
+const touchExpansion = (s, id) => {
+	pending(s).expansions.add(id);
+};
+/** This function adds a node to the store. Readers that waited for its ID get rewired. */
+const insertNode = (s, n) => {
+	s.nodes.set(n.id, n);
+	touch(s, n.id);
+	const waiting = s.dangling.get(n.id);
+	if (waiting) {
+		for (const r of waiting) touch(s, r);
+		s.dangling.delete(n.id);
+	}
+};
+/**
+* This function expands a node with a settled value. Each field of a plain object becomes an owned
+* slot, and a field that is a plain object becomes a container in turn. A field that holds one of its own
+* ancestors stays a leaf, thus a cyclic object gives a finite tree. The caller flushes.
+* The build uses its own stack, not the call stack, thus a deep value does not overflow it.
+*/
+const expandNow = (s, id) => {
+	const n = s.nodes.get(id);
+	const value = n && isSome(n.value) ? n.value.value : void 0;
+	if (!n || n.slots.size > 0 || !isPlainObject(value)) return;
+	const ancestors = /* @__PURE__ */ new Set([value]);
+	const frames = [{
+		owner: n,
+		value,
+		fields: Object.entries(value),
+		next: 0
+	}];
+	for (let frame = frames.at(-1); frame !== void 0; frame = frames.at(-1)) {
+		const field = frame.fields[frame.next++];
+		if (field === void 0) {
+			frames.pop();
+			ancestors.delete(frame.value);
+			if (frame.owner !== n) touchRecord(s, frame.owner.id);
+			continue;
+		}
+		const [key, fieldValue] = field;
+		const sub = makeNode(freshId(s, `${frame.owner.id}.${key}`), lit(fieldValue));
+		sub.parent = frame.owner.id;
+		sub.value = some(fieldValue);
+		insertNode(s, sub);
+		linkSlot(frame.owner, key, sub);
+		if (isPlainObject(fieldValue) && !ancestors.has(fieldValue)) {
+			ancestors.add(fieldValue);
+			frames.push({
+				owner: sub,
+				value: fieldValue,
+				fields: Object.entries(fieldValue),
+				next: 0
+			});
+		}
+	}
+	touchRecord(s, n.id);
+	for (const r of n.seats) touch(s, r);
+	for (const r of n.seatsStructural) touch(s, r);
+};
+/** This function does the pending work at once, except inside a batch. */
+const flushUnlessBatched = (s) => {
+	if (s.batchDepth === 0) flush(s);
+};
+/**
+* This function makes `fn` one transaction: the pending work of all its writes becomes one epoch at the end.
+* When `fn` throws, the flush still does the pending work, and the error of `fn` is the error of the batch.
+*/
+const runBatch = (s, fn) => {
+	s.batchDepth++;
+	let result;
+	try {
+		result = fn();
+	} catch (error) {
+		s.batchDepth--;
+		if (s.batchDepth === 0) try {
+			flush(s);
+		} catch {}
+		throw error;
+	}
+	s.batchDepth--;
+	if (s.batchDepth === 0) flush(s);
+	return result;
+};
+/** The limit of follow-up epochs in one flush. Only a custom op that writes on each epoch reaches it. */
+const MAX_FOLLOW_UPS = 1e3;
+/** The error of an op during an epoch, with the dirty nodes that the epoch did not evaluate. */
+var EpochFailure = class {
+	retry;
+	cause;
+	constructor(retry, cause) {
+		this.retry = retry;
+		this.cause = cause;
+	}
+};
+/**
+* This function does the pending work. A custom op can write during an epoch. That write does not go into
+* the epoch: it becomes pending, and the flush does it in a follow-up epoch. The stats join all epochs.
+*
+* When an op throws, the dirty nodes that the epoch did not evaluate stay pending. The next flush evaluates them,
+* and the error goes to the caller. A throw before the evaluation, for example of a custom `targets` or `flow`
+* op, keeps all the work of the round pending.
+*/
+const flush = (s) => {
+	let stats = null;
+	s.batchDepth++;
+	try {
+		for (let round = 0; s.pending; round++) {
+			if (round > MAX_FOLLOW_UPS) {
+				s.pending = null;
+				throw new Error(`The epochs did not settle after ${String(MAX_FOLLOW_UPS)} follow-ups: an op writes on each epoch.`);
+			}
+			const p = s.pending;
+			s.pending = null;
+			let epoch;
+			try {
+				for (const id of p.records) {
+					const n = s.nodes.get(id);
+					if (!n) continue;
+					if (!isRecordOf(n)) replaceExpr(s, n, recordOf(n));
+					p.touched.add(id);
+				}
+				for (const id of p.touched) {
+					const n = s.nodes.get(id);
+					if (!n) continue;
+					unwireNode(s, n);
+					wireNode(s, n);
+				}
+				epoch = runEpoch(s, p.touched);
+			} catch (failure) {
+				if (failure instanceof EpochFailure) {
+					for (const id of failure.retry) touch(s, id);
+					for (const id of p.expansions) touchExpansion(s, id);
+					throw failure.cause;
+				}
+				for (const id of p.records) touchRecord(s, id);
+				for (const id of p.touched) touch(s, id);
+				for (const id of p.expansions) touchExpansion(s, id);
+				throw failure;
+			}
+			if (!stats) stats = epoch;
+			else {
+				for (const id of epoch.evaluated) stats.evaluated.add(id);
+				for (const id of epoch.changed) stats.changed.add(id);
+				for (const id of epoch.cyclic) stats.cyclic.add(id);
+			}
+			for (const id of p.expansions) expandNow(s, id);
+		}
+	} finally {
+		s.batchDepth--;
+	}
+	s.epochStats = {
+		evaluated: stats?.evaluated ?? /* @__PURE__ */ new Set(),
+		changed: stats?.changed ?? /* @__PURE__ */ new Set(),
+		cyclic: stats?.cyclic ?? /* @__PURE__ */ new Set(),
+		total: s.nodes.size
+	};
+};
+/** This function makes the resolver that the expressions of a store use: `path[0]` is a node ID. */
+const resolverOf = (store) => (path) => {
+	const rootId = path[0];
+	const root = rootId === void 0 ? void 0 : store.nodes.get(rootId);
+	return root ? store.nodeOps.deref(root, path.length === 1 ? [] : path.slice(1), store) : none;
+};
+/**
+* The limit of the rounds of a cycle in one epoch. Like the iterative calculation of a spreadsheet, the members
+* of a cycle evaluate again until their values are stable, or until this limit.
+*/
+const MAX_CYCLE_ROUNDS = 100;
+/**
+* This function gives the strongly connected components of the closure (Tarjan, without recursion).
+* Tarjan gives each component after all components that it reaches. Thus the reverse list is a topological
+* order of the components, and each node comes after its inputs.
+*/
+const components = (closure) => {
+	const out = [];
+	const stack = [];
+	let counter = 0;
+	for (const start of closure) {
+		if (start.index !== -1) continue;
+		const frames = [];
+		const open = (v) => {
+			v.index = v.low = counter++;
+			v.onStack = true;
+			stack.push(v);
+			frames.push({
+				node: v,
+				next: 0
+			});
+		};
+		open(start);
+		while (frames.length > 0) {
+			const frame = frames[frames.length - 1];
+			const v = frame.node;
+			const successors = v.next;
+			if (frame.next < successors.length) {
+				const w = successors[frame.next++];
+				if (w.index === -1) open(w);
+				else if (w.onStack) v.low = Math.min(v.low, w.index);
+				continue;
+			}
+			frames.pop();
+			const parent = frames[frames.length - 1];
+			if (parent) parent.node.low = Math.min(parent.node.low, v.low);
+			if (v.low === v.index) {
+				const component = [];
+				let w;
+				do {
+					w = stack.pop();
+					w.onStack = false;
+					component.push(w);
+				} while (w !== v);
+				out.push(component);
+			}
+		}
+	}
+	return out.toReversed();
+};
+/**
+* One epoch. The engine finds the closure of the frontier through `flow`, and it orders the strongly connected
+* components of the closure topologically. Then it evaluates each dirty node in that order, thus each node
+* reads settled values. A node is dirty when it is in the frontier or when one of its inputs changed.
+*
+* A node outside a cycle evaluates at most one time. The members of a cycle (a component with more than one
+* node) evaluate again while one of them changes, up to `MAX_CYCLE_ROUNDS` rounds. The stats report them.
+* The machine keeps its state in the scratch fields of the nodes, with the epoch number as a stamp.
+*/
+const runEpoch = (s, frontier) => {
+	const store = publicStore(s);
+	const epoch = ++s.epoch;
+	const closure = [];
+	const stack = [];
+	const enter = (n) => {
+		n.mark = epoch;
+		n.index = -1;
+		n.low = -1;
+		n.onStack = false;
+		n.next = null;
+		stack.push(n);
+	};
+	for (const id of frontier) {
+		const n = s.nodes.get(id);
+		if (n && n.mark !== epoch) {
+			enter(n);
+			n.dirty = epoch;
+		}
+	}
+	while (stack.length > 0) {
+		const n = stack.pop();
+		closure.push(n);
+		const next = [];
+		for (const id of s.nodeOps.flow(n, store)) {
+			const m = s.nodes.get(id);
+			if (!m || m === n) continue;
+			next.push(m);
+			if (m.mark !== epoch) enter(m);
+		}
+		n.next = next;
+	}
+	const order = components(closure);
+	const resolver = resolverOf(store);
+	const evaluated = /* @__PURE__ */ new Set();
+	const changed = /* @__PURE__ */ new Set();
+	const cyclic = /* @__PURE__ */ new Set();
+	const evaluateNode = (n) => {
+		n.dirty = 0;
+		evaluated.add(n.id);
+		if (!s.nodeOps.splash(evaluate(n.expr, resolver, s.ops), n, store)) return false;
+		changed.add(n.id);
+		for (const m of n.next) m.dirty = epoch;
+		return true;
+	};
+	let position = 0;
+	try {
+		for (; position < order.length; position++) {
+			const component = order[position];
+			if (component.length === 1) {
+				const n = component[0];
+				if (n.dirty === epoch) evaluateNode(n);
+				continue;
+			}
+			for (const n of component) cyclic.add(n.id);
+			for (let round = 0; round < 100; round++) {
+				let any = false;
+				for (const n of component) if (n.dirty === epoch && evaluateNode(n)) any = true;
+				if (!any) break;
+			}
+		}
+	} catch (cause) {
+		const retry = /* @__PURE__ */ new Set();
+		for (let i = position; i < order.length; i++) for (const n of order[i]) if (n.dirty === epoch || i === position) retry.add(n.id);
+		for (const n of closure) n.next = null;
+		throw new EpochFailure(retry, cause);
+	}
+	for (const n of closure) n.next = null;
+	return {
+		evaluated,
+		changed,
+		cyclic
+	};
+};
+//#endregion
+//#region src/writes.ts
+/** This function makes an empty store. The options give its reactive semantics and its op registry. */
+const nodeStore = (options = {}) => publicStore(makeState(options.nodeOps ?? defaultOps, options.ops ?? {}));
+/**
+* This function gives an independent copy of a store: the same nodes, values, slots and seats, and the same
+* counters. A write to one store does not change the other. The expressions and the values are immutable,
+* thus the copy shares them. The options replace the semantics or the op registry of the copy, for example the
+* class semantics of a copied biblo. The function throws inside a batch, because a batch has pending work.
+*/
+const forkStore = (store, options = {}) => {
+	const s = state(store);
+	if (s.pending !== null || s.batchDepth > 0) throw new Error("forkStore: the store is in a batch");
+	const copy = {
+		nodes: /* @__PURE__ */ new Map(),
+		nodeOps: options.nodeOps ?? s.nodeOps,
+		ops: options.ops ?? s.ops,
+		epochStats: s.epochStats,
+		nextId: s.nextId,
+		dangling: new Map([...s.dangling].map(([id, readers]) => [id, new Set(readers)])),
+		pending: null,
+		batchDepth: 0,
+		epoch: s.epoch
+	};
+	for (const [id, n] of s.nodes) {
+		const node = {
+			...n,
+			seats: new Set(n.seats),
+			seatsStructural: new Set(n.seatsStructural),
+			seatedOn: new Set(n.seatedOn),
+			heldBy: new Set(n.heldBy),
+			slots: new Map(n.slots),
+			mark: 0,
+			dirty: 0,
+			index: -1,
+			low: -1,
+			onStack: false,
+			next: null
+		};
+		copy.nodes.set(id, node);
+	}
+	return publicStore(copy);
+};
+/** This function gives a node of the store, or `undefined`. */
+const getNode = (store, id) => store.nodes.get(id);
+/** This function gives the value of a node, or `none` when the store has no such node. */
+const readValue = (store, id) => store.nodes.get(id)?.value ?? none;
+/**
+* This function makes `fn` one transaction. The writes in `fn` change the structure at once, and one epoch
+* at the end evaluates all their effects. A batch inside a batch joins the outer batch.
+*/
+const batch = (store, fn) => runBatch(state(store), fn);
+/**
+* This function adds a node with an expression and evaluates it. It gives the ID of the node.
+* The ID is the hint when no node has it, otherwise a fresh ID. A reader that waited for this ID gets rewired.
+*/
+const addNode = (store, expr, idHint) => {
+	const s = state(store);
+	const n = makeNode(freshId(s, idHint), expr);
+	insertNode(s, n);
+	flushUnlessBatched(s);
+	return n.id;
+};
+/**
+* This function sets the expression of a node. This is the fundamental write.
+* The engine rewires the reads of the node, evaluates it and propagates the change.
+* A write to a container collapses it first: its own slots are removed, and the expression replaces the record.
+*/
+const setExpr = (store, id, expr) => {
+	const s = state(store);
+	const n = s.nodes.get(id);
+	if (n) {
+		if (n.slots.size > 0) collapse(s, n);
+		replaceExpr(s, n, expr);
+		touch(s, id);
+	}
+	flushUnlessBatched(s);
+};
+/**
+* This function writes a literal value: it is `setExpr` with `lit(value)`.
+* A write to a derived node makes it an input node, like a value that a person types over a formula.
+*/
+const setValue = (store, id, value) => {
+	setExpr(store, id, lit(value));
+};
+/** This function writes many literal values in one batch, thus in one epoch. */
+const fillMany = (store, writes) => {
+	batch(store, () => {
+		for (const [id, value] of writes) setValue(store, id, value);
+	});
+};
+/**
+* This function points a slot of a container at a node, or removes the slot when `childId` is `undefined`.
+* This is the structural write: the container gets a new record expression, and each reader whose path goes
+* through the container resolves its path again. A node that the container owns and drops is removed.
+* The function does nothing when a node is missing or when the child is the container itself.
+*/
+const setSlot = (store, parentId, name, childId, options = {}) => {
+	const s = state(store);
+	const parent = s.nodes.get(parentId);
+	const child = childId === void 0 ? void 0 : s.nodes.get(childId);
+	if (parent && (childId === void 0 || child && childId !== parentId) && parent.slots.get(name) !== childId) {
+		const previous = parent.slots.get(name);
+		if (previous !== void 0) unlinkSlot(s, parent, name);
+		if (child) {
+			linkSlot(parent, name, child);
+			if (options.own === true && (child.parent === void 0 || !s.nodes.has(child.parent))) child.parent = parent.id;
+		}
+		if (previous !== void 0) dropIfOwned(s, parent, previous);
+		touchRecord(s, parent.id);
+		for (const r of parent.seatsStructural) touch(s, r);
+		for (const r of parent.seats) touch(s, r);
+	}
+	flushUnlessBatched(s);
+};
+/**
+* This function expands a node whose value is a plain object. Each field becomes a slot, and
+* a field that is a plain object becomes a container in turn. The node becomes a container, and its slots
+* are from then on the source of truth of its fields. A reader of a field gets a seat on the field node,
+* thus an edit of one field makes only its own readers dirty. An expansion of a derived node keeps the current fields.
+*
+* Inside a batch, the expansion waits for the epoch of the batch, thus it uses the settled value.
+* The function does nothing for a container or for a value that is not a plain object.
+*/
+const expandNode = (store, id) => {
+	const s = state(store);
+	if (s.batchDepth > 0) touchExpansion(s, id);
+	else expandNow(s, id);
+	flushUnlessBatched(s);
+};
+/**
+* This function removes a node and the slots that it owns. The containers that hold it lose the slot.
+* Its readers resolve their paths again: a path to a removed node gives `none`. If a node with the same ID
+* comes back later, the readers find it.
+*/
+const removeNode = (store, id) => {
+	const s = state(store);
+	const n = s.nodes.get(id);
+	if (n) removeOwned(s, n);
+	flushUnlessBatched(s);
+};
+/**
+* This function evaluates the full store again. It rewires each node, makes each record expression again,
+* and starts one epoch in which each node evaluates one time in topological order. The operations keep the
+* store consistent, thus this function is a repair tool. It does not revert a write.
+*/
+const resolveAll = (store) => {
+	const s = state(store);
+	for (const n of s.nodes.values()) {
+		touch(s, n.id);
+		if (n.slots.size > 0) touchRecord(s, n.id);
+	}
+	flushUnlessBatched(s);
+};
+/** A node that the container owns and no longer holds is removed: it was a part of the container. */
+const dropIfOwned = (s, container, childId) => {
+	const former = s.nodes.get(childId);
+	if (!former || former.parent !== container.id) return;
+	for (const target of container.slots.values()) if (target === childId) return;
+	removeOwned(s, former);
+};
+/** A container gives up its slots: the owned slot nodes are removed, and the shared ones are only released. */
+const collapse = (s, n) => {
+	const slots = [...n.slots.values()];
+	for (const name of Array.from(n.slots.keys())) unlinkSlot(s, n, name);
+	for (const childId of slots) {
+		const child = s.nodes.get(childId);
+		if (child && child.parent === n.id) removeOwned(s, child);
+	}
+	for (const r of n.seatsStructural) touch(s, r);
+};
+/** This function removes a node and its owned slot subtree, and touches each reader that stays. */
+const removeOwned = (s, root) => {
+	const doomed = [];
+	const doomedIds = /* @__PURE__ */ new Set();
+	for (const todo = [root]; todo.length > 0;) {
+		const n = todo.pop();
+		if (n === void 0 || doomedIds.has(n.id)) continue;
+		doomedIds.add(n.id);
+		doomed.push(n);
+		for (const childId of n.slots.values()) {
+			const child = s.nodes.get(childId);
+			if (child && child.parent === n.id) todo.push(child);
+		}
+	}
+	for (const n of doomed) {
+		for (const r of n.seatsStructural) touch(s, r);
+		for (const r of n.seats) touch(s, r);
+		for (const holderId of Array.from(n.heldBy)) {
+			const holder = doomedIds.has(holderId) ? void 0 : s.nodes.get(holderId);
+			if (!holder) continue;
+			for (const [name, target] of Array.from(holder.slots)) if (target === n.id) unlinkSlot(s, holder, name);
+			touchRecord(s, holder.id);
+			for (const r of holder.seatsStructural) touch(s, r);
+		}
+	}
+	for (const n of doomed) for (const target of n.slots.values()) if (!doomedIds.has(target)) s.nodes.get(target)?.heldBy.delete(n.id);
+	for (const n of doomed) {
+		for (const readerId of n.seats) s.nodes.get(readerId)?.seatedOn.delete(n.id);
+		for (const readerId of n.seatsStructural) s.nodes.get(readerId)?.seatedOn.delete(n.id);
+		n.seats.clear();
+		n.seatsStructural.clear();
+	}
+	for (const n of doomed) {
+		unwireNode(s, n);
+		s.nodes.delete(n.id);
+	}
+};
+//#endregion
+//#region src/toposort.ts
+/**
+* This function sorts the nodes of a store by their static dependencies (Kahn's algorithm).
+*
+* The edges come from the `targets` op of the store, like the seat wiring.
+* A reader depends on the terminal of each path and on each node that the path goes through.
+* A path to a node that is not in the store adds no edge.
+*
+* The result has the dependencies before their readers. A node on a cycle of two or more nodes is not in the
+* result. A reference of a node to itself adds no edge. The epochs of the engine use the edges of `flow`
+* instead, thus this function is a tool for analysis.
+*/
+const toposort = (store) => {
+	const dependedBy = /* @__PURE__ */ new Map();
+	const inDegree = /* @__PURE__ */ new Map();
+	for (const id of store.nodes.keys()) {
+		dependedBy.set(id, /* @__PURE__ */ new Set());
+		inDegree.set(id, 0);
+	}
+	for (const [id, n] of store.nodes) for (const path of n.reads) {
+		const root = path[0] === void 0 ? void 0 : store.nodes.get(path[0]);
+		if (!root) continue;
+		const { through, terminal } = store.nodeOps.targets(root, path.slice(1), store);
+		for (const target of terminal === void 0 ? through : [...through, terminal]) {
+			const readers = dependedBy.get(target.id);
+			if (target.id === id || readers.has(id)) continue;
+			readers.add(id);
+			inDegree.set(id, inDegree.get(id) + 1);
+		}
+	}
+	const order = [];
+	for (const [id, d] of inDegree) if (d === 0) order.push(id);
+	for (let head = 0; head < order.length; head++) for (const readerId of dependedBy.get(order[head])) {
+		const d = inDegree.get(readerId) - 1;
+		inDegree.set(readerId, d);
+		if (d === 0) order.push(readerId);
+	}
+	return order;
+};
+//#endregion
+export { MAX_CYCLE_ROUNDS, addNode, batch, defaultDeref, defaultFlow, defaultOps, defaultSplash, defaultTargets, expandNode, fillMany, forkStore, getNode, isPlainObject, nodeStore, readTargets, readValue, removeNode, resolveAll, setExpr, setSlot, setValue, resolverOf as storeResolver, toposort, valueEquals };
+
+//# sourceMappingURL=index.js.map