process-graph 1.0.5 → 1.1.0

package/dist/cli.d.ts

@@ -0,0 +1,512 @@
+import { F as Status, _ as StatusRule, k as Facts, m as IncomingBasis, p as ArtefactBasis } from "./index-CCfe0csl.js";
+import { E as Participant, F as OverlayStatus, G as IdSpace, K as OpenIds, S as EventDef, a as Overlay, b as ArtefactDef, g as Model, k as Transition, x as Element } from "./index-CmZOswkx.js";
+import { C as Gap, n as GraphqlFetch, t as GitHubTokenPort, v as GraphSourceClient } from "./graphql-C1j5wQFz.js";
+import { Q as GraphStoreClient } from "./index-DhbvDgK4.js";
+import "./index-CptUHq6F.js";
+import { A as Flowchart, E as Swimlane, M as Handoff, g as SequenceDiagram, x as StateMachine } from "./index-CoA6vXqe.js";
+//#region ../graph-cli/dist/exit-codes.d.ts
+/**
+ * The exit status of every command, by meaning. A script tells the outcomes apart without reading the output: a model with problems is not a failure to run, and neither is an element that does not exist.
+ *
+ * - `success`: the command did what it was asked, and for `validate` and `cycles`, found nothing wrong.
+ * - `failure`: anything not listed below, such as a store that cannot be opened.
+ * - `usage`: the command line is wrong: an unknown command or option, a missing argument, a value outside its choices.
+ * - `notFound`: the model, an element or another identifier named on the command line does not exist.
+ * - `invalidModel`: the model has problems: `validate` found issues, `cycles` found an illegal cycle, a reasoning command met an illegal cycle, or the store rejected a change that would leave the model invalid.
+ * - `sourceFailure`: a source refused the sync: bad credentials, a rate limit or a scope it does not accept.
+ * - `missingPeers`: the `process-graph` bin could not start because optional peer dependencies the command line needs are not installed beside it.
+ */
+export declare const exitCodes: {
+  readonly success: 0;
+  readonly failure: 1;
+  readonly usage: 2;
+  readonly notFound: 3;
+  readonly invalidModel: 4;
+  readonly sourceFailure: 5;
+  readonly missingPeers: 6;
+};
+/** One of the exit statuses in `exitCodes`. */
+type ExitCode = (typeof exitCodes)[keyof typeof exitCodes];
+//#endregion
+//#region ../graph-cli/dist/ports.d.ts
+/** A store opened for one command, and how to release it. */
+interface OpenedStore {
+  /** The store, over whatever transport the opener chose. */
+  readonly client: GraphStoreClient;
+  /** Releases the store. Called once, after the command, whether it succeeded or not. */
+  readonly close: () => void | Promise<void>;
+  /** Lines the command line writes to standard error before the command runs, such as permissions it narrowed on the store's files; empty when there is nothing to say. */
+  readonly warnings: readonly string[];
+}
+/**
+ * Everything the command line touches outside itself. Commands read and write only through these, so the whole command surface runs in a test, or inside another program such as Switchboard, with no process, file system or network of its own. `nodePorts` supplies them for a real process.
+ */
+interface CliPorts {
+  /** Writes text to standard output, exactly as given. */
+  readonly stdout: (text: string) => void;
+  /** Writes text to standard error, exactly as given. */
+  readonly stderr: (text: string) => void;
+  /** Opens the store kept at a data path. */
+  readonly openStore: (path: string) => OpenedStore | Promise<OpenedStore>;
+  /** The data path used when `--data` is not given. */
+  readonly defaultDataPath: string;
+  /**
+   * The source that serves scopes with an identifier prefix, such as `github` for `github:owner/repo`, or `undefined` when no source has that prefix.
+   * @param prefix - The part of a scope identifier before its first colon.
+   */
+  readonly source: (prefix: string) => GraphSourceClient | undefined;
+  /**
+   * Reads a text file, for `validate <file>`.
+   * @param path - The file to read.
+   * @param signal - Aborts the read.
+   */
+  readonly readFile: (path: string, signal: AbortSignal | undefined) => Promise<string>;
+  /** The facts that decision conditions read, and which input artefacts are provided. */
+  readonly facts: Facts;
+  /** Aborts every store and source call a command makes. */
+  readonly signal: AbortSignal | undefined;
+}
+//#endregion
+//#region ../graph-cli/dist/program.d.ts
+/** How the program presents itself. */
+interface ProgramIdentity {
+  /** The command name shown in help and usage, such as `process-graph`, or `sb graph` when embedded. */
+  readonly name: string;
+  /** The version `--version` prints. */
+  readonly version: string;
+}
+/** The model a command works on when `--model` is not given. */
+export declare const defaultModelId = "default";
+/**
+ * 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`.
+ */
+export declare const runCli: (args: readonly string[], ports: CliPorts, identity: ProgramIdentity) => Promise<ExitCode>;
+//#endregion
+//#region ../graph-cli/dist/errors.d.ts
+/** A failure the command line reports with its own exit status and message, and nothing else. */
+export declare class CliError extends Error {
+  /** The exit status the failure maps to. */
+  readonly exitCode: 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: ExitCode, message: string, options?: ErrorOptions);
+}
+/** The exit status and message an error is reported with. */
+interface Failure {
+  readonly exitCode: ExitCode;
+  readonly message: string;
+}
+/**
+ * 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.
+ */
+export declare const failureOf: (error: unknown) => Failure;
+//#endregion
+//#region ../graph-cli/dist/node.d.ts
+/** Where a Node process finds its ports. Each is injectable, and each defaults to the real thing. */
+interface NodePortsOptions {
+  /** The environment, for the data path and the GitHub token; `process.env` when absent. */
+  readonly env?: Readonly<Record<string, string | undefined>>;
+  /** The home directory the default data path falls back on; the user's when absent. */
+  readonly home?: string;
+  /** Supplies GitHub tokens; `GITHUB_TOKEN` or the GitHub CLI's token (`githubTokenFromEnvironment`) when absent. */
+  readonly token?: GitHubTokenPort;
+  /** How requests reach GitHub; the global `fetch` when absent. */
+  readonly fetch?: GraphqlFetch;
+  /** The clock, in milliseconds since the epoch, for a rate limit's retry time; `Date.now` when absent. */
+  readonly now?: () => number;
+  /** The facts decision conditions read and which input artefacts are provided; nothing is known when absent. */
+  readonly facts?: Facts;
+  /** Aborts every store and source call. */
+  readonly signal?: AbortSignal;
+  /** Standard output; the process's when absent. */
+  readonly stdout?: (text: string) => void;
+  /** Standard error; the process's when absent. */
+  readonly stderr?: (text: string) => void;
+  /** The platform, which decides whether file modes are set; the process's when absent. */
+  readonly platform?: NodeJS.Platform;
+}
+/**
+ * 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.
+ */
+export declare const defaultDataPath: (env: Readonly<Record<string, string | undefined>>, home: string) => string;
+/**
+ * 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`.
+ */
+export declare const packageVersion: (manifest: URL) => string;
+/**
+ * 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.
+ */
+export declare const nodePorts: (options?: NodePortsOptions) => CliPorts;
+/**
+ * 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.
+ */
+export declare const runProcess: (identity: ProgramIdentity) => Promise<ExitCode>;
+//#endregion
+//#region ../graph-cli/dist/session.d.ts
+/** What every operation works against: one model in one store, the facts its conditions read, and the signal that aborts its calls. */
+interface GraphSession {
+  readonly store: GraphStoreClient;
+  /** The name the model is filed under in the store. */
+  readonly modelId: string;
+  readonly facts: Facts;
+  readonly signal: AbortSignal | undefined;
+}
+/** A stored model and its run state, as an operation reads them. */
+interface StoredRun {
+  readonly revision: number;
+  readonly model: Model<OpenIds>;
+  readonly overlay: Overlay<OpenIds>;
+}
+/** An element as commands report it: its identifier and its human label. */
+interface ElementSummary {
+  readonly id: string;
+  readonly label: string;
+}
+/**
+ * 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.
+ */
+export declare const findRun: (session: GraphSession) => Promise<StoredRun | undefined>;
+/**
+ * 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.
+ */
+export declare const loadRun: (session: GraphSession) => Promise<StoredRun>;
+//#endregion
+//#region ../graph-cli/dist/queries.d.ts
+/** An element with its derived status. */
+interface ElementStatus extends ElementSummary {
+  readonly status: Status;
+}
+/** Every element that can be worked on now. */
+interface ReadyResult {
+  readonly elements: readonly ElementSummary[];
+}
+/** What an element is waiting on. */
+interface BlockedResult {
+  readonly element: ElementStatus;
+  /** The open work to finish first: the ends of the element's blocked-by chain, in model order. */
+  readonly blockedBy: readonly ElementSummary[];
+}
+/** What finishing, delaying or dropping an element affects. */
+interface ImpactResult {
+  readonly element: ElementStatus;
+  /** The live elements that transitively depend on it, in model order. */
+  readonly impacted: readonly ElementSummary[];
+}
+/** The longest chain of work still ahead. */
+interface PathResult {
+  /** The chain in dependency order. */
+  readonly path: readonly ElementSummary[];
+  /** Its length in elements, each counting one step. */
+  readonly weight: number;
+}
+/** The cycles no decision closes. */
+interface CyclesResult {
+  /** Each cycle as a closed path: each element needs the next, and the first is repeated at the end. */
+  readonly cycles: readonly (readonly string[])[];
+}
+/** The transitions between elements with different actors. */
+interface HandoffsResult {
+  readonly handoffs: readonly Handoff<OpenIds>[];
+}
+/** One element of a blocked-by chain, with its label and status. */
+interface WhyLink extends ElementStatus {
+  /** The unfinished needs it still waits on, in model order. */
+  readonly waitingOn: readonly string[];
+}
+/** Why an element has its status. */
+interface WhyResult {
+  readonly element: ElementStatus;
+  /** The rule of the status derivation that decided it. */
+  readonly rule: StatusRule;
+  /** Its incoming transitions other than loop edges, each with its branch, its source's status and whether it is cut. */
+  readonly transitions: readonly IncomingBasis<OpenIds>[];
+  /** The artefacts it consumes, each with whether it is provided and its producers' statuses. */
+  readonly artefacts: readonly ArtefactBasis<OpenIds>[];
+  /** The element, then every unfinished need reached from it, in model order. */
+  readonly chain: readonly WhyLink[];
+}
+/**
+ * The elements that are ready: not done, with every live need done.
+ * @param session - The store, model and facts.
+ */
+export declare const ready: (session: GraphSession) => Promise<ReadyResult>;
+/**
+ * What an element is waiting on.
+ * @param session - The store, model and facts.
+ * @param id - The element asked about.
+ */
+export declare const blocked: (session: GraphSession, id: string) => Promise<BlockedResult>;
+/**
+ * What depends on an element.
+ * @param session - The store, model and facts.
+ * @param id - The element asked about.
+ */
+export declare const impactOf: (session: GraphSession, id: string) => Promise<ImpactResult>;
+/**
+ * The critical path: the longest chain through the work still ahead.
+ * @param session - The store, model and facts.
+ */
+export declare const path: (session: GraphSession) => Promise<PathResult>;
+/**
+ * The cycles of the model that no decision closes, which make every status undefined.
+ * @param session - The store and model.
+ */
+export declare const cycles: (session: GraphSession) => Promise<CyclesResult>;
+/**
+ * The hand-offs: transitions from one actor's work to another's.
+ * @param session - The store and model.
+ */
+export declare const handoffsOf: (session: GraphSession) => Promise<HandoffsResult>;
+/**
+ * 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.
+ */
+export declare const why: (session: GraphSession, id: string) => Promise<WhyResult>;
+//#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. */
+export declare const formatNames: readonly ["json", "mermaid", "dot"];
+/** One of the formats `show` writes. */
+type FormatName = (typeof formatNames)[number];
+/** What to draw. */
+interface ShowRequest {
+  readonly view: ViewName;
+  readonly format: FormatName;
+  /** The entity a state machine follows; the model's declared state machine projection when absent. */
+  readonly subject?: string;
+  /** The transitions a sequence diagram follows, in order; the model's declared sequence projection when absent. */
+  readonly scenario?: readonly string[];
+}
+/** A projected view, tagged by which it is. */
+type ProjectedView = {
+  readonly view: "flowchart";
+  readonly projection: Flowchart<OpenIds>;
+} | {
+  readonly view: "swimlane";
+  readonly projection: Swimlane<OpenIds>;
+} | {
+  readonly view: "state";
+  readonly projection: StateMachine<OpenIds>;
+} | {
+  readonly view: "sequence";
+  readonly projection: SequenceDiagram<OpenIds>;
+};
+/** A drawn view: the projection, and its text in the requested format (the projection as JSON for `json`). */
+type ShowResult = ProjectedView & {
+  readonly format: FormatName;
+  readonly text: string;
+};
+/**
+ * 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.
+ */
+export declare const project: (model: Model<OpenIds>, request: Pick<ShowRequest, "view" | "subject" | "scenario">) => ProjectedView;
+/**
+ * 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.
+ */
+export declare const emit: (model: Model<OpenIds>, projected: ProjectedView, format: Exclude<FormatName, "json">) => string;
+/**
+ * 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.
+ */
+export declare const show: (session: GraphSession, request: ShowRequest) => Promise<ShowResult>;
+//#endregion
+//#region ../graph-cli/dist/edit.d.ts
+/** A record to add to the model, by the part of the model it belongs to. */
+type Addition = {
+  readonly kind: "participant";
+  readonly record: Participant<string>;
+} | {
+  readonly kind: "element";
+  readonly record: Element<string, OpenIds>;
+} | {
+  readonly kind: "event";
+  readonly record: EventDef<string>;
+} | {
+  readonly kind: "artefact";
+  readonly record: ArtefactDef<string>;
+} | {
+  readonly kind: "transition";
+  readonly record: Transition<string, OpenIds>;
+};
+/** A change the store accepted. */
+interface Written {
+  /** The revision the change took. */
+  readonly revision: number;
+}
+/**
+ * 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.
+ */
+export declare const add: (session: GraphSession, addition: Addition) => Promise<Written>;
+/** The run state an element was given. */
+interface SetResult extends Written {
+  readonly element: string;
+  readonly state: OverlayStatus;
+}
+/**
+ * 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.
+ */
+export declare const setState: (session: GraphSession, id: string, state: OverlayStatus) => Promise<SetResult>;
+//#endregion
+//#region ../graph-cli/dist/validate.d.ts
+/** One problem with a model. */
+interface ValidationIssue {
+  /** What kind of problem: a `validate` issue code, `illegal-cycle`, or `schema` for a document whose shape is wrong. */
+  readonly code: string;
+  readonly message: string;
+  /** Where in a document the problem is, as a JSON pointer, for a shape problem. */
+  readonly pointer?: string;
+}
+/** Whether a model is valid, and every problem found. */
+interface ValidateResult {
+  /** True exactly when `issues` is empty. */
+  readonly valid: boolean;
+  readonly issues: readonly ValidationIssue[];
+}
+/**
+ * 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.
+ */
+export declare const validateStored: (session: GraphSession) => Promise<ValidateResult>;
+/**
+ * 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.
+ */
+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. */
+  readonly after?: string;
+}
+/** What a sync wrote. */
+interface SyncResult {
+  readonly modelId: string;
+  /** The revision the write took. */
+  readonly revision: number;
+  /** The participants, activities and transitions written, each identifier counted once. */
+  readonly participants: number;
+  readonly activities: number;
+  readonly transitions: 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.
+ *
+ * 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.
+ */
+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
+export type { Addition, BlockedResult, CliPorts, CyclesResult, ElementStatus, ElementSummary, ExitCode, Failure, FormatName, GraphSession, HandoffsResult, ImpactResult, NodePortsOptions, OpenedStore, PathResult, ProgramIdentity, ProjectedView, ReadyResult, SetResult, ShowRequest, ShowResult, SourceLookup, StoredRun, SyncRequest, SyncResult, ValidateResult, ValidationIssue, ViewName, WhyLink, WhyResult, Written };

package/dist/cli.js

@@ -0,0 +1,3 @@
+import { t as exitCodes } from "./exit-codes-0ultCqdS.js";
+import { A as add, C as blocked, D as path, E as impactOf, F as failureOf, M as findRun, N as loadRun, O as ready, P as CliError, S as swimlaneToMermaid, T as handoffsOf, _ as stateMachineToDot, a as defaultModelId, b as sequenceToMermaid, c as validateStored, d as formatNames, f as project, g as sequenceToDot, h as flowchartToDot, i as runProcess, j as setState, k as why, l as sync, m as viewNames, n as nodePorts, o as runCli, p as show, r as packageVersion, s as validateDocument, t as defaultDataPath, u as emit, v as swimlaneToDot, w as cycles, x as stateMachineToMermaid, y as flowchartToMermaid } from "./dist-HLlW8vgT.js";
+export { CliError, add, blocked, cycles, defaultDataPath, defaultModelId, emit, exitCodes, failureOf, findRun, flowchartToDot, flowchartToMermaid, formatNames, handoffsOf, impactOf, loadRun, nodePorts, packageVersion, path, project, ready, runCli, runProcess, sequenceToDot, sequenceToMermaid, setState, show, stateMachineToDot, stateMachineToMermaid, swimlaneToDot, swimlaneToMermaid, sync, validateDocument, validateStored, viewNames, why };