process-graph 1.1.1 → 1.3.0

package/dist/{dist-HLlW8vgT.js → dist-BI01yxFA.js}

@@ -1,20 +1,21 @@
-import { a as validateOverlay, d as overlayStatuses, f as participantKinds } from "./schema-CVnS6HiX.js";
+import { a as validateOverlay, d as overlayStatuses, f as participantKinds } from "./schema-BPT8fmfa.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 { n as parseModel, t as ModelParseError } from "./parse-C1Q1zsGt.js";
+import { c as deriveStatuses, f as toStateMachine, g as handoffs, h as toFlowchart, i as readySet, n as criticalPath, p as toSwimlane, r as impact, s as explainStatus, t as blockedBy, u as toSequence } from "./queries-C8kIDRiY.js";
+import { S as UnknownNodeError, f as layeredFacts, n as illegalCycles, u as factsFrom, x as CycleError } from "./control-DiygoEhm.js";
+import { l as assembleSync, t as createGitHubIssuesSource, u as createGraphSourceRouter } from "./source-D51N7K3A.js";
+import { t as GraphSourceError } from "./errors-BZe5WzCn.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 { g as emptyModel } from "./store-DKzvLGgl.js";
+import { t as createGraphStoreRouter } from "./router-Dk91O_9p.js";
+import { i as openNodeGraphStore, t as prepareDataFile } from "./data-file-BVMxkTug.js";
 import { t as exitCodes } from "./exit-codes-0ultCqdS.js";
 import { ORPCError, createRouterClient } from "@orpc/server";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
 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 {
@@ -46,6 +47,16 @@ const issueLines = (data) => {
 	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}`] : []);
 };
 /**
+* The error underneath a source's failure, for a failure's cause. A source called in process through oRPC fails with an `ORPCError` whose cause is the `GraphSourceError` the source threw, whose own cause, when it has one, is what went wrong underneath, such as a token port's error. Those two layers say nothing more than the failure's message and exit status already do, so the innermost error is the one worth keeping.
+* @param error - What the source call threw.
+* @returns The `GraphSourceError`'s cause when it has one, otherwise that `GraphSourceError`; anything else as it is.
+*/
+const underlyingCause = (error) => {
+	const sourceError = error instanceof ORPCError && error.cause instanceof GraphSourceError ? error.cause : error;
+	if (!(sourceError instanceof GraphSourceError)) return error;
+	return sourceError.cause === void 0 ? sourceError : sourceError.cause;
+};
+/**
 * 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.
@@ -95,6 +106,13 @@ const failureOf = (error) => {
 //#endregion
 //#region ../graph-cli/dist/session.js
 /**
+* The facts a run's reasoning reads: the model's stored fact record first, then the session's own facts for every key the record does not answer. What `set artefact` and `set fact` record therefore overrides a host's facts only where it says something.
+* @param session - The session, whose facts the host supplied.
+* @param run - The stored run.
+* @returns The `Facts` port for graph-domain.
+*/
+const runFacts = (session, run) => layeredFacts(factsFrom(run.facts), session.facts);
+/**
 * 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.
 */
@@ -110,7 +128,8 @@ const findRun = async (session) => {
 		return {
 			revision: stored.revision,
 			model: stored.model,
-			overlay: stored.overlay
+			overlay: stored.overlay,
+			facts: stored.facts
 		};
 	} catch (error) {
 		if (error instanceof ORPCError && error.code === "NOT_FOUND") return;
@@ -212,6 +231,74 @@ const setState = async (session, id, state) => {
 		revision
 	};
 };
+/** What can be recorded about an artefact: `provided`, known not provided (`absent`), or `unknown`, which forgets whatever was recorded. */
+const artefactStates = [
+	"provided",
+	"absent",
+	"unknown"
+];
+/**
+* Records whether an artefact of the session's model is provided, so a consumer of an input no activity produces can become ready, or forgets it with `unknown`.
+* @param session - The store and model.
+* @param id - The artefact.
+* @param state - `provided`, `absent` or `unknown`.
+* @returns The artefact, its new state and the revision the change took.
+* @throws CliError with `notFound` when the model or the artefact does not exist.
+*/
+const setArtefact = async (session, id, state) => {
+	const { model } = await loadRun(session);
+	if (!model.artefacts.some((artefact) => artefact.id === id)) throw new CliError(exitCodes.notFound, `no artefact "${id}" in the model`);
+	const options = callOptions(session.signal);
+	const { revision } = state === "unknown" ? await session.store.v1.facts.clear({
+		modelId: session.modelId,
+		facts: { artefacts: [id] }
+	}, options) : await session.store.v1.facts.set({
+		modelId: session.modelId,
+		facts: { artefacts: { [id]: state === "provided" } }
+	}, options);
+	return {
+		artefact: id,
+		state,
+		revision
+	};
+};
+/**
+* Records a named fact's value for the session's model, so every condition reading that name evaluates against it, or forgets it with `unknown`, so those conditions are indeterminate again.
+* @param session - The store and model.
+* @param name - The fact's name, the key a condition's `reference` node gives.
+* @param value - Its trilean value, or `unknown`.
+* @returns The fact, its new value and the revision the change took.
+* @throws CliError with `notFound` when the model does not exist.
+*/
+const setFact = async (session, name, value) => {
+	await loadRun(session);
+	const options = callOptions(session.signal);
+	const { revision } = value === "unknown" ? await session.store.v1.facts.clear({
+		modelId: session.modelId,
+		facts: { values: [name] }
+	}, options) : await session.store.v1.facts.set({
+		modelId: session.modelId,
+		facts: { values: { [name]: value } }
+	}, options);
+	return {
+		fact: name,
+		value,
+		revision
+	};
+};
+/**
+* Reads what is recorded about the session's model's run: which artefacts are provided or absent, and each named fact's value.
+* @param session - The store and model.
+* @returns The fact record and the model's revision.
+* @throws CliError with `notFound` when the model does not exist.
+*/
+const factsOf = async (session) => {
+	const { revision, facts } = await loadRun(session);
+	return {
+		revision,
+		facts
+	};
+};
 //#endregion
 //#region ../graph-cli/dist/queries.js
 /** Each element counts as one step, so the critical path is the longest chain of elements. */
@@ -221,8 +308,9 @@ const stepWeight = 1;
 * @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 run = await loadRun(session);
+	const { model, overlay } = run;
+	return { elements: summarise(model, readySet(model, overlay, runFacts(session, run))) };
 };
 const statusOf = (statuses, summary) => {
 	const status = statuses.get(summary.id);
@@ -238,15 +326,17 @@ const statusOf = (statuses, summary) => {
 * @param id - The element asked about.
 */
 const blocked = async (session, id) => {
-	const { model, overlay } = await loadRun(session);
+	const run = await loadRun(session);
+	const { model, overlay } = run;
+	const facts = runFacts(session, run);
 	const element = requireElement(model, id);
-	const statuses = deriveStatuses(model, overlay, session.facts);
+	const statuses = deriveStatuses(model, overlay, facts);
 	return {
 		element: statusOf(statuses, {
 			id,
 			label: labelOf(element)
 		}),
-		blockedBy: summarise(model, blockedBy(model, overlay, session.facts, id))
+		blockedBy: summarise(model, blockedBy(model, overlay, facts, id))
 	};
 };
 /**
@@ -255,15 +345,17 @@ const blocked = async (session, id) => {
 * @param id - The element asked about.
 */
 const impactOf = async (session, id) => {
-	const { model, overlay } = await loadRun(session);
+	const run = await loadRun(session);
+	const { model, overlay } = run;
+	const facts = runFacts(session, run);
 	const element = requireElement(model, id);
-	const statuses = deriveStatuses(model, overlay, session.facts);
+	const statuses = deriveStatuses(model, overlay, facts);
 	return {
 		element: statusOf(statuses, {
 			id,
 			label: labelOf(element)
 		}),
-		impacted: summarise(model, impact(model, overlay, session.facts, id))
+		impacted: summarise(model, impact(model, overlay, facts, id))
 	};
 };
 /**
@@ -271,8 +363,9 @@ const impactOf = async (session, id) => {
 * @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);
+	const run = await loadRun(session);
+	const { model, overlay } = run;
+	const found = criticalPath(model, overlay, runFacts(session, run), () => stepWeight);
 	return {
 		path: summarise(model, found.path),
 		weight: found.weight
@@ -300,9 +393,10 @@ const handoffsOf = async (session) => {
 * @param id - The element asked about.
 */
 const why = async (session, id) => {
-	const { model, overlay } = await loadRun(session);
+	const run = await loadRun(session);
+	const { model, overlay } = run;
 	requireElement(model, id);
-	const explained = explainStatus(model, overlay, session.facts, id);
+	const explained = explainStatus(model, overlay, runFacts(session, run), id);
 	const chain = explained.chain.map((link) => ({
 		id: link.element,
 		label: labelOf(requireElement(model, link.element)),
@@ -375,8 +469,34 @@ const renderWhy = (result) => {
 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)}`]);
+/** A fact's value as the command line reads it back: a boolean or number as written, text as it is, and the other kinds as their JSON. */
+const valueText = (value) => {
+	if (value.kind === "boolean" || value.kind === "number") return value.kind === "number" && value.unit !== void 0 ? JSON.stringify(value) : String(value.value);
+	return value.kind === "text" ? value.value : JSON.stringify(value);
+};
+/** `set artefact`: the artefact's new state and the revision it took. */
+const renderSetArtefact = (result) => lines([`set artefact ${result.artefact} to ${result.state} at revision ${String(result.revision)}`]);
+/** `set fact`: the fact's new value and the revision it took. */
+const renderSetFact = (result) => lines([`set fact ${result.fact} to ${result.value === "unknown" ? "unknown" : valueText(result.value)} at revision ${String(result.revision)}`]);
+/** `facts`: each recorded artefact as `artefact`, its id and `provided` or `absent`, then each named fact as `fact`, its name and its value, each sorted by id or name. */
+const renderFacts = (result) => lines([...Object.entries(result.facts.artefacts).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([id, provided]) => `artefact\t${id}\t${provided ? "provided" : "absent"}`), ...Object.entries(result.facts.values).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([name, value]) => `fact\t${name}\t${valueText(value)}`)]);
 /** `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}`)]);
+/**
+* A sync a source interrupted: the source's failure, whether the pages read before it were saved, and the commands that carry on, `resume with: sync <scopes> --after <cursor>` for the failing source and `then: sync <scopes>` for the sources not reached.
+* @param message - The source's failure.
+* @param interruption - Where the sync carries on.
+* @returns The lines for standard error, without a final line break.
+*/
+const renderSyncInterruption = (message, interruption) => {
+	const { resume, remaining, saved } = interruption;
+	return [
+		message,
+		...saved ? ["the pages read before the failure are saved"] : [],
+		`resume with: sync ${resume.scopes.join(" ")}${resume.after === void 0 ? "" : ` --after ${resume.after}`}`,
+		...remaining.length === 0 ? [] : [`then: sync ${remaining.join(" ")}`]
+	].join("\n");
+};
 /** `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
@@ -788,6 +908,27 @@ const show = async (session, request) => {
 };
 //#endregion
 //#region ../graph-cli/dist/sync.js
+/**
+* Thrown by `sync` when a source fails part way. Its exit status and message are the source's failure, classified as `failureOf` classifies it; its cause is the error underneath that failure, such as the token port's own error; and what to run next is data, in `resume` and `remaining`, never text.
+*/
+var SyncInterruptedError = class extends CliError {
+	resume;
+	remaining;
+	saved;
+	/**
+	* @param exitCode - The exit status the source's failure maps to.
+	* @param message - The source's failure.
+	* @param interruption - Where the sync carries on.
+	* @param options - The underlying error, kept as the cause.
+	*/
+	constructor(exitCode, message, interruption, options) {
+		super(exitCode, message, options);
+		this.name = "SyncInterruptedError";
+		this.resume = interruption.resume;
+		this.remaining = interruption.remaining;
+		this.saved = interruption.saved;
+	}
+};
 const scopeSeparator = ":";
 /** Groups scopes by their source prefix, keeping the order in which each prefix first appears. */
 const bySource = (scopes) => {
@@ -823,12 +964,12 @@ const boundActivities = (pages) => {
 /**
 * 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.
+* When a source fails part way, the pages read before the failure are still written, and the error carries where to carry on: the request that resumes the failing source after the cursor of its last page read, and the scopes of the sources not reached.
 * @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.
+* @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 SyncInterruptedError, with the source's failure and where to carry on, when a source fails part way.
 */
 const sync = async (session, sources, request) => {
 	const groups = bySource(request.scopes);
@@ -875,13 +1016,14 @@ const sync = async (session, sources, request) => {
 			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 });
+			throw new SyncInterruptedError(failure.exitCode, failure.message, {
+				resume: cursor === void 0 ? { scopes: group.scopes } : {
+					scopes: group.scopes,
+					after: cursor
+				},
+				remaining: clients.slice(index + 1).flatMap((next) => next.scopes),
+				saved
+			}, { cause: underlyingCause(error) });
 		}
 		await readFrom(index + 1);
 	};
@@ -962,12 +1104,42 @@ const readGlobals = (command, ports) => {
 		json: json === true
 	};
 };
+/** Narrows a variadic option's values, which commander gives as an untyped array, to the strings they are. */
+const isText = (value) => typeof value === "string";
 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;
 };
+/** The word that forgets a named fact rather than giving it a value. */
+const unknownValue = "unknown";
+/** A number as JSON writes one, so a value that reads as a number is never also meant as text. */
+const jsonNumber = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/u;
+/**
+* Reads a fact's value from the command line: `true` and `false` are booleans, `unknown` forgets the fact, a JSON number is a number, and anything else is text; `--text` reads the value as text whatever it looks like.
+* @param value - The value as given.
+* @param asText - Whether `--text` was given.
+* @returns The trilean value, or `unknown`.
+*/
+const factValueOf = (value, asText) => {
+	if (asText) return {
+		kind: "text",
+		value
+	};
+	if (value === unknownValue) return unknownValue;
+	if (value === "true" || value === "false") return {
+		kind: "boolean",
+		value: value === "true"
+	};
+	return jsonNumber.test(value) ? {
+		kind: "number",
+		value: Number(value)
+	} : {
+		kind: "text",
+		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"]`.
@@ -1013,14 +1185,19 @@ const runCli = async (args, ports, identity) => {
 	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)
-			};
+			try {
+				const result = await sync(session, ports.source, typeof after === "string" ? {
+					scopes,
+					after
+				} : { scopes });
+				return {
+					json: result,
+					text: renderSync(result)
+				};
+			} catch (error) {
+				if (error instanceof SyncInterruptedError) throw new CliError(error.exitCode, renderSyncInterruption(error.message, error), { cause: error });
+				throw error;
+			}
 		})(command);
 	});
 	program.command("ready").description("list the work that can start now").action(async (_options, command) => {
@@ -1131,15 +1308,17 @@ const runCli = async (args, ports, identity) => {
 			}
 		}, "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;
+	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").option("--consumes <artefact...>", "the artefacts it needs before it can start").option("--produces <artefact...>", "the artefacts it makes").action(async (id, label, options, command) => {
+		const { actor, consumes, produces } = options;
 		await added(command, {
 			kind: "element",
 			record: {
 				kind: "activity",
 				id,
 				label,
-				...typeof actor === "string" ? { actor } : {}
+				...typeof actor === "string" ? { actor } : {},
+				...Array.isArray(consumes) ? { consumes: consumes.filter(isText) } : {},
+				...Array.isArray(produces) ? { produces: produces.filter(isText) } : {}
 			}
 		}, "activity");
 	});
@@ -1202,7 +1381,7 @@ const runCli = async (args, ports, identity) => {
 			}
 		}, "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 setCommand = program.command("set").description("set an element's run state; set artefact and set fact record what is known from outside the process").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);
@@ -1212,6 +1391,35 @@ const runCli = async (args, ports, identity) => {
 			};
 		})(command);
 	});
+	setCommand.command("artefact").description("record whether an artefact is provided, so work consuming it can start; unknown forgets it").argument("<id>", "the artefact").addArgument(new Argument("<state>", "whether it is provided").choices(artefactStates)).action(async (id, state, _options, command) => {
+		const provision = choice(artefactStates, state, "state");
+		await withSession(async (session) => {
+			const result = await setArtefact(session, id, provision);
+			return {
+				json: result,
+				text: renderSetArtefact(result)
+			};
+		})(command);
+	});
+	setCommand.command("fact").description("record the value of a named fact that decision conditions read; unknown forgets it").argument("<name>", "the fact's name, as a condition's reference gives it").argument("<value>", "true, false, unknown, a number, or any other text").option("--text", "read the value as text, even true, false or a number").action(async (name, value, options, command) => {
+		const parsed = factValueOf(value, options.text === true);
+		await withSession(async (session) => {
+			const result = await setFact(session, name, parsed);
+			return {
+				json: result,
+				text: renderSetFact(result)
+			};
+		})(command);
+	});
+	program.command("facts").description("list what is recorded about the run: each artefact provided or absent, and each named fact's value").action(async (_options, command) => {
+		await withSession(async (session) => {
+			const result = await factsOf(session);
+			return {
+				json: result,
+				text: renderFacts(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,
@@ -1233,61 +1441,6 @@ const runCli = async (args, ports, identity) => {
 	}
 	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. */
@@ -1330,7 +1483,7 @@ const packageVersion = (manifest) => {
 	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.
+* The ports for a Node process: the SQLite store over `node:sqlite` (creating the data file's directory when needed, private when the command line or the host owns it), 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.
 */
@@ -1338,7 +1491,7 @@ 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);
+	const ownDataPath = options.dataPath ?? xdgDataPath(env, home);
 	return {
 		stdout: options.stdout ?? ((text) => {
 			process.stdout.write(text);
@@ -1346,7 +1499,7 @@ const nodePorts = (options = {}) => {
 		stderr: options.stderr ?? ((text) => {
 			process.stderr.write(text);
 		}),
-		defaultDataPath: defaultDataPath(env, home),
+		defaultDataPath: options.dataPath ?? defaultDataPath(env, home),
 		openStore: (path) => {
 			const warnings = path === inMemory ? [] : prepareDataFile(path, {
 				ownsDirectory: path === ownDataPath,
@@ -1385,4 +1538,4 @@ const runProcess = async (identity) => {
 	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 };
+export { why as A, CliError as B, swimlaneToMermaid as C, impactOf as D, handoffsOf as E, setFact as F, setState as I, findRun as L, artefactStates as M, factsOf as N, path as O, setArtefact as P, loadRun as R, stateMachineToMermaid as S, cycles as T, failureOf as V, sequenceToDot as _, defaultModelId as a, flowchartToMermaid as b, validateStored as c, emit as d, formatNames as f, flowchartToDot as g, viewNames as h, runProcess as i, add as j, ready as k, SyncInterruptedError as l, show as m, nodePorts as n, runCli as o, project as p, packageVersion as r, validateDocument as s, defaultDataPath as t, sync as u, stateMachineToDot as v, blocked as w, sequenceToMermaid as x, swimlaneToDot as y, runFacts as z };