process-graph 1.0.5 → 1.1.0

package/dist/index-CoA6vXqe.d.ts

@@ -0,0 +1,404 @@
+import { G as IdSpace, L as PseudoRole, M as FragmentOperator, N as MessageMode, P as Notation, g as Model, k as Transition, x as Element } from "./index-CmZOswkx.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;
+/** An element a projection could not draw, and what it was. */
+interface UnrepresentedElement<I extends IdSpace> {
+  readonly element: I["element"];
+  readonly kind: UnrepresentedKind;
+}
+/**
+ * Something a projection does not carry from the model into its result. A projection returns every loss that applies, in this order: layout, extensions, message elements, fragments, then the notation's own choice (unrepresented elements, subject, scenario, unshown branches, skipped steps). A kind is only reported when something was actually dropped.
+ */
+type Loss<I extends IdSpace> =
+/** Positions recorded for this projection's notation in `views`. No projection reads or keeps coordinates. */
+{
+  readonly kind: "layout";
+  readonly elements: readonly I["element"][];
+} |
+/** Elements carrying notation-only `extensions`, which no projection shows. */
+{
+  readonly kind: "extensions";
+  readonly elements: readonly I["element"][];
+} |
+/** `message` elements the projection neither draws nor folds into an edge or transition. */
+{
+  readonly kind: "message-elements";
+  readonly elements: readonly I["element"][];
+} |
+/** Authored fragments the projection does not draw. */
+{
+  readonly kind: "fragments";
+  readonly fragments: readonly I["fragment"][];
+} |
+/** Elements, other than messages, that the notation has no way to draw, and the transitions left out because one end of them is such an element. */
+{
+  readonly kind: "unrepresented-elements";
+  readonly notation: Notation;
+  readonly elements: readonly UnrepresentedElement<I>[];
+  readonly transitions: readonly I["transition"][];
+} |
+/** Activities left out of a state machine because they do not affect its subject. */
+{
+  readonly kind: "subject";
+  readonly subject: I["entity"];
+  readonly elements: readonly I["element"][];
+} |
+/** Elements of the model that are not on the sequence diagram's scenario. */
+{
+  readonly kind: "scenario";
+  readonly elements: readonly I["element"][];
+} |
+/** Transitions leaving an element on the scenario that the scenario does not take. */
+{
+  readonly kind: "unshown-branches";
+  readonly transitions: readonly I["transition"][];
+} |
+/** Scenario steps that produced no message because an end of the transition has no actor. */
+{
+  readonly kind: "skipped-steps";
+  readonly transitions: readonly I["transition"][];
+};
+//#endregion
+//#region ../../core/graph/projection/dist/handoffs.d.ts
+interface Handoff<I extends IdSpace> {
+  /** The transition the hand-off starts with. */
+  readonly transition: I["transition"];
+  readonly from: I["actor"];
+  readonly to: I["actor"];
+  /** The `message` elements the hand-off passes through, each once in the order met, when it is carried by a message; built when first read. */
+  readonly through?: readonly I["element"][];
+}
+/**
+ * Swimlane view: a transition between two elements with different actors is a hand-off. A transition into a `message` element continues through it to the element after it, so a message between two steps is part of the hand-off it carries, not an end of it. Elements without an actor never produce one.
+ * @param model - The model to read.
+ * @returns The hand-offs, in the order of the transitions they start with.
+ */
+declare const handoffs: <I extends IdSpace>(model: Model<I>) => readonly Handoff<I>[];
+//#endregion
+//#region ../../core/graph/projection/dist/flowchart.d.ts
+interface FlowNode<I extends IdSpace> {
+  readonly id: I["element"];
+  readonly label: string;
+  readonly shape: "terminator" | "process" | "decision" | "bar";
+}
+/** A drawn edge. It stands for one model transition, or for a chain of them through `message` elements, which a flowchart draws as the edge that carries the message rather than as a node. */
+interface FlowEdge<I extends IdSpace> {
+  readonly from: I["element"];
+  readonly to: I["element"];
+  /** On a single route, its guards joined with "and", or, when there are none, the labels of the messages it carries. On several merged routes, the labels of the messages it carries. */
+  readonly label?: string;
+  /** The model transitions the edge stands for: one, or every transition on some route through the message elements it carries, each once, in the order they were met. An edit to the edge maps back to the model through these. */
+  readonly transitions: readonly I["transition"][];
+  /** The `message` elements the edge carries, each once, in the order they were met, when it stands for more than one transition. */
+  readonly through?: readonly I["element"][];
+}
+interface Flowchart<I extends IdSpace> {
+  readonly nodes: readonly FlowNode<I>[];
+  readonly edges: readonly FlowEdge<I>[];
+  /** What the projection dropped from the model. */
+  readonly loss: readonly Loss<I>[];
+}
+/**
+ * Activities, decisions and terminators, joined by the transitions between them. A `message` element is not a node: a transition into it continues through it, so the edge runs from the step before the message to the step after it and carries the message (`through`). There is one edge per transition leaving a node and node it leads to, however many routes through message elements connect them; such an edge's `transitions`, `through` and `label` are built when first read. A message element no edge carries is reported as a `message-elements` loss. `state` elements and `history` pseudo-states have no flowchart shape and are reported as unrepresented, with the transitions that touch them.
+ * @param model - The model to project.
+ * @returns The nodes in model order, the edges in the order of the transitions they start with, and what was dropped.
+ */
+declare const toFlowchart: <I extends IdSpace>(model: Model<I>) => Flowchart<I>;
+//#endregion
+//#region ../../core/graph/projection/dist/swimlane.d.ts
+/** One lane. `participant` is a declared role or system; in a runtime model it may instead be an actor that was named but never declared, which `validate` reports. */
+interface Lane<I extends IdSpace> {
+  readonly participant: I["participant"] | I["actor"];
+  readonly label: string;
+  readonly nodes: readonly I["element"][];
+}
+interface Swimlane<I extends IdSpace> extends Flowchart<I> {
+  readonly lanes: readonly Lane<I>[];
+  /** Nodes with no actor, such as start and end terminators. */
+  readonly unassigned: readonly I["element"][];
+  readonly handoffs: readonly Handoff<I>[];
+}
+/**
+ * A flowchart plus partitions: a lane for every declared role or system, in declaration order and empty when nothing is assigned to it, then a lane for each actor that was named but never declared. Hand-offs are the edges that change lane.
+ */
+declare const toSwimlane: <I extends IdSpace>(model: Model<I>) => Swimlane<I>;
+//#endregion
+//#region ../../core/graph/projection/dist/state-machine.d.ts
+interface StateMachineState<I extends IdSpace> {
+  readonly id: I["element"];
+  readonly label: string;
+  readonly role: "initial" | "state" | "final";
+}
+interface StateMachineTransition<I extends IdSpace> {
+  readonly source: I["element"];
+  readonly target: I["element"];
+  readonly event?: I["event"];
+  readonly guard?: string;
+  readonly effect?: I["action"];
+  /** The model transitions this transition stands for: one, or every transition on some route through the elements folded into it, each once, in the order they were met. An edit to it maps back to the model through these. */
+  readonly transitions: readonly I["transition"][];
+  /** The elements folded into it, each once, in the order they were met: decisions, activities that do not affect the subject, and `message` elements. */
+  readonly through?: readonly I["element"][];
+}
+interface StateMachine<I extends IdSpace> {
+  readonly subject: I["entity"];
+  readonly states: readonly StateMachineState<I>[];
+  readonly transitions: readonly StateMachineTransition<I>[];
+  /** What the projection dropped from the model. */
+  readonly loss: readonly Loss<I>[];
+}
+/**
+ * Activity-as-state projection. Each activity that affects the subject becomes a state the subject entity rests in, and a decision collapses into guarded transitions leaving the state before it. The target activity's action becomes the effect of the transition that enters it.
+ *
+ * Which activities affect the subject is declared by their `affects`. An activity that does not list the subject is not a state of it: transitions through it are folded into the transition that leaves the previous state, exactly as a decision is. Authored `state` elements and pseudo-states are always kept. When no activity in the model declares `affects`, the model carries no such information and every activity is kept, which is the unscoped behaviour.
+ *
+ * A `message` element is folded the same way, and its `event`, when it has one, triggers the transition that carries it. A message element no drawn transition carries is reported as a `message-elements` loss.
+ *
+ * Each drawn transition lists the model `transitions` it stands for and the elements folded into it (`through`), so an edit to it maps back to the model. Several routes through folded elements from the same transition to the same state are one drawn transition whose `transitions` and `through` are the union over the routes, each once in the order met; it carries no event or guard, which differ by route, and its effect is only the target's entry action.
+ *
+ * Decisions are folded into guards by design and are not a loss. Fork, join and history pseudo-states have no state of their own here and are reported as unrepresented, together with the transitions that touch them, which are left out rather than pointing at a state that is not drawn.
+ *
+ * Other conventions exist, such as steps as transitions with states between them. Naming states such as "Paid" needs authored states, which the model can hold as `state` elements.
+ * @param model - The model to project.
+ * @param subject - The entity whose lifecycle the machine shows.
+ * @returns The states in model order, the transitions leaving each in turn, and what was dropped.
+ * @throws Error when `subject` is not a declared entity participant, which only a runtime model can cause.
+ */
+declare const toStateMachine: <I extends IdSpace>(model: Model<I>, subject: I["entity"]) => StateMachine<I>;
+//#endregion
+//#region ../../core/graph/projection/dist/sequence.d.ts
+interface SequenceMessage<I extends IdSpace> {
+  readonly transition: I["transition"];
+  readonly from: I["actor"];
+  /** Equal to `from` for a self-message. */
+  readonly to: I["actor"];
+  readonly label: string;
+  /** The `message` element drawn, when the step arrives at one; its `from`, `to`, `label` and `mode` are the message's own. In an edited diagram passed to `diffSequence`, a new message names here the element it arrives at instead. */
+  readonly element?: I["element"];
+  /** How the message is sent, when it is a `message` element's. A step between two activities has no mode of its own. */
+  readonly mode?: MessageMode;
+}
+/** One operand of an emitted fragment: the operand's guard, when it has one, and what happens inside it. */
+interface SequenceOperand<I extends IdSpace> {
+  readonly guard?: string;
+  readonly items: readonly SequenceItem<I>[];
+}
+/** What every drawn fragment carries, authored or derived. */
+interface FragmentItem<I extends IdSpace> {
+  readonly kind: "fragment";
+  readonly operator: FragmentOperator;
+  /** The operands the scenario takes, in authored or branch order. */
+  readonly operands: readonly SequenceOperand<I>[];
+}
+/** A message, or a fragment wrapping the messages of the scenario that fall inside it: an authored one, named by `fragment`, or one derived from the decision or fork named by `element`. */
+type SequenceItem<I extends IdSpace> = {
+  readonly kind: "message";
+  readonly message: SequenceMessage<I>;
+} | (FragmentItem<I> & {
+  readonly fragment: I["fragment"];
+  readonly element?: never;
+}) | (FragmentItem<I> & {
+  readonly element: I["element"];
+  readonly fragment?: never;
+});
+interface SequenceDiagram<I extends IdSpace> {
+  /** Actors in order of first appearance. */
+  readonly lifelines: readonly I["actor"][];
+  /** Every message in scenario order, including those inside fragments. */
+  readonly messages: readonly SequenceMessage<I>[];
+  /** The same messages, with authored and derived fragments wrapped around the ones that fall inside them. */
+  readonly items: readonly SequenceItem<I>[];
+  /** What the projection dropped from the model. */
+  readonly loss: readonly Loss<I>[];
+}
+/**
+ * One path through the process as messages.
+ *
+ * A step between two elements with actors becomes a message, labelled by the transition's event when it has one and by the target's label otherwise. A step arriving at a `message` element draws that message, with its own `from`, `to`, `label` and `mode`, and the step leaving it continues the same message rather than drawing another. An element with no actor that the scenario passes through, such as a fork or join, passes on whoever reached it: a step leaving it is sent by the actor of the step that arrived. A step that still has no sender, or that arrives at an element with no actor, draws nothing and is reported as `skipped-steps`. Branches off the path are not drawn, which is why this direction is lossy and one-to-many.
+ *
+ * `messages` is the flat list. `items` is the same messages with fragments wrapped around the ones that fall inside them: the authored `fragments` the scenario passes through, and those its structure implies (an `alt` or `opt` at a decision, a `loop` back through a decision, a `par` at a fork), each derived fragment naming the decision or fork it comes from. A fragment that cannot be drawn faithfully is left out, and an authored one left out is reported in `loss`.
+ * @param model - The model to project.
+ * @param scenario - The transitions the path takes, in order.
+ * @returns Lifelines in order of first appearance, the messages, the items and what was dropped.
+ * @throws Error when a scenario step is not a declared transition.
+ */
+declare const toSequence: <I extends IdSpace>(model: Model<I>, scenario: readonly I["transition"][]) => SequenceDiagram<I>;
+//#endregion
+//#region ../../core/graph/projection/dist/diff.d.ts
+/** Where a transition runs from and to. */
+interface Ends<I extends IdSpace> {
+  readonly source: I["element"];
+  readonly target: I["element"];
+}
+/** Who sends and who receives a `message` element. */
+interface Addressing<I extends IdSpace> {
+  readonly from: I["actor"];
+  readonly to: I["actor"];
+}
+/**
+ * A change to one element that an edited view implies. `inferred` is true when the view did not determine the change and the inverse chose it, for instance a new step a sequence diagram implies; such a change stays unapplied until it is confirmed with `confirmChanges`.
+ */
+type ElementChange<I extends IdSpace> = {
+  readonly kind: "added";
+  readonly element: Element<I["element"], I>;
+  readonly inferred: boolean;
+} | {
+  readonly kind: "removed";
+  readonly element: I["element"];
+  readonly inferred: boolean;
+} | {
+  readonly kind: "renamed";
+  readonly element: I["element"];
+  readonly from: string;
+  readonly to: string;
+  readonly inferred: boolean;
+} |
+/** The element moved to another actor's lane; `undefined` is no actor. */
+{
+  readonly kind: "relaned";
+  readonly element: I["element"];
+  readonly from: I["actor"] | undefined;
+  readonly to: I["actor"] | undefined;
+  readonly inferred: boolean;
+} |
+/** A `message` element now goes between other actors. */
+{
+  readonly kind: "readdressed";
+  readonly element: I["element"];
+  readonly from: Addressing<I>;
+  readonly to: Addressing<I>;
+  readonly inferred: boolean;
+};
+/** A change to one of a transition's labels: its human `guard`, its `trigger` event or its `effect` action. */
+type TransitionFieldChange<I extends IdSpace> = {
+  readonly field: "guard";
+  readonly from: string | undefined;
+  readonly to: string | undefined;
+} | {
+  readonly field: "trigger";
+  readonly from: I["event"] | undefined;
+  readonly to: I["event"] | undefined;
+} | {
+  readonly field: "effect";
+  readonly from: I["action"] | undefined;
+  readonly to: I["action"] | undefined;
+};
+/** A change to one transition that an edited view implies. `inferred` has the same meaning as on `ElementChange`. */
+type TransitionChange<I extends IdSpace> = {
+  readonly kind: "added";
+  readonly transition: Transition<I["transition"], I>;
+  readonly inferred: boolean;
+} | {
+  readonly kind: "removed";
+  readonly transition: I["transition"];
+  readonly inferred: boolean;
+} | {
+  readonly kind: "rewired";
+  readonly transition: I["transition"];
+  readonly from: Ends<I>;
+  readonly to: Ends<I>;
+  readonly inferred: boolean;
+} | (TransitionFieldChange<I> & {
+  readonly kind: "changed";
+  readonly transition: I["transition"];
+  readonly inferred: boolean;
+});
+/** A renamed event: a sequence message labelled by its trigger's name was relabelled. */
+interface EventChange<I extends IdSpace> {
+  readonly kind: "renamed";
+  readonly event: I["event"];
+  readonly from: string;
+  readonly to: string;
+  readonly inferred: boolean;
+}
+/** What an edited view changes in the model, by identifier. Each list is in the order the changes were found: the model's order for what was there, then the view's order for what is new. */
+interface ModelDiff<I extends IdSpace> {
+  readonly elements: readonly ElementChange<I>[];
+  readonly transitions: readonly TransitionChange<I>[];
+  readonly events: readonly EventChange<I>[];
+}
+/** Any one change in a `ModelDiff`. */
+type Change<I extends IdSpace> = ElementChange<I> | TransitionChange<I> | EventChange<I>;
+/** Thrown by `applyModelDiff` when the diff still holds changes the inverse inferred and nobody confirmed. */
+declare class UnconfirmedChangeError<I extends IdSpace> extends Error {
+  /** The changes still marked `inferred`. */
+  readonly changes: readonly Change<I>[];
+  constructor(changes: readonly Change<I>[]);
+}
+/**
+ * Marks inferred changes as confirmed, so `applyModelDiff` will apply them.
+ * @param diff - A diff returned by one of the view inverses.
+ * @param accept - Chooses which inferred changes to confirm; the rest stay inferred.
+ * @returns A new diff; `diff` is not modified.
+ */
+declare const confirmChanges: <I extends IdSpace>(diff: ModelDiff<I>, accept: (change: Change<I>) => boolean) => ModelDiff<I>;
+/**
+ * Applies a confirmed diff to the model, returning a new model.
+ *
+ * Removing an element also takes it out of fragment bodies and recorded positions; removing a transition also takes it out of every sequence scenario. Transitions that touched a removed element are only removed when the diff says so, as every view inverse does, so a diff built by hand that leaves one dangling yields a model `validate` reports.
+ * @param model - The model the diff was computed against.
+ * @param diff - The changes, with every inferred one confirmed.
+ * @returns The changed model; `model` is not modified.
+ * @throws UnconfirmedChangeError when a change is still marked `inferred`.
+ * @throws Error when a change names an element, transition or event the model does not have, or asks for something the element's kind cannot carry, such as a label on a pseudo-state.
+ */
+declare const applyModelDiff: <I extends IdSpace>(model: Model<I>, diff: ModelDiff<I>) => Model<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.
+ *
+ * A node not in the projection is an added element: a process an activity, a decision a decision, both certain; a terminator or bar a pseudo-state whose role is inferred from its edges. A projected node missing from the edit is removed, and a changed label renames the element. An edge is matched by where it comes from: the transition it starts with and the node one of its transitions arrives at. A new edge must carry one new transition id and is an added transition; a projected edge missing from the edit removes its transition; moved ends rewire it; a changed label changes its guard. An edge that carries messages stands for every route through them, so its earlier steps are shared with other edges: moving its source rewires its first transition, which is certain, while removing it or moving its target acts on each step from a message into its end, once however many edges share them, and is inferred.
+ * @param model - The model the flowchart was projected from.
+ * @param edited - The projected flowchart after editing. Its `loss` is not read.
+ * @returns The changes, with no event changes, since a flowchart draws no events.
+ * @throws Error when the edit cannot be expressed in the model: a node that is a model element the flowchart does not draw, a changed shape, a relabelled terminator or bar, an unmatched edge that is not a single new transition, a relabelled edge that carries a message, or edges sharing their last steps moved to different ends.
+ */
+declare const diffFlowchart: <I extends IdSpace>(model: Model<I>, edited: Readonly<{
+  nodes: readonly FlowNode<I>[];
+  edges: readonly FlowEdge<I>[];
+}>) => ModelDiff<I>;
+/**
+ * The inverse of `toSwimlane`: the flowchart changes plus the lane moves. A node is placed with the actor of the lane it is in, or with none when it is in `unassigned`; an activity or decision whose actor differs from the model's is relaned, and an added activity or decision takes its lane's actor. Hand-offs are derived and not read.
+ * @param model - The model the swimlane was projected from.
+ * @param edited - The projected swimlane after editing.
+ * @returns The changes; see `diffFlowchart` for nodes and edges.
+ * @throws Error in the cases `diffFlowchart` does, when a lane belongs to a participant that cannot act, or when a pseudo-state is put in a lane.
+ */
+declare const diffSwimlane: <I extends IdSpace>(model: Model<I>, edited: Readonly<Pick<Swimlane<I>, "nodes" | "edges" | "lanes">>) => ModelDiff<I>;
+//#endregion
+//#region ../../core/graph/projection/dist/inverse-state-machine.d.ts
+/**
+ * The inverse of `toStateMachine`: what an edited state machine changes in the model, matched by element and transition id.
+ *
+ * A state not in the projection is an added element: a `state` element for a plain state, or an initial or final pseudo-state. A projected state missing from the edit is removed, and a changed label renames the activity or state behind it.
+ *
+ * A drawn transition is matched by where it comes from: its first model transition and the state one of its model transitions arrives at. One that stands for a single transition maps straight back: moved ends rewire it, and a changed event, guard or effect changes that transition's trigger, guard or effect. One that stands for a chain through folded elements (decisions, activities that do not affect the subject, messages) shares its later steps with every other chain through the same elements, so the inverse has to choose: moving its source rewires the first step and is certain, but moving its target, changing its labels or removing it acts on each step from a folded element into its target state, once however many drawn transitions share it, and is marked `inferred`. A new transition must carry one new transition id and is added with its event, guard and effect.
+ * @param model - The model the machine was projected from.
+ * @param edited - The projected machine after editing; `subject` says which projection it was. Its `loss` is not read.
+ * @returns The changes, with no event changes, since a state machine names events by id.
+ * @throws Error when the edit cannot be expressed in the model: a state that is a model element the machine does not draw, a changed role, a relabelled initial or final state, an unmatched transition that is not a single new transition, or a changed effect where the effect is the target activity's action.
+ */
+declare const diffStateMachine: <I extends IdSpace>(model: Model<I>, edited: Readonly<Pick<StateMachine<I>, "subject" | "states" | "transitions">>) => ModelDiff<I>;
+//#endregion
+//#region ../../core/graph/projection/dist/inverse-sequence.d.ts
+/**
+ * The inverse of `toSequence`: what an edited sequence diagram changes in the model. A sequence diagram shows one path and leaves out who owns which step, so most of what it implies has to be inferred, and every such change is marked `inferred` until it is confirmed.
+ *
+ * Messages are matched to the projection by transition id, occurrence by occurrence, since a loop repeats a step. For a matched message:
+ *
+ * - a changed label renames what the label came from, which is certain: the `message` element it draws, the event that triggers the step, or the step's target element;
+ * - changed ends on a `message` element readdress it, which is certain;
+ * - a changed receiver relanes the step's target and a changed sender relanes its source, both inferred, since the edit could equally mean a different element.
+ *
+ * A projected message missing from the edit removes its transition, inferred, since it may only have left this scenario. A message with a new transition id is a new step, inferred: it must name the element it arrives at in `element` (an existing element, or a new activity owned by its receiver, labelled with the message), and it leaves from where the latest earlier message to its sender arrived. When the message after it was a step from that same place, that step is rewired to leave from the new element instead, inferred. Lifelines and items are derived from the messages and not read.
+ * @param model - The model the diagram was projected from.
+ * @param scenario - The scenario it was projected for.
+ * @param edited - The projected diagram after editing.
+ * @returns The changes, each listed once.
+ * @throws Error when the edit cannot be expressed in the model: a model transition added to the diagram that the scenario does not take (a scenario change, not a model change), a changed `element` on a drawn message, a changed sender on a step whose sender comes from an earlier step, or a new message with no `element` or with no earlier message to its sender.
+ */
+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 };

package/dist/index-CptUHq6F.d.ts

@@ -0,0 +1,58 @@
+import { n as GraphqlFetch, t as GitHubTokenPort, u as GraphSourcePager } from "./graphql-C1j5wQFz.js";
+//#region ../../adapters/graph/source-github-issues/dist/source.d.ts
+/** What the GitHub issues source needs. */
+interface GitHubIssuesSourceOptions {
+  /** Supplies a token per owner. `githubTokenFromEnvironment`, from the `./node` entry point, reads `GITHUB_TOKEN` or `gh auth token`. */
+  readonly token: GitHubTokenPort;
+  /** The fetch implementation; the global `fetch` when absent. */
+  readonly fetch?: GraphqlFetch;
+  /** The clock, in milliseconds since the epoch; `Date.now` when absent. */
+  readonly now?: () => number;
+  /** Issues per page, and connection items per request, from 1 to GitHub's limit of 100. */
+  readonly pageSize?: number;
+}
+/**
+ * The GitHub issues `GraphSourcePager`. A page is one page of one repository's issues, or of one board's items: each issue becomes a bound activity (`github:owner/repo#n`) whose actor is its repository, each `blockedBy` and `blocking` entry a transition from the blocker to the blocked issue (one transition, whichever side it is read from), each sub-issue a `child-of` relation, each assignee an `assigned-to` relation, and the repository `part-of` its owner. Blockers, blocked issues and sub-issues in other repositories or organisations are included with their own repository and owner. Open issues are `open` in the overlay and closed ones `done`.
+ *
+ * Scopes are read in request order, each once: `github:owner/repo` for one repository, `github:owner` for every repository the account owns, by name, and `github:owner/projects/number` for the issues on an organisation's or user's Projects v2 board, in the board's order (its pull requests and draft issues are not issues, so they are passed over). A repository, owner or board that does not exist or that the token cannot see is a gap, and the sync continues. A filter narrows and orders each repository's issue listing on GitHub's side; a board has no such listing, so a filter with a board scope is a `bad-request` with `invalid-scope`.
+ *
+ * The pager also lists scopes: the viewer's own account and organisations at the top, and an owner's repositories, by name, inside it.
+ * @param options - The token port, and optionally fetch, clock and page size.
+ * @returns A pager for `createGraphSourceRouter`.
+ * @throws RangeError when `pageSize` is not an integer from 1 to 100.
+ */
+declare const createGitHubIssuesSource: (options: GitHubIssuesSourceOptions) => GraphSourcePager;
+//#endregion
+//#region ../../adapters/graph/source-github-issues/dist/tokens.d.ts
+/** A token a host keeps, such as one a person entered in a browser, with what it may be used for. */
+interface StoredGitHubToken {
+  /** The token itself. It is only ever returned to the adapter, which sends it in the `Authorization` header. */
+  readonly token: string;
+  /** The logins of the owners it is for, or `"any"` for a token that serves every owner. */
+  readonly owners: readonly string[] | "any";
+  /** When it was last used, as an ISO 8601 instant; absent when it never has been. */
+  readonly lastUsedAt?: string;
+}
+/**
+ * Picks the stored token for a request about one owner. A token scoped to that owner wins over one scoped to any owner; among owner-scoped tokens the one naming the fewest owners wins, being the most specific, then the most recently used; among tokens for any owner the most recently used wins. A request about the token's own holder (`owner` undefined) can only use a token for any owner. Logins match without regard to case, as GitHub's do.
+ * @param tokens - The stored tokens.
+ * @param owner - The login the request is about, or `undefined` for the token's own holder.
+ * @returns The token to use, or `undefined` when none fits.
+ */
+declare const selectStoredToken: (tokens: readonly StoredGitHubToken[], owner: string | undefined) => StoredGitHubToken | undefined;
+/** Where `storedTokenPort` reads the host's tokens, and how it reports one being used. */
+interface StoredTokenPortOptions {
+  /** Reads the stored tokens; called for every request, so a token added or removed takes effect on the next one. */
+  readonly list: (signal: AbortSignal | undefined) => Promise<readonly StoredGitHubToken[]>;
+  /** Told of each token chosen, so the host can record when it was used and keep the recency order current. */
+  readonly used?: (token: StoredGitHubToken) => void;
+}
+/**
+ * A token port over tokens a host keeps, choosing one per request with `selectStoredToken`.
+ * @param options - How to read the stored tokens, and how to report one being used.
+ * @returns The token port.
+ * @throws GraphSourceError with `unauthorised`, from the port, when no stored token fits the owner; the message names the owner and never a token.
+ */
+declare const storedTokenPort: (options: StoredTokenPortOptions) => GitHubTokenPort;
+//#endregion
+export { GitHubIssuesSourceOptions as a, storedTokenPort as i, StoredTokenPortOptions as n, createGitHubIssuesSource as o, selectStoredToken as r, StoredGitHubToken as t };

package/dist/index-CrM5qWUA.d.ts

@@ -0,0 +1,110 @@
+import { A as Views, G as IdSpace } from "./index-CmZOswkx.js";
+import { A as Flowchart, E as Swimlane, x as StateMachine } from "./index-CoA6vXqe.js";
+//#region ../../core/graph/layout/dist/engine.d.ts
+/** A box with a fixed size, which the engine places. */
+interface EngineLeaf {
+  readonly id: string;
+  readonly width: number;
+  readonly height: number;
+  readonly children?: never;
+}
+/**
+ * A box that encloses other nodes. The engine sizes it to fit its children, and never makes it smaller than `width` by `height`, so an empty group keeps a usable extent.
+ */
+interface EngineGroup {
+  readonly id: string;
+  readonly width: number;
+  readonly height: number;
+  readonly children: readonly EngineNode[];
+}
+type EngineNode = EngineLeaf | EngineGroup;
+/** A directed edge between two leaves, which may sit in different groups. */
+interface EngineEdge {
+  readonly id: string;
+  readonly source: string;
+  readonly target: string;
+}
+/** The direction in which edges generally point. */
+type Direction = "right" | "down" | "left" | "up";
+/** A layered layout request, free of any engine's own vocabulary. */
+interface EngineGraph {
+  readonly direction: Direction;
+  /** The gap between two nodes in the same layer. */
+  readonly nodeGap: number;
+  /** The gap between two consecutive layers. */
+  readonly layerGap: number;
+  /** The space between a group's border and its children. */
+  readonly groupPadding: number;
+  readonly nodes: readonly EngineNode[];
+  readonly edges: readonly EngineEdge[];
+}
+/** One placed node, with its top-left corner in the coordinate space of the whole graph. */
+interface EngineBox {
+  readonly id: string;
+  readonly x: number;
+  readonly y: number;
+  readonly width: number;
+  readonly height: number;
+}
+/**
+ * The layout engine behind `layout`. An implementation must place every node of the graph, groups included, and return the same boxes for the same graph. It may run in the calling context or across a transport such as a Worker; `layout` stops waiting for it when the signal aborts, and an implementation should stop work as well.
+ */
+interface LayoutEngine {
+  readonly arrange: (graph: EngineGraph, signal: AbortSignal | undefined) => Promise<readonly EngineBox[]>;
+}
+//#endregion
+//#region ../../core/graph/layout/dist/metrics.d.ts
+/** The room a node of each kind of shape takes, in the coordinate space of the layout. */
+interface Size {
+  readonly width: number;
+  readonly height: number;
+}
+//#endregion
+//#region ../../core/graph/layout/dist/layout.d.ts
+/**
+ * A projection result that can be laid out. A sequence diagram is not here: its lifelines and messages have a fixed arrangement, not a graph to place.
+ */
+type LayoutView<I extends IdSpace> = Flowchart<I> | Swimlane<I> | StateMachine<I>;
+interface LayoutOptions {
+  /** The direction in which edges generally point. Defaults to `"right"`. */
+  readonly direction?: Direction;
+  /** Overrides for the gaps, in layout units. Each defaults to a grid-derived constant. */
+  readonly spacing?: {
+    /** The gap between two nodes in the same layer. */
+    readonly node?: number;
+    /** The gap between consecutive layers. */
+    readonly layer?: number;
+  };
+  /** Rejects the returned promise with the signal's reason when it aborts. */
+  readonly signal?: AbortSignal;
+  /** The engine that places the nodes. Defaults to elkjs's layered algorithm run in the calling context. */
+  readonly engine?: LayoutEngine;
+}
+/** The bounds of one swimlane, in the same coordinate space as the node positions. */
+interface LaneBounds<I extends IdSpace> {
+  readonly participant: I["participant"] | I["actor"];
+  readonly x: number;
+  readonly y: number;
+  readonly width: number;
+  readonly height: number;
+}
+interface LayoutResult<I extends IdSpace> {
+  /** Top-left positions keyed by notation and element id: the model's `views` shape, ready to assign to `Model.views`. */
+  readonly views: Views<I["element"]>;
+  /** The extent of each placed element, which a position alone does not give. */
+  readonly sizes: Readonly<Partial<Record<I["element"], Size>>>;
+  /** One entry per swimlane lane, in the view's lane order; empty for a flowchart and a state machine. */
+  readonly lanes: readonly LaneBounds<I>[];
+}
+/**
+ * Places a projected view with a layered layout and returns where each element goes, as the model's `views` shape.
+ *
+ * Pure with respect to the model: it reads only the view, never mutates it, and the model stores the result apart from its semantics, so no projection reads a coordinate. The same view and options give the same positions with the default engine. Swimlane lanes are groups, and every node lies inside its lane's bounds.
+ * @param view - A flowchart, swimlane or state machine from the projection package.
+ * @param options - Direction, spacing, abort signal and engine.
+ * @returns Positions keyed by notation and element id, element sizes and lane bounds.
+ * @throws The signal's reason when `options.signal` aborts before the layout completes.
+ */
+declare const layout: <I extends IdSpace>(view: LayoutView<I>, options?: LayoutOptions) => Promise<LayoutResult<I>>;
+//#endregion
+export { layout as a, EngineBox as c, EngineGroup as d, EngineLeaf as f, LayoutView as i, EngineEdge as l, LayoutEngine as m, LayoutOptions as n, Size as o, EngineNode as p, LayoutResult as r, Direction as s, LaneBounds as t, EngineGraph as u };