process-graph 1.0.5 → 1.1.0

package/dist/react.js

@@ -0,0 +1,107 @@
+import { _ as toSwimlane, g as toStateMachine, m as toSequence, y as toFlowchart } from "./queries-CCexJAE2.js";
+import { a as filterOptions, c as useElementFilter, d as useBlockers, f as useCriticalPath, g as useWhyStatus, h as useStatuses, i as filterElements, l as stepWeight, m as useReadySet, n as actorsOf, o as matchesFilter, p as useImpact, r as emptyFilter, s as sourceScope, t as useGraphSelection, u as useBlockedChain } from "./selection-BW_xXWOy.js";
+import { a as TransitionItem, c as elementLabel, i as Lane, l as ruleDescriptions, n as FilterPanel, o as ElementCard, r as Legend, s as StatusBadge, t as DetailPanel, u as statusLabels } from "./detail-panel-B1ZmMuJT.js";
+import { ORPCError } from "@orpc/client";
+import { useEffect, useMemo, useState } from "react";
+//#region ../../ui/graph/react/dist/run.js
+/**
+* The facts port of a run that has no facts source: every key is not found, so a condition that reads one is indeterminate and no input artefact counts as provided.
+* @returns `{ found: false }` for every key.
+*/
+const noFacts = () => ({ found: false });
+//#endregion
+//#region ../../ui/graph/react/dist/model.js
+const loading = { status: "loading" };
+const missing = { status: "missing" };
+/** Revisions are positive, so every change to a model is newer than this: the revision a missing model is treated as having. */
+const noRevision = 0;
+/**
+* Loads a model from a store and follows it: every change the store reports loads the model again, so the result always reflects the store's latest revision. It subscribes before the first load, so no change between the two is missed. A model the store does not have is `missing` and still followed, so a model that is created later, or deleted and saved again, is loaded when it is.
+* @param client - A `GraphStore` client, over any transport. Keep it stable between renders.
+* @param modelId - The model to follow.
+* @returns `loading` until the first load; then `loaded` with the model, its overlay and revision, `missing` while the store has no such model (its load answers `NOT_FOUND`), or `failed` with any other error a load or the subscription ended with.
+*/
+const useModel = (client, modelId) => {
+	const [state, setState] = useState({
+		client,
+		modelId,
+		value: loading
+	});
+	useEffect(() => {
+		const controller = new AbortController();
+		const { signal } = controller;
+		const settle = (value) => {
+			setState({
+				client,
+				modelId,
+				value
+			});
+		};
+		const load = async () => {
+			try {
+				const stored = await client.v1.models.load({ modelId }, { signal });
+				settle({
+					status: "loaded",
+					stored
+				});
+				return stored.revision;
+			} catch (error) {
+				if (error instanceof ORPCError && error.code === "NOT_FOUND") {
+					settle(missing);
+					return noRevision;
+				}
+				throw error;
+			}
+		};
+		const follow = async () => {
+			const changes = await client.v1.changes({ modelId }, { signal });
+			let loaded = await load();
+			for await (const change of changes) if (change.kind === "missed" || change.revision > loaded) loaded = await load();
+		};
+		follow().catch((error) => {
+			if (!signal.aborted) settle({
+				status: "failed",
+				error
+			});
+		});
+		return () => {
+			controller.abort();
+		};
+	}, [client, modelId]);
+	return state.client === client && state.modelId === modelId ? state.value : loading;
+};
+//#endregion
+//#region ../../ui/graph/react/dist/projection.js
+/**
+* Projects a model into the notation a projection names, with the input it records (a subject, a scenario).
+* @param model - The model to project.
+* @param projection - One of the model's declared projections, or one built the same way.
+* @returns The notation and its view.
+*/
+const project = (model, projection) => {
+	if (projection.notation === "stateMachine") return {
+		notation: "stateMachine",
+		view: toStateMachine(model, projection.subject)
+	};
+	if (projection.notation === "sequence") return {
+		notation: "sequence",
+		view: toSequence(model, projection.scenario)
+	};
+	return projection.notation === "swimlane" ? {
+		notation: "swimlane",
+		view: toSwimlane(model)
+	} : {
+		notation: "flowchart",
+		view: toFlowchart(model)
+	};
+};
+/**
+* A model's view in one notation, projected again only when the model or the projection changes.
+* @param model - The model to project.
+* @param projection - The projection to draw. Keep it stable between renders, for instance one of `model.projections`.
+* @returns The notation and its view.
+* @throws Error when a state machine's subject is not a declared entity.
+*/
+const useProjection = (model, projection) => useMemo(() => project(model, projection), [model, projection]);
+//#endregion
+export { DetailPanel, ElementCard, FilterPanel, Lane, Legend, StatusBadge, TransitionItem, actorsOf, elementLabel, emptyFilter, filterElements, filterOptions, matchesFilter, noFacts, project, ruleDescriptions, sourceScope, statusLabels, stepWeight, useBlockedChain, useBlockers, useCriticalPath, useElementFilter, useGraphSelection, useImpact, useModel, useProjection, useReadySet, useStatuses, useWhyStatus };

package/dist/rolldown-runtime-D7D4PA-g.js

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };

package/dist/router-D4gtTlXm.js

@@ -0,0 +1,188 @@
+import { r as overlaySchema, t as modelSchema } from "./schema-CVnS6HiX.js";
+import { C as modelSummarySchema, D as revisionSchema, E as relationSchema, O as storeChangeSchema, S as modelIdSchema, _ as GraphStoreError, k as storedModelSchema, w as reachSchema, x as issueSchema, y as boundItemsSchema } from "./store-BcR70CaO.js";
+import { z } from "zod";
+import { eventIterator, oc } from "@orpc/contract";
+import { implement } from "@orpc/server";
+//#region ../../core/graph/store-contract/dist/contract.js
+/**
+* The typed errors a procedure can end with, each carrying its detail as data. The codes are oRPC's common codes, so an HTTP transport answers with the matching status (404, 422) without any per-transport mapping.
+*/
+const graphStoreErrors = {
+	NOT_FOUND: {
+		message: "No such model, or no such element in it.",
+		data: z.strictObject({
+			modelId: z.string(),
+			element: z.string().exactOptional()
+		})
+	},
+	UNPROCESSABLE_CONTENT: {
+		message: "The change would leave the model or its overlay invalid.",
+		data: z.strictObject({ issues: z.array(issueSchema).readonly() })
+	}
+};
+const modelRef = z.strictObject({ modelId: modelIdSchema }).readonly();
+const elementRef = z.strictObject({
+	modelId: modelIdSchema,
+	element: z.string()
+}).readonly();
+const written = z.strictObject({ revision: revisionSchema }).readonly();
+/** The `GraphStore` port: an oRPC router contract, keyed by version. */
+const graphStoreContract = { v1: oc.errors(graphStoreErrors).router({
+	models: {
+		list: oc.output(z.array(modelSummarySchema).readonly()),
+		save: oc.input(z.strictObject({
+			modelId: modelIdSchema,
+			model: modelSchema
+		}).readonly()).output(written),
+		load: oc.input(modelRef).output(storedModelSchema),
+		delete: oc.input(modelRef).output(z.union([z.strictObject({
+			deleted: z.literal(true),
+			revision: revisionSchema
+		}).readonly(), z.strictObject({ deleted: z.literal(false) }).readonly()]))
+	},
+	overlay: { set: oc.input(z.strictObject({
+		modelId: modelIdSchema,
+		overlay: overlaySchema
+	}).readonly()).output(written) },
+	items: { upsert: oc.input(z.strictObject({
+		modelId: modelIdSchema,
+		items: boundItemsSchema
+	}).readonly()).output(written) },
+	relations: { list: oc.input(modelRef).output(z.strictObject({ relations: z.array(relationSchema).readonly() }).readonly()) },
+	query: {
+		ready: oc.input(modelRef).output(z.strictObject({ elements: z.array(z.string()).readonly() }).readonly()),
+		blockedChain: oc.input(elementRef).output(z.strictObject({ chain: z.array(reachSchema).readonly() }).readonly()),
+		impact: oc.input(elementRef).output(z.strictObject({ impacted: z.array(reachSchema).readonly() }).readonly()),
+		children: oc.input(elementRef).output(z.strictObject({ children: z.array(z.string()).readonly() }).readonly()),
+		descendants: oc.input(elementRef).output(z.strictObject({ descendants: z.array(reachSchema).readonly() }).readonly()),
+		ancestors: oc.input(elementRef).output(z.strictObject({ ancestors: z.array(reachSchema).readonly() }).readonly())
+	},
+	changes: oc.input(z.strictObject({
+		modelId: modelIdSchema,
+		since: revisionSchema.exactOptional()
+	}).readonly()).output(eventIterator(storeChangeSchema))
+}) };
+//#endregion
+//#region ../../core/graph/store-contract/dist/router.js
+const os = implement(graphStoreContract);
+/** Rethrows a store's `GraphStoreError` as the contract's typed oRPC error; anything else propagates unchanged. */
+const toContractError = (error, errors) => {
+	if (!(error instanceof GraphStoreError)) return error;
+	const { failure } = error;
+	if (failure.kind === "not-found") return errors.NOT_FOUND({
+		message: error.message,
+		data: failure.element === void 0 ? { modelId: failure.modelId } : {
+			modelId: failure.modelId,
+			element: failure.element
+		},
+		cause: error
+	});
+	return errors.UNPROCESSABLE_CONTENT({
+		message: error.message,
+		data: { issues: failure.issues },
+		cause: error
+	});
+};
+/** Runs one store call: refuses an already-aborted signal before touching the store, and maps the store's failures to the contract's errors. */
+const call = async (signal, errors, operation) => {
+	signal?.throwIfAborted();
+	try {
+		return await operation();
+	} catch (error) {
+		throw toContractError(error, errors);
+	}
+};
+/**
+* Builds the `GraphStore` router over a store. Serve it over any oRPC transport, or call it in process with `createRouterClient`.
+*
+* `changes` subscribes to the store's feed before it reads the model's revision and before it returns, so no change is lost between the two, and a caller holding the iterator is already subscribed. When the caller names a revision `since` and the model is no longer at it, the first event is `missed`; every later change follows as it commits.
+* @param store - The adapter.
+* @returns The implemented router for `graphStoreContract`.
+*/
+const createGraphStoreRouter = (store) => os.router({ v1: {
+	models: {
+		list: os.v1.models.list.handler(async ({ signal, errors }) => call(signal, errors, async () => store.listModels({ signal }))),
+		save: os.v1.models.save.handler(async ({ input, signal, errors }) => call(signal, errors, async () => ({ revision: await store.saveModel({
+			...input,
+			signal
+		}) }))),
+		load: os.v1.models.load.handler(async ({ input, signal, errors }) => call(signal, errors, async () => store.loadModel({
+			...input,
+			signal
+		}))),
+		delete: os.v1.models.delete.handler(async ({ input, signal, errors }) => call(signal, errors, async () => {
+			const revision = await store.deleteModel({
+				...input,
+				signal
+			});
+			return revision === void 0 ? { deleted: false } : {
+				deleted: true,
+				revision
+			};
+		}))
+	},
+	overlay: { set: os.v1.overlay.set.handler(async ({ input, signal, errors }) => call(signal, errors, async () => ({ revision: await store.applyOverlay({
+		...input,
+		signal
+	}) }))) },
+	items: { upsert: os.v1.items.upsert.handler(async ({ input, signal, errors }) => call(signal, errors, async () => ({ revision: await store.upsertItems({
+		...input,
+		signal
+	}) }))) },
+	relations: { list: os.v1.relations.list.handler(async ({ input, signal, errors }) => call(signal, errors, async () => ({ relations: await store.relations({
+		...input,
+		signal
+	}) }))) },
+	query: {
+		ready: os.v1.query.ready.handler(async ({ input, signal, errors }) => call(signal, errors, async () => ({ elements: await store.ready({
+			...input,
+			signal
+		}) }))),
+		blockedChain: os.v1.query.blockedChain.handler(async ({ input, signal, errors }) => call(signal, errors, async () => ({ chain: await store.blockedChain({
+			...input,
+			signal
+		}) }))),
+		impact: os.v1.query.impact.handler(async ({ input, signal, errors }) => call(signal, errors, async () => ({ impacted: await store.impact({
+			...input,
+			signal
+		}) }))),
+		children: os.v1.query.children.handler(async ({ input, signal, errors }) => call(signal, errors, async () => ({ children: await store.children({
+			...input,
+			signal
+		}) }))),
+		descendants: os.v1.query.descendants.handler(async ({ input, signal, errors }) => call(signal, errors, async () => ({ descendants: await store.descendants({
+			...input,
+			signal
+		}) }))),
+		ancestors: os.v1.query.ancestors.handler(async ({ input, signal, errors }) => call(signal, errors, async () => ({ ancestors: await store.ancestors({
+			...input,
+			signal
+		}) })))
+	},
+	changes: os.v1.changes.handler(async ({ input, signal, errors }) => {
+		const subscription = store.feed.subscribe(input.modelId, { signal });
+		let missed = false;
+		try {
+			if (input.since !== void 0) missed = await call(signal, errors, async () => store.revisionOf({
+				modelId: input.modelId,
+				signal
+			})) !== input.since;
+		} catch (error) {
+			subscription.close();
+			throw error;
+		}
+		return (async function* () {
+			try {
+				if (missed) yield {
+					modelId: input.modelId,
+					kind: "missed"
+				};
+				yield* subscription;
+			} finally {
+				subscription.close();
+			}
+		})();
+	})
+} });
+//#endregion
+export { graphStoreContract as n, createGraphStoreRouter as t };

package/dist/schema-CVnS6HiX.js

@@ -0,0 +1,234 @@
+import { z } from "zod";
+import { JsonValueSchema, PredicateNodeSchema } from "trilean";
+//#region ../../core/graph/schema/dist/vocabulary.js
+/** What a participant is: a `role` or `system` can act, an `entity` has a lifecycle a state machine can track. */
+const participantKinds = [
+	"role",
+	"system",
+	"entity"
+];
+const pseudoRoles = [
+	"initial",
+	"final",
+	"fork",
+	"join",
+	"history"
+];
+const messageModes = [
+	"sync",
+	"async",
+	"reply",
+	"create",
+	"destroy"
+];
+const fragmentOperators = [
+	"alt",
+	"opt",
+	"loop",
+	"par",
+	"break"
+];
+/** Where an element stands in a run: finished, still to do, or not known. Run state is supplied by sources and never stored in the model. */
+const overlayStatuses = [
+	"done",
+	"open",
+	"unknown"
+];
+const notations = [
+	"flowchart",
+	"swimlane",
+	"stateMachine",
+	"sequence"
+];
+/** The kinds of element a model declares, one per variant of `Element`. */
+const elementKinds = [
+	"activity",
+	"decision",
+	"state",
+	"pseudo",
+	"message"
+];
+//#endregion
+//#region ../../core/graph/schema/dist/pointer.js
+/** Encodes a schema issue path as an RFC 6901 JSON pointer, escaping `~` and `/` inside a segment. The empty path is the document itself, `""`. */
+const toPointer = (path) => path.map((segment) => `/${String(segment).replaceAll("~", "~0").replaceAll("/", "~1")}`).join("");
+//#endregion
+//#region ../../core/graph/schema/dist/overlay.js
+/** The open overlay shape: element identifiers are plain strings. Its inferred type is exactly `Overlay<OpenIds>`. */
+const overlaySchema = z.partialRecord(z.string(), z.enum(overlayStatuses)).readonly();
+/** Thrown by `parseOverlay` when the input is not a valid overlay. */
+var OverlayParseError = class extends Error {
+	/** Every problem found. Never empty. */
+	issues;
+	/**
+	* @param issues - The problems found. Must not be empty.
+	*/
+	constructor(issues) {
+		super(`Invalid overlay: ${issues.map((issue) => `${issue.pointer === "" ? "/" : issue.pointer}: ${issue.message}`).join("; ")}`);
+		this.name = "OverlayParseError";
+		this.issues = issues;
+	}
+};
+/**
+* Checks an overlay against the model it is laid over. `parseOverlay` is model-independent, so this is where an element identifier that the model does not declare is found.
+* @param model - The model the overlay is for.
+* @param overlay - The overlay to check.
+* @returns One `overlay-unknown-element` issue per entry whose key is not an element of the model, in the overlay's key order. Empty when every entry names a declared element.
+*/
+const validateOverlay = (model, overlay) => {
+	const elementIds = new Set(model.elements.map((e) => e.id));
+	return Object.keys(overlay).filter((id) => !elementIds.has(id)).map((id) => ({
+		code: "overlay-unknown-element",
+		message: `overlay refers to unknown element id "${id}"`
+	}));
+};
+/**
+* Loads an overlay from untrusted input, such as parsed JSON.
+* @param input - The value to load.
+* @returns The overlay, keyed by plain-string element identifiers.
+* @throws OverlayParseError when the input is not an object of element identifier to `"done"`, `"open"` or `"unknown"`.
+*/
+const parseOverlay = (input) => {
+	const parsed = overlaySchema.safeParse(input);
+	if (!parsed.success) throw new OverlayParseError(parsed.error.issues.map((issue) => ({
+		pointer: toPointer(issue.path),
+		message: issue.message
+	})));
+	return parsed.data;
+};
+//#endregion
+//#region ../../core/graph/schema/dist/schema.js
+/** An object schema that rejects unknown keys, so a misspelt field in a loaded document is an error and not silently dropped. */
+const record = (shape) => z.strictObject(shape).readonly();
+const id = z.string();
+const elementRef = z.string();
+const actorRef = z.string();
+const eventRef = z.string();
+const actionRef = z.string();
+const transitionRef = z.string();
+const entityRef = z.string();
+const artefactRef = z.string();
+const extensionsSchema = z.record(z.string(), JsonValueSchema).readonly();
+const participantSchema = record({
+	id,
+	label: z.string(),
+	kind: z.enum(participantKinds)
+});
+const eventSchema = record({
+	id,
+	name: z.string(),
+	payload: z.record(z.string(), z.string()).readonly().exactOptional()
+});
+const actionSchema = record({
+	id,
+	name: z.string()
+});
+const artefactSchema = record({
+	id,
+	name: z.string(),
+	deliverable: z.boolean().exactOptional()
+});
+const elementSchema = z.discriminatedUnion("kind", [
+	record({
+		kind: z.literal("activity"),
+		id,
+		extensions: extensionsSchema.exactOptional(),
+		label: z.string(),
+		actor: actorRef.exactOptional(),
+		action: actionRef.exactOptional(),
+		source: z.string().exactOptional(),
+		affects: z.array(entityRef).readonly().exactOptional(),
+		consumes: z.array(artefactRef).readonly().exactOptional(),
+		produces: z.array(artefactRef).readonly().exactOptional()
+	}),
+	record({
+		kind: z.literal("decision"),
+		id,
+		extensions: extensionsSchema.exactOptional(),
+		label: z.string(),
+		actor: actorRef.exactOptional()
+	}),
+	record({
+		kind: z.literal("state"),
+		id,
+		extensions: extensionsSchema.exactOptional(),
+		label: z.string(),
+		parent: elementRef.exactOptional(),
+		entry: actionRef.exactOptional(),
+		exit: actionRef.exactOptional()
+	}),
+	record({
+		kind: z.literal("pseudo"),
+		id,
+		extensions: extensionsSchema.exactOptional(),
+		role: z.enum(pseudoRoles),
+		parent: elementRef.exactOptional()
+	}),
+	record({
+		kind: z.literal("message"),
+		id,
+		extensions: extensionsSchema.exactOptional(),
+		label: z.string(),
+		from: actorRef,
+		to: actorRef,
+		mode: z.enum(messageModes),
+		event: eventRef.exactOptional()
+	})
+]);
+const transitionSchema = record({
+	id,
+	source: elementRef,
+	target: elementRef,
+	trigger: eventRef.exactOptional(),
+	guard: z.string().exactOptional(),
+	condition: PredicateNodeSchema.exactOptional(),
+	effect: actionRef.exactOptional()
+});
+const fragmentOperandSchema = record({
+	guard: z.string().exactOptional(),
+	body: z.array(elementRef).readonly()
+});
+const fragmentSchema = record({
+	id,
+	operator: z.enum(fragmentOperators),
+	operands: z.array(fragmentOperandSchema).readonly()
+});
+const projectionSchema = z.union([
+	record({
+		id: z.string(),
+		notation: z.enum(["flowchart", "swimlane"])
+	}),
+	record({
+		id: z.string(),
+		notation: z.literal("stateMachine"),
+		subject: entityRef
+	}),
+	record({
+		id: z.string(),
+		notation: z.literal("sequence"),
+		scenario: z.array(transitionRef).readonly()
+	})
+]);
+const pointSchema = record({
+	x: z.number(),
+	y: z.number()
+});
+const viewsSchema = z.partialRecord(z.enum(notations), z.partialRecord(z.string(), pointSchema).readonly()).readonly();
+/**
+* The open (runtime) shape of a model: identifiers are plain strings, so references are not checked here. `validate` checks what the shape cannot, and `parseModel` runs both.
+*
+* Every object is strict. The inferred type is exactly `Model<OpenIds>`, which a type-level test pins in both directions.
+*/
+const modelSchema = record({
+	participants: z.array(participantSchema).readonly(),
+	events: z.array(eventSchema).readonly(),
+	actions: z.array(actionSchema).readonly(),
+	artefacts: z.array(artefactSchema).readonly(),
+	elements: z.array(elementSchema).readonly(),
+	transitions: z.array(transitionSchema).readonly(),
+	fragments: z.array(fragmentSchema).readonly(),
+	projections: z.array(projectionSchema).readonly(),
+	views: viewsSchema.exactOptional()
+});
+//#endregion
+export { validateOverlay as a, fragmentOperators as c, overlayStatuses as d, participantKinds as f, parseOverlay as i, messageModes as l, OverlayParseError as n, toPointer as o, pseudoRoles as p, overlaySchema as r, elementKinds as s, modelSchema as t, notations as u };