process-graph 1.3.0 → 1.4.0

package/README.md

@@ -40,24 +40,25 @@ deriveStatuses(model, { submit: "done" }, facts); // Map { "submit" => "done", "
 
 The package is built from the repository's internal packages, which are bundled into it and not published on their own; each internal package's README documents its functions and rules. Each subpath loads only the code it reaches.
 
-| Import                               | What it is                                                                                                                                                                                          | Runs in               |
-| ------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------- |
-| `process-graph`                      | The model (`defineModel`, `parseModel`, `validate`), its projections and inverses, and the reasoning over a run (statuses, ready set, blocked-by, impact, what-if, critical path).                  | Browser, Worker, Node |
-| `process-graph/layout`               | `layout`: positions for a projected flowchart, swimlane or state machine, in the model's `views` shape, through elkjs.                                                                              | Browser, Worker, Node |
-| `process-graph/source/github`        | The `GraphSource` port (contract, schemas, router, pagination and an in-memory fake) and the GitHub issues adapter, `createGitHubIssuesSource`.                                                     | Browser, Worker, Node |
-| `process-graph/source/github/node`   | `githubTokenFromEnvironment`: a token port reading `GITHUB_TOKEN` or the GitHub CLI's token.                                                                                                        | Node                  |
-| `process-graph/store`                | The `GraphStore` port (contract, schemas, router, change feed, structural queries and an in-memory fake) and the SQLite store over any Drizzle SQLite database.                                     | Browser, Worker, Node |
-| `process-graph/store/node`           | `openNodeGraphStore`: the SQLite store on Node's built-in `node:sqlite`; `prepareDataFile`: makes its data file and directory private before it opens.                                              | Node                  |
-| `process-graph/store/wasm`           | `connectGraphStore`: connects a page to the store a dedicated worker serves.                                                                                                                        | Browser               |
-| `process-graph/store/wasm/worker`    | `serveGraphStoreInWorker`: serves the store from a dedicated worker on SQLite wasm and OPFS, shared between tabs with no special headers.                                                           | Dedicated worker      |
-| `process-graph/react`                | Headless React hooks and unstyled components: follow a stored model, derive its run, project, filter and select.                                                                                    | Browser               |
-| `process-graph/ui`                   | Styled components over `process-graph/react`, the SVG sequence diagram and the theme contract with light and dark themes.                                                                           | Browser               |
-| `process-graph/ui/theme`             | The theme contract `vars`, `lightTheme`, `darkTheme`, `lightValues` and `darkValues` without the components, for a Vanilla Extract stylesheet that themes `process-graph/ui` without loading React. | Any                   |
-| `process-graph/ui/style.css`         | The compiled styles for `process-graph/ui`.                                                                                                                                                         | Browser               |
-| `process-graph/react-flow`           | React Flow views of a flowchart, swimlane or state machine, laid out by `process-graph/layout`.                                                                                                     | Browser               |
-| `process-graph/react-flow/style.css` | The compiled styles for `process-graph/react-flow`, React Flow's own included.                                                                                                                      | Browser               |
-| `process-graph/cli`                  | The command line as a library: `runCli` over injected ports, `nodePorts` for a Node process, each command's operation returning plain data, and `version`, this package's own.                      | Node                  |
-| `process-graph/package.json`         | The package's manifest, for reading its version or anything else it declares.                                                                                                                       | Any                   |
+| Import                               | What it is                                                                                                                                                                                                                                        | Runs in               |
+| ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------- |
+| `process-graph`                      | The model (`defineModel`, `parseModel`, `validate`), its projections and inverses, each projected view as Mermaid, DOT or JSON text (`viewText`), and the reasoning over a run (statuses, ready set, blocked-by, impact, what-if, critical path). | Browser, Worker, Node |
+| `process-graph/layout`               | `layout`: positions for a projected flowchart, swimlane or state machine, in the model's `views` shape, through elkjs.                                                                                                                            | Browser, Worker, Node |
+| `process-graph/source/github`        | The `GraphSource` port (contract, schemas, router, pagination and an in-memory fake) and the GitHub issues adapter, `createGitHubIssuesSource`.                                                                                                   | Browser, Worker, Node |
+| `process-graph/source/github/node`   | `githubTokenFromEnvironment`: a token port reading `GITHUB_TOKEN` or the GitHub CLI's token.                                                                                                                                                      | Node                  |
+| `process-graph/store`                | The `GraphStore` port (contract, schemas, router, change feed, structural queries and an in-memory fake) and the SQLite store over any Drizzle SQLite database.                                                                                   | Browser, Worker, Node |
+| `process-graph/store/node`           | `openNodeGraphStore`: the SQLite store on Node's built-in `node:sqlite`; `prepareDataFile`: makes its data file and directory private before it opens.                                                                                            | Node                  |
+| `process-graph/store/wasm`           | `connectGraphStore`: connects a page to the store a dedicated worker serves.                                                                                                                                                                      | Browser               |
+| `process-graph/store/wasm/worker`    | `serveGraphStoreInWorker`: serves the store from a dedicated worker on SQLite wasm and OPFS, shared between tabs with no special headers.                                                                                                         | Dedicated worker      |
+| `process-graph/sync`                 | `syncScopes`: syncs sources into a store page by page, relations included, resumable from a checkpoint and narrowed by a typed filter.                                                                                                            | Browser, Worker, Node |
+| `process-graph/react`                | Headless React hooks and unstyled components: follow a stored model, derive its run, project, filter and select.                                                                                                                                  | Browser               |
+| `process-graph/ui`                   | Styled components over `process-graph/react`, the SVG sequence diagram and the theme contract with light and dark themes.                                                                                                                         | Browser               |
+| `process-graph/ui/theme`             | The theme contract `vars`, `lightTheme`, `darkTheme`, `lightValues` and `darkValues` without the components, for a Vanilla Extract stylesheet that themes `process-graph/ui` without loading React.                                               | Any                   |
+| `process-graph/ui/style.css`         | The compiled styles for `process-graph/ui`.                                                                                                                                                                                                       | Browser               |
+| `process-graph/react-flow`           | React Flow views of a flowchart, swimlane or state machine, laid out by `process-graph/layout`.                                                                                                                                                   | Browser               |
+| `process-graph/react-flow/style.css` | The compiled styles for `process-graph/react-flow`, React Flow's own included.                                                                                                                                                                    | Browser               |
+| `process-graph/cli`                  | The command line as a library: `runCli` over injected ports, `nodePorts` for a Node process, each command's operation returning plain data, and `version`, this package's own.                                                                    | Node                  |
+| `process-graph/package.json`         | The package's manifest, for reading its version or anything else it declares.                                                                                                                                                                     | Any                   |
 
 `zod` and `trilean`, which the root entry needs, are dependencies; a project with an install age gate exempts `trilean` and `trilean-regex` beside `process-graph` (see [Install](../../../README.md#install)). The libraries only other subpaths need are optional peer dependencies, so installing `process-graph` for its root entry pulls in nothing else; install the peers of each subpath you import beside it:
 
@@ -69,6 +70,7 @@ The package is built from the repository's internal packages, which are bundled
 | `store/node`        | `drizzle-orm`                                                                |
 | `store/wasm`        | `@orpc/client`                                                               |
 | `store/wasm/worker` | `@orpc/contract`, `@orpc/server`, `drizzle-orm`, `@sqlite.org/sqlite-wasm`   |
+| `sync`              | `@orpc/client`                                                               |
 | `react`             | `react`                                                                      |
 | `ui`                | `react`, `@vanilla-extract/recipes`, `@vanilla-extract/css` (types)          |
 | `ui/theme`          | `@vanilla-extract/css` (types)                                               |
@@ -120,7 +122,7 @@ Run without them, the bin starts nothing: it names the missing peers and the com
 
 ## What is exported, and under which name
 
-The root entry exports the model, projection and domain layers flat, under their own names, and the DAG layer as the namespace `dag`, in its entirety: `dag.buildDag`, `dag.topologicalLayers`, `dag.criticalPath`, `dag.CycleError` and the rest. The DAG layer is namespaced because its `criticalPath` has the same name as the domain's, which answers a different question (the heaviest chain through the work still ahead of a run, not through a bare node set). The whole layer is namespaced rather than only the colliding name, so a name added to a layer later cannot start colliding silently.
+The root entry exports the model, projection, export and domain layers flat, under their own names, and the DAG layer as the namespace `dag`, in its entirety: `dag.buildDag`, `dag.topologicalLayers`, `dag.criticalPath`, `dag.CycleError` and the rest. The DAG layer is namespaced because its `criticalPath` has the same name as the domain's, which answers a different question (the heaviest chain through the work still ahead of a run, not through a bare node set). The whole layer is namespaced rather than only the colliding name, so a name added to a layer later cannot start colliding silently.
 
 - A name is never shadowed. Two layers exporting the same name on one entry point is a compile error, and the unit tests compare each entry point's runtime exports with the layers it carries.
 - Types follow the same rule as values: a model, projection or domain type is a flat import, a DAG type is `dag.Dag` and so on.

package/dist/bin.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { t as exitCodes } from "./exit-codes-0ultCqdS.js";
-import { t as version } from "./version-Dagrkvwt.js";
+import { t as version } from "./version-DMNBcTZ-.js";
 import { readFileSync } from "node:fs";
 //#region src/missing-peers.ts
 /**
@@ -84,7 +84,7 @@ if (missing.length > 0) {
 	process.stderr.write(missingPeersMessage(missing, declaredPeers(), process.env.npm_config_user_agent));
 	process.exitCode = exitCodes.missingPeers;
 } else {
-	const { runProcess } = await import("./dist-81kTKnMq.js");
+	const { runProcess } = await import("./dist-DipyhCvb.js");
 	process.exitCode = await runProcess({
 		name: "process-graph",
 		version

package/dist/cli.d.ts

@@ -1,9 +1,12 @@
 import { A as Facts, B as Status, _ as StatusRule, k as FactRecord, m as IncomingBasis, p as ArtefactBasis } from "./index-D4CnOhNf.js";
-import { A as Transition, C as EventDef, D as Participant, I as OverlayStatus, K as IdSpace, S as Element, _ as Model, o as Overlay, q as OpenIds, x as ArtefactDef } from "./index-Dvz_I_uQ.js";
-import { C as Gap, n as GraphqlFetch, t as GitHubTokenPort, v as GraphSourceClient } from "./graphql-BE7xm5dB.js";
+import { A as Transition, C as EventDef, D as Participant, I as OverlayStatus, S as Element, _ as Model, o as Overlay, q as OpenIds, x as ArtefactDef } from "./index-Dvz_I_uQ.js";
+import { P as SyncFilter, b as Gap, h as GraphSourceClient } from "./index-Cs1CWlEg.js";
 import { ut as GraphStoreClient } from "./index-CR8xUK3S.js";
-import "./index-hri2a13-.js";
-import { A as Flowchart, E as Swimlane, M as Handoff, g as SequenceDiagram, x as StateMachine } from "./index-D06bcdfw.js";
+import { n as GraphqlFetch, t as GitHubTokenPort } from "./graphql-3DSUSUvL.js";
+import "./index-Cp5selgs.js";
+import { F as Handoff, N as Flowchart, k as Swimlane, w as StateMachine, y as SequenceDiagram } from "./index-4f4PVH7K.js";
+import { n as SourceLookup } from "./index-DoMIav3D.js";
+import { a as flowchartToMermaid, c as swimlaneToMermaid, i as swimlaneToDot, n as sequenceToDot, o as sequenceToMermaid, r as stateMachineToDot, s as stateMachineToMermaid, t as flowchartToDot } from "./index-Bb90VKMc.js";
 import { ComputedValue } from "trilean";
 //#region ../graph-cli/dist/exit-codes.d.ts
 /**
@@ -263,6 +266,22 @@ interface WhyResult {
   /** The element, then every unfinished need reached from it, in model order. */
   readonly chain: readonly WhyLink[];
 }
+/** An element of a hierarchy walk, with how many `child-of` relations away it is. */
+interface HierarchyLink extends ElementSummary {
+  readonly distance: number;
+}
+/** An element's sub-tasks: the elements related to it by `child-of`. */
+interface ChildrenResult {
+  readonly element: ElementSummary;
+  /** Its direct children, in model order. */
+  readonly children: readonly ElementSummary[];
+}
+/** What an element is a sub-task of, up to the top of its hierarchy. */
+interface AncestorsResult {
+  readonly element: ElementSummary;
+  /** Its parent, its parent's parent and so on, nearest first, each once with the fewest relations it takes to reach it. */
+  readonly ancestors: readonly HierarchyLink[];
+}
 /**
  * The elements that are ready: not done, with every live need done.
  * @param session - The store, model and facts.
@@ -301,13 +320,27 @@ export declare const handoffsOf: (session: GraphSession) => Promise<HandoffsResu
  * @param id - The element asked about.
  */
 export declare const why: (session: GraphSession, id: string) => Promise<WhyResult>;
+/**
+ * An element's direct sub-tasks, from the `child-of` relations a sync keeps, as the store's hierarchy query answers.
+ * @param session - The store and model.
+ * @param id - The element asked about.
+ * @throws CliError with `notFound` when the model or the element does not exist.
+ */
+export declare const children: (session: GraphSession, id: string) => Promise<ChildrenResult>;
+/**
+ * The elements an element is a sub-task of, nearest first, from the `child-of` relations a sync keeps, as the store's hierarchy query answers.
+ * @param session - The store and model.
+ * @param id - The element asked about.
+ * @throws CliError with `notFound` when the model or the element does not exist.
+ */
+export declare const ancestors: (session: GraphSession, id: string) => Promise<AncestorsResult>;
 //#endregion
 //#region ../graph-cli/dist/show.d.ts
 /** The views `show` draws, as named on the command line. */
 export declare const viewNames: readonly ["flowchart", "swimlane", "state", "sequence"];
 /** One of the views `show` draws. */
 type ViewName = (typeof viewNames)[number];
-/** The formats `show` writes. */
+/** The formats `show` writes, graph-export's, with JSON named first. */
 export declare const formatNames: readonly ["json", "mermaid", "dot"];
 /** One of the formats `show` writes. */
 type FormatName = (typeof formatNames)[number];
@@ -348,13 +381,13 @@ type ShowResult = ProjectedView & {
  */
 export declare const project: (model: Model<OpenIds>, request: Pick<ShowRequest, "view" | "subject" | "scenario">) => ProjectedView;
 /**
- * Writes a projected view as Mermaid or DOT source.
+ * Writes a projected view as Mermaid or DOT source, or as JSON, through graph-export's `viewText`, the writer the web app's downloads use too.
  * @param model - The model, for participant labels.
  * @param projected - The view.
- * @param format - `mermaid` or `dot`.
- * @returns The diagram source.
+ * @param format - `mermaid`, `dot` or `json`.
+ * @returns The text.
  */
-export declare const emit: (model: Model<OpenIds>, projected: ProjectedView, format: Exclude<FormatName, "json">) => string;
+export declare const emit: (model: Model<OpenIds>, projected: ProjectedView, format: FormatName) => string;
 /**
  * Draws the session's model as a view in a format.
  * @param session - The store and model.
@@ -480,20 +513,20 @@ export declare const validateStored: (session: GraphSession) => Promise<Validate
 export declare const validateDocument: (text: string) => ValidateResult;
 //#endregion
 //#region ../graph-cli/dist/sync.d.ts
-/** Finds the source that serves scopes with an identifier prefix, such as `github`. */
-type SourceLookup = (prefix: string) => GraphSourceClient | undefined;
 /** What to sync. */
 interface SyncRequest {
   /** Source-qualified scope identifiers, such as `github:owner` or `github:owner/repo`, read in order. */
   readonly scopes: readonly string[];
-  /** A cursor from an interrupted sync: the first source's sync continues after it. */
+  /** A cursor from an interrupted sync: the first source's sync continues after it. It is valid only with the filter it was issued under. */
   readonly after?: string;
+  /** Narrows and orders what each scope lists, on the source's side. */
+  readonly filter?: SyncFilter;
 }
 /** Where a sync a source interrupted carries on, as data a host acts on; the command line renders it as the commands to run. */
 interface SyncInterruption {
-  /** The request that continues the failing source: its scopes, after the cursor of the last page read from it, or from the start when none was read. */
+  /** The request that continues the failing source: its scopes and the sync's filter, after the cursor of the last page read from it, or from the start when none was read. */
   readonly resume: SyncRequest;
-  /** The scopes of the sources after the failing one, which were not read; sync them afresh once `resume` has finished. */
+  /** The scopes of the sources after the failing one, which were not read; sync them afresh, under the same filter, once `resume` has finished. */
   readonly remaining: readonly string[];
   /** Whether pages read before the failure were written to the model. */
   readonly saved: boolean;
@@ -516,83 +549,30 @@ export declare class SyncInterruptedError extends CliError implements SyncInterr
 /** What a sync wrote. */
 interface SyncResult {
   readonly modelId: string;
-  /** The revision the write took. */
+  /** The revision the last write took. */
   readonly revision: number;
-  /** The participants, activities and transitions written, each identifier counted once. */
+  /** The participants, activities, transitions and relations written, each counted once. */
   readonly participants: number;
   readonly activities: number;
   readonly transitions: number;
+  readonly relations: number;
   /** The parts of the scope the sources could not read, in the order they were met. */
   readonly gaps: readonly Gap[];
 }
 /**
- * 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.
+ * Reads every page of the scopes from their sources and merges each into the session's model as it is read, creating the model when the store has none: participants, bound activities, transitions, relations (sub-issues, assignees, repository membership) and run state. 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 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.
+ * When a source fails part way, the pages read before the failure are already 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.
+ * @param request - The scopes, a cursor to resume after, and a filter.
  * @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 SyncInterruptedError, with the source's failure and where to carry on, when a source fails part way.
  */
 export declare const sync: (session: GraphSession, sources: SourceLookup, request: SyncRequest) => Promise<SyncResult>;
 //#endregion
-//#region ../graph-cli/dist/emit/mermaid.d.ts
-/**
- * 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.
- */
-export declare const flowchartToMermaid: <I extends IdSpace>(view: Flowchart<I>) => string;
-/**
- * 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.
- */
-export declare const swimlaneToMermaid: <I extends IdSpace>(view: Swimlane<I>) => string;
-/**
- * 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.
- */
-export declare const stateMachineToMermaid: <I extends IdSpace>(view: StateMachine<I>) => string;
-/**
- * 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.
- */
-export declare const sequenceToMermaid: <I extends IdSpace>(view: SequenceDiagram<I>, participantLabel: (participant: I["actor"]) => string) => string;
-//#endregion
-//#region ../graph-cli/dist/emit/dot.d.ts
-/**
- * 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.
- */
-export declare const flowchartToDot: <I extends IdSpace>(view: Flowchart<I>) => string;
-/**
- * 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.
- */
-export declare const swimlaneToDot: <I extends IdSpace>(view: Swimlane<I>) => string;
-/**
- * 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.
- */
-export declare const stateMachineToDot: <I extends IdSpace>(view: StateMachine<I>) => string;
-/**
- * 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.
- */
-export declare const sequenceToDot: <I extends IdSpace>(view: SequenceDiagram<I>, participantLabel: (participant: I["actor"]) => string) => string;
-//#endregion
 //#region src/version.d.ts
 /** The version of the installed `process-graph` package, as its manifest names it. The bundler writes it in when the package is built, so reading it touches no file. */
 export declare const version: string;
 //#endregion
-export type { Addition, ArtefactState, BlockedResult, CliPorts, CyclesResult, ElementStatus, ElementSummary, ExitCode, FactsResult, Failure, FormatName, GraphSession, HandoffsResult, ImpactResult, NodePortsOptions, OpenedStore, PathResult, ProgramIdentity, ProjectedView, ReadyResult, SetArtefactResult, SetFactResult, SetResult, ShowRequest, ShowResult, SourceLookup, StoredRun, SyncInterruption, SyncRequest, SyncResult, ValidateResult, ValidationIssue, ViewName, WhyLink, WhyResult, Written };
+export { type Addition, type AncestorsResult, type ArtefactState, type BlockedResult, type ChildrenResult, type CliPorts, type CyclesResult, type ElementStatus, type ElementSummary, type ExitCode, type FactsResult, type Failure, type FormatName, type GraphSession, type HandoffsResult, type HierarchyLink, type ImpactResult, type NodePortsOptions, type OpenedStore, type PathResult, type ProgramIdentity, type ProjectedView, type ReadyResult, type SetArtefactResult, type SetFactResult, type SetResult, type ShowRequest, type ShowResult, type SourceLookup, type StoredRun, type SyncInterruption, type SyncRequest, type SyncResult, type ValidateResult, type ValidationIssue, type ViewName, type WhyLink, type WhyResult, type Written, flowchartToDot, flowchartToMermaid, sequenceToDot, sequenceToMermaid, stateMachineToDot, stateMachineToMermaid, swimlaneToDot, swimlaneToMermaid };

package/dist/cli.js

@@ -1,4 +1,5 @@
+import { a as stateMachineToDot, c as sequenceToMermaid, i as sequenceToDot, l as stateMachineToMermaid, o as swimlaneToDot, r as flowchartToDot, s as flowchartToMermaid, u as swimlaneToMermaid } from "./view-DTeNUhGG.js";
 import { t as exitCodes } from "./exit-codes-0ultCqdS.js";
-import { A as why, B as CliError, C as swimlaneToMermaid, D as impactOf, E as handoffsOf, F as setFact, I as setState, L as findRun, M as artefactStates, N as factsOf, O as path, P as setArtefact, R as loadRun, S as stateMachineToMermaid, T as cycles, V as failureOf, _ as sequenceToDot, a as defaultModelId, b as flowchartToMermaid, c as validateStored, d as emit, f as formatNames, g as flowchartToDot, h as viewNames, i as runProcess, j as add, k as ready, l as SyncInterruptedError, m as show, n as nodePorts, o as runCli, p as project, r as packageVersion, s as validateDocument, t as defaultDataPath, u as sync, v as stateMachineToDot, w as blocked, x as sequenceToMermaid, y as swimlaneToDot, z as runFacts } from "./dist-BI01yxFA.js";
-import { t as version } from "./version-Dagrkvwt.js";
-export { CliError, SyncInterruptedError, add, artefactStates, blocked, cycles, defaultDataPath, defaultModelId, emit, exitCodes, factsOf, failureOf, findRun, flowchartToDot, flowchartToMermaid, formatNames, handoffsOf, impactOf, loadRun, nodePorts, packageVersion, path, project, ready, runCli, runFacts, runProcess, sequenceToDot, sequenceToMermaid, setArtefact, setFact, setState, show, stateMachineToDot, stateMachineToMermaid, swimlaneToDot, swimlaneToMermaid, sync, validateDocument, validateStored, version, viewNames, why };
+import { A as setState, C as ready, D as factsOf, E as artefactStates, F as failureOf, M as loadRun, N as runFacts, O as setArtefact, P as CliError, S as path, T as add, _ as blocked, a as defaultModelId, b as handoffsOf, c as validateStored, d as project, f as show, g as ancestors, h as sync, i as runProcess, j as findRun, k as setFact, l as emit, m as SyncInterruptedError, n as nodePorts, o as runCli, p as viewNames, r as packageVersion, s as validateDocument, t as defaultDataPath, u as formatNames, v as children, w as why, x as impactOf, y as cycles } from "./dist-C8zDuW-y.js";
+import { t as version } from "./version-DMNBcTZ-.js";
+export { CliError, SyncInterruptedError, add, ancestors, artefactStates, blocked, children, cycles, defaultDataPath, defaultModelId, emit, exitCodes, factsOf, failureOf, findRun, flowchartToDot, flowchartToMermaid, formatNames, handoffsOf, impactOf, loadRun, nodePorts, packageVersion, path, project, ready, runCli, runFacts, runProcess, sequenceToDot, sequenceToMermaid, setArtefact, setFact, setState, show, stateMachineToDot, stateMachineToMermaid, swimlaneToDot, swimlaneToMermaid, sync, validateDocument, validateStored, version, viewNames, why };