process-graph 1.0.6 → 1.1.1

package/dist/store-BcR70CaO.js

@@ -0,0 +1,1287 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { a as validateOverlay, c as fragmentOperators, d as overlayStatuses, f as participantKinds, l as messageModes, p as pseudoRoles, r as overlaySchema, s as elementKinds, t as modelSchema, u as notations } from "./schema-CVnS6HiX.js";
+import { t as validate } from "./validate-DF3mQZww.js";
+import { r as loopTransitions } from "./control-aDk9560d.js";
+import { z } from "zod";
+import { and, asc, eq, inArray, sql } from "drizzle-orm";
+import { index, integer, primaryKey, sqliteTable, text } from "drizzle-orm/sqlite-core";
+//#region ../../core/graph/store-contract/dist/schema.js
+/**
+* The model's own record schemas, taken from `modelSchema` rather than restated, so what the store accepts is exactly a model or a slice of one and can never drift from it.
+*/
+const modelShape = modelSchema.unwrap().shape;
+/** The model's `activity` element: the first variant of its element union. A type test pins the order, so reordering the union is a compile error. */
+const [activityElementSchema] = modelShape.elements.unwrap().element.options;
+/** The name a store files a model under. Any non-empty string; the store gives it no structure. */
+const modelIdSchema = z.string().min(1);
+/**
+* A position in the store's history. Every change to any model takes the next revision from one store-wide sequence, so revisions only grow, a model's revision is the revision of its last change, and a model deleted and saved again never reuses an earlier one.
+*/
+const revisionSchema = z.int().positive();
+/**
+* An activity bound to the external record it stands for. `source` is required here, where the model leaves it optional: a bound item's identity is its source record, and the source-qualified identifier is its element id.
+*/
+const boundActivitySchema = activityElementSchema.unwrap().extend({ source: z.string().min(1) }).refine((activity) => activity.id === activity.source, {
+	message: "a bound activity's id must equal its source",
+	path: ["id"]
+}).readonly();
+/** The relation kinds a store keeps beside a model, the same kinds a source reports. */
+const relationKinds = [
+	"child-of",
+	"assigned-to",
+	"part-of"
+];
+/**
+* A structural link the model has no field for, kept beside it: `child-of` from a sub-task element to its parent element, `assigned-to` from an element to a person participant, `part-of` from one participant to the participant that contains it (a repository to its organisation). A relation is identified by its kind and its two ends. Relations carry no ordering, so the structural queries never treat a parent as waiting on its children.
+*/
+const relationSchema = z.strictObject({
+	kind: z.enum(relationKinds),
+	from: z.string().min(1),
+	to: z.string().min(1)
+}).readonly();
+/**
+* Items read from a source, to be merged into a stored model by identifier. Each participant, activity and transition replaces the one with the same id or is appended after the existing ones; the overlay's entries replace the run state of the elements they name; each relation not already stored is appended. Everything else in the model is left as it is.
+*/
+const boundItemsSchema = z.strictObject({
+	participants: z.array(modelShape.participants.unwrap().element).readonly(),
+	activities: z.array(boundActivitySchema).readonly(),
+	transitions: z.array(modelShape.transitions.unwrap().element).readonly(),
+	overlay: overlaySchema,
+	relations: z.array(relationSchema).readonly().exactOptional()
+}).readonly();
+/** One stored model and the run state laid over it, at the revision of its last change. */
+const storedModelSchema = z.strictObject({
+	modelId: modelIdSchema,
+	revision: revisionSchema,
+	model: modelSchema,
+	overlay: overlaySchema
+}).readonly();
+/** A stored model's name and the revision of its last change. */
+const modelSummarySchema = z.strictObject({
+	modelId: modelIdSchema,
+	revision: revisionSchema
+}).readonly();
+/** An element reached by a traversal and its distance from the start, in transitions. */
+const reachSchema = z.strictObject({
+	element: z.string(),
+	distance: z.int().positive()
+}).readonly();
+/** The kinds of change a store reports. */
+const changeKinds = [
+	"saved",
+	"overlay",
+	"items",
+	"deleted"
+];
+/**
+* A change to a model. `revision` is the revision the change took. `missed` says the subscriber missed one or more changes and should load the model again: it is sent at the start of a subscription that names a revision the model is no longer at (the model changed, or has gone), and in place of the changes a subscriber that reads too slowly has let pile up beyond its subscription's capacity.
+*/
+const storeChangeSchema = z.union([z.strictObject({
+	modelId: modelIdSchema,
+	kind: z.enum(changeKinds),
+	revision: revisionSchema
+}).readonly(), z.strictObject({
+	modelId: modelIdSchema,
+	kind: z.literal("missed")
+}).readonly()]);
+/** A structural issue in a model or overlay, as `validate` and `validateOverlay` report it. */
+const issueSchema = z.strictObject({
+	code: z.string(),
+	message: z.string()
+}).readonly();
+//#endregion
+//#region ../../core/graph/store-contract/dist/errors.js
+/**
+* The one error a `GraphStore` implementation throws for an expected failure. `createGraphStoreRouter` turns it into the contract's typed oRPC error, so every store reports failures the same way over every transport.
+*/
+var GraphStoreError = class extends Error {
+	/** What went wrong. */
+	failure;
+	/**
+	* @param failure - What went wrong.
+	*/
+	constructor(failure) {
+		super(failure.kind === "not-found" ? failure.element === void 0 ? `No model "${failure.modelId}"` : `Model "${failure.modelId}" has no element "${failure.element}"` : `Invalid change: ${failure.issues.map((issue) => issue.message).join("; ")}`);
+		this.name = "GraphStoreError";
+		this.failure = failure;
+	}
+};
+//#endregion
+//#region ../../core/graph/store-contract/dist/feed.js
+/**
+* How many undelivered changes a subscription holds by default before it collapses them into `missed`.
+*
+* A change tells a subscriber only that its model has moved on to a later revision, and the one thing a subscriber can do about it is read the model again. A subscriber that has not yet taken one pending change will read the model after that change, and the model it reads already reflects every later one, so a second pending change gives it nothing it could act on: one held change is all a lagging subscriber can use. A subscriber that is waiting when a change commits receives it directly and never touches the buffer, so a subscriber that keeps reading misses nothing at this capacity.
+*/
+const defaultSubscriptionCapacity = 1;
+/** Checks a capacity is a positive integer, since a subscription must be able to hold the `missed` it reports. */
+const checkedCapacity = (capacity) => {
+	if (!Number.isInteger(capacity) || capacity < 1) throw new RangeError(`A subscription capacity must be a positive integer, not ${capacity}`);
+	return capacity;
+};
+/**
+* Fans the changes one store makes out to every subscriber of the model they touch. A store publishes after each committed write; the router reads a subscription for `changes`.
+*
+* A subscription is registered the moment `subscribe` returns, so a caller can subscribe first and then read the current revision without missing a change made in between. A change that arrives while the subscriber is waiting is handed straight to it; one that arrives while it is busy is held, up to the subscription's capacity. Past that, the held changes are replaced by a single `missed` event: memory stays bounded however slowly a subscriber reads, and a subscriber is never left unaware that it fell behind.
+*
+* A feed only sees the writes made through the store that owns it. Several processes or tabs writing to one database each need their own bridge (a `BroadcastChannel`, a database notification) that publishes the others' changes into their feed.
+*/
+var ChangeFeed = class {
+	#listeners = /* @__PURE__ */ new Map();
+	#capacity;
+	/**
+	* @param options - The capacity every subscription gets unless it sets its own.
+	* @throws RangeError when the capacity is not a positive integer.
+	*/
+	constructor(options = {}) {
+		this.#capacity = checkedCapacity(options.capacity ?? 1);
+	}
+	/**
+	* Delivers a change to every current subscriber of its model.
+	* @param change - The change, after it is committed.
+	*/
+	publish(change) {
+		for (const listener of this.#listeners.get(change.modelId) ?? []) listener(change);
+	}
+	/**
+	* Subscribes to one model's changes from now on.
+	* @param modelId - The model to follow.
+	* @param options - The signal that ends it, and a capacity overriding the feed's.
+	* @returns The live subscription.
+	* @throws RangeError when the capacity is not a positive integer.
+	*/
+	subscribe(modelId, options = {}) {
+		const { signal } = options;
+		const capacity = checkedCapacity(options.capacity ?? this.#capacity);
+		let buffered = [];
+		let waiting;
+		let closed = false;
+		const listeners = this.#listeners.get(modelId) ?? /* @__PURE__ */ new Set();
+		this.#listeners.set(modelId, listeners);
+		const finished = {
+			done: true,
+			value: void 0
+		};
+		const listener = (change) => {
+			if (waiting === void 0) buffered = buffered.length < capacity ? [...buffered, change] : [{
+				modelId,
+				kind: "missed"
+			}];
+			else {
+				waiting({
+					done: false,
+					value: change
+				});
+				waiting = void 0;
+			}
+		};
+		const close = () => {
+			if (closed) return;
+			closed = true;
+			listeners.delete(listener);
+			if (listeners.size === 0) this.#listeners.delete(modelId);
+			signal?.removeEventListener("abort", close);
+			waiting?.(finished);
+			waiting = void 0;
+		};
+		listeners.add(listener);
+		signal?.addEventListener("abort", close);
+		if (signal?.aborted === true) close();
+		const iterator = {
+			next: async () => {
+				const [change, ...rest] = buffered;
+				buffered = rest;
+				if (change !== void 0) return {
+					done: false,
+					value: change
+				};
+				if (closed) return finished;
+				return new Promise((resolve) => {
+					waiting = resolve;
+				});
+			},
+			return: async () => {
+				close();
+				return Promise.resolve(finished);
+			}
+		};
+		return {
+			close,
+			[Symbol.asyncIterator]: () => iterator
+		};
+	}
+};
+//#endregion
+//#region ../../core/graph/store-contract/dist/merge.js
+/** A model with nothing in it, which `items.upsert` starts from when the model does not exist yet. */
+const emptyModel = {
+	participants: [],
+	events: [],
+	actions: [],
+	artefacts: [],
+	elements: [],
+	transitions: [],
+	fragments: [],
+	projections: []
+};
+/** Replaces each record of `current` that an incoming record shares an id with, in place, and appends the rest in their incoming order. */
+const upsertById = (current, incoming) => {
+	const replacements = new Map(incoming.map((record) => [record.id, record]));
+	const known = new Set(current.map(({ id }) => id));
+	return [...current.map((record) => replacements.get(record.id) ?? record), ...incoming.filter(({ id }) => !known.has(id))];
+};
+/**
+* Merges items read from a source into a model and its overlay: participants, activities and transitions by id, replacing a record in its place or appending a new one; overlay entries replace the run state of the elements they name. The result is not checked; see `checkStored`.
+* @param model - The stored model.
+* @param overlay - The stored overlay.
+* @param items - The items to merge.
+* @returns The merged model and overlay.
+*/
+const mergeBoundItems = (model, overlay, items) => ({
+	model: {
+		...model,
+		participants: upsertById(model.participants, items.participants),
+		elements: upsertById(model.elements, items.activities),
+		transitions: upsertById(model.transitions, items.transitions)
+	},
+	overlay: {
+		...overlay,
+		...items.overlay
+	}
+});
+/**
+* Keeps only the overlay entries that name an element of the model, so replacing a model drops the run state of elements it no longer declares.
+* @param model - The model the overlay is for.
+* @param overlay - The overlay to narrow.
+* @returns The entries whose key is an element of `model`.
+*/
+const overlayWithin = (model, overlay) => {
+	const elements = new Set(model.elements.map(({ id }) => id));
+	return Object.fromEntries(Object.entries(overlay).filter(([id]) => elements.has(id)));
+};
+/**
+* Checks a model and overlay a write is about to store. Every store runs this before committing, so a store never holds a model `validate` rejects or an overlay entry for an element the model does not declare.
+* @param model - The model to store.
+* @param overlay - The overlay to store with it.
+* @throws GraphStoreError with `invalid` and every issue found, when there is any.
+*/
+const checkStored = (model, overlay) => {
+	const issues = [...validate(model), ...validateOverlay(model, overlay)];
+	if (issues.length > 0) throw new GraphStoreError({
+		kind: "invalid",
+		issues
+	});
+};
+//#endregion
+//#region ../../core/graph/store-contract/dist/hierarchy.js
+/** Which identifier space each end of a relation of each kind names: a sub-task and its parent are elements, an assignee and a containing organisation are participants. */
+const endpoints = {
+	"child-of": {
+		from: "element",
+		to: "element"
+	},
+	"assigned-to": {
+		from: "element",
+		to: "participant"
+	},
+	"part-of": {
+		from: "participant",
+		to: "participant"
+	}
+};
+/** The identity of a relation: one relation of a kind between two identifiers, however often it is reported. */
+const relationKey = (relation) => JSON.stringify([
+	relation.kind,
+	relation.from,
+	relation.to
+]);
+/**
+* Adds relations to a stored list: one already there is kept in its place, and a new one is appended in its incoming order, each distinct relation once.
+* @param current - The stored relations.
+* @param incoming - The relations to add.
+* @returns The merged relations.
+*/
+const mergeRelations = (current, incoming) => {
+	return [...new Map([...current, ...incoming].map((relation) => [relationKey(relation), relation])).values()];
+};
+/** The identifiers a model declares in each space a relation can name. */
+const spacesOf = (model) => ({
+	element: new Set(model.elements.map(({ id }) => id)),
+	participant: new Set(model.participants.map(({ id }) => id))
+});
+/**
+* Keeps only the relations both of whose ends the model still declares, in the space their kind names, so replacing a model drops the relations of what it no longer has.
+* @param model - The model the relations are for.
+* @param relations - The relations to narrow.
+* @returns The relations whose ends are both declared.
+*/
+const relationsWithin = (model, relations) => {
+	const spaces = spacesOf(model);
+	return relations.filter((relation) => spaces[endpoints[relation.kind].from].has(relation.from) && spaces[endpoints[relation.kind].to].has(relation.to));
+};
+/**
+* The issues with a model's relations: an end that names nothing the model declares in the space its kind requires is an `unknown-reference`, as an unknown reference anywhere else in a model is.
+* @param model - The model the relations are for.
+* @param relations - The relations to check.
+* @returns One issue per end that names nothing, empty when every end resolves.
+*/
+const relationIssues = (model, relations) => {
+	const spaces = spacesOf(model);
+	return relations.flatMap((relation) => ["from", "to"].flatMap((end) => {
+		const space = endpoints[relation.kind][end];
+		const id = relation[end];
+		return spaces[space].has(id) ? [] : [{
+			code: "unknown-reference",
+			message: `${relation.kind} relation ${end} refers to unknown ${space} id "${id}"`
+		}];
+	}));
+};
+/**
+* Orders elements by their position in the model. Every element a hierarchy query reports is the end of a stored `child-of` relation, which `relationIssues` has checked the model declares.
+* @throws Error for an element the model does not declare, which only a store that skipped that check can cause.
+*/
+const byModelOrder = (model) => {
+	const order = new Map(model.elements.map(({ id }, index) => [id, index]));
+	const positionOf = (element) => {
+		const position = order.get(element);
+		if (position === void 0) throw new Error(`No element "${element}" in the model`);
+		return position;
+	};
+	return (left, right) => positionOf(left) - positionOf(right);
+};
+/**
+* Breadth-first walk along `child-of` relations from `start`, with the fewest steps it takes to reach each element, by that distance and then model order. `start` itself is never reported, so a cycle of `child-of` relations through it ends the walk.
+*/
+const walk$1 = (model, relations, start, direction) => {
+	const next = /* @__PURE__ */ new Map();
+	for (const { kind, from, to } of relations) if (kind === "child-of") {
+		const [key, value] = direction === "down" ? [to, from] : [from, to];
+		next.set(key, [...next.get(key) ?? [], value]);
+	}
+	const compare = byModelOrder(model);
+	const distance = /* @__PURE__ */ new Map([[start, 0]]);
+	let frontier = [start];
+	for (let depth = 1; frontier.length > 0; depth += 1) {
+		const reached = [...new Set(frontier.flatMap((element) => next.get(element) ?? []))].filter((element) => !distance.has(element));
+		for (const element of reached) distance.set(element, depth);
+		frontier = reached;
+	}
+	distance.delete(start);
+	return [...distance].map(([element, steps]) => ({
+		element,
+		distance: steps
+	})).sort((left, right) => left.distance - right.distance || compare(left.element, right.element));
+};
+/**
+* The direct children of an element: every element related to it by `child-of`.
+* @param model - The model, which declares `element`.
+* @param relations - The model's relations.
+* @param element - The parent.
+* @returns The children, in model order.
+*/
+const childrenOf = (model, relations, element) => [...new Set(relations.filter(({ kind, to }) => kind === "child-of" && to === element).map(({ from }) => from))].filter((child) => child !== element).sort(byModelOrder(model));
+/**
+* Everything beneath an element: its children, their children and so on, each with the fewest `child-of` steps between them.
+* @param model - The model, which declares `element`.
+* @param relations - The model's relations.
+* @param element - The element at the top.
+* @returns The descendants, by distance and then model order.
+*/
+const descendantsOf = (model, relations, element) => walk$1(model, relations, element, "down");
+/**
+* Everything above an element: its parents, their parents and so on, nearest first.
+* @param model - The model, which declares `element`.
+* @param relations - The model's relations.
+* @param element - The element at the bottom.
+* @returns The ancestors, by distance and then model order.
+*/
+const ancestorsOf = (model, relations, element) => walk$1(model, relations, element, "up");
+//#endregion
+//#region ../../adapters/graph/store-sqlite/dist/database.js
+/**
+* Runs steps one after another, each starting once the one before has finished: the statements of one transaction, which must not overlap on a connection.
+* @param steps - The steps, in order.
+*/
+const sequentially = async (steps) => {
+	await steps.reduce(async (previous, step) => {
+		await previous;
+		return step();
+	}, Promise.resolve());
+};
+/**
+* Runs work inside one immediate transaction: committed when the work resolves, rolled back when it throws, and the error rethrown.
+*
+* The transaction is opened with plain statements rather than Drizzle's `transaction`, whose callback must be synchronous on a synchronous driver and asynchronous on an async one. The caller must hold the connection exclusively for the duration, so no other work interleaves between the statements.
+* @param db - The database.
+* @param work - The work to run.
+* @returns What the work returns.
+*/
+const inTransaction = async (db, work) => {
+	await db.run(sql`BEGIN IMMEDIATE`);
+	try {
+		const result = await work();
+		await db.run(sql`COMMIT`);
+		return result;
+	} catch (error) {
+		await db.run(sql`ROLLBACK`);
+		throw error;
+	}
+};
+/**
+* An `Exclusive` for one process: operations wait for the one before to settle, in call order.
+* @returns The serialiser.
+*/
+const serialised = () => {
+	let tail = Promise.resolve();
+	return async (operation) => {
+		const result = tail.then(operation);
+		tail = result.then(() => void 0, () => void 0);
+		return result;
+	};
+};
+//#endregion
+//#region ../../adapters/graph/store-sqlite/dist/generated/migrations.js
+const migrations = [{
+	"sql": [
+		"CREATE TABLE `actions` (\n	`model_id` text NOT NULL,\n	`id` text NOT NULL,\n	`position` integer NOT NULL,\n	`name` text NOT NULL,\n	CONSTRAINT `actions_pk` PRIMARY KEY(`model_id`, `id`)\n);\n",
+		"\nCREATE TABLE `artefacts` (\n	`model_id` text NOT NULL,\n	`id` text NOT NULL,\n	`position` integer NOT NULL,\n	`name` text NOT NULL,\n	`deliverable` integer,\n	CONSTRAINT `artefacts_pk` PRIMARY KEY(`model_id`, `id`)\n);\n",
+		"\nCREATE TABLE `elements` (\n	`model_id` text NOT NULL,\n	`id` text NOT NULL,\n	`position` integer NOT NULL,\n	`kind` text NOT NULL,\n	`label` text,\n	`actor` text,\n	`action` text,\n	`source` text,\n	`affects` text,\n	`consumes` text,\n	`produces` text,\n	`parent` text,\n	`entry` text,\n	`exit` text,\n	`role` text,\n	`from_actor` text,\n	`to_actor` text,\n	`mode` text,\n	`event` text,\n	`extensions` text,\n	CONSTRAINT `elements_pk` PRIMARY KEY(`model_id`, `id`)\n);\n",
+		"\nCREATE TABLE `events` (\n	`model_id` text NOT NULL,\n	`id` text NOT NULL,\n	`position` integer NOT NULL,\n	`name` text NOT NULL,\n	`payload` text,\n	CONSTRAINT `events_pk` PRIMARY KEY(`model_id`, `id`)\n);\n",
+		"\nCREATE TABLE `fragments` (\n	`model_id` text NOT NULL,\n	`id` text NOT NULL,\n	`position` integer NOT NULL,\n	`operator` text NOT NULL,\n	`operands` text NOT NULL,\n	CONSTRAINT `fragments_pk` PRIMARY KEY(`model_id`, `id`)\n);\n",
+		"\nCREATE TABLE `models` (\n	`id` text PRIMARY KEY,\n	`revision` integer NOT NULL,\n	`views` text\n);\n",
+		"\nCREATE TABLE `overlay` (\n	`model_id` text NOT NULL,\n	`element` text NOT NULL,\n	`status` text NOT NULL,\n	CONSTRAINT `overlay_pk` PRIMARY KEY(`model_id`, `element`)\n);\n",
+		"\nCREATE TABLE `participants` (\n	`model_id` text NOT NULL,\n	`id` text NOT NULL,\n	`position` integer NOT NULL,\n	`label` text NOT NULL,\n	`kind` text NOT NULL,\n	CONSTRAINT `participants_pk` PRIMARY KEY(`model_id`, `id`)\n);\n",
+		"\nCREATE TABLE `projections` (\n	`model_id` text NOT NULL,\n	`position` integer NOT NULL,\n	`id` text NOT NULL,\n	`notation` text NOT NULL,\n	`subject` text,\n	`scenario` text,\n	CONSTRAINT `projections_pk` PRIMARY KEY(`model_id`, `position`)\n);\n",
+		"\nCREATE TABLE `sequences` (\n	`name` text PRIMARY KEY,\n	`value` integer NOT NULL\n);\n",
+		"\nCREATE TABLE `transitions` (\n	`model_id` text NOT NULL,\n	`id` text NOT NULL,\n	`position` integer NOT NULL,\n	`source` text NOT NULL,\n	`target` text NOT NULL,\n	`trigger` text,\n	`guard` text,\n	`condition` text,\n	`effect` text,\n	`loop` integer NOT NULL,\n	CONSTRAINT `transitions_pk` PRIMARY KEY(`model_id`, `id`)\n);\n",
+		"\nCREATE INDEX `transitions_by_target` ON `transitions` (`model_id`,`target`);",
+		"\nCREATE INDEX `transitions_by_source` ON `transitions` (`model_id`,`source`);"
+	],
+	"bps": true,
+	"folderMillis": 1791646949e3,
+	"hash": "78b8523685396fc94dd78dccb22bc64697fc985a1be4e398b34e86af9f2b9bd3",
+	"name": "20261010154229_init"
+}, {
+	"sql": ["CREATE TABLE `relations` (\n	`model_id` text NOT NULL,\n	`kind` text NOT NULL,\n	`from_id` text NOT NULL,\n	`to_id` text NOT NULL,\n	`position` integer NOT NULL,\n	CONSTRAINT `relations_pk` PRIMARY KEY(`model_id`, `kind`, `from_id`, `to_id`)\n);\n", "\nCREATE INDEX `relations_by_to` ON `relations` (`model_id`,`kind`,`to_id`);"],
+	"bps": true,
+	"folderMillis": 1791685834e3,
+	"hash": "441d05be00056c89f041364a03d9068c26d7a277538cf0561ae0fe198daecafc",
+	"name": "20261011023034_relations"
+}];
+//#endregion
+//#region ../../adapters/graph/store-sqlite/dist/migrate.js
+/** The journal table drizzle's own migrators keep, so a database migrated here is one drizzle-kit recognises, and the reverse. */
+const journal = "__drizzle_migrations";
+const appliedRow = z.tuple([z.string().nullable()]);
+/**
+* Brings a database up to the package's schema by applying, in one transaction, every embedded drizzle-kit migration its journal does not name, and recording each in drizzle's `__drizzle_migrations` journal with the name, hash and folder time drizzle's own migrators record. A migration is matched by name, as drizzle's `getMigrationsToRun` matches it.
+*
+* Drizzle's migrators cannot serve every runtime: `drizzle-orm/migrator` reads the migrations folder through `node:fs`, and `migrateAsync` reads its journal in object mode, which the `sqlite-proxy` session refuses. This one reads the journal through `values`, which every async SQLite driver answers, and takes the migrations from the package itself, so a Node process and a browser worker apply exactly the same statements.
+* @param db - The database to migrate. The caller holds it exclusively for the duration.
+* @param options - What to apply and how to stamp it.
+*/
+const migrate = async (db, options = {}) => {
+	const { migrations: available = migrations, now = () => /* @__PURE__ */ new Date() } = options;
+	await db.run(sql`CREATE TABLE IF NOT EXISTS ${sql.identifier(journal)} (id INTEGER PRIMARY KEY, hash text NOT NULL, created_at numeric, name text, applied_at TEXT)`);
+	const applied = new Set((await db.values(sql`SELECT name FROM ${sql.identifier(journal)}`)).map((row) => appliedRow.parse(row)[0]));
+	const pending = available.filter(({ name }) => !applied.has(name));
+	if (pending.length === 0) return;
+	await inTransaction(db, async () => sequentially(pending.flatMap((migration) => [...migration.sql.map((statement) => sql.raw(statement)), sql`INSERT INTO ${sql.identifier(journal)} ("hash", "created_at", "name", "applied_at") VALUES (${migration.hash}, ${migration.folderMillis}, ${migration.name}, ${now().toISOString()})`]).map((statement) => async () => {
+		await db.run(statement);
+	})));
+};
+//#endregion
+//#region ../../adapters/graph/store-sqlite/dist/queries.js
+/** The element kinds the queries pass through and never report. */
+const control = sql`('decision', 'pseudo')`;
+/** Whether the overlay records `element` (an SQL expression) as done in `modelId`. */
+const isDone = (modelId, element) => sql`EXISTS (SELECT 1 FROM overlay o WHERE o.model_id = ${modelId} AND o.element = ${element} AND o.status = 'done')`;
+const reachRow = z.tuple([z.string(), z.number().int().positive()]);
+const idRow = z.tuple([z.string()]);
+const upstream = {
+	from: sql.raw("target"),
+	to: sql.raw("source")
+};
+const downstream = {
+	from: sql.raw("source"),
+	to: sql.raw("target")
+};
+/**
+* Every element not done and not a control element reachable from `element` along non-loop transitions in one direction, expanding only elements that are not done, with the fewest transitions it takes, by that distance and then model order.
+*
+* Distances are capped at the model's element count: no shortest path is longer, and the cap ends the recursion on a model whose transitions cycle without a decision.
+*/
+const walk = async (db, { modelId, element }, { from, to }) => {
+	return (await db.values(sql`
+    WITH RECURSIVE
+      bound(n) AS (SELECT count(*) FROM elements WHERE model_id = ${modelId}),
+      walk(element, distance) AS (
+        SELECT t.${to}, 1 FROM transitions t
+          WHERE t.model_id = ${modelId} AND t.${from} = ${element} AND t.loop = 0
+        UNION
+        SELECT t.${to}, w.distance + 1 FROM walk w
+          JOIN transitions t ON t.model_id = ${modelId} AND t.${from} = w.element AND t.loop = 0
+          WHERE w.distance < (SELECT n FROM bound)
+            AND NOT ${isDone(modelId, sql`w.element`)}
+      )
+    SELECT w.element, min(w.distance) AS distance
+      FROM walk w
+      JOIN elements e ON e.model_id = ${modelId} AND e.id = w.element
+      WHERE w.element <> ${element}
+        AND e.kind NOT IN ${control}
+        AND NOT ${isDone(modelId, sql`w.element`)}
+      GROUP BY w.element, e.position
+      ORDER BY distance, e.position
+  `)).map((row) => {
+		const [reached, distance] = reachRow.parse(row);
+		return {
+			element: reached,
+			distance
+		};
+	});
+};
+/**
+* The unfinished work upstream of an element; nothing when the element is done.
+* @param db - The database.
+* @param request - The model and the element, which the caller has checked exist.
+* @returns The chain, by distance and then model order.
+*/
+const blockedChain = async (db, request) => {
+	const [done] = await db.values(sql`SELECT ${isDone(request.modelId, sql`${request.element}`)}`);
+	return z.tuple([z.number()]).parse(done)[0] === 1 ? [] : walk(db, request, upstream);
+};
+/**
+* The unfinished work downstream of an element, whatever its own state.
+* @param db - The database.
+* @param request - The model and the element, which the caller has checked exist.
+* @returns The impacted elements, by distance and then model order.
+*/
+const impact = async (db, request) => walk(db, request, downstream);
+/**
+* The work that can start now: every element that is not a control element, whose run state is absent or `open`, and from which no unfinished work is reachable upstream through control elements that are not done. That is exactly "its blocked chain is empty": the first unfinished work on any upstream path is reached through control elements alone.
+* @param db - The database.
+* @param modelId - The model, which the caller has checked exists.
+* @returns The ready elements, in model order.
+*/
+const ready = async (db, modelId) => {
+	return (await db.values(sql`
+    WITH RECURSIVE
+      behind(start, element) AS (
+        SELECT t.target, t.source FROM transitions t
+          WHERE t.model_id = ${modelId} AND t.loop = 0
+        UNION
+        SELECT b.start, t.source FROM behind b
+          JOIN elements c ON c.model_id = ${modelId} AND c.id = b.element AND c.kind IN ${control}
+          JOIN transitions t ON t.model_id = ${modelId} AND t.target = b.element AND t.loop = 0
+          WHERE NOT ${isDone(modelId, sql`b.element`)}
+      )
+    SELECT e.id FROM elements e
+      WHERE e.model_id = ${modelId}
+        AND e.kind NOT IN ${control}
+        AND NOT EXISTS (
+          SELECT 1 FROM overlay o
+            WHERE o.model_id = ${modelId} AND o.element = e.id AND o.status IN ('done', 'unknown')
+        )
+        AND NOT EXISTS (
+          SELECT 1 FROM behind b
+            JOIN elements p ON p.model_id = ${modelId} AND p.id = b.element
+            WHERE b.start = e.id
+              AND p.kind NOT IN ${control}
+              AND NOT ${isDone(modelId, sql`b.element`)}
+        )
+      ORDER BY e.position
+  `)).map((row) => idRow.parse(row)[0]);
+};
+/** Which way a hierarchy walk follows `child-of` relations: from a parent (`to_id`) to its children (`from_id`), or from a child to its parents. */
+const down = {
+	from: sql.raw("to_id"),
+	to: sql.raw("from_id")
+};
+const up = {
+	from: sql.raw("from_id"),
+	to: sql.raw("to_id")
+};
+/**
+* Every element reachable from `element` along `child-of` relations in one direction, with the fewest relations it takes, by that distance and then model order. The element itself is never reported.
+*
+* Distances are capped at the model's element count: no shortest path is longer, and the cap ends the recursion on a cycle of `child-of` relations.
+*/
+const hierarchyWalk = async (db, { modelId, element }, { from, to }) => {
+	return (await db.values(sql`
+    WITH RECURSIVE
+      bound(n) AS (SELECT count(*) FROM elements WHERE model_id = ${modelId}),
+      walk(element, distance) AS (
+        SELECT r.${to}, 1 FROM relations r
+          WHERE r.model_id = ${modelId} AND r.kind = 'child-of' AND r.${from} = ${element}
+        UNION
+        SELECT r.${to}, w.distance + 1 FROM walk w
+          JOIN relations r ON r.model_id = ${modelId} AND r.kind = 'child-of' AND r.${from} = w.element
+          WHERE w.distance < (SELECT n FROM bound)
+      )
+    SELECT w.element, min(w.distance) AS distance
+      FROM walk w
+      JOIN elements e ON e.model_id = ${modelId} AND e.id = w.element
+      WHERE w.element <> ${element}
+      GROUP BY w.element, e.position
+      ORDER BY distance, e.position
+  `)).map((row) => {
+		const [reached, distance] = reachRow.parse(row);
+		return {
+			element: reached,
+			distance
+		};
+	});
+};
+/**
+* The direct children of an element: every element related to it by `child-of`, other than itself.
+* @param db - The database.
+* @param request - The model and the element, which the caller has checked exist.
+* @returns The children, in model order.
+*/
+const children = async (db, request) => {
+	const { modelId, element } = request;
+	return (await db.values(sql`
+    SELECT r.from_id FROM relations r
+      JOIN elements e ON e.model_id = ${modelId} AND e.id = r.from_id
+      WHERE r.model_id = ${modelId} AND r.kind = 'child-of' AND r.to_id = ${element}
+        AND r.from_id <> ${element}
+      ORDER BY e.position
+  `)).map((row) => idRow.parse(row)[0]);
+};
+/**
+* Everything beneath an element along `child-of` relations.
+* @param db - The database.
+* @param request - The model and the element, which the caller has checked exist.
+* @returns The descendants, by distance and then model order.
+*/
+const descendants = async (db, request) => hierarchyWalk(db, request, down);
+/**
+* Everything above an element along `child-of` relations.
+* @param db - The database.
+* @param request - The model and the element, which the caller has checked exist.
+* @returns The ancestors, by distance and then model order.
+*/
+const ancestors = async (db, request) => hierarchyWalk(db, request, up);
+//#endregion
+//#region ../../adapters/graph/store-sqlite/dist/rows.js
+/** A field that is present only when its column holds a value. Its type is loose on purpose: `fromRows` hands everything to `modelSchema`, which is the check. */
+const present = (key, value) => value === null ? {} : Object.fromEntries([[key, value]]);
+/**
+* Flattens a model into rows.
+* @param modelId - The model's id in the store.
+* @param model - A valid model.
+* @param revision - The revision this write takes.
+* @param loops - The ids of the transitions graph-domain counts as loop edges.
+* @returns The rows to insert.
+*/
+const toRows = (modelId, model, revision, loops) => ({
+	model: {
+		id: modelId,
+		revision,
+		views: model.views ?? null
+	},
+	participants: model.participants.map(({ id, label, kind }, position) => ({
+		modelId,
+		id,
+		position,
+		label,
+		kind
+	})),
+	events: model.events.map(({ id, name, payload }, position) => ({
+		modelId,
+		id,
+		position,
+		name,
+		payload: payload ?? null
+	})),
+	actions: model.actions.map(({ id, name }, position) => ({
+		modelId,
+		id,
+		position,
+		name
+	})),
+	artefacts: model.artefacts.map(({ id, name, deliverable }, position) => ({
+		modelId,
+		id,
+		position,
+		name,
+		deliverable: deliverable ?? null
+	})),
+	elements: model.elements.map((element, position) => {
+		const common = {
+			modelId,
+			id: element.id,
+			position,
+			kind: element.kind,
+			extensions: element.extensions ?? null
+		};
+		if (element.kind === "activity") return {
+			...common,
+			label: element.label,
+			actor: element.actor ?? null,
+			action: element.action ?? null,
+			source: element.source ?? null,
+			affects: element.affects ?? null,
+			consumes: element.consumes ?? null,
+			produces: element.produces ?? null
+		};
+		if (element.kind === "decision") return {
+			...common,
+			label: element.label,
+			actor: element.actor ?? null
+		};
+		if (element.kind === "state") return {
+			...common,
+			label: element.label,
+			parent: element.parent ?? null,
+			entry: element.entry ?? null,
+			exit: element.exit ?? null
+		};
+		if (element.kind === "pseudo") return {
+			...common,
+			role: element.role,
+			parent: element.parent ?? null
+		};
+		return {
+			...common,
+			label: element.label,
+			from: element.from,
+			to: element.to,
+			mode: element.mode,
+			event: element.event ?? null
+		};
+	}),
+	transitions: model.transitions.map((transition, position) => ({
+		modelId,
+		id: transition.id,
+		position,
+		source: transition.source,
+		target: transition.target,
+		trigger: transition.trigger ?? null,
+		guard: transition.guard ?? null,
+		condition: transition.condition ?? null,
+		effect: transition.effect ?? null,
+		loop: loops.has(transition.id)
+	})),
+	fragments: model.fragments.map(({ id, operator, operands }, position) => ({
+		modelId,
+		id,
+		position,
+		operator,
+		operands
+	})),
+	projections: model.projections.map((projection, position) => ({
+		modelId,
+		position,
+		id: projection.id,
+		notation: projection.notation,
+		subject: "subject" in projection ? projection.subject : null,
+		scenario: "scenario" in projection ? projection.scenario : null
+	}))
+});
+/** The fields each element kind takes from its row, beyond the kind, id and extensions every element has. Keyed by every kind, so a new kind is a compile error here until it is mapped. */
+const kindFields = {
+	activity: (row) => ({
+		label: row.label,
+		...present("actor", row.actor),
+		...present("action", row.action),
+		...present("source", row.source),
+		...present("affects", row.affects),
+		...present("consumes", row.consumes),
+		...present("produces", row.produces)
+	}),
+	decision: (row) => ({
+		label: row.label,
+		...present("actor", row.actor)
+	}),
+	state: (row) => ({
+		label: row.label,
+		...present("parent", row.parent),
+		...present("entry", row.entry),
+		...present("exit", row.exit)
+	}),
+	pseudo: (row) => ({
+		role: row.role,
+		...present("parent", row.parent)
+	}),
+	message: (row) => ({
+		label: row.label,
+		from: row.from,
+		to: row.to,
+		mode: row.mode,
+		...present("event", row.event)
+	})
+};
+/** Puts back the fields of one element row that belong to its kind. */
+const elementOf = (row) => ({
+	kind: row.kind,
+	id: row.id,
+	...present("extensions", row.extensions),
+	...kindFields[row.kind](row)
+});
+/**
+* Reassembles a model from its rows.
+* @param rows - Every row of the model, each table in position order.
+* @returns The model.
+* @throws ZodError when the rows do not make a model, which only a database changed outside the store can cause.
+*/
+const fromRows = (rows) => modelSchema.parse({
+	participants: rows.participants.map(({ id, label, kind }) => ({
+		id,
+		label,
+		kind
+	})),
+	events: rows.events.map(({ id, name, payload }) => ({
+		id,
+		name,
+		...present("payload", payload)
+	})),
+	actions: rows.actions.map(({ id, name }) => ({
+		id,
+		name
+	})),
+	artefacts: rows.artefacts.map(({ id, name, deliverable }) => ({
+		id,
+		name,
+		...present("deliverable", deliverable)
+	})),
+	elements: rows.elements.map(elementOf),
+	transitions: rows.transitions.map((row) => ({
+		id: row.id,
+		source: row.source,
+		target: row.target,
+		...present("trigger", row.trigger),
+		...present("guard", row.guard),
+		...present("condition", row.condition),
+		...present("effect", row.effect)
+	})),
+	fragments: rows.fragments.map(({ id, operator, operands }) => ({
+		id,
+		operator,
+		operands
+	})),
+	projections: rows.projections.map((row) => ({
+		id: row.id,
+		notation: row.notation,
+		...present("subject", row.subject),
+		...present("scenario", row.scenario)
+	})),
+	...present("views", rows.model.views)
+});
+/**
+* Reassembles an overlay from its rows.
+* @param rows - The model's overlay rows.
+* @returns The overlay.
+*/
+const overlayFromRows = (rows) => overlaySchema.parse(Object.fromEntries(rows.map(({ element, status }) => [element, status])));
+//#endregion
+//#region ../../adapters/graph/store-sqlite/dist/tables.js
+var tables_exports = /* @__PURE__ */ __exportAll({
+	actions: () => actions,
+	artefacts: () => artefacts,
+	elements: () => elements,
+	events: () => events,
+	fragments: () => fragments,
+	models: () => models,
+	overlay: () => overlay,
+	participants: () => participants,
+	projections: () => projections,
+	relations: () => relations,
+	sequences: () => sequences,
+	transitions: () => transitions
+});
+/**
+* The storage projection of the process model. Every record a model declares is one row keyed by its model and its id, with `position` keeping the model's declared order, so a model loads back exactly as it was saved. Enumerated columns take their values from graph-schema's own vocabulary, and nested values (lists, extensions, conditions) are JSON text, typed `unknown` here because `rows.ts` checks them with the model schema on every read. Rows are never the contract's shape: `rows.ts` maps them to the model and back.
+*
+* No foreign keys are declared: SQLite enforces them only on connections that enable them, which a store cannot assume of the driver it is given, so the store keeps a model's rows together itself by writing and deleting them in one transaction.
+*/
+/** The store-wide revision sequence: one row, named so it reads as what it is. */
+const sequences = sqliteTable("sequences", {
+	name: text("name").primaryKey(),
+	value: integer("value").notNull()
+});
+/** One row per stored model: its revision and its layout. */
+const models = sqliteTable("models", {
+	id: text("id").primaryKey(),
+	revision: integer("revision").notNull(),
+	views: text("views", { mode: "json" })
+});
+const participants = sqliteTable("participants", {
+	modelId: text("model_id").notNull(),
+	id: text("id").notNull(),
+	position: integer("position").notNull(),
+	label: text("label").notNull(),
+	kind: text("kind", { enum: participantKinds }).notNull()
+}, (table) => [primaryKey({ columns: [table.modelId, table.id] })]);
+const events = sqliteTable("events", {
+	modelId: text("model_id").notNull(),
+	id: text("id").notNull(),
+	position: integer("position").notNull(),
+	name: text("name").notNull(),
+	payload: text("payload", { mode: "json" })
+}, (table) => [primaryKey({ columns: [table.modelId, table.id] })]);
+const actions = sqliteTable("actions", {
+	modelId: text("model_id").notNull(),
+	id: text("id").notNull(),
+	position: integer("position").notNull(),
+	name: text("name").notNull()
+}, (table) => [primaryKey({ columns: [table.modelId, table.id] })]);
+const artefacts = sqliteTable("artefacts", {
+	modelId: text("model_id").notNull(),
+	id: text("id").notNull(),
+	position: integer("position").notNull(),
+	name: text("name").notNull(),
+	deliverable: integer("deliverable", { mode: "boolean" })
+}, (table) => [primaryKey({ columns: [table.modelId, table.id] })]);
+/**
+* Every element kind in one table, so the structural queries traverse a single relation. A column a kind does not have is null on its rows; `rows.ts` reads only the columns of the row's kind.
+*/
+const elements = sqliteTable("elements", {
+	modelId: text("model_id").notNull(),
+	id: text("id").notNull(),
+	position: integer("position").notNull(),
+	kind: text("kind", { enum: elementKinds }).notNull(),
+	label: text("label"),
+	actor: text("actor"),
+	action: text("action"),
+	source: text("source"),
+	affects: text("affects", { mode: "json" }),
+	consumes: text("consumes", { mode: "json" }),
+	produces: text("produces", { mode: "json" }),
+	parent: text("parent"),
+	entry: text("entry"),
+	exit: text("exit"),
+	role: text("role", { enum: pseudoRoles }),
+	from: text("from_actor"),
+	to: text("to_actor"),
+	mode: text("mode", { enum: messageModes }),
+	event: text("event"),
+	extensions: text("extensions", { mode: "json" })
+}, (table) => [primaryKey({ columns: [table.modelId, table.id] })]);
+/** Transitions, with `loop` recording whether graph-domain counts the transition as a decision's loop edge, so the recursive queries can leave it out without loading the model. */
+const transitions = sqliteTable("transitions", {
+	modelId: text("model_id").notNull(),
+	id: text("id").notNull(),
+	position: integer("position").notNull(),
+	source: text("source").notNull(),
+	target: text("target").notNull(),
+	trigger: text("trigger"),
+	guard: text("guard"),
+	condition: text("condition", { mode: "json" }),
+	effect: text("effect"),
+	loop: integer("loop", { mode: "boolean" }).notNull()
+}, (table) => [
+	primaryKey({ columns: [table.modelId, table.id] }),
+	index("transitions_by_target").on(table.modelId, table.target),
+	index("transitions_by_source").on(table.modelId, table.source)
+]);
+const fragments = sqliteTable("fragments", {
+	modelId: text("model_id").notNull(),
+	id: text("id").notNull(),
+	position: integer("position").notNull(),
+	operator: text("operator", { enum: fragmentOperators }).notNull(),
+	operands: text("operands", { mode: "json" }).notNull()
+}, (table) => [primaryKey({ columns: [table.modelId, table.id] })]);
+/** Projections, keyed by position because the model does not require their ids to be unique. */
+const projections = sqliteTable("projections", {
+	modelId: text("model_id").notNull(),
+	position: integer("position").notNull(),
+	id: text("id").notNull(),
+	notation: text("notation", { enum: notations }).notNull(),
+	subject: text("subject"),
+	scenario: text("scenario", { mode: "json" })
+}, (table) => [primaryKey({ columns: [table.modelId, table.position] })]);
+/** Run state, one row per element that has any. */
+const overlay = sqliteTable("overlay", {
+	modelId: text("model_id").notNull(),
+	element: text("element").notNull(),
+	status: text("status", { enum: overlayStatuses }).notNull()
+}, (table) => [primaryKey({ columns: [table.modelId, table.element] })]);
+/**
+* Relations kept beside a model, one row per kind and pair of ends, so a relation sent twice is stored once, with `position` keeping the order relations were first stored. The ends are identifiers of the model's elements or participants, by kind.
+*/
+const relations = sqliteTable("relations", {
+	modelId: text("model_id").notNull(),
+	kind: text("kind", { enum: relationKinds }).notNull(),
+	from: text("from_id").notNull(),
+	to: text("to_id").notNull(),
+	position: integer("position").notNull()
+}, (table) => [primaryKey({ columns: [
+	table.modelId,
+	table.kind,
+	table.from,
+	table.to
+] }), index("relations_by_to").on(table.modelId, table.kind, table.to)]);
+//#endregion
+//#region ../../adapters/graph/store-sqlite/dist/store.js
+/** The tables that hold a model's own records and the relations kept beside it, every one keyed by `modelId`. */
+const recordTables = [
+	participants,
+	events,
+	actions,
+	artefacts,
+	elements,
+	transitions,
+	fragments,
+	projections,
+	relations
+];
+/** The name of the store-wide revision sequence's row in `sequences`. */
+const revisionSequence = "revision";
+/**
+* A `GraphStore` over SQLite through Drizzle. It migrates the database on its first operation, keeps every model as rows (see `tables.ts` and `rows.ts`), checks every write with the contract's `checkStored` before committing it, and answers the structural queries with recursive SQL.
+*
+* Writes rewrite the model's rows inside one transaction, so a failed check or an aborted signal leaves the previous rows in place.
+* @param options - The database, and optionally the exclusivity and feed a host provides.
+* @returns The store, ready to serve with `createGraphStoreRouter`.
+*/
+const createSqliteGraphStore = (options) => {
+	const { db, exclusive = serialised(), feed = new ChangeFeed() } = options;
+	let migrated;
+	/** Runs an operation exclusively on a migrated database. */
+	const operation = async (work) => exclusive(async () => {
+		migrated ??= migrate(db);
+		await migrated;
+		return work();
+	});
+	const nextRevision = async () => {
+		const [row] = await db.insert(sequences).values({
+			name: revisionSequence,
+			value: 1
+		}).onConflictDoUpdate({
+			target: sequences.name,
+			set: { value: sql`${sequences.value} + 1` }
+		}).returning({ value: sequences.value });
+		return z.object({ value: z.number() }).parse(row).value;
+	};
+	const revisionOf = async (modelId) => {
+		const [row] = await db.select({ revision: models.revision }).from(models).where(eq(models.id, modelId));
+		return row?.revision;
+	};
+	const requireModel = async (modelId) => {
+		if (await revisionOf(modelId) === void 0) throw new GraphStoreError({
+			kind: "not-found",
+			modelId
+		});
+	};
+	const requireElement = async (modelId, element) => {
+		await requireModel(modelId);
+		const [row] = await db.select({ id: elements.id }).from(elements).where(and(eq(elements.modelId, modelId), eq(elements.id, element)));
+		if (row === void 0) throw new GraphStoreError({
+			kind: "not-found",
+			modelId,
+			element
+		});
+	};
+	const readOverlay = async (modelId) => overlayFromRows(await db.select().from(overlay).where(eq(overlay.modelId, modelId)));
+	const readRelations = async (modelId) => db.select({
+		kind: relations.kind,
+		from: relations.from,
+		to: relations.to
+	}).from(relations).where(eq(relations.modelId, modelId)).orderBy(asc(relations.position));
+	const read = async (modelId) => {
+		const [model] = await db.select().from(models).where(eq(models.id, modelId));
+		if (model === void 0) throw new GraphStoreError({
+			kind: "not-found",
+			modelId
+		});
+		const rows = {
+			model,
+			participants: await db.select().from(participants).where(eq(participants.modelId, modelId)).orderBy(asc(participants.position)),
+			events: await db.select().from(events).where(eq(events.modelId, modelId)).orderBy(asc(events.position)),
+			actions: await db.select().from(actions).where(eq(actions.modelId, modelId)).orderBy(asc(actions.position)),
+			artefacts: await db.select().from(artefacts).where(eq(artefacts.modelId, modelId)).orderBy(asc(artefacts.position)),
+			elements: await db.select().from(elements).where(eq(elements.modelId, modelId)).orderBy(asc(elements.position)),
+			transitions: await db.select().from(transitions).where(eq(transitions.modelId, modelId)).orderBy(asc(transitions.position)),
+			fragments: await db.select().from(fragments).where(eq(fragments.modelId, modelId)).orderBy(asc(fragments.position)),
+			projections: await db.select().from(projections).where(eq(projections.modelId, modelId)).orderBy(asc(projections.position))
+		};
+		return {
+			modelId,
+			revision: model.revision,
+			model: fromRows(rows),
+			overlay: await readOverlay(modelId)
+		};
+	};
+	const removeRecords = async (modelId) => sequentially(recordTables.map((table) => async () => db.delete(table).where(eq(table.modelId, modelId))));
+	/** Inserts a model's record rows, skipping the tables it has no records for (an insert needs at least one row). */
+	const insertAll = async (rows) => sequentially([
+		...rows.participants.length > 0 ? [async () => db.insert(participants).values([...rows.participants])] : [],
+		...rows.events.length > 0 ? [async () => db.insert(events).values([...rows.events])] : [],
+		...rows.actions.length > 0 ? [async () => db.insert(actions).values([...rows.actions])] : [],
+		...rows.artefacts.length > 0 ? [async () => db.insert(artefacts).values([...rows.artefacts])] : [],
+		...rows.elements.length > 0 ? [async () => db.insert(elements).values([...rows.elements])] : [],
+		...rows.transitions.length > 0 ? [async () => db.insert(transitions).values([...rows.transitions])] : [],
+		...rows.fragments.length > 0 ? [async () => db.insert(fragments).values([...rows.fragments])] : [],
+		...rows.projections.length > 0 ? [async () => db.insert(projections).values([...rows.projections])] : []
+	]);
+	/** Replaces a model's rows, overlay and relations in one transaction and publishes the change once it commits. */
+	const write = async ({ modelId, kind, model, overlay: overlay$1, relations: relations$1, signal }) => {
+		checkStored(model, overlay$1);
+		const issues = relationIssues(model, relations$1);
+		if (issues.length > 0) throw new GraphStoreError({
+			kind: "invalid",
+			issues
+		});
+		const revision = await inTransaction(db, async () => {
+			const taken = await nextRevision();
+			const rows = toRows(modelId, model, taken, new Set(loopTransitions(model)));
+			await removeRecords(modelId);
+			await db.delete(overlay).where(eq(overlay.modelId, modelId));
+			await db.insert(models).values(rows.model).onConflictDoUpdate({
+				target: models.id,
+				set: {
+					revision: rows.model.revision,
+					views: rows.model.views
+				}
+			});
+			await insertAll(rows);
+			const entries = Object.entries(overlay$1).flatMap(([element, status]) => status === void 0 ? [] : [{
+				modelId,
+				element,
+				status
+			}]);
+			if (entries.length > 0) await db.insert(overlay).values(entries);
+			if (relations$1.length > 0) await db.insert(relations).values(relations$1.map((relation, position) => ({
+				modelId,
+				...relation,
+				position
+			})));
+			signal?.throwIfAborted();
+			return taken;
+		});
+		feed.publish({
+			modelId,
+			kind,
+			revision
+		});
+		return revision;
+	};
+	return {
+		feed,
+		listModels: async () => operation(async () => db.select({
+			modelId: models.id,
+			revision: models.revision
+		}).from(models).orderBy(asc(models.id))),
+		saveModel: async ({ modelId, model, signal }) => operation(async () => {
+			const stored = await revisionOf(modelId) !== void 0;
+			return write({
+				modelId,
+				kind: "saved",
+				model,
+				overlay: overlayWithin(model, stored ? await readOverlay(modelId) : {}),
+				relations: relationsWithin(model, stored ? await readRelations(modelId) : []),
+				signal
+			});
+		}),
+		loadModel: async ({ modelId }) => operation(async () => read(modelId)),
+		deleteModel: async ({ modelId, signal }) => operation(async () => {
+			if (await revisionOf(modelId) === void 0) return;
+			const revision = await inTransaction(db, async () => {
+				const taken = await nextRevision();
+				await removeRecords(modelId);
+				await db.delete(overlay).where(eq(overlay.modelId, modelId));
+				await db.delete(models).where(eq(models.id, modelId));
+				signal?.throwIfAborted();
+				return taken;
+			});
+			feed.publish({
+				modelId,
+				kind: "deleted",
+				revision
+			});
+			return revision;
+		}),
+		applyOverlay: async ({ modelId, overlay: overlay$2, signal }) => operation(async () => {
+			const stored = await read(modelId);
+			const merged = {
+				...stored.overlay,
+				...overlay$2
+			};
+			checkStored(stored.model, merged);
+			const named = Object.keys(overlay$2);
+			const revision = await inTransaction(db, async () => {
+				const taken = await nextRevision();
+				await db.update(models).set({ revision: taken }).where(eq(models.id, modelId));
+				await db.delete(overlay).where(and(eq(overlay.modelId, modelId), inArray(overlay.element, named)));
+				const entries = Object.entries(overlay$2).flatMap(([element, status]) => status === void 0 ? [] : [{
+					modelId,
+					element,
+					status
+				}]);
+				if (entries.length > 0) await db.insert(overlay).values(entries);
+				signal?.throwIfAborted();
+				return taken;
+			});
+			feed.publish({
+				modelId,
+				kind: "overlay",
+				revision
+			});
+			return revision;
+		}),
+		upsertItems: async ({ modelId, items, signal }) => operation(async () => {
+			const stored = await revisionOf(modelId) === void 0 ? {
+				model: emptyModel,
+				overlay: {},
+				relations: []
+			} : {
+				...await read(modelId),
+				relations: await readRelations(modelId)
+			};
+			return write({
+				modelId,
+				kind: "items",
+				...mergeBoundItems(stored.model, stored.overlay, items),
+				relations: mergeRelations(stored.relations, items.relations ?? []),
+				signal
+			});
+		}),
+		relations: async ({ modelId }) => operation(async () => {
+			await requireModel(modelId);
+			return readRelations(modelId);
+		}),
+		children: async ({ modelId, element }) => operation(async () => {
+			await requireElement(modelId, element);
+			return children(db, {
+				modelId,
+				element
+			});
+		}),
+		descendants: async ({ modelId, element }) => operation(async () => {
+			await requireElement(modelId, element);
+			return descendants(db, {
+				modelId,
+				element
+			});
+		}),
+		ancestors: async ({ modelId, element }) => operation(async () => {
+			await requireElement(modelId, element);
+			return ancestors(db, {
+				modelId,
+				element
+			});
+		}),
+		ready: async ({ modelId }) => operation(async () => {
+			await requireModel(modelId);
+			return ready(db, modelId);
+		}),
+		blockedChain: async ({ modelId, element }) => operation(async () => {
+			await requireElement(modelId, element);
+			return blockedChain(db, {
+				modelId,
+				element
+			});
+		}),
+		impact: async ({ modelId, element }) => operation(async () => {
+			await requireElement(modelId, element);
+			return impact(db, {
+				modelId,
+				element
+			});
+		}),
+		revisionOf: async ({ modelId }) => operation(async () => revisionOf(modelId))
+	};
+};
+//#endregion
+export { modelSummarySchema as C, revisionSchema as D, relationSchema as E, storeChangeSchema as O, modelIdSchema as S, relationKinds as T, GraphStoreError as _, ancestorsOf as a, changeKinds as b, mergeRelations as c, checkStored as d, emptyModel as f, defaultSubscriptionCapacity as g, ChangeFeed as h, serialised as i, storedModelSchema as k, relationIssues as l, overlayWithin as m, tables_exports as n, childrenOf as o, mergeBoundItems as p, migrate as r, descendantsOf as s, createSqliteGraphStore as t, relationsWithin as u, boundActivitySchema as v, reachSchema as w, issueSchema as x, boundItemsSchema as y };