process-graph 1.0.5 → 1.1.0

package/dist/dist-HLlW8vgT.js

@@ -0,0 +1,1388 @@
+import { a as validateOverlay, d as overlayStatuses, f as participantKinds } from "./schema-CVnS6HiX.js";
+import { t as validate } from "./validate-DF3mQZww.js";
+import { n as parseModel, t as ModelParseError } from "./parse-CuipC_2K.js";
+import { _ as toSwimlane, b as handoffs, c as deriveStatuses, g as toStateMachine, i as readySet, m as toSequence, n as criticalPath, r as impact, s as explainStatus, t as blockedBy, y as toFlowchart } from "./queries-CCexJAE2.js";
+import { f as CycleError, n as illegalCycles, p as UnknownNodeError } from "./control-aDk9560d.js";
+import { l as assembleSync, t as createGitHubIssuesSource, u as createGraphSourceRouter } from "./source-DRDpEA8Q.js";
+import { t as githubTokenFromEnvironment } from "./node-AchI1T-K.js";
+import { f as emptyModel } from "./store-BcR70CaO.js";
+import { t as createGraphStoreRouter } from "./router-D4gtTlXm.js";
+import { t as openNodeGraphStore } from "./open-CyRXJ4bt.js";
+import { t as exitCodes } from "./exit-codes-0ultCqdS.js";
+import { ORPCError, createRouterClient } from "@orpc/server";
+import { Argument, Command, CommanderError, Option } from "commander";
+import { chmodSync, closeSync, mkdirSync, openSync, readFileSync, statSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+//#region ../graph-cli/dist/errors.js
+/** A failure the command line reports with its own exit status and message, and nothing else. */
+var CliError = class extends Error {
+	/** The exit status the failure maps to. */
+	exitCode;
+	/**
+	* @param exitCode - The exit status to report.
+	* @param message - What went wrong, as one line for standard error.
+	* @param options - The underlying error, kept as the cause.
+	*/
+	constructor(exitCode, message, options) {
+		super(message, options);
+		this.name = "CliError";
+		this.exitCode = exitCode;
+	}
+};
+/** The store's codes for a missing model or element and for a change that would leave the model invalid. */
+const notFoundCode = "NOT_FOUND";
+const unprocessableCode = "UNPROCESSABLE_CONTENT";
+/** The codes a source answers with when it refuses a sync. */
+const sourceRefusalCodes = /* @__PURE__ */ new Set([
+	"UNAUTHORIZED",
+	"TOO_MANY_REQUESTS",
+	"BAD_REQUEST"
+]);
+/** The issues an `UNPROCESSABLE_CONTENT` error carries, each as `code: message`, or nothing when its data has no issues. */
+const issueLines = (data) => {
+	if (typeof data !== "object" || data === null || !("issues" in data) || !Array.isArray(data.issues)) return [];
+	return data.issues.flatMap((issue) => typeof issue === "object" && issue !== null && "code" in issue && "message" in issue && typeof issue.code === "string" && typeof issue.message === "string" ? [`${issue.code}: ${issue.message}`] : []);
+};
+/**
+* Classifies anything a command threw into its exit status and the message for standard error. A commander usage error has already printed its own message, so it is reported with an empty one.
+* @param error - What was thrown.
+* @returns The exit status and message.
+*/
+const failureOf = (error) => {
+	if (error instanceof CliError) return {
+		exitCode: error.exitCode,
+		message: error.message
+	};
+	if (error instanceof CommanderError) return {
+		exitCode: error.exitCode === exitCodes.success ? exitCodes.success : exitCodes.usage,
+		message: ""
+	};
+	if (error instanceof CycleError) return {
+		exitCode: exitCodes.invalidModel,
+		message: `${error.message}; run cycles to list them`
+	};
+	if (error instanceof UnknownNodeError) return {
+		exitCode: exitCodes.notFound,
+		message: error.message
+	};
+	if (error instanceof ModelParseError) return {
+		exitCode: exitCodes.invalidModel,
+		message: error.message
+	};
+	if (error instanceof ORPCError) {
+		const code = error.code;
+		const data = error.data;
+		if (code === notFoundCode) return {
+			exitCode: exitCodes.notFound,
+			message: error.message
+		};
+		if (code === unprocessableCode) return {
+			exitCode: exitCodes.invalidModel,
+			message: [error.message, ...issueLines(data)].join("\n")
+		};
+		if (typeof code === "string" && sourceRefusalCodes.has(code)) return {
+			exitCode: exitCodes.sourceFailure,
+			message: error.message
+		};
+	}
+	return {
+		exitCode: exitCodes.failure,
+		message: error instanceof Error ? error.message : String(error)
+	};
+};
+//#endregion
+//#region ../graph-cli/dist/session.js
+/**
+* The oRPC client options carrying the session's signal. The key is left out when there is no signal, since the options type does not accept an explicit `undefined`.
+* @param signal - The signal, if any.
+*/
+const callOptions = (signal) => signal === void 0 ? {} : { signal };
+/**
+* Reads the session's model and run state, if the store has the model.
+* @param session - The store and model.
+* @returns The stored run, or `undefined` when the store has no such model.
+*/
+const findRun = async (session) => {
+	try {
+		const stored = await session.store.v1.models.load({ modelId: session.modelId }, callOptions(session.signal));
+		return {
+			revision: stored.revision,
+			model: stored.model,
+			overlay: stored.overlay
+		};
+	} catch (error) {
+		if (error instanceof ORPCError && error.code === "NOT_FOUND") return;
+		throw error;
+	}
+};
+/**
+* Loads the session's model and run state.
+* @param session - The store and model.
+* @returns The stored run.
+* @throws CliError with `notFound` when the store has no such model.
+*/
+const loadRun = async (session) => {
+	const run = await findRun(session);
+	if (run === void 0) throw new CliError(exitCodes.notFound, `no model "${session.modelId}" in the store; sync or add something first`);
+	return run;
+};
+/** The label an element is shown with: its own label, or for a pseudo-state, its role. */
+const labelOf = (element) => element.kind === "pseudo" ? element.role : element.label;
+/**
+* Looks an element up by identifier.
+* @param model - The model to read.
+* @param id - The element asked about.
+* @returns The element.
+* @throws CliError with `notFound` when the model declares no such element.
+*/
+const requireElement = (model, id) => {
+	const element = model.elements.find((candidate) => candidate.id === id);
+	if (element === void 0) throw new CliError(exitCodes.notFound, `no element "${id}" in the model`);
+	return element;
+};
+/**
+* Summaries of elements, in the order given.
+* @param model - The model the identifiers belong to.
+* @param ids - The element identifiers.
+*/
+const summarise = (model, ids) => ids.map((id) => ({
+	id,
+	label: labelOf(requireElement(model, id))
+}));
+//#endregion
+//#region ../graph-cli/dist/edit.js
+/** The model with one record appended to the part it belongs to. */
+const withAddition = (model, addition) => {
+	if (addition.kind === "participant") return {
+		...model,
+		participants: [...model.participants, addition.record]
+	};
+	if (addition.kind === "element") return {
+		...model,
+		elements: [...model.elements, addition.record]
+	};
+	if (addition.kind === "event") return {
+		...model,
+		events: [...model.events, addition.record]
+	};
+	if (addition.kind === "artefact") return {
+		...model,
+		artefacts: [...model.artefacts, addition.record]
+	};
+	return {
+		...model,
+		transitions: [...model.transitions, addition.record]
+	};
+};
+/**
+* Adds a record to the session's model, creating the model when the store has none. The store checks the result, so a duplicate identifier or a reference to something undeclared is rejected and nothing changes.
+*
+* The model is read and then saved whole, so a write made by another process between the two is overwritten.
+* @param session - The store and model.
+* @param addition - The record to add.
+* @returns The revision the save took.
+*/
+const add = async (session, addition) => {
+	const model = (await findRun(session))?.model ?? emptyModel;
+	return session.store.v1.models.save({
+		modelId: session.modelId,
+		model: withAddition(model, addition)
+	}, callOptions(session.signal));
+};
+/**
+* Sets an element's run state, leaving every other element's as it is.
+* @param session - The store and model.
+* @param id - The element.
+* @param state - `done`, `open` or `unknown`.
+* @returns The element, its new state and the revision the change took.
+* @throws CliError with `notFound` when the model or the element does not exist.
+*/
+const setState = async (session, id, state) => {
+	const { model } = await loadRun(session);
+	requireElement(model, id);
+	const { revision } = await session.store.v1.overlay.set({
+		modelId: session.modelId,
+		overlay: { [id]: state }
+	}, callOptions(session.signal));
+	return {
+		element: id,
+		state,
+		revision
+	};
+};
+//#endregion
+//#region ../graph-cli/dist/queries.js
+/** Each element counts as one step, so the critical path is the longest chain of elements. */
+const stepWeight = 1;
+/**
+* The elements that are ready: not done, with every live need done.
+* @param session - The store, model and facts.
+*/
+const ready = async (session) => {
+	const { model, overlay } = await loadRun(session);
+	return { elements: summarise(model, readySet(model, overlay, session.facts)) };
+};
+const statusOf = (statuses, summary) => {
+	const status = statuses.get(summary.id);
+	if (status === void 0) throw new Error(`no status was derived for "${summary.id}"`);
+	return {
+		...summary,
+		status
+	};
+};
+/**
+* What an element is waiting on.
+* @param session - The store, model and facts.
+* @param id - The element asked about.
+*/
+const blocked = async (session, id) => {
+	const { model, overlay } = await loadRun(session);
+	const element = requireElement(model, id);
+	const statuses = deriveStatuses(model, overlay, session.facts);
+	return {
+		element: statusOf(statuses, {
+			id,
+			label: labelOf(element)
+		}),
+		blockedBy: summarise(model, blockedBy(model, overlay, session.facts, id))
+	};
+};
+/**
+* What depends on an element.
+* @param session - The store, model and facts.
+* @param id - The element asked about.
+*/
+const impactOf = async (session, id) => {
+	const { model, overlay } = await loadRun(session);
+	const element = requireElement(model, id);
+	const statuses = deriveStatuses(model, overlay, session.facts);
+	return {
+		element: statusOf(statuses, {
+			id,
+			label: labelOf(element)
+		}),
+		impacted: summarise(model, impact(model, overlay, session.facts, id))
+	};
+};
+/**
+* The critical path: the longest chain through the work still ahead.
+* @param session - The store, model and facts.
+*/
+const path = async (session) => {
+	const { model, overlay } = await loadRun(session);
+	const found = criticalPath(model, overlay, session.facts, () => stepWeight);
+	return {
+		path: summarise(model, found.path),
+		weight: found.weight
+	};
+};
+/**
+* The cycles of the model that no decision closes, which make every status undefined.
+* @param session - The store and model.
+*/
+const cycles = async (session) => {
+	const { model } = await loadRun(session);
+	return { cycles: illegalCycles(model) };
+};
+/**
+* The hand-offs: transitions from one actor's work to another's.
+* @param session - The store and model.
+*/
+const handoffsOf = async (session) => {
+	const { model } = await loadRun(session);
+	return { handoffs: handoffs(model) };
+};
+/**
+* Why an element has its status, and the chain of unfinished work behind it.
+* @param session - The store, model and facts.
+* @param id - The element asked about.
+*/
+const why = async (session, id) => {
+	const { model, overlay } = await loadRun(session);
+	requireElement(model, id);
+	const explained = explainStatus(model, overlay, session.facts, id);
+	const chain = explained.chain.map((link) => ({
+		id: link.element,
+		label: labelOf(requireElement(model, link.element)),
+		status: link.status,
+		waitingOn: link.waitingOn
+	}));
+	const [first] = chain;
+	if (first === void 0) throw new Error(`the explanation of "${id}" has no chain`);
+	return {
+		element: {
+			id: first.id,
+			label: first.label,
+			status: first.status
+		},
+		rule: explained.rule,
+		transitions: explained.transitions,
+		artefacts: explained.artefacts,
+		chain
+	};
+};
+//#endregion
+//#region ../graph-cli/dist/render.js
+/**
+* Text renderings of each command's result. Lists are one item per line with tab-separated fields, so they cut, sort and grep cleanly, and an empty list prints nothing. Every rendering ends with a line break when it is not empty.
+*/
+const lines = (rows) => rows.length === 0 ? "" : `${rows.join("\n")}\n`;
+const elementRows = (elements) => elements.map((element) => `${element.id}\t${element.label}`);
+/** `ready`: each ready element's identifier and label. */
+const renderReady = (result) => lines(elementRows(result.elements));
+/** `blocked`: each element at the end of the blocked-by chain. */
+const renderBlocked = (result) => lines(elementRows(result.blockedBy));
+/** `impact`: each element that depends on the one asked about. */
+const renderImpact = (result) => lines(elementRows(result.impacted));
+/** `path`: the critical path, one element per line in dependency order. */
+const renderPath = (result) => lines(elementRows(result.path));
+/** `cycles`: each illegal cycle as a closed path. */
+const renderCycles = (result) => lines(result.cycles.map((cycle) => cycle.join(" -> ")));
+/** `handoffs`: each hand-off's transition and the actors it passes between. */
+const renderHandoffs = (result) => lines(result.handoffs.map((handoff) => `${handoff.transition}\t${handoff.from} -> ${handoff.to}`));
+/** The sentence that says why each rule gives its status. `needs-met` gives a decision or pseudo-state `done` rather than `ready`, and says so. */
+const ruleSentences = {
+	"overlay-done": "its run state is done",
+	"overlay-unknown": "its run state is unknown",
+	"unknown-need": "something it needs is unknown, or a condition on the way to it cannot be decided",
+	"all-cut": "every transition into it is cut",
+	"needs-met": "everything it needs is done",
+	waiting: "it waits on work that is not done"
+};
+const ruleSentence = (rule, status) => rule === "needs-met" && status === "done" ? "it is a decision or pseudo-state and everything it needs is done" : ruleSentences[rule];
+/** `why`: the status and the rule behind it, then its needs, its artefacts and the blocked-by chain, each section only when it has something in it. */
+const renderWhy = (result) => {
+	const { element } = result;
+	const needs = result.transitions.map((transition) => {
+		const notes = [...transition.branch === "taken" ? [] : [`condition ${transition.branch}`], ...transition.cut ? ["cut"] : []];
+		return `  ${transition.source} (${transition.sourceStatus}) through ${transition.transition}${notes.length === 0 ? "" : `, ${notes.join(", ")}`}`;
+	});
+	const artefacts = result.artefacts.map((artefact) => {
+		const producers = artefact.producers.length === 0 ? "produced by nothing" : `produced by ${artefact.producers.map((producer) => `${producer.element} (${producer.status})`).join(", ")}`;
+		return `  ${artefact.artefact}: ${artefact.provided ? "provided" : "not provided"}, ${producers}`;
+	});
+	const chain = result.chain.length > 1 || result.chain.some((link) => link.waitingOn.length > 0) ? result.chain.map((link) => `  ${link.id} (${link.status})${link.waitingOn.length === 0 ? "" : ` waits on ${link.waitingOn.join(", ")}`}`) : [];
+	return lines([
+		`${element.id} is ${element.status}: ${ruleSentence(result.rule, element.status)}`,
+		...needs.length === 0 ? [] : ["needs:", ...needs],
+		...artefacts.length === 0 ? [] : ["artefacts:", ...artefacts],
+		...chain.length === 0 ? [] : ["blocked-by chain:", ...chain]
+	]);
+};
+/** `add`: what was added and the revision it took. */
+const renderAdded = (kind, id, written) => lines([`added ${kind} ${id} at revision ${String(written.revision)}`]);
+/** `set`: the element's new run state and the revision it took. */
+const renderSet = (result) => lines([`set ${result.element} to ${result.state} at revision ${String(result.revision)}`]);
+/** `sync`: what was written, then each gap as its reason, target and message. */
+const renderSync = (result) => lines([`synced ${String(result.activities)} activities, ${String(result.transitions)} transitions and ${String(result.participants)} participants into "${result.modelId}" at revision ${String(result.revision)}`, ...result.gaps.map((gap) => `gap\t${gap.reason}\t${gap.target}\t${gap.message}`)]);
+/** `validate`: `valid`, or each issue as its code, its JSON pointer when it has one, and its message. */
+const renderValidate = (result) => result.valid ? lines(["valid"]) : lines(result.issues.map((issue) => issue.pointer === void 0 ? `${issue.code}\t${issue.message}` : `${issue.code}\t${issue.pointer === "" ? "/" : issue.pointer}\t${issue.message}`));
+//#endregion
+//#region ../graph-cli/dist/terminal-text.js
+/**
+* The characters that must never reach a terminal as they are, by Unicode general category: controls (`Cc`, where ESC starts the sequences that clear the screen, move the cursor or, through OSC 52, set the clipboard, and the C1 controls some terminals read as the same sequences), format characters (`Cf`, which holds every bidirectional control, the invisible operators, the soft hyphen, the interlinear annotation characters and the tag characters, all of which reorder, hide or change what is shown), the line and paragraph separators (`Zl`, `Zp`), and the unassigned and private-use code points (`Cn`, `Co`), which no font shows reliably. Text from a source (an issue title, a label, an actor's name) can carry any of them. A category, not a list of ranges, so a character Unicode adds to one of them is covered without a change here.
+*
+* Three are allowed: line feed and tab, which every text output uses, and the zero-width non-joiner and joiner (U+200C, U+200D), formats that emoji sequences (a family, a profession) and scripts such as Persian, Hindi and Malayalam need to be written correctly, and that cannot reorder or hide text on their own.
+*/
+const unsafeCharacters = /[[\p{Cc}\p{Cf}\p{Zl}\p{Zp}\p{Cn}\p{Co}]--[\n\t\u200C\u200D]]/gv;
+/** Code points are written in hexadecimal. */
+const hexadecimal = 16;
+/** A JSON `\u` escape always has four hexadecimal digits. */
+const jsonEscapeDigits = 4;
+/**
+* A character's code point.
+* @param character - One character, as the unsafe-character pattern matches it.
+* @returns Its code point.
+* @throws Error when given an empty string, which the pattern never matches.
+*/
+const codePointOf = (character) => {
+	const point = character.codePointAt(0);
+	if (point === void 0) throw new Error("an unsafe character match was empty");
+	return point;
+};
+/**
+* Text made safe to write to a terminal. Each unsafe character (see `unsafeCharacters`) is written as the visible escape `\u{<hex>}` of its code point, such as `\u{1b}` for ESC, `\u{202e}` for a right-to-left override or `\u{e0041}` for a tag character, so nothing is lost and nothing acts on the terminal. Line feed, tab, the zero-width joiners and every other character, accented letters, CJK, Arabic and emoji included, pass through. A literal `\u{...}` already in the text is left as it is, so the escaped form is for reading, not for reversing.
+* @param text - The text as written.
+* @returns The text with every unsafe character escaped.
+*/
+const terminalText = (text) => text.replaceAll(unsafeCharacters, (character) => `\\u{${codePointOf(character).toString(hexadecimal)}}`);
+/**
+* A value as JSON that is also safe to write to a terminal. `JSON.stringify` escapes the C0 controls but writes every other unsafe character (see `unsafeCharacters`) as it is; this writes those as `\u` escapes too, a surrogate pair for a code point beyond the Basic Multilingual Plane, which leaves the JSON, and every value parsed from it, exactly the same.
+* @param value - The value to write.
+* @returns The JSON text, indented by two spaces and ending in a line break.
+*/
+const terminalJson = (value) => `${JSON.stringify(value, null, 2).replaceAll(unsafeCharacters, (character) => character.split("").map((unit) => `\\u${unit.charCodeAt(0).toString(hexadecimal).padStart(jsonEscapeDigits, "0")}`).join(""))}\n`;
+//#endregion
+//#region ../graph-cli/dist/emit/text.js
+/**
+* The Mermaid entity code for a character that would end or change the meaning of a label: quotes, statement and edge-label delimiters, the entity marker itself and HTML.
+*/
+const mermaidEntity = (character) => {
+	switch (character) {
+		case "#": return "#35;";
+		case "\"": return "#quot;";
+		case "<": return "#lt;";
+		case ">": return "#gt;";
+		case "&": return "#amp;";
+		case ";": return "#59;";
+		case "|": return "#124;";
+		case ":": return "#58;";
+		default: return character;
+	}
+};
+/**
+* Text made safe to place inside any Mermaid label: a line break becomes a space, every control and invisible format character is written as its visible `\u{<hex>}` escape (see `terminalText`), and every character that Mermaid reads as syntax is written as its entity code, so a label from a source (an issue title, a repository name) can never break the diagram or act on the terminal it is printed to.
+* @param text - The label as written.
+* @returns The label as Mermaid source.
+*/
+const mermaidText = (text) => terminalText(text.replaceAll(/[\r\n]/gu, " ")).replaceAll(/[#"<>&;|:]/gu, mermaidEntity);
+/**
+* A Graphviz DOT double-quoted string: line breaks written as DOT's own centred line break, every control and invisible format character as its visible `\u{<hex>}` escape (see `terminalText`), then backslashes, the escapes' included, and quotes escaped. Any identifier or label is valid DOT once quoted this way, and reads back as the escaped text.
+* @param text - The text as written.
+* @returns The quoted DOT string, quotes included.
+*/
+const dotString = (text) => `"${text.split(/\r?\n/u).map((line) => terminalText(line).replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")).join("\\n")}"`;
+//#endregion
+//#region ../graph-cli/dist/emit/mermaid.js
+/**
+* Model identifiers are free text (`github:org/repo#12`), which Mermaid does not accept as a node identifier, so every emitter names things by position in the view instead: a prefix and the index. The view's order is the model's order, so the same model always gives the same names.
+*/
+const positionalIds = (prefix, ids) => new Map(ids.map((id, index) => [id, `${prefix}${String(index)}`]));
+/** Reads a name the emitter itself assigned, which exists for every identifier the view lists. */
+const nameIn = (names, id) => {
+	const name = names.get(id);
+	if (name === void 0) throw new Error(`"${id}" is not part of the view being emitted`);
+	return name;
+};
+const indent$1 = "  ";
+/** Each flowchart shape in Mermaid's syntax around a node name and quoted label: a stadium for a terminator, a rectangle for a process, a rhombus for a decision and a fork bar for a fork or join. */
+const mermaidShapes = {
+	terminator: (name, label) => `${name}(["${label}"])`,
+	process: (name, label) => `${name}["${label}"]`,
+	decision: (name, label) => `${name}{"${label}"}`,
+	bar: (name, label) => `${name}@{ shape: fork, label: "${label}" }`
+};
+const mermaidNode = (name, node) => mermaidShapes[node.shape](name, mermaidText(node.label));
+/** The edges of a flowchart, a hand-off (an edge whose ends are in different lanes) drawn thick. */
+const mermaidEdges = (view, names, isHandoff) => view.edges.map((edge) => {
+	const arrow = isHandoff(edge.from, edge.to) ? "==>" : "-->";
+	const label = edge.label === void 0 ? "" : `|"${mermaidText(edge.label)}"|`;
+	return `${indent$1}${nameIn(names, edge.from)} ${arrow}${label} ${nameIn(names, edge.to)}`;
+});
+/**
+* A flowchart as a Mermaid `flowchart`, top to bottom. Nodes are declared in the view's order, then edges, each with its guard as the edge label.
+* @param view - The projected flowchart.
+* @returns Mermaid source, ending with a line break.
+*/
+const flowchartToMermaid = (view) => {
+	const names = positionalIds("n", view.nodes.map((node) => node.id));
+	return `${[
+		"flowchart TD",
+		...view.nodes.map((node) => `${indent$1}${mermaidNode(nameIn(names, node.id), node)}`),
+		...mermaidEdges(view, names, () => false)
+	].join("\n")}\n`;
+};
+/**
+* A swimlane as a Mermaid `flowchart`, left to right, with one subgraph per lane in the view's lane order (an empty lane is an empty subgraph, so it stays visible) and nodes with no actor outside every lane. Hand-offs, the edges that change lane, are drawn thick.
+* @param view - The projected swimlane.
+* @returns Mermaid source, ending with a line break.
+*/
+const swimlaneToMermaid = (view) => {
+	const names = positionalIds("n", view.nodes.map((node) => node.id));
+	const nodes = new Map(view.nodes.map((node) => [node.id, node]));
+	const laneOf = /* @__PURE__ */ new Map();
+	view.lanes.forEach((lane, index) => {
+		for (const id of lane.nodes) laneOf.set(id, index);
+	});
+	const declare = (id, depth) => {
+		const node = nodes.get(id);
+		if (node === void 0) throw new Error(`lane member "${id}" is not a node of the view`);
+		return `${depth}${mermaidNode(nameIn(names, id), node)}`;
+	};
+	return `${[
+		"flowchart LR",
+		...view.lanes.flatMap((lane, index) => [
+			`${indent$1}subgraph lane${String(index)}["${mermaidText(lane.label)}"]`,
+			...lane.nodes.map((id) => declare(id, indent$1.repeat(2))),
+			`${indent$1}end`
+		]),
+		...view.unassigned.map((id) => declare(id, indent$1)),
+		...mermaidEdges(view, names, (from, to) => {
+			const fromLane = laneOf.get(from);
+			const toLane = laneOf.get(to);
+			return fromLane !== void 0 && toLane !== void 0 && fromLane !== toLane;
+		})
+	].join("\n")}\n`;
+};
+/** A state machine transition's label: its event, its guard in brackets and its effect after a slash, each only when present. */
+const transitionLabel = (transition) => [
+	transition.event,
+	transition.guard === void 0 ? void 0 : `[${transition.guard}]`,
+	transition.effect === void 0 ? void 0 : `/ ${transition.effect}`
+].filter((part) => part !== void 0).join(" ");
+/**
+* A state machine as a Mermaid `stateDiagram-v2`. Initial and final pseudo-states are Mermaid's `[*]`; every other state is declared with its label. Each transition carries its event, guard and effect.
+* @param view - The projected state machine.
+* @returns Mermaid source, ending with a line break.
+*/
+const stateMachineToMermaid = (view) => {
+	const drawn = view.states.filter((state) => state.role === "state");
+	const names = new Map([...positionalIds("s", drawn.map((state) => state.id)), ...view.states.filter((state) => state.role !== "state").map((state) => [state.id, "[*]"])]);
+	return `${[
+		"stateDiagram-v2",
+		...drawn.map((state) => `${indent$1}state "${mermaidText(state.label)}" as ${nameIn(names, state.id)}`),
+		...view.transitions.map((transition) => {
+			const label = transitionLabel(transition);
+			return `${indent$1}${nameIn(names, transition.source)} --> ${nameIn(names, transition.target)}${label === "" ? "" : ` : ${mermaidText(label)}`}`;
+		})
+	].join("\n")}\n`;
+};
+/** The Mermaid keyword that separates one operand of a fragment from the next, for the operators with more than one operand. */
+const operandSeparator = (operator) => operator === "par" ? "and" : "else";
+/**
+* A sequence diagram as a Mermaid `sequenceDiagram`. Lifelines are declared in order of first appearance, labelled through `participantLabel`; messages follow in scenario order, wrapped in the fragments the projection drew (`alt` operands separated by `else`, `par` operands by `and`), each operand headed by its guard.
+* @param view - The projected sequence diagram.
+* @param participantLabel - The label of a lifeline's participant.
+* @returns Mermaid source, ending with a line break.
+*/
+const sequenceToMermaid = (view, participantLabel) => {
+	const names = positionalIds("p", view.lifelines);
+	const items = (list, depth) => list.flatMap((item) => {
+		const prefix = indent$1.repeat(depth);
+		if (item.kind === "message") {
+			const { message } = item;
+			return [`${prefix}${nameIn(names, message.from)}->>${nameIn(names, message.to)}: ${mermaidText(message.label)}`];
+		}
+		return [...item.operands.flatMap((operand, index) => {
+			const keyword = index === 0 ? item.operator : operandSeparator(item.operator);
+			const guard = operand.guard === void 0 ? "" : ` ${mermaidText(operand.guard)}`;
+			return [`${prefix}${keyword}${guard}`, ...items(operand.items, depth + 1)];
+		}), `${prefix}end`];
+	});
+	return `${[
+		"sequenceDiagram",
+		...view.lifelines.map((lifeline) => `${indent$1}participant ${nameIn(names, lifeline)} as ${mermaidText(participantLabel(lifeline))}`),
+		...items(view.items, 1)
+	].join("\n")}\n`;
+};
+//#endregion
+//#region ../graph-cli/dist/emit/dot.js
+const indent = "  ";
+/** A DOT attribute list from name and value pairs, each value quoted; empty when there are none. */
+const attributes = (pairs) => pairs.length === 0 ? "" : ` [${pairs.map(([name, value]) => `${name}=${dotString(value)}`).join(", ")}]`;
+/** A flowchart node's DOT shape: an oval terminator, a box process, a diamond decision, and a filled bar for a fork or join. */
+const nodeShapes = {
+	terminator: [["shape", "oval"]],
+	process: [["shape", "box"]],
+	decision: [["shape", "diamond"]],
+	bar: [
+		["shape", "box"],
+		["style", "filled"],
+		["fillcolor", "black"],
+		["fontcolor", "white"]
+	]
+};
+const dotNode = (node, depth) => `${depth}${dotString(node.id)}${attributes([["label", node.label], ...nodeShapes[node.shape]])};`;
+/** The edges of a flowchart, a hand-off (an edge whose ends are in different lanes) drawn bold. */
+const dotEdges = (view, isHandoff) => view.edges.map((edge) => `${indent}${dotString(edge.from)} -> ${dotString(edge.to)}${attributes([...edge.label === void 0 ? [] : [["label", edge.label]], ...isHandoff(edge.from, edge.to) ? [["style", "bold"]] : []])};`);
+/**
+* A flowchart as a Graphviz `digraph`, top to bottom. Nodes are named by their model identifiers, so the DOT source reads back to the model directly.
+* @param view - The projected flowchart.
+* @returns DOT source, ending with a line break.
+*/
+const flowchartToDot = (view) => `${[
+	`digraph ${dotString("flowchart")} {`,
+	`${indent}rankdir="TB";`,
+	...view.nodes.map((node) => dotNode(node, indent)),
+	...dotEdges(view, () => false),
+	"}"
+].join("\n")}\n`;
+/**
+* A swimlane as a Graphviz `digraph`, left to right, with one `cluster` subgraph per lane in the view's lane order and nodes with no actor outside every lane. An empty lane holds one invisible point so Graphviz still draws it. Hand-offs, the edges that change lane, are drawn bold.
+* @param view - The projected swimlane.
+* @returns DOT source, ending with a line break.
+*/
+const swimlaneToDot = (view) => {
+	const nodes = new Map(view.nodes.map((node) => [node.id, node]));
+	const laneOf = /* @__PURE__ */ new Map();
+	view.lanes.forEach((lane, index) => {
+		for (const id of lane.nodes) laneOf.set(id, index);
+	});
+	const declare = (id, depth) => {
+		const node = nodes.get(id);
+		if (node === void 0) throw new Error(`lane member "${id}" is not a node of the view`);
+		return dotNode(node, depth);
+	};
+	return `${[
+		`digraph ${dotString("swimlane")} {`,
+		`${indent}rankdir="LR";`,
+		...view.lanes.flatMap((lane, index) => {
+			const cluster = `cluster_lane${String(index)}`;
+			return [
+				`${indent}subgraph ${dotString(cluster)} {`,
+				`${indent.repeat(2)}label=${dotString(lane.label)};`,
+				...lane.nodes.length === 0 ? [`${indent.repeat(2)}${dotString(`${cluster}:empty`)}${attributes([["shape", "point"], ["style", "invis"]])};`] : lane.nodes.map((id) => declare(id, indent.repeat(2))),
+				`${indent}}`
+			];
+		}),
+		...view.unassigned.map((id) => declare(id, indent)),
+		...dotEdges(view, (from, to) => {
+			const fromLane = laneOf.get(from);
+			const toLane = laneOf.get(to);
+			return fromLane !== void 0 && toLane !== void 0 && fromLane !== toLane;
+		}),
+		"}"
+	].join("\n")}\n`;
+};
+/** A state's DOT shape: a filled point for an initial pseudo-state, a double circle for a final one, a rounded box for a state. */
+const stateShape = (state) => {
+	if (state.role === "initial") return [["label", ""], ["shape", "point"]];
+	if (state.role === "final") return [["label", ""], ["shape", "doublecircle"]];
+	return [
+		["label", state.label],
+		["shape", "box"],
+		["style", "rounded"]
+	];
+};
+/**
+* A state machine as a Graphviz `digraph`, left to right. Each transition is labelled with its event, guard and effect.
+* @param view - The projected state machine.
+* @returns DOT source, ending with a line break.
+*/
+const stateMachineToDot = (view) => `${[
+	`digraph ${dotString("state machine")} {`,
+	`${indent}rankdir="LR";`,
+	...view.states.map((state) => `${indent}${dotString(state.id)}${attributes(stateShape(state))};`),
+	...view.transitions.map((transition) => {
+		const label = transitionLabel(transition);
+		return `${indent}${dotString(transition.source)} -> ${dotString(transition.target)}${attributes(label === "" ? [] : [["label", label]])};`;
+	}),
+	"}"
+].join("\n")}\n`;
+const placeMessages = (items, fragments) => items.flatMap((item) => item.kind === "message" ? [{
+	message: item.message,
+	fragments
+}] : item.operands.flatMap((operand) => placeMessages(operand.items, [...fragments, operand.guard === void 0 ? item.operator : `${item.operator} [${operand.guard}]`])));
+/**
+* A sequence diagram as a Graphviz `digraph`. DOT has no sequence notation, so the diagram is drawn as a grid: a column per lifeline, headed by its participant's label, with one row per message in scenario order. Each message is an arrow across its row, numbered by its step and prefixed with the fragments around it (operator and guard, outermost first), since DOT cannot draw a box around arrows.
+* @param view - The projected sequence diagram.
+* @param participantLabel - The label of a lifeline's participant.
+* @returns DOT source, ending with a line break.
+*/
+const sequenceToDot = (view, participantLabel) => {
+	const columns = new Map(view.lifelines.map((lifeline, index) => [lifeline, index]));
+	const column = (lifeline) => {
+		const index = columns.get(lifeline);
+		if (index === void 0) throw new Error(`"${lifeline}" is not a lifeline of the view`);
+		return index;
+	};
+	const head = (index) => dotString(`p${String(index)}`);
+	const cell = (index, row) => dotString(`p${String(index)}.${String(row)}`);
+	const placed = placeMessages(view.items, []);
+	const rows = placed.map((_, row) => row + 1);
+	const pointAttributes = attributes([["shape", "point"], ["width", "0"]]);
+	return `${[
+		`digraph ${dotString("sequence")} {`,
+		`${indent}rankdir="TB";`,
+		...view.lifelines.map((lifeline, index) => `${indent}${head(index)}${attributes([["label", participantLabel(lifeline)], ["shape", "box"]])};`),
+		`${indent}{ rank="same"; ${view.lifelines.map((_, index) => `${head(index)};`).join(" ")} }`,
+		...view.lifelines.slice(1).map((_, index) => `${indent}${head(index)} -> ${head(index + 1)}${attributes([["style", "invis"]])};`),
+		...rows.flatMap((row) => [...view.lifelines.map((_, index) => `${indent}${cell(index, row)}${pointAttributes};`), `${indent}{ rank="same"; ${view.lifelines.map((_, index) => `${cell(index, row)};`).join(" ")} }`]),
+		...rows.length === 0 ? [] : view.lifelines.map((_, index) => `${indent}${[head(index), ...rows.map((row) => cell(index, row))].join(" -> ")}${attributes([["style", "dashed"], ["arrowhead", "none"]])};`),
+		...placed.map(({ message, fragments }, index) => {
+			const row = index + 1;
+			const text = fragments.length === 0 ? message.label : `${fragments.join(" / ")}: ${message.label}`;
+			return `${indent}${cell(column(message.from), row)} -> ${cell(column(message.to), row)}${attributes([["label", `${String(row)}. ${text}`], ["constraint", "false"]])};`;
+		}),
+		"}"
+	].join("\n")}\n`;
+};
+//#endregion
+//#region ../graph-cli/dist/show.js
+/** The views `show` draws, as named on the command line. */
+const viewNames = [
+	"flowchart",
+	"swimlane",
+	"state",
+	"sequence"
+];
+/** The formats `show` writes. */
+const formatNames = [
+	"json",
+	"mermaid",
+	"dot"
+];
+const subjectOf = (model, given) => {
+	const subject = given ?? model.projections.find((projection) => projection.notation === "stateMachine")?.subject;
+	if (subject === void 0) throw new CliError(exitCodes.usage, "the state view needs --subject <entity>: the model declares no state machine projection");
+	const participant = model.participants.find((candidate) => candidate.id === subject);
+	if (participant === void 0) throw new CliError(exitCodes.notFound, `no participant "${subject}" in the model`);
+	if (participant.kind !== "entity") throw new CliError(exitCodes.usage, `"${subject}" is a ${participant.kind}; a state machine follows an entity`);
+	return subject;
+};
+const scenarioOf = (model, given) => {
+	const scenario = given ?? model.projections.find((projection) => projection.notation === "sequence")?.scenario;
+	if (scenario === void 0) throw new CliError(exitCodes.usage, "the sequence view needs --scenario <transition...>: the model declares no sequence projection");
+	const declared = new Set(model.transitions.map((transition) => transition.id));
+	const unknown = scenario.filter((id) => !declared.has(id));
+	if (unknown.length > 0) throw new CliError(exitCodes.notFound, `no transition ${unknown.map((id) => `"${id}"`).join(", ")} in the model`);
+	return scenario;
+};
+/**
+* Projects a model into a view.
+* @param model - The model.
+* @param request - The view, and the subject or scenario it needs.
+* @returns The projection, tagged by view.
+* @throws CliError with `usage` when a state machine or sequence diagram has nothing to follow, or the subject is not an entity, and with `notFound` when the subject or a scenario transition does not exist.
+*/
+const project = (model, request) => {
+	if (request.view === "flowchart") return {
+		view: "flowchart",
+		projection: toFlowchart(model)
+	};
+	if (request.view === "swimlane") return {
+		view: "swimlane",
+		projection: toSwimlane(model)
+	};
+	if (request.view === "state") return {
+		view: "state",
+		projection: toStateMachine(model, subjectOf(model, request.subject))
+	};
+	return {
+		view: "sequence",
+		projection: toSequence(model, scenarioOf(model, request.scenario))
+	};
+};
+/**
+* Writes a projected view as Mermaid or DOT source.
+* @param model - The model, for participant labels.
+* @param projected - The view.
+* @param format - `mermaid` or `dot`.
+* @returns The diagram source.
+*/
+const emit = (model, projected, format) => {
+	const labels = new Map(model.participants.map((participant) => [participant.id, participant.label]));
+	const participantLabel = (id) => labels.get(id) ?? id;
+	const mermaid = format === "mermaid";
+	if (projected.view === "flowchart") return mermaid ? flowchartToMermaid(projected.projection) : flowchartToDot(projected.projection);
+	if (projected.view === "swimlane") return mermaid ? swimlaneToMermaid(projected.projection) : swimlaneToDot(projected.projection);
+	if (projected.view === "state") return mermaid ? stateMachineToMermaid(projected.projection) : stateMachineToDot(projected.projection);
+	return mermaid ? sequenceToMermaid(projected.projection, participantLabel) : sequenceToDot(projected.projection, participantLabel);
+};
+/**
+* Draws the session's model as a view in a format.
+* @param session - The store and model.
+* @param request - The view, format, and the subject or scenario the view needs.
+*/
+const show = async (session, request) => {
+	const { model } = await loadRun(session);
+	const projected = project(model, request);
+	const text = request.format === "json" ? `${JSON.stringify(projected.projection, null, 2)}\n` : emit(model, projected, request.format);
+	return {
+		...projected,
+		format: request.format,
+		text
+	};
+};
+//#endregion
+//#region ../graph-cli/dist/sync.js
+const scopeSeparator = ":";
+/** Groups scopes by their source prefix, keeping the order in which each prefix first appears. */
+const bySource = (scopes) => {
+	const groups = /* @__PURE__ */ new Map();
+	for (const scope of scopes) {
+		const separator = scope.indexOf(scopeSeparator);
+		if (separator <= 0) throw new CliError(exitCodes.usage, `"${scope}" is not a scope: write <source>:<scope>, such as github:owner/repo`);
+		const prefix = scope.slice(0, separator);
+		groups.set(prefix, [...groups.get(prefix) ?? [], scope]);
+	}
+	return [...groups].map(([prefix, grouped]) => ({
+		prefix,
+		scopes: grouped
+	}));
+};
+/** Bound activities are the only elements a sync assembles, since a page's activities are bound by schema. */
+const boundActivities = (pages) => {
+	const { model, overlay, gaps } = assembleSync(pages);
+	const activities = model.elements.flatMap((element) => element.kind === "activity" && element.source !== void 0 ? [{
+		...element,
+		source: element.source
+	}] : []);
+	return {
+		items: {
+			participants: model.participants,
+			activities,
+			transitions: model.transitions,
+			overlay
+		},
+		gaps
+	};
+};
+/**
+* Reads every page of the scopes from their sources and merges them into the session's model in one write, creating the model when the store has none. Records already in the model are replaced by identifier and the rest are kept, so syncing again refreshes what changed.
+*
+* When a source fails part way, the pages read before the failure are still written, and the error says how to resume: the failing source's scopes with `--after` and the cursor of its last page read.
+* @param session - The store and model.
+* @param sources - The source for each identifier prefix.
+* @param request - The scopes, and a cursor to resume after.
+* @returns What was written, and the gaps the sources reported.
+* @throws CliError with `usage` for a scope with no source prefix, a prefix no source serves, or `after` with scopes of more than one source; and with the source's failure, the resume command added, when a source refuses the sync.
+*/
+const sync = async (session, sources, request) => {
+	const groups = bySource(request.scopes);
+	if (request.after !== void 0 && groups.length > 1) throw new CliError(exitCodes.usage, "--after resumes one source's sync: give only that source's scopes");
+	const clients = groups.map((group) => {
+		const client = sources(group.prefix);
+		if (client === void 0) throw new CliError(exitCodes.usage, `no source reads "${group.prefix}" scopes`);
+		return {
+			...group,
+			client
+		};
+	});
+	const pages = [];
+	const write = async () => {
+		const { items, gaps } = boundActivities(pages);
+		const { revision } = await session.store.v1.items.upsert({
+			modelId: session.modelId,
+			items
+		}, callOptions(session.signal));
+		return {
+			modelId: session.modelId,
+			revision,
+			participants: items.participants.length,
+			activities: items.activities.length,
+			transitions: items.transitions.length,
+			gaps
+		};
+	};
+	/** Reads the sources in order, each only after the one before has finished, since a source's failure must stop the ones after it. */
+	const readFrom = async (index) => {
+		const group = clients.at(index);
+		if (group === void 0) return;
+		let cursor = index === 0 ? request.after : void 0;
+		try {
+			const stream = await group.client.v1.sync.stream(cursor === void 0 ? { scope: group.scopes } : {
+				scope: group.scopes,
+				after: cursor
+			}, callOptions(session.signal));
+			for await (const page of stream) {
+				pages.push(page);
+				cursor = page.next;
+			}
+		} catch (error) {
+			const failure = failureOf(error);
+			const saved = pages.length > 0;
+			if (saved) await write();
+			const later = clients.slice(index + 1).flatMap((next) => next.scopes);
+			throw new CliError(failure.exitCode, [
+				failure.message,
+				...saved ? ["the pages read before the failure are saved"] : [],
+				`resume with: sync ${group.scopes.join(" ")}${cursor === void 0 ? "" : ` --after ${cursor}`}`,
+				...later.length === 0 ? [] : [`then: sync ${later.join(" ")}`]
+			].join("\n"), { cause: error });
+		}
+		await readFrom(index + 1);
+	};
+	await readFrom(0);
+	return write();
+};
+//#endregion
+//#region ../graph-cli/dist/validate.js
+/** A cycle that no decision closes, as an issue: status is undefined on it. */
+const cycleIssues = (model) => illegalCycles(model).map((cycle) => ({
+	code: "illegal-cycle",
+	message: `cycle with no decision in it: ${cycle.join(" -> ")}`
+}));
+const resultOf = (issues) => ({
+	valid: issues.length === 0,
+	issues
+});
+/**
+* Checks the session's stored model and run state: the structural rules of `validate`, run state naming elements the model lacks, and cycles no decision closes.
+* @param session - The store and model.
+*/
+const validateStored = async (session) => {
+	const { model, overlay } = await loadRun(session);
+	return resultOf([
+		...validate(model),
+		...validateOverlay(model, overlay),
+		...cycleIssues(model)
+	]);
+};
+/**
+* Checks a model document, such as a file of JSON: its shape against the model schema (each problem located by JSON pointer), then the structural rules of `validate`, then cycles no decision closes. Text that is not JSON is one `schema` issue at the document itself.
+* @param text - The document.
+*/
+const validateDocument = (text) => {
+	let input;
+	try {
+		input = JSON.parse(text);
+	} catch (error) {
+		return resultOf([{
+			code: "schema",
+			message: `not JSON: ${error instanceof Error ? error.message : String(error)}`,
+			pointer: ""
+		}]);
+	}
+	try {
+		return resultOf(cycleIssues(parseModel(input)));
+	} catch (error) {
+		if (!(error instanceof ModelParseError)) throw error;
+		return resultOf(error.issues.map((issue) => issue.source === "schema" ? {
+			code: "schema",
+			message: issue.message,
+			pointer: issue.pointer
+		} : {
+			code: issue.code,
+			message: issue.message
+		}));
+	}
+};
+//#endregion
+//#region ../graph-cli/dist/program.js
+/** The model a command works on when `--model` is not given. */
+const defaultModelId = "default";
+const exitStatusHelp = `
+Exit status:
+  ${String(exitCodes.success)}  success; for validate and cycles, nothing wrong was found
+  ${String(exitCodes.failure)}  failure not listed below
+  ${String(exitCodes.usage)}  usage error: unknown command or option, missing argument, value outside its choices
+  ${String(exitCodes.notFound)}  the model, an element or another identifier named does not exist
+  ${String(exitCodes.invalidModel)}  the model has problems: validation issues, an illegal cycle, or a change the store rejected
+  ${String(exitCodes.sourceFailure)}  a source refused the sync: credentials, rate limit or scope
+
+Every command writes JSON with --json. The store is a SQLite file, chosen with --data.`;
+const readGlobals = (command, ports) => {
+	const { data, model, json } = command.optsWithGlobals();
+	return {
+		data: typeof data === "string" ? data : ports.defaultDataPath,
+		model: typeof model === "string" ? model : defaultModelId,
+		json: json === true
+	};
+};
+const isOneOf = (values, value) => values.some((candidate) => candidate === value);
+/** Reads an option whose choices commander has already checked, narrowing it to its type. */
+const choice = (values, value, name) => {
+	if (!isOneOf(values, value)) throw new Error(`--${name} was not checked against its choices`);
+	return value;
+};
+/**
+* Runs the command line with the given arguments, writing only through the ports, and resolves with the exit status. It never exits the process or reads its arguments itself, so a test or a host program such as Switchboard runs it as a function.
+* @param args - The arguments after the program name, such as `["ready", "--json"]`.
+* @param ports - Output, store, sources, facts and the abort signal.
+* @param identity - The name and version the program presents.
+* @returns The exit status, one of `exitCodes`.
+*/
+const runCli = async (args, ports, identity) => {
+	let exitCode = exitCodes.success;
+	const writeOut = (text) => {
+		ports.stdout(terminalText(text));
+	};
+	const writeErr = (text) => {
+		ports.stderr(terminalText(text));
+	};
+	const program = new Command(identity.name);
+	program.description("Sync work from its sources into a process model, and ask what is ready, blocked, on the critical path or handed off, why, and what it looks like as a diagram.").version(identity.version).configureOutput({
+		writeOut,
+		writeErr
+	}).configureHelp({ showGlobalOptions: true }).exitOverride().option("--data <path>", "the SQLite file the store keeps", ports.defaultDataPath).option("--model <id>", "the model in the store", defaultModelId).option("--json", "write the result as JSON").addHelpText("after", exitStatusHelp).showHelpAfterError();
+	/** Writes a command's result, as JSON or text, and records its exit status. */
+	const respond = (globals, outcome) => {
+		writeOut(globals.json ? terminalJson(outcome.json) : outcome.text);
+		exitCode = outcome.exitCode ?? exitCodes.success;
+	};
+	/** Opens the store for one command, runs it, writes its result and records its exit status; the store is closed whatever happens. */
+	const withSession = (handler) => async (command, ...values) => {
+		const globals = readGlobals(command, ports);
+		const opened = await ports.openStore(globals.data);
+		for (const warning of opened.warnings) writeErr(`warning: ${warning}\n`);
+		try {
+			const outcome = await handler({
+				store: opened.client,
+				modelId: globals.model,
+				facts: ports.facts,
+				signal: ports.signal
+			}, ...values);
+			respond(globals, outcome);
+		} finally {
+			await opened.close();
+		}
+	};
+	program.command("sync").description("read the scopes from their sources and merge them into the model").argument("<scope...>", "source-qualified scopes, such as github:owner or github:owner/repo").option("--after <cursor>", "resume an interrupted sync after this cursor").action(async (scopes, options, command) => {
+		const { after } = options;
+		await withSession(async (session) => {
+			const result = await sync(session, ports.source, typeof after === "string" ? {
+				scopes,
+				after
+			} : { scopes });
+			return {
+				json: result,
+				text: renderSync(result)
+			};
+		})(command);
+	});
+	program.command("ready").description("list the work that can start now").action(async (_options, command) => {
+		await withSession(async (session) => {
+			const result = await ready(session);
+			return {
+				json: result,
+				text: renderReady(result)
+			};
+		})(command);
+	});
+	program.command("blocked").description("list the open work an element is waiting on").argument("<id>", "the element").action(async (id, _options, command) => {
+		await withSession(async (session) => {
+			const result = await blocked(session, id);
+			return {
+				json: result,
+				text: renderBlocked(result)
+			};
+		})(command);
+	});
+	program.command("impact").description("list the live work that depends on an element").argument("<id>", "the element").action(async (id, _options, command) => {
+		await withSession(async (session) => {
+			const result = await impactOf(session, id);
+			return {
+				json: result,
+				text: renderImpact(result)
+			};
+		})(command);
+	});
+	program.command("path").description("list the critical path: the longest chain of work still ahead").action(async (_options, command) => {
+		await withSession(async (session) => {
+			const result = await path(session);
+			return {
+				json: result,
+				text: renderPath(result)
+			};
+		})(command);
+	});
+	program.command("cycles").description("list the cycles no decision closes; exits with the invalid model status when there are any").action(async (_options, command) => {
+		await withSession(async (session) => {
+			const result = await cycles(session);
+			return {
+				json: result,
+				text: renderCycles(result),
+				exitCode: result.cycles.length === 0 ? exitCodes.success : exitCodes.invalidModel
+			};
+		})(command);
+	});
+	program.command("handoffs").description("list the transitions from one actor's work to another's").action(async (_options, command) => {
+		await withSession(async (session) => {
+			const result = await handoffsOf(session);
+			return {
+				json: result,
+				text: renderHandoffs(result)
+			};
+		})(command);
+	});
+	program.command("why").description("explain an element's status: the rule that decided it, its needs and the blocked-by chain").argument("<id>", "the element").action(async (id, _options, command) => {
+		await withSession(async (session) => {
+			const result = await why(session, id);
+			return {
+				json: result,
+				text: renderWhy(result)
+			};
+		})(command);
+	});
+	program.command("show").description("draw the model as a view").addOption(new Option("--view <view>", "the view to draw").choices(viewNames).default("flowchart")).addOption(new Option("--format <format>", "the format to write").choices(formatNames).default("mermaid")).option("--subject <entity>", "the entity a state view follows; defaults to the model's declared state machine projection").option("--scenario <transition...>", "the transitions a sequence view follows, in order; defaults to the model's declared sequence projection").action(async (options, command) => {
+		const view = choice(viewNames, options.view, "view");
+		const format = choice(formatNames, options.format, "format");
+		const { subject, scenario } = options;
+		await withSession(async (session) => {
+			const result = await show(session, {
+				view,
+				format,
+				...typeof subject === "string" ? { subject } : {},
+				...Array.isArray(scenario) ? { scenario: scenario.filter((id) => typeof id === "string") } : {}
+			});
+			return {
+				json: format === "json" ? result.projection : {
+					view,
+					format,
+					text: result.text
+				},
+				text: result.text
+			};
+		})(command);
+	});
+	const addCommand = program.command("add").description("add a record to the model, creating the model if needed");
+	const added = async (command, addition, kind) => withSession(async (session) => {
+		const written = await add(session, addition);
+		return {
+			json: {
+				added: kind,
+				id: addition.record.id,
+				revision: written.revision
+			},
+			text: renderAdded(kind, addition.record.id, written)
+		};
+	})(command);
+	addCommand.command("participant").description("add a participant: a role or system that acts, or an entity with a lifecycle").argument("<id>", "its identifier").argument("<label>", "its label").addOption(new Option("--kind <kind>", "what it is").choices(participantKinds).default("role")).action(async (id, label, options, command) => {
+		const kind = choice(participantKinds, options.kind, "kind");
+		await added(command, {
+			kind: "participant",
+			record: {
+				id,
+				label,
+				kind
+			}
+		}, "participant");
+	});
+	addCommand.command("activity").description("add an activity: a step of work").argument("<id>", "its identifier").argument("<label>", "its label").option("--actor <participant>", "the role or system that does it").action(async (id, label, options, command) => {
+		const { actor } = options;
+		await added(command, {
+			kind: "element",
+			record: {
+				kind: "activity",
+				id,
+				label,
+				...typeof actor === "string" ? { actor } : {}
+			}
+		}, "activity");
+	});
+	addCommand.command("decision").description("add a decision: a point where the flow branches").argument("<id>", "its identifier").argument("<label>", "its label, the question it asks").option("--actor <participant>", "the role or system that decides").action(async (id, label, options, command) => {
+		const { actor } = options;
+		await added(command, {
+			kind: "element",
+			record: {
+				kind: "decision",
+				id,
+				label,
+				...typeof actor === "string" ? { actor } : {}
+			}
+		}, "decision");
+	});
+	addCommand.command("state").description("add a state an entity rests in").argument("<id>", "its identifier").argument("<label>", "its label").option("--parent <state>", "the state it is nested in").action(async (id, label, options, command) => {
+		const { parent } = options;
+		await added(command, {
+			kind: "element",
+			record: {
+				kind: "state",
+				id,
+				label,
+				...typeof parent === "string" ? { parent } : {}
+			}
+		}, "state");
+	});
+	addCommand.command("event").description("add an event that can trigger a transition").argument("<id>", "its identifier").argument("<name>", "its name").action(async (id, name, _options, command) => {
+		await added(command, {
+			kind: "event",
+			record: {
+				id,
+				name
+			}
+		}, "event");
+	});
+	addCommand.command("artefact").description("add an artefact that activities consume or produce").argument("<id>", "its identifier").argument("<name>", "its name").option("--deliverable", "mark it as an output the process exists to deliver").action(async (id, name, options, command) => {
+		await added(command, {
+			kind: "artefact",
+			record: options.deliverable === true ? {
+				id,
+				name,
+				deliverable: true
+			} : {
+				id,
+				name
+			}
+		}, "artefact");
+	});
+	addCommand.command("transition").description("add a transition: the target waits on the source").argument("<source>", "the element that comes first").argument("<target>", "the element that follows").option("--id <id>", "its identifier; <source>-><target> when not given, as a source names its transitions").option("--guard <label>", "the label of the branch it takes").option("--trigger <event>", "the event that fires it").action(async (source, target, options, command) => {
+		const { id, guard, trigger } = options;
+		await added(command, {
+			kind: "transition",
+			record: {
+				id: typeof id === "string" ? id : `${source}->${target}`,
+				source,
+				target,
+				...typeof guard === "string" ? { guard } : {},
+				...typeof trigger === "string" ? { trigger } : {}
+			}
+		}, "transition");
+	});
+	program.command("set").description("set an element's run state").argument("<id>", "the element").addArgument(new Argument("<state>", "its run state").choices(overlayStatuses)).action(async (id, state, _options, command) => {
+		const status = choice(overlayStatuses, state, "state");
+		await withSession(async (session) => {
+			const result = await setState(session, id, status);
+			return {
+				json: result,
+				text: renderSet(result)
+			};
+		})(command);
+	});
+	program.command("validate").description("check the stored model, or a model file, for problems; exits with the invalid model status when there are any").argument("[file]", "a model as JSON, checked instead of the stored model").action(async (file, _options, command) => {
+		const outcome = (result) => ({
+			json: result,
+			text: renderValidate(result),
+			exitCode: result.valid ? exitCodes.success : exitCodes.invalidModel
+		});
+		if (file === void 0) {
+			await withSession(async (session) => outcome(await validateStored(session)))(command);
+			return;
+		}
+		respond(readGlobals(command, ports), outcome(validateDocument(await ports.readFile(file, ports.signal))));
+	});
+	try {
+		await program.parseAsync(args, { from: "user" });
+	} catch (error) {
+		const failure = failureOf(error);
+		if (failure.message !== "") writeErr(`${failure.message}\n`);
+		return failure.exitCode;
+	}
+	return exitCode;
+};
+/** The permission bits of a file mode, without its type. */
+const permissionBits = 511;
+/** The bits that give the file's group or anyone else any access. */
+const groupAndOtherBits = 63;
+/** The SQLite files a store at `path` uses: the database and its write-ahead log and shared-memory index. */
+const storeFiles = (path) => [
+	path,
+	`${path}-wal`,
+	`${path}-shm`
+];
+/** Whether an error is the file system's report that a path does not exist, or already does. */
+const hasCode = (error, code) => error instanceof Error && "code" in error && error.code === code;
+/**
+* Narrows a path's mode to `mode` when its group or others have any access.
+* @param path - The path.
+* @param mode - The private mode it should have.
+* @returns Whether the mode was changed; `false` too when the path does not exist.
+*/
+const tighten = (path, mode) => {
+	let current;
+	try {
+		current = statSync(path).mode & permissionBits;
+	} catch (error) {
+		if (hasCode(error, "ENOENT")) return false;
+		throw error;
+	}
+	if ((current & groupAndOtherBits) === 0) return false;
+	chmodSync(path, mode);
+	return true;
+};
+/**
+* Makes a data file ready for SQLite to open. The directory is created when missing, private when it is the command line's own. The database file is created private when missing, before SQLite opens it, so the file and the sidecars SQLite derives from it are never readable by others, whatever the umask; a file that already exists is left alone unless the directory is the command line's own. In its own directory, an existing directory or store file that group or others can read is narrowed to the private mode.
+* @param path - The database file.
+* @param options - How much of the path the command line owns, and the platform.
+* @returns One warning line naming what was narrowed, or nothing.
+*/
+const prepareDataFile = (path, options) => {
+	const directory = dirname(path);
+	if (options.platform === "win32") {
+		mkdirSync(directory, { recursive: true });
+		return [];
+	}
+	mkdirSync(directory, options.ownsDirectory ? {
+		recursive: true,
+		mode: 448
+	} : { recursive: true });
+	try {
+		closeSync(openSync(path, "wx", 384));
+	} catch (error) {
+		if (!hasCode(error, "EEXIST")) throw error;
+	}
+	if (!options.ownsDirectory) return [];
+	const narrowed = [...tighten(directory, 448) ? [directory] : [], ...storeFiles(path).filter((file) => tighten(file, 384))];
+	return narrowed.length === 0 ? [] : [`made ${narrowed.join(", ")} readable by its owner only, since other users could read the synced work in it`];
+};
+//#endregion
+//#region ../graph-cli/dist/node.js
+/** The variable that names the data file outright. */
+const dataVariable = "PROCESS_GRAPH_DATA";
+/** The data file's path under the data directory. */
+const dataFile = join("process-graph", "graph.sqlite3");
+/** `node:sqlite`'s path for a private database in memory, which has no directory to create. */
+const inMemory = ":memory:";
+/**
+* The command line's own data file: `process-graph/graph.sqlite3` under the XDG data directory (`XDG_DATA_HOME`, or `.local/share` in the home directory).
+* @param env - The environment.
+* @param home - The home directory.
+* @returns The path.
+*/
+const xdgDataPath = (env, home) => {
+	const xdg = env.XDG_DATA_HOME;
+	return join(xdg !== void 0 && xdg !== "" ? xdg : join(home, ".local", "share"), dataFile);
+};
+/**
+* The data file used when `--data` is not given: `PROCESS_GRAPH_DATA` when it is set and not empty, otherwise `process-graph/graph.sqlite3` under the XDG data directory (`XDG_DATA_HOME`, or `.local/share` in the home directory).
+* @param env - The environment.
+* @param home - The home directory.
+* @returns The path.
+*/
+const defaultDataPath = (env, home) => {
+	const named = env[dataVariable];
+	return named !== void 0 && named !== "" ? named : xdgDataPath(env, home);
+};
+/** A fact port that knows nothing: every condition is indeterminate and no input artefact is provided. */
+const noFacts = () => ({ found: false });
+/**
+* The version in a package manifest, which `--version` prints. Each bin passes its own manifest, so the entry point reports its own version rather than this package's.
+* @param manifest - The manifest's location, such as `new URL("../package.json", import.meta.url)` from a module in `dist/`.
+* @returns The version.
+* @throws Error when the manifest has no string `version`.
+*/
+const packageVersion = (manifest) => {
+	const parsed = JSON.parse(readFileSync(manifest, "utf8"));
+	if (typeof parsed !== "object" || parsed === null || !("version" in parsed) || typeof parsed.version !== "string") throw new Error(`${manifest.pathname} has no version`);
+	return parsed.version;
+};
+/**
+* The ports for a Node process: the SQLite store over `node:sqlite` (creating the data file's directory when needed), the GitHub issues source for `github:` scopes, the file system and the process's streams.
+* @param options - Replacements for any of the defaults.
+* @returns The ports.
+*/
+const nodePorts = (options = {}) => {
+	const env = options.env ?? process.env;
+	const token = options.token ?? githubTokenFromEnvironment({ env });
+	const home = options.home ?? homedir();
+	const ownDataPath = xdgDataPath(env, home);
+	return {
+		stdout: options.stdout ?? ((text) => {
+			process.stdout.write(text);
+		}),
+		stderr: options.stderr ?? ((text) => {
+			process.stderr.write(text);
+		}),
+		defaultDataPath: defaultDataPath(env, home),
+		openStore: (path) => {
+			const warnings = path === inMemory ? [] : prepareDataFile(path, {
+				ownsDirectory: path === ownDataPath,
+				platform: options.platform ?? process.platform
+			});
+			const { store, close } = openNodeGraphStore(path);
+			return {
+				client: createRouterClient(createGraphStoreRouter(store)),
+				close,
+				warnings
+			};
+		},
+		source: (prefix) => prefix === "github" ? createRouterClient(createGraphSourceRouter(createGitHubIssuesSource({
+			token,
+			now: options.now ?? Date.now,
+			...options.fetch === void 0 ? {} : { fetch: options.fetch }
+		}))) : void 0,
+		readFile: async (path, signal) => readFile(path, signal === void 0 ? { encoding: "utf8" } : {
+			encoding: "utf8",
+			signal
+		}),
+		facts: options.facts ?? noFacts,
+		signal: options.signal
+	};
+};
+/**
+* Runs the command line as the current process: its arguments, its streams and the real ports, with an interrupt aborting whatever the command is waiting on. It resolves with the exit status rather than exiting, so the bin sets `process.exitCode` and pending output is flushed.
+* @param identity - The name and version the program presents.
+* @returns The exit status.
+*/
+const runProcess = async (identity) => {
+	const controller = new AbortController();
+	process.once("SIGINT", () => {
+		controller.abort();
+	});
+	return runCli(process.argv.slice(2), nodePorts({ signal: controller.signal }), identity);
+};
+//#endregion
+export { add as A, blocked as C, path as D, impactOf as E, failureOf as F, findRun as M, loadRun as N, ready as O, CliError as P, swimlaneToMermaid as S, handoffsOf as T, stateMachineToDot as _, defaultModelId as a, sequenceToMermaid as b, validateStored as c, formatNames as d, project as f, sequenceToDot as g, flowchartToDot as h, runProcess as i, setState as j, why as k, sync as l, viewNames as m, nodePorts as n, runCli as o, show as p, packageVersion as r, validateDocument as s, defaultDataPath as t, emit as u, swimlaneToDot as v, cycles as w, stateMachineToMermaid as x, flowchartToMermaid as y };