process-graph 1.3.0 → 2.0.0

package/dist/graphql-CGWZ6USe.d.ts

@@ -0,0 +1,17 @@
+import "./index-CotF9Lhh.js";
+import { z } from "zod";
+//#region ../../adapters/graph/source-github-issues/dist/graphql.d.ts
+/** GitHub's GraphQL endpoint. */
+declare const githubGraphqlEndpoint = "https://api.github.com/graphql";
+/**
+ * Supplies the token for requests about one owner's repositories, so different organisations can use different credentials. The token is only ever sent in the `Authorization` header; this adapter never logs or returns it.
+ * @param owner - The login of the account whose repositories or board the request reads, or `undefined` for a request about the token's own holder (the viewer and the organisations it belongs to), which no owner names.
+ * @param signal - The caller's abort signal.
+ * @returns The token.
+ * @throws GraphSourceError with `unauthorised` when no token can be had, with a message saying how to get one; any other error is reported by the adapter as `unauthorised` too, naming the token port and the owner, with that error as the cause.
+ */
+type GitHubTokenPort = (owner: string | undefined, signal: AbortSignal | undefined) => Promise<string>;
+/** The part of `fetch` this adapter uses: one POST to the GraphQL endpoint. The global `fetch` satisfies it. */
+type GraphqlFetch = (url: string, init: RequestInit) => Promise<Response>;
+//#endregion
+export { GraphqlFetch as n, githubGraphqlEndpoint as r, GitHubTokenPort as t };

package/dist/index-7nV7hCmv.d.ts

@@ -0,0 +1,118 @@
+import { N as SyncFilter, h as GraphSourceClient, y as Gap } from "./index-CotF9Lhh.js";
+import { ct as GraphStoreClient } from "./index-KhygugOP.js";
+import { z } from "zod";
+//#region ../../core/graph/sync/dist/checkpoint.d.ts
+/**
+ * Where a sync stopped: the model, every scope it was asked for in order, the filter it read them with, the prefix of the source to read next, and the cursor after the last page it wrote within that source's scopes (absent to read them from the start). Everything before it is in the store, so a sync started from it reads only what is left. A source's cursor is valid only with the scopes and filter it was issued for, which is why both are kept with it.
+ */
+declare const syncCheckpointSchema: z.ZodReadonly<z.ZodObject<{
+  modelId: z.ZodString;
+  scopes: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+  filter: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+    states: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+      open: "open";
+      done: "done";
+    }>>>>;
+    labels: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    order: z.ZodExactOptional<z.ZodReadonly<z.ZodObject<{
+      field: z.ZodEnum<{
+        created: "created";
+        updated: "updated";
+        comments: "comments";
+      }>;
+      direction: z.ZodEnum<{
+        ascending: "ascending";
+        descending: "descending";
+      }>;
+    }, z.core.$strict>>>;
+  }, z.core.$strict>>>;
+  source: z.ZodString;
+  after: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>>;
+type SyncCheckpoint = z.infer<typeof syncCheckpointSchema>;
+//#endregion
+//#region ../../core/graph/sync/dist/sync.d.ts
+/** Finds the source that reads scopes with an identifier prefix, such as `github`, or nothing when no source does. */
+type SourceLookup = (prefix: string) => GraphSourceClient | undefined;
+/** The part of the `GraphStore` client a sync calls: loading the model it merges into and upserting each page. */
+interface SyncStore {
+  readonly v1: {
+    readonly models: Pick<GraphStoreClient["v1"]["models"], "load">;
+    readonly items: Pick<GraphStoreClient["v1"]["items"], "upsert">;
+  };
+}
+/** How far a sync has got. Each count is of distinct identifiers (relations by kind and both ends) written by this sync. */
+interface SyncProgress {
+  /** Pages read and written. */
+  readonly pages: number;
+  /** The revision the last write took. */
+  readonly revision: number;
+  readonly participants: number;
+  /** Bound activities. */
+  readonly activities: number;
+  readonly transitions: number;
+  /** Relations: sub-issues to their parents, assignees, repositories to their owners. */
+  readonly relations: number;
+  /** The parts of the scope the sources could not read, in the order met. */
+  readonly gaps: readonly Gap[];
+  /** Where to resume; absent once every scope has been read. */
+  readonly checkpoint: SyncCheckpoint | undefined;
+}
+/** What to sync and where to. */
+interface SyncRequest {
+  readonly store: SyncStore;
+  readonly sources: SourceLookup;
+  readonly modelId: string;
+  /** Source-qualified scopes, read in order, one source after another. */
+  readonly scopes: readonly string[];
+  /** Narrows and orders what each scope lists. It is recorded in every checkpoint, since a cursor is valid only with the filter it was issued under. */
+  readonly filter?: SyncFilter | undefined;
+  /** A checkpoint from an interrupted sync of the same model, scopes and filter: the sync carries on from it. */
+  readonly resume?: SyncCheckpoint | undefined;
+  /** Ends the sync between or during reads; what was written stays written. */
+  readonly signal?: AbortSignal | undefined;
+  /** Called after every page is written, with the progress so far. */
+  readonly onProgress?: ((progress: SyncProgress) => void) | undefined;
+}
+/** Thrown when a scope names a source no reader serves. */
+declare class UnknownSourceError extends Error {
+  /** The source prefix no reader serves. */
+  readonly prefix: string;
+  /**
+   * @param prefix - The source prefix no reader serves.
+   */
+  constructor(prefix: string);
+}
+/** Where a sync a source interrupted carries on, as data. */
+interface SyncInterruption {
+  /** The checkpoint that continues the failing source: its prefix, after the cursor of the last page read from it, or from the start of its scopes when none was read. */
+  readonly resume: SyncCheckpoint;
+  /** The scopes of the sources after the failing one, which were not read. */
+  readonly remaining: readonly string[];
+  /** Whether this sync wrote any pages before the failure. */
+  readonly saved: boolean;
+}
+/**
+ * Thrown by `syncScopes` when a source fails while it is being read: opening its stream or reading a page. Its message is the source's, its cause is what the source threw, and where to carry on is data in `resume` and `remaining`. A failure of the store, or of the request itself (an unknown source, a malformed scope), is thrown as it is.
+ */
+declare class InterruptedSyncError extends Error implements SyncInterruption {
+  readonly resume: SyncCheckpoint;
+  readonly remaining: readonly string[];
+  readonly saved: boolean;
+  /**
+   * @param interruption - Where the sync carries on.
+   * @param cause - What the source threw.
+   */
+  constructor(interruption: SyncInterruption, cause: unknown);
+}
+/**
+ * Reads the scopes from their sources page by page and merges each page into the stored model as soon as it is read: participants, bound activities, transitions, relations and run state. Progress is kept as it is made, so a sync that is cancelled, rate limited or interrupted leaves everything it read in the store, and a checkpoint to carry on from.
+ *
+ * A store rejects a write that leaves a transition or a relation naming an element or participant the model lacks, and a source may report a dependency or a sub-issue whose other end a later page brings. A transition or relation is therefore held back until the model has both of its ends, and written with the page that completes it. One whose end never arrives is written with the last page, where the store's rejection says which reference is missing.
+ * @param request - The store, sources, model, scopes, an optional filter and checkpoint, the signal and a progress listener.
+ * @returns The final progress, with no checkpoint.
+ * @throws InvalidScopeError for a scope that names no source; UnknownSourceError for a scope whose source no reader serves; an Error for a checkpoint naming a source none of the scopes use, and for a sync of no scopes; InterruptedSyncError, after the pages before it are written, when a source fails while it is read, an abort included; and whatever the store throws.
+ */
+declare const syncScopes: (request: SyncRequest) => Promise<SyncProgress>;
+//#endregion
+export { SyncRequest as a, syncScopes as c, SyncProgress as i, SyncCheckpoint as l, SourceLookup as n, SyncStore as o, SyncInterruption as r, UnknownSourceError as s, InterruptedSyncError as t, syncCheckpointSchema as u };

package/dist/{index-BC4tmAuQ.d.ts → index-B2p3mEJ3.d.ts}

@@ -1,5 +1,5 @@
-import { K as IdSpace, j as Views } from "./index-Dvz_I_uQ.js";
-import { A as Flowchart, E as Swimlane, x as StateMachine } from "./index-D06bcdfw.js";
+import { P as Views, Y as IdSpace } from "./index-DYl6lZLe.js";
+import { N as Flowchart, k as Swimlane, w as StateMachine } from "./index-DluJZTbT.js";
 //#region ../../core/graph/layout/dist/engine.d.ts
 /** A box with a fixed size, which the engine places. */
 interface EngineLeaf {

package/dist/{index-9Au8pAmP.d.ts → index-C-ZNF81j.d.ts}

@@ -1,7 +1,7 @@
-import { A as Facts, B as Status, C as CriticalPath, _ as StatusRule, d as StatusExplanation, u as ChainLink } from "./index-D4CnOhNf.js";
-import { K as IdSpace, S as Element, _ as Model, k as Projection, o as Overlay } from "./index-Dvz_I_uQ.js";
-import { K as StoredModel, ut as GraphStoreClient } from "./index-CR8xUK3S.js";
-import { A as Flowchart, E as Swimlane, g as SequenceDiagram, x as StateMachine } from "./index-D06bcdfw.js";
+import { A as Facts, B as Status, C as CriticalPath, _ as StatusRule, d as StatusExplanation, u as ChainLink } from "./index-wQnLXJmD.js";
+import { M as Projection, T as Element, Y as IdSpace, b as Model, l as Overlay } from "./index-DYl6lZLe.js";
+import { G as StoredModel, ct as GraphStoreClient } from "./index-KhygugOP.js";
+import { a as ProjectedView } from "./index-DluJZTbT.js";
 import { KeyboardEvent, ReactElement, ReactNode, RefCallback } from "react";
 //#region ../../ui/graph/react/dist/run.d.ts
 /**
@@ -114,25 +114,6 @@ declare const stepWeight: () => number;
 declare const useCriticalPath: <I extends IdSpace>(run: Run<I>, weight?: (id: I["element"]) => number) => CriticalPath<I["element"]>;
 //#endregion
 //#region ../../ui/graph/react/dist/projection.d.ts
-/** The view each projection notation produces. */
-interface ViewsByNotation<I extends IdSpace> {
-  readonly flowchart: Flowchart<I>;
-  readonly swimlane: Swimlane<I>;
-  readonly stateMachine: StateMachine<I>;
-  readonly sequence: SequenceDiagram<I>;
-}
-/** A projection request together with the view it produced, discriminated by notation. */
-type ProjectedView<I extends IdSpace> = { readonly [N in keyof ViewsByNotation<I>]: {
-  readonly notation: N;
-  readonly view: ViewsByNotation<I>[N];
-}; }[keyof ViewsByNotation<I>];
-/**
- * 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.
- */
-declare const project: <I extends IdSpace>(model: Model<I>, projection: Projection<I>) => ProjectedView<I>;
 /**
  * A model's view in one notation, projected again only when the model or the projection changes.
  * @param model - The model to project.
@@ -418,4 +399,4 @@ interface DetailPanelProps<I extends IdSpace> {
  */
 declare const DetailPanel: <I extends IdSpace>(props: DetailPanelProps<I>) => ReactElement;
 //#endregion
-export { useWhyStatus as $, ElementFilter as A, useElementFilter as B, ruleDescriptions as C, SelectionContainerProps as D, GraphSelectionOptions as E, emptyFilter as F, BlockedChain as G, ViewsByNotation as H, filterElements as I, useBlockers as J, stepWeight as K, filterOptions as L, FilterOption as M, FilterOptions as N, SelectionItemProps as O, actorsOf as P, useStatuses as Q, matchesFilter as R, elementLabel as S, GraphSelection as T, project as U, ProjectedView as V, useProjection as W, useImpact as X, useCriticalPath as Y, useReadySet as Z, ElementCardPart as _, FilterPanelPart as a, StatusBadge as b, LegendPart as c, LanePart as d, ModelClient as et, LaneProps as f, ElementCard as g, TransitionItemProps as h, FilterPanel as i, noFacts as it, ElementFilterState as j, useGraphSelection as k, LegendProps as l, TransitionItemPart as m, DetailPanelPart as n, useModel as nt, FilterPanelProps as o, TransitionItem as p, useBlockedChain as q, DetailPanelProps as r, Run as rt, Legend as s, DetailPanel as t, ModelState as tt, Lane as u, ElementCardProps as v, statusLabels as w, StatusBadgeProps as x, NamedElement as y, sourceScope as z };
+export { useModel as $, ElementFilter as A, useElementFilter as B, ruleDescriptions as C, SelectionContainerProps as D, GraphSelectionOptions as E, emptyFilter as F, useBlockers as G, BlockedChain as H, filterElements as I, useReadySet as J, useCriticalPath as K, filterOptions as L, FilterOption as M, FilterOptions as N, SelectionItemProps as O, actorsOf as P, ModelState as Q, matchesFilter as R, elementLabel as S, GraphSelection as T, stepWeight as U, useProjection as V, useBlockedChain as W, useWhyStatus as X, useStatuses as Y, ModelClient as Z, ElementCardPart as _, FilterPanelPart as a, StatusBadge as b, LegendPart as c, LanePart as d, Run as et, LaneProps as f, ElementCard as g, TransitionItemProps as h, FilterPanel as i, ElementFilterState as j, useGraphSelection as k, LegendProps as l, TransitionItemPart as m, DetailPanelPart as n, FilterPanelProps as o, TransitionItem as p, useImpact as q, DetailPanelProps as r, Legend as s, DetailPanel as t, noFacts as tt, Lane as u, ElementCardProps as v, statusLabels as w, StatusBadgeProps as x, NamedElement as y, sourceScope as z };

package/dist/{index-hri2a13-.d.ts → index-CiaCmQDP.d.ts}

@@ -1,4 +1,5 @@
-import { n as GraphqlFetch, t as GitHubTokenPort, u as GraphSourcePager } from "./graphql-BE7xm5dB.js";
+import { s as GraphSourcePager } from "./index-CotF9Lhh.js";
+import { n as GraphqlFetch, t as GitHubTokenPort } from "./graphql-CGWZ6USe.js";
 //#region ../../adapters/graph/source-github-issues/dist/source.d.ts
 /** What the GitHub issues source needs. */
 interface GitHubIssuesSourceOptions {

package/dist/{graphql-BE7xm5dB.d.ts → index-CotF9Lhh.d.ts}

@@ -1,4 +1,4 @@
-import { _ as Model, o as Overlay, q as OpenIds } from "./index-Dvz_I_uQ.js";
+import { X as OpenIds, a as BoundActivitySchema, b as Model, l as Overlay } from "./index-DYl6lZLe.js";
 import { z } from "zod";
 import { ContractRouterClient, InitialInputSchema, ProcedureContract, RouterContract, eventIterator } from "@orpc/contract";
 import { ContractedRouter, DefaultInitialContext } from "@orpc/server";
@@ -88,21 +88,6 @@ declare const transitionSchema: z.ZodReadonly<z.ZodObject<{
   }, z.core.$strip>], "kind">>;
   effect: z.ZodExactOptional<z.ZodString>;
 }, z.core.$strict>>;
-/**
- * An activity bound to the external record it stands for. `source` is required here, where the model leaves it optional, and it equals `id`: the source-qualified identifier (`github:org/repo#12`) is the element's identity, so the same record synced twice, or reached from two places, is the same element.
- */
-declare const boundActivitySchema: z.ZodReadonly<z.ZodObject<{
-  kind: z.ZodLiteral<"activity">;
-  id: z.ZodString;
-  extensions: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>>>>;
-  label: z.ZodString;
-  actor: z.ZodExactOptional<z.ZodString>;
-  action: z.ZodExactOptional<z.ZodString>;
-  affects: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-  consumes: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-  produces: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-  source: z.ZodString;
-}, z.core.$strict>>;
 /** The relation kinds a source reports beside the model's transitions. */
 declare const relationKinds: readonly ["child-of", "assigned-to", "part-of"];
 /**
@@ -131,7 +116,7 @@ declare const gapSchema: z.ZodReadonly<z.ZodObject<{
   message: z.ZodString;
 }, z.core.$strict>>;
 /**
- * One page of a sync: bound activities, the participants they name, the transitions between them, their relations, their run state, and any gaps. A page is a partial view; `assembleSync` merges a whole sync into one model.
+ * One page of a sync: bound activities (graph-schema's `boundActivitySchema`), the participants they name, the transitions between them, their relations, their run state, and any gaps. A page is a partial view; `assembleSync` merges a whole sync into one model.
  *
  * `next` is the cursor to resume after this page. It is absent on the last page.
  */
@@ -145,18 +130,7 @@ declare const syncPageSchema: z.ZodReadonly<z.ZodObject<{
       entity: "entity";
     }>;
   }, z.core.$strict>>>>;
-  activities: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
-    kind: z.ZodLiteral<"activity">;
-    id: z.ZodString;
-    extensions: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>>>>;
-    label: z.ZodString;
-    actor: z.ZodExactOptional<z.ZodString>;
-    action: z.ZodExactOptional<z.ZodString>;
-    affects: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-    consumes: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-    produces: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-    source: z.ZodString;
-  }, z.core.$strict>>>>;
+  activities: z.ZodReadonly<z.ZodArray<BoundActivitySchema>>;
   transitions: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
     id: z.ZodString;
     source: z.ZodString;
@@ -361,7 +335,6 @@ declare const sourceDescriptionSchema: z.ZodReadonly<z.ZodObject<{
 }, z.core.$strict>>;
 /** Why a request was rejected as malformed. */
 declare const badRequestReasons: readonly ["invalid-cursor", "invalid-scope"];
-type BoundActivity = z.infer<typeof boundActivitySchema>;
 type SourceParticipant = z.infer<typeof participantSchema>;
 type SourceTransition = z.infer<typeof transitionSchema>;
 type Relation = z.infer<typeof relationSchema>;
@@ -615,18 +588,4 @@ interface FakeGraphSourceOptions {
  */
 declare const createFakeGraphSource: (options: FakeGraphSourceOptions) => GraphSourcePager;
 //#endregion
-//#region ../../adapters/graph/source-github-issues/dist/graphql.d.ts
-/** GitHub's GraphQL endpoint. */
-declare const githubGraphqlEndpoint = "https://api.github.com/graphql";
-/**
- * Supplies the token for requests about one owner's repositories, so different organisations can use different credentials. The token is only ever sent in the `Authorization` header; this adapter never logs or returns it.
- * @param owner - The login of the account whose repositories or board the request reads, or `undefined` for a request about the token's own holder (the viewer and the organisations it belongs to), which no owner names.
- * @param signal - The caller's abort signal.
- * @returns The token.
- * @throws GraphSourceError with `unauthorised` when no token can be had, with a message saying how to get one; any other error is reported by the adapter as `unauthorised` too, naming the token port and the owner, with that error as the cause.
- */
-type GitHubTokenPort = (owner: string | undefined, signal: AbortSignal | undefined) => Promise<string>;
-/** The part of `fetch` this adapter uses: one POST to the GraphQL endpoint. The global `fetch` satisfies it. */
-type GraphqlFetch = (url: string, init: RequestInit) => Promise<Response>;
-//#endregion
-export { scopeRootsInputSchema as $, ScopeEntry as A, badRequestReasons as B, Gap as C, Relation as D, OrderField as E, SourceParticipant as F, orderDirections as G, filterStates as H, SourceTransition as I, relationKinds as J, orderFields as K, SyncFilter as L, ScopeListingInput as M, ScopeRootsInput as N, RelationKind as O, SourceDescription as P, scopeListingSchema as Q, SyncInput as R, FilterState as S, OrderDirection as T, gapReasons as U, boundActivitySchema as V, gapSchema as W, scopeChildrenInputSchema as X, relationSchema as Y, scopeEntrySchema as Z, GraphSourceFailure as _, FakePage as a, BadRequestReason as b, assembleSync as c, GraphSourceRouter as d, sourceDescriptionSchema as et, GraphSourceScopes as f, GraphSourceError as g, createGraphSourceRouter as h, FakeGraphSourceOptions as i, transitionSchema as it, ScopeListing as j, ScopeChildrenInput as k, ChildrenRequest as l, PageRequest as m, GraphqlFetch as n, syncInputSchema as nt, createFakeGraphSource as o, ListingRequest as p, participantSchema as q, githubGraphqlEndpoint as r, syncPageSchema as rt, AssembledSync as s, GitHubTokenPort as t, syncFilterSchema as tt, GraphSourcePager as u, GraphSourceClient as v, GapReason as w, BoundActivity as x, graphSourceContract as y, SyncPage as z };
+export { transitionSchema as $, SourceDescription as A, orderDirections as B, Relation as C, ScopeListing as D, ScopeEntry as E, SyncPage as F, scopeChildrenInputSchema as G, participantSchema as H, badRequestReasons as I, scopeRootsInputSchema as J, scopeEntrySchema as K, filterStates as L, SourceTransition as M, SyncFilter as N, ScopeListingInput as O, SyncInput as P, syncPageSchema as Q, gapReasons as R, OrderField as S, ScopeChildrenInput as T, relationKinds as U, orderFields as V, relationSchema as W, syncFilterSchema as X, sourceDescriptionSchema as Y, syncInputSchema as Z, BadRequestReason as _, assembleSync as a, GapReason as b, GraphSourceRouter as c, PageRequest as d, createGraphSourceRouter as f, graphSourceContract as g, GraphSourceClient as h, AssembledSync as i, SourceParticipant as j, ScopeRootsInput as k, GraphSourceScopes as l, GraphSourceFailure as m, FakePage as n, ChildrenRequest as o, GraphSourceError as p, scopeListingSchema as q, createFakeGraphSource as r, GraphSourcePager as s, FakeGraphSourceOptions as t, ListingRequest as u, FilterState as v, RelationKind as w, OrderDirection as x, Gap as y, gapSchema as z };

package/dist/index-DAevZqW-.d.ts

@@ -0,0 +1,71 @@
+import { X as OpenIds, Y as IdSpace, b as Model } from "./index-DYl6lZLe.js";
+import { N as Flowchart, a as ProjectedView, k as Swimlane, w as StateMachine, y as SequenceDiagram } from "./index-DluJZTbT.js";
+//#region ../../core/graph/export/dist/view.d.ts
+/** The text formats a view is written in: Mermaid, Graphviz DOT, and the projection itself as JSON. */
+declare const exportFormats: readonly ["mermaid", "dot", "json"];
+/** One of the text formats a view is written in. */
+type ExportFormat = (typeof exportFormats)[number];
+/**
+ * A projected view as text: Mermaid or Graphviz DOT source, or the projection as JSON indented by two spaces and ending in a line break, with every control, format, separator, unassigned and private-use character in it written as a JSON `\u` escape (see `terminalJson`), so the text shows nothing hidden or reordered wherever it is saved or printed and parses back to exactly the projection. This is the one writer of a view's text, so the command line's `show` and a download from the web app give the same text for the same view.
+ * @param model - The model the view was projected from, for the labels of a sequence diagram's participants.
+ * @param projected - The view, as graph-projection's `project` gives it.
+ * @param format - The format to write.
+ * @returns The text.
+ */
+declare const viewText: (model: Model<OpenIds>, projected: ProjectedView<OpenIds>, format: ExportFormat) => string;
+//#endregion
+//#region ../../core/graph/export/dist/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.
+ */
+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.
+ */
+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.
+ */
+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.
+ */
+declare const sequenceToMermaid: <I extends IdSpace>(view: SequenceDiagram<I>, participantLabel: (participant: I["actor"]) => string) => string;
+//#endregion
+//#region ../../core/graph/export/dist/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.
+ */
+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.
+ */
+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.
+ */
+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.
+ */
+declare const sequenceToDot: <I extends IdSpace>(view: SequenceDiagram<I>, participantLabel: (participant: I["actor"]) => string) => string;
+//#endregion
+export { flowchartToMermaid as a, swimlaneToMermaid as c, viewText as d, swimlaneToDot as i, ExportFormat as l, sequenceToDot as n, sequenceToMermaid as o, stateMachineToDot as r, stateMachineToMermaid as s, flowchartToDot as t, exportFormats as u };

package/dist/{index-Dvz_I_uQ.d.ts → index-DYl6lZLe.d.ts}

@@ -486,6 +486,34 @@ interface ModelSchema extends z.ZodReadonly<typeof modelObjectSchema> {
  * Every object is strict. The inferred type is exactly `Model<OpenIds>`, which a type-level test pins in both directions.
  */
 declare const modelSchema: ModelSchema;
+/** The strict object schema inside `boundActivitySchema`, before it is made read-only. */
+declare const boundActivityObjectSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"activity">;
+  id: z.ZodString;
+  extensions: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>>>>;
+  label: z.ZodString;
+  actor: z.ZodExactOptional<z.ZodString>;
+  action: z.ZodExactOptional<z.ZodString>;
+  affects: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+  consumes: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+  produces: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+  source: z.ZodString;
+}, z.core.$strict>;
+/**
+ * The type of `boundActivitySchema`, declared by name for the same reason as `ModelSchema`: a consumer's declaration file that embeds the schema, such as a source page's or a store's item list, refers to `BoundActivitySchema` rather than writing out the activity with trilean's JSON value inline.
+ */
+interface BoundActivitySchema extends z.ZodReadonly<typeof boundActivityObjectSchema> {
+  /** The strict object schema inside, whose `shape` holds each field's own schema. */
+  readonly unwrap: () => typeof boundActivityObjectSchema;
+}
+/**
+ * An activity bound to the external record it stands for: the model's `activity` element with `source` required, where the model leaves it optional, and equal to `id`. The source-qualified identifier (`github:org/repo#12`) is the element's identity, so the same record synced twice, or reached from two places, is the same element.
+ *
+ * This is the one definition of a bound activity: a source's sync page and a store's upserted items both use it, so what a source emits is exactly what a store accepts.
+ */
+declare const boundActivitySchema: BoundActivitySchema;
+/** An activity bound to the external record it stands for, as `boundActivitySchema` parses it. */
+type BoundActivity = z.output<BoundActivitySchema>;
 //#endregion
 //#region ../../core/graph/schema/dist/parse.d.ts
 /** A problem found while loading a model: a shape violation located by JSON pointer, or a rule `validate` reports. */
@@ -518,4 +546,4 @@ declare class ModelParseError extends Error {
  */
 declare const parseModel: (input: unknown) => Model<OpenIds>;
 //#endregion
-export { Transition as A, fragmentOperators as B, EventDef as C, Participant as D, FragmentOperand as E, Notation as F, pseudoRoles as G, notations as H, OverlayStatus as I, IdSpace as K, ParticipantKind as L, ElementKind as M, FragmentOperator as N, Point as O, MessageMode as P, PseudoRole as R, Element as S, Fragment as T, overlayStatuses as U, messageModes as V, participantKinds as W, Model as _, modelSchema as a, ActionDef as b, OverlayParseError as c, validateOverlay as d, Issue as f, outputsOf as g, inputsOf as h, ModelSchema as i, Views as j, Projection as k, overlaySchema as l, validate as m, ModelParseError as n, Overlay as o, IssueCode as p, OpenIds as q, parseModel as r, OverlayIssue as s, ModelIssue as t, parseOverlay as u, ModelParts as v, Extensions as w, ArtefactDef as x, defineModel as y, elementKinds as z };
+export { Participant as A, ParticipantKind as B, ActionDef as C, Extensions as D, EventDef as E, ElementKind as F, notations as G, elementKinds as H, FragmentOperator as I, pseudoRoles as J, overlayStatuses as K, MessageMode as L, Projection as M, Transition as N, Fragment as O, Views as P, Notation as R, defineModel as S, Element as T, fragmentOperators as U, PseudoRole as V, messageModes as W, OpenIds as X, IdSpace as Y, validate as _, BoundActivitySchema as a, Model as b, modelSchema as c, OverlayParseError as d, overlaySchema as f, IssueCode as g, Issue as h, BoundActivity as i, Point as j, FragmentOperand as k, Overlay as l, validateOverlay as m, ModelParseError as n, ModelSchema as o, parseOverlay as p, participantKinds as q, parseModel as r, boundActivitySchema as s, ModelIssue as t, OverlayIssue as u, inputsOf as v, ArtefactDef as w, ModelParts as x, outputsOf as y, OverlayStatus as z };

package/dist/{index-D06bcdfw.d.ts → index-DluJZTbT.d.ts}

@@ -1,4 +1,4 @@
-import { A as Transition, F as Notation, K as IdSpace, N as FragmentOperator, P as MessageMode, R as PseudoRole, S as Element, _ as Model } from "./index-Dvz_I_uQ.js";
+import { I as FragmentOperator, L as MessageMode, M as Projection, N as Transition, R as Notation, T as Element, V as PseudoRole, Y as IdSpace, b as Model } from "./index-DYl6lZLe.js";
 //#region ../../core/graph/projection/dist/loss.d.ts
 /** What an element that a notation cannot draw is: an element kind, or the role of a pseudo-state. A `message` element is one only when the notation would fold it but folding it would multiply edges. */
 type UnrepresentedKind = "activity" | "decision" | "state" | "message" | PseudoRole;
@@ -345,6 +345,27 @@ declare const confirmChanges: <I extends IdSpace>(diff: ModelDiff<I>, accept: (c
  */
 declare const applyModelDiff: <I extends IdSpace>(model: Model<I>, diff: ModelDiff<I>) => Model<I>;
 //#endregion
+//#region ../../core/graph/projection/dist/project.d.ts
+/** The view each projection notation produces. */
+interface ViewsByNotation<I extends IdSpace> {
+  readonly flowchart: Flowchart<I>;
+  readonly swimlane: Swimlane<I>;
+  readonly stateMachine: StateMachine<I>;
+  readonly sequence: SequenceDiagram<I>;
+}
+/** A projection request together with the view it produced, discriminated by notation. */
+type ProjectedView<I extends IdSpace> = { readonly [N in keyof ViewsByNotation<I>]: {
+  readonly notation: N;
+  readonly view: ViewsByNotation<I>[N];
+}; }[keyof ViewsByNotation<I>];
+/**
+ * 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.
+ */
+declare const project: <I extends IdSpace>(model: Model<I>, projection: Projection<I>) => ProjectedView<I>;
+//#endregion
 //#region ../../core/graph/projection/dist/inverse-flowchart.d.ts
 /**
  * The inverse of `toFlowchart`: what an edited flowchart changes in the model, matched by element and transition id.
@@ -401,4 +422,4 @@ declare const diffStateMachine: <I extends IdSpace>(model: Model<I>, edited: Rea
  */
 declare const diffSequence: <I extends IdSpace>(model: Model<I>, scenario: readonly I["transition"][], edited: Readonly<Pick<SequenceDiagram<I>, "messages">>) => ModelDiff<I>;
 //#endregion
-export { Flowchart as A, StateMachineTransition as C, toSwimlane as D, Swimlane as E, UnrepresentedElement as F, UnrepresentedKind as I, Handoff as M, handoffs as N, FlowEdge as O, Loss as P, StateMachineState as S, Lane as T, SequenceItem as _, Addressing as a, toSequence as b, Ends as c, TransitionChange as d, TransitionFieldChange as f, SequenceDiagram as g, confirmChanges as h, diffSwimlane as i, toFlowchart as j, FlowNode as k, EventChange as l, applyModelDiff as m, diffStateMachine as n, Change as o, UnconfirmedChangeError as p, diffFlowchart as r, ElementChange as s, diffSequence as t, ModelDiff as u, SequenceMessage as v, toStateMachine as w, StateMachine as x, SequenceOperand as y };
+export { toSwimlane as A, toSequence as C, toStateMachine as D, StateMachineTransition as E, Handoff as F, handoffs as I, Loss as L, FlowNode as M, Flowchart as N, Lane as O, toFlowchart as P, UnrepresentedElement as R, SequenceOperand as S, StateMachineState as T, applyModelDiff as _, ProjectedView as a, SequenceItem as b, Addressing as c, Ends as d, EventChange as f, UnconfirmedChangeError as g, TransitionFieldChange as h, diffSwimlane as i, FlowEdge as j, Swimlane as k, Change as l, TransitionChange as m, diffStateMachine as n, ViewsByNotation as o, ModelDiff as p, diffFlowchart as r, project as s, diffSequence as t, ElementChange as u, confirmChanges as v, StateMachine as w, SequenceMessage as x, SequenceDiagram as y, UnrepresentedKind as z };

package/dist/{index-CR8xUK3S.d.ts → index-KhygugOP.d.ts}

@@ -1,5 +1,5 @@
-import { k as FactRecord } from "./index-D4CnOhNf.js";
-import { _ as Model, f as Issue, i as ModelSchema, o as Overlay, q as OpenIds } from "./index-Dvz_I_uQ.js";
+import { k as FactRecord } from "./index-wQnLXJmD.js";
+import { X as OpenIds, a as BoundActivitySchema, b as Model, h as Issue, l as Overlay, o as ModelSchema } from "./index-DYl6lZLe.js";
 import { z } from "zod";
 import { ContractRouterClient } from "@orpc/contract";
 import { ContractedRouter } from "@orpc/server";
@@ -320,18 +320,7 @@ declare const graphStoreContract: {
               entity: "entity";
             }>;
           }, z.core.$strict>>>>;
-          activities: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
-            kind: z.ZodLiteral<"activity">;
-            id: z.ZodString;
-            extensions: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>>>>;
-            label: z.ZodString;
-            actor: z.ZodExactOptional<z.ZodString>;
-            action: z.ZodExactOptional<z.ZodString>;
-            affects: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-            consumes: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-            produces: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-            source: z.ZodString;
-          }, z.core.$strict>>>>;
+          activities: z.ZodReadonly<z.ZodArray<BoundActivitySchema>>;
           transitions: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
             id: z.ZodString;
             source: z.ZodString;
@@ -672,21 +661,6 @@ declare const modelIdSchema: z.ZodString;
  * A position in the store's history. Every change to any model takes the next revision from one store-wide sequence, so revisions only grow, a model's revision is the revision of its last change, and a model deleted and saved again never reuses an earlier one.
  */
 declare const revisionSchema: z.ZodInt;
-/**
- * An activity bound to the external record it stands for. `source` is required here, where the model leaves it optional: a bound item's identity is its source record, and the source-qualified identifier is its element id.
- */
-declare const boundActivitySchema: z.ZodReadonly<z.ZodObject<{
-  kind: z.ZodLiteral<"activity">;
-  id: z.ZodString;
-  extensions: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>>>>;
-  label: z.ZodString;
-  actor: z.ZodExactOptional<z.ZodString>;
-  action: z.ZodExactOptional<z.ZodString>;
-  affects: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-  consumes: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-  produces: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-  source: z.ZodString;
-}, z.core.$strict>>;
 /** The relation kinds a store keeps beside a model, the same kinds a source reports. */
 declare const relationKinds: readonly ["child-of", "assigned-to", "part-of"];
 /**
@@ -702,7 +676,7 @@ declare const relationSchema: z.ZodReadonly<z.ZodObject<{
   to: z.ZodString;
 }, z.core.$strict>>;
 /**
- * Items read from a source, to be merged into a stored model by identifier. Each participant, activity and transition replaces the one with the same id or is appended after the existing ones; the overlay's entries replace the run state of the elements they name; each relation not already stored is appended. Everything else in the model is left as it is.
+ * Items read from a source, to be merged into a stored model by identifier. Activities are graph-schema's `boundActivitySchema`, the same schema a source's sync page uses, so a page's items pass unchanged. Each participant, activity and transition replaces the one with the same id or is appended after the existing ones; the overlay's entries replace the run state of the elements they name; each relation not already stored is appended. Everything else in the model is left as it is.
  */
 declare const boundItemsSchema: z.ZodReadonly<z.ZodObject<{
   participants: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
@@ -714,18 +688,7 @@ declare const boundItemsSchema: z.ZodReadonly<z.ZodObject<{
       entity: "entity";
     }>;
   }, z.core.$strict>>>>;
-  activities: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
-    kind: z.ZodLiteral<"activity">;
-    id: z.ZodString;
-    extensions: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>>>>;
-    label: z.ZodString;
-    actor: z.ZodExactOptional<z.ZodString>;
-    action: z.ZodExactOptional<z.ZodString>;
-    affects: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-    consumes: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-    produces: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-    source: z.ZodString;
-  }, z.core.$strict>>>>;
+  activities: z.ZodReadonly<z.ZodArray<BoundActivitySchema>>;
   transitions: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
     id: z.ZodString;
     source: z.ZodString;
@@ -1012,7 +975,6 @@ declare const issueSchema: z.ZodReadonly<z.ZodObject<{
 }, z.core.$strict>>;
 type ModelId = z.infer<typeof modelIdSchema>;
 type Revision = z.infer<typeof revisionSchema>;
-type BoundActivity = z.infer<typeof boundActivitySchema>;
 type BoundItems = z.infer<typeof boundItemsSchema>;
 type Relation = z.infer<typeof relationSchema>;
 type RelationKind = (typeof relationKinds)[number];
@@ -1387,4 +1349,4 @@ type GraphStoreRouter = ContractedRouter<typeof graphStoreContract, object>;
  */
 declare const createFakeGraphStore: () => GraphStore;
 //#endregion
-export { factRecordSchema as $, defaultSubscriptionCapacity as A, Reach as B, ElementRequest as C, ChangeFeedOptions as D, ChangeFeed as E, ChangeKind as F, StoredFacts as G, RelationKind as H, FactChange as I, boundItemsSchema as J, StoredModel as K, FactClearing as L, GraphStoreFailure as M, BoundActivity as N, ChangeSubscription as O, BoundItems as P, factNameSchema as Q, ModelId as R, overlayWithin as S, ModelRequest as T, Revision as U, Relation as V, StoreChange as W, factChangeSchema as X, changeKinds as Y, factClearingSchema as Z, mergeFacts as _, blockedChainOf as a, relationSchema as at, emptyModel as b, structureOf as c, storedFactsSchema as ct, descendantsOf as d, graphStoreContract as dt, issueSchema as et, mergeRelations as f, factsWithin as g, factIssues as h, Structure as i, relationKinds as it, GraphStoreError as j, SubscribeOptions as k, ancestorsOf as l, storedModelSchema as lt, relationsWithin as m, GraphStoreRouter as n, modelSummarySchema as nt, impactOf as o, revisionSchema as ot, relationIssues as p, boundActivitySchema as q, createGraphStoreRouter as r, reachSchema as rt, readyOf as s, storeChangeSchema as st, createFakeGraphStore as t, modelIdSchema as tt, childrenOf as u, GraphStoreClient as ut, withoutFacts as v, GraphStore as w, mergeBoundItems as x, checkStored as y, ModelSummary as z };
+export { modelIdSchema as $, defaultSubscriptionCapacity as A, Relation as B, ElementRequest as C, ChangeFeedOptions as D, ChangeFeed as E, FactChange as F, StoredModel as G, Revision as H, FactClearing as I, factChangeSchema as J, boundItemsSchema as K, ModelId as L, GraphStoreFailure as M, BoundItems as N, ChangeSubscription as O, ChangeKind as P, issueSchema as Q, ModelSummary as R, overlayWithin as S, ModelRequest as T, StoreChange as U, RelationKind as V, StoredFacts as W, factNameSchema as X, factClearingSchema as Y, factRecordSchema as Z, mergeFacts as _, blockedChainOf as a, storeChangeSchema as at, emptyModel as b, structureOf as c, GraphStoreClient as ct, descendantsOf as d, modelSummarySchema as et, mergeRelations as f, factsWithin as g, factIssues as h, Structure as i, revisionSchema as it, GraphStoreError as j, SubscribeOptions as k, ancestorsOf as l, graphStoreContract as lt, relationsWithin as m, GraphStoreRouter as n, relationKinds as nt, impactOf as o, storedFactsSchema as ot, relationIssues as p, changeKinds as q, createGraphStoreRouter as r, relationSchema as rt, readyOf as s, storedModelSchema as st, createFakeGraphStore as t, reachSchema as tt, childrenOf as u, withoutFacts as v, GraphStore as w, mergeBoundItems as x, checkStored as y, Reach as z };

package/dist/{index-D4CnOhNf.d.ts → index-wQnLXJmD.d.ts}

@@ -1,4 +1,4 @@
-import { K as IdSpace, _ as Model, o as Overlay } from "./index-Dvz_I_uQ.js";
+import { Y as IdSpace, b as Model, l as Overlay } from "./index-DYl6lZLe.js";
 import { ComputedValue, ExpressionNode, JsonValue, PredicateNode, Resolution } from "trilean";
 //#region ../../core/graph/domain/dist/status.d.ts
 /** The derived states of an element, in the order the derivation considers them. */

package/dist/index.d.ts

@@ -1,6 +1,7 @@
-import { A as Facts, B as Status, C as CriticalPath, D as UnknownReference, E as NodeId, F as evaluateBranches, I as factNamesIn, L as factsFrom, M as artefactKey, N as elementStatusKey, O as buildDag, P as emptyFactRecord, R as layeredFacts, S as loopTransitions, T as Dag, V as statuses, _ as StatusRule, a as criticalPath, b as controlDag, c as unmetOutputs, d as StatusExplanation, f as explainStatus, g as StatusBasis, h as ProducerBasis, i as blockedBy, j as UnsupportedConditionError, k as FactRecord, l as whatIfDone, m as IncomingBasis, n as UnmetOutput, o as impact, p as ArtefactBasis, r as WhatIf, s as readySet, t as StatusChange, u as ChainLink, v as deriveStatuses, w as criticalPath$1, x as illegalCycles, y as statusRules, z as Branch } from "./index-D4CnOhNf.js";
-import { A as Transition, B as fragmentOperators, C as EventDef, D as Participant, E as FragmentOperand, F as Notation, G as pseudoRoles, H as notations, I as OverlayStatus, K as IdSpace, L as ParticipantKind, M as ElementKind, N as FragmentOperator, O as Point, P as MessageMode, R as PseudoRole, S as Element, T as Fragment, U as overlayStatuses, V as messageModes, W as participantKinds, _ as Model, a as modelSchema, b as ActionDef, c as OverlayParseError, d as validateOverlay, f as Issue, g as outputsOf, h as inputsOf, i as ModelSchema, j as Views, k as Projection, l as overlaySchema, m as validate, n as ModelParseError, o as Overlay, p as IssueCode, q as OpenIds, r as parseModel, s as OverlayIssue, t as ModelIssue, u as parseOverlay, v as ModelParts, w as Extensions, x as ArtefactDef, y as defineModel, z as elementKinds } from "./index-Dvz_I_uQ.js";
-import { A as Flowchart, C as StateMachineTransition, D as toSwimlane, E as Swimlane, F as UnrepresentedElement, I as UnrepresentedKind, M as Handoff, N as handoffs, O as FlowEdge, P as Loss, S as StateMachineState, T as Lane, _ as SequenceItem, a as Addressing, b as toSequence, c as Ends, d as TransitionChange, f as TransitionFieldChange, g as SequenceDiagram, h as confirmChanges, i as diffSwimlane, j as toFlowchart, k as FlowNode, l as EventChange, m as applyModelDiff, n as diffStateMachine, o as Change, p as UnconfirmedChangeError, r as diffFlowchart, s as ElementChange, t as diffSequence, u as ModelDiff, v as SequenceMessage, w as toStateMachine, x as StateMachine, y as SequenceOperand } from "./index-D06bcdfw.js";
+import { A as Facts, B as Status, C as CriticalPath, D as UnknownReference, E as NodeId, F as evaluateBranches, I as factNamesIn, L as factsFrom, M as artefactKey, N as elementStatusKey, O as buildDag, P as emptyFactRecord, R as layeredFacts, S as loopTransitions, T as Dag, V as statuses, _ as StatusRule, a as criticalPath, b as controlDag, c as unmetOutputs, d as StatusExplanation, f as explainStatus, g as StatusBasis, h as ProducerBasis, i as blockedBy, j as UnsupportedConditionError, k as FactRecord, l as whatIfDone, m as IncomingBasis, n as UnmetOutput, o as impact, p as ArtefactBasis, r as WhatIf, s as readySet, t as StatusChange, u as ChainLink, v as deriveStatuses, w as criticalPath$1, x as illegalCycles, y as statusRules, z as Branch } from "./index-wQnLXJmD.js";
+import { A as Participant, B as ParticipantKind, C as ActionDef, D as Extensions, E as EventDef, F as ElementKind, G as notations, H as elementKinds, I as FragmentOperator, J as pseudoRoles, K as overlayStatuses, L as MessageMode, M as Projection, N as Transition, O as Fragment, P as Views, R as Notation, S as defineModel, T as Element, U as fragmentOperators, V as PseudoRole, W as messageModes, X as OpenIds, Y as IdSpace, _ as validate, a as BoundActivitySchema, b as Model, c as modelSchema, d as OverlayParseError, f as overlaySchema, g as IssueCode, h as Issue, i as BoundActivity, j as Point, k as FragmentOperand, l as Overlay, m as validateOverlay, n as ModelParseError, o as ModelSchema, p as parseOverlay, q as participantKinds, r as parseModel, s as boundActivitySchema, t as ModelIssue, u as OverlayIssue, v as inputsOf, w as ArtefactDef, x as ModelParts, y as outputsOf, z as OverlayStatus } from "./index-DYl6lZLe.js";
+import { A as toSwimlane, C as toSequence, D as toStateMachine, E as StateMachineTransition, F as Handoff, I as handoffs, L as Loss, M as FlowNode, N as Flowchart, O as Lane, P as toFlowchart, R as UnrepresentedElement, S as SequenceOperand, T as StateMachineState, _ as applyModelDiff, a as ProjectedView, b as SequenceItem, c as Addressing, d as Ends, f as EventChange, g as UnconfirmedChangeError, h as TransitionFieldChange, i as diffSwimlane, j as FlowEdge, k as Swimlane, l as Change, m as TransitionChange, n as diffStateMachine, o as ViewsByNotation, p as ModelDiff, r as diffFlowchart, s as project, t as diffSequence, u as ElementChange, v as confirmChanges, w as StateMachine, x as SequenceMessage, y as SequenceDiagram, z as UnrepresentedKind } from "./index-DluJZTbT.js";
+import { a as flowchartToMermaid, c as swimlaneToMermaid, d as viewText, i as swimlaneToDot, l as ExportFormat, n as sequenceToDot, o as sequenceToMermaid, r as stateMachineToDot, s as stateMachineToMermaid, t as flowchartToDot, u as exportFormats } from "./index-DAevZqW-.js";
 //#region ../../core/graph/dag/dist/errors.d.ts
 /**
  * Thrown when an operation that is only defined on an acyclic graph is given one that contains a cycle.
@@ -108,4 +109,24 @@ declare namespace index_d_exports {
   export { CriticalPath, CycleError, Dag, NodeId, TopologicalLayers, UnknownNodeError, UnknownReference, ancestorsOf, buildDag, criticalPath$1 as criticalPath, descendantsOf, findCycles, immediateDominators, stronglyConnectedComponents, topologicalLayers, transitiveReduction };
 }
 //#endregion
-export { type ActionDef, type Addressing, type ArtefactBasis, type ArtefactDef, type Branch, type ChainLink, type Change, type Element, type ElementChange, type ElementKind, type Ends, type EventChange, type EventDef, type Extensions, type FactRecord, type Facts, type FlowEdge, type FlowNode, type Flowchart, type Fragment, type FragmentOperand, type FragmentOperator, type Handoff, type IdSpace, type IncomingBasis, type Issue, type IssueCode, type Lane, type Loss, type MessageMode, type Model, type ModelDiff, type ModelIssue, ModelParseError, type ModelParts, type ModelSchema, type Notation, type OpenIds, type Overlay, type OverlayIssue, OverlayParseError, type OverlayStatus, type Participant, type ParticipantKind, type Point, type ProducerBasis, type Projection, type PseudoRole, type SequenceDiagram, type SequenceItem, type SequenceMessage, type SequenceOperand, type StateMachine, type StateMachineState, type StateMachineTransition, type Status, type StatusBasis, type StatusChange, type StatusExplanation, type StatusRule, type Swimlane, type Transition, type TransitionChange, type TransitionFieldChange, UnconfirmedChangeError, type UnmetOutput, type UnrepresentedElement, type UnrepresentedKind, UnsupportedConditionError, type Views, type WhatIf, applyModelDiff, artefactKey, blockedBy, confirmChanges, controlDag, criticalPath, index_d_exports as dag, defineModel, deriveStatuses, diffFlowchart, diffSequence, diffStateMachine, diffSwimlane, elementKinds, elementStatusKey, emptyFactRecord, evaluateBranches, explainStatus, factNamesIn, factsFrom, fragmentOperators, handoffs, illegalCycles, impact, inputsOf, layeredFacts, loopTransitions, messageModes, modelSchema, notations, outputsOf, overlaySchema, overlayStatuses, parseModel, parseOverlay, participantKinds, pseudoRoles, readySet, statusRules, statuses, toFlowchart, toSequence, toStateMachine, toSwimlane, unmetOutputs, validate, validateOverlay, whatIfDone };
+//#region ../../core/graph/export/dist/terminal-text.d.ts
+/**
+ * Whether a character is one of the unsafe ones (see `unsafeCharacters`).
+ * @param character - One character: one code point, which may be two UTF-16 code units.
+ * @returns Whether it must be escaped.
+ */
+export declare const isUnsafeCharacter: (character: string) => boolean;
+/**
+ * Text made safe to write to a terminal. Each unsafe character (see `unsafeCharacters`) is written as the visible escape `\u{<hex>}` of its code point, such as `\u{1b}` for ESC, `\u{202e}` for a right-to-left override or `\u{e0041}` for a tag character, so nothing is lost and nothing acts on the terminal. Line feed, tab, the zero-width joiners and every other character, accented letters, CJK, Arabic and emoji included, pass through. A literal `\u{...}` already in the text is left as it is, so the escaped form is for reading, not for reversing.
+ * @param text - The text as written.
+ * @returns The text with every unsafe character escaped.
+ */
+export declare const terminalText: (text: string) => string;
+/**
+ * A value as JSON that is also safe to write to a terminal. `JSON.stringify` escapes the C0 controls but writes every other unsafe character (see `unsafeCharacters`) as it is; this writes those as `\u` escapes too, a surrogate pair for a code point beyond the Basic Multilingual Plane, which leaves the JSON, and every value parsed from it, exactly the same.
+ * @param value - The value to write.
+ * @returns The JSON text, indented by two spaces and ending in a line break.
+ */
+export declare const terminalJson: (value: unknown) => string;
+//#endregion
+export { type ActionDef, type Addressing, type ArtefactBasis, type ArtefactDef, type BoundActivity, type BoundActivitySchema, type Branch, type ChainLink, type Change, type Element, type ElementChange, type ElementKind, type Ends, type EventChange, type EventDef, type ExportFormat, type Extensions, type FactRecord, type Facts, type FlowEdge, type FlowNode, type Flowchart, type Fragment, type FragmentOperand, type FragmentOperator, type Handoff, type IdSpace, type IncomingBasis, type Issue, type IssueCode, type Lane, type Loss, type MessageMode, type Model, type ModelDiff, type ModelIssue, ModelParseError, type ModelParts, type ModelSchema, type Notation, type OpenIds, type Overlay, type OverlayIssue, OverlayParseError, type OverlayStatus, type Participant, type ParticipantKind, type Point, type ProducerBasis, type ProjectedView, type Projection, type PseudoRole, type SequenceDiagram, type SequenceItem, type SequenceMessage, type SequenceOperand, type StateMachine, type StateMachineState, type StateMachineTransition, type Status, type StatusBasis, type StatusChange, type StatusExplanation, type StatusRule, type Swimlane, type Transition, type TransitionChange, type TransitionFieldChange, UnconfirmedChangeError, type UnmetOutput, type UnrepresentedElement, type UnrepresentedKind, UnsupportedConditionError, type Views, type ViewsByNotation, type WhatIf, applyModelDiff, artefactKey, blockedBy, boundActivitySchema, confirmChanges, controlDag, criticalPath, index_d_exports as dag, defineModel, deriveStatuses, diffFlowchart, diffSequence, diffStateMachine, diffSwimlane, elementKinds, elementStatusKey, emptyFactRecord, evaluateBranches, explainStatus, exportFormats, factNamesIn, factsFrom, flowchartToDot, flowchartToMermaid, fragmentOperators, handoffs, illegalCycles, impact, inputsOf, layeredFacts, loopTransitions, messageModes, modelSchema, notations, outputsOf, overlaySchema, overlayStatuses, parseModel, parseOverlay, participantKinds, project, pseudoRoles, readySet, sequenceToDot, sequenceToMermaid, stateMachineToDot, stateMachineToMermaid, statusRules, statuses, swimlaneToDot, swimlaneToMermaid, toFlowchart, toSequence, toStateMachine, toSwimlane, unmetOutputs, validate, validateOverlay, viewText, whatIfDone };