process-graph 1.0.5 → 1.1.0

package/dist/index-DricKcyl.d.ts

@@ -0,0 +1,421 @@
+import { C as CriticalPath, F as Status, _ as StatusRule, d as StatusExplanation, k as Facts, u as ChainLink } from "./index-CCfe0csl.js";
+import { G as IdSpace, O as Projection, a as Overlay, g as Model, x as Element } from "./index-CmZOswkx.js";
+import { Q as GraphStoreClient, z as StoredModel } from "./index-DhbvDgK4.js";
+import { A as Flowchart, E as Swimlane, g as SequenceDiagram, x as StateMachine } from "./index-CoA6vXqe.js";
+import { KeyboardEvent, ReactElement, ReactNode, RefCallback } from "react";
+//#region ../../ui/graph/react/dist/run.d.ts
+/**
+ * Everything the reasoning hooks read: the model, its run overlay and the injected source of facts that conditions and provided artefacts are answered from. Keep the three stable between renders (from state, a store or `useMemo`), since the hooks recompute whenever one of them changes identity.
+ */
+interface Run<I extends IdSpace> {
+  readonly model: Model<I>;
+  readonly overlay: Readonly<Overlay<I>>;
+  readonly facts: Facts;
+}
+/**
+ * The facts port of a run that has no facts source: every key is not found, so a condition that reads one is indeterminate and no input artefact counts as provided.
+ * @returns `{ found: false }` for every key.
+ */
+declare const noFacts: Facts;
+//#endregion
+//#region ../../ui/graph/react/dist/model.d.ts
+/**
+ * Where a model being followed from a store stands. `missing` is a model the store does not have, yet or any more: it is still followed, so the first write that creates it, such as a sync, loads it.
+ */
+type ModelState = {
+  readonly status: "loading";
+} | {
+  readonly status: "missing";
+} | {
+  readonly status: "loaded";
+  readonly stored: StoredModel;
+} | {
+  readonly status: "failed";
+  readonly error: unknown;
+};
+/** The part of the `GraphStore` client `useModel` calls: loading a model and following its changes. */
+interface ModelClient {
+  readonly v1: {
+    readonly models: Pick<GraphStoreClient["v1"]["models"], "load">;
+    readonly changes: GraphStoreClient["v1"]["changes"];
+  };
+}
+/**
+ * Loads a model from a store and follows it: every change the store reports loads the model again, so the result always reflects the store's latest revision. It subscribes before the first load, so no change between the two is missed. A model the store does not have is `missing` and still followed, so a model that is created later, or deleted and saved again, is loaded when it is.
+ * @param client - A `GraphStore` client, over any transport. Keep it stable between renders.
+ * @param modelId - The model to follow.
+ * @returns `loading` until the first load; then `loaded` with the model, its overlay and revision, `missing` while the store has no such model (its load answers `NOT_FOUND`), or `failed` with any other error a load or the subscription ended with.
+ */
+declare const useModel: (client: ModelClient, modelId: string) => ModelState;
+//#endregion
+//#region ../../ui/graph/react/dist/analysis.d.ts
+/**
+ * The status of every element in a run, derived by `deriveStatuses`.
+ * @param run - The model, overlay and facts.
+ * @returns Each element's status, in model order.
+ * @throws CycleError when the model has an illegal cycle, so an error boundary shows it.
+ */
+declare const useStatuses: <I extends IdSpace>(run: Run<I>) => ReadonlyMap<I["element"], Status>;
+/**
+ * The work that can start now, by `readySet`.
+ * @param run - The model, overlay and facts.
+ * @returns The ready elements, in model order.
+ */
+declare const useReadySet: <I extends IdSpace>(run: Run<I>) => readonly I["element"][];
+/**
+ * Why an element has its status, by `explainStatus`.
+ * @param run - The model, overlay and facts.
+ * @param id - The element asked about, or `undefined` when nothing is.
+ * @returns The explanation, or `undefined` when `id` is.
+ * @throws UnknownNodeError when `id` is not an element of the model.
+ */
+declare const useWhyStatus: <I extends IdSpace>(run: Run<I>, id: I["element"] | undefined) => StatusExplanation<I> | undefined;
+/** The unfinished work behind an element. */
+interface BlockedChain<I extends IdSpace> {
+  /** The element, then every unfinished need reached from it, each with the needs it still waits on; see `explainStatus`. */
+  readonly chain: readonly ChainLink<I>[];
+  /** The open work at the end of the chain, which waits on nothing further: what to finish first. The same elements `blockedBy` returns. */
+  readonly blockers: readonly I["element"][];
+}
+/**
+ * The unfinished work holding an element back: the whole chain and the blockers at its end.
+ * @param run - The model, overlay and facts.
+ * @param id - The element asked about, or `undefined` when nothing is.
+ * @returns The chain and its blockers; both empty when `id` is `undefined`.
+ * @throws UnknownNodeError when `id` is not an element of the model.
+ */
+declare const useBlockedChain: <I extends IdSpace>(run: Run<I>, id: I["element"] | undefined) => BlockedChain<I>;
+/**
+ * What every blocked element is blocked by, by `blockedBy`, for a view that shows each element's blockers beside it.
+ * @param run - The model, overlay and facts.
+ * @returns The open work at the end of each blocked element's chain, keyed by the blocked element, in model order. Elements that are not blocked are absent.
+ */
+declare const useBlockers: <I extends IdSpace>(run: Run<I>) => ReadonlyMap<I["element"], readonly I["element"][]>;
+/**
+ * The live work that transitively depends on an element, by `impact`.
+ * @param run - The model, overlay and facts.
+ * @param id - The element asked about, or `undefined` when nothing is.
+ * @returns The impacted elements; empty when `id` is `undefined`.
+ * @throws UnknownNodeError when `id` is not an element of the model.
+ */
+declare const useImpact: <I extends IdSpace>(run: Run<I>, id: I["element"] | undefined) => readonly I["element"][];
+/**
+ * Every element weighs one step, so the critical path is the longest chain of work still ahead.
+ * @returns One.
+ */
+declare const stepWeight: () => number;
+/**
+ * The heaviest chain through the work still ahead, by `criticalPath`.
+ * @param run - The model, overlay and facts.
+ * @param weight - The cost of an element, finite and not negative. Keep it stable between renders. Defaults to `stepWeight`.
+ * @returns The path in dependency order and its total weight; empty when nothing is live.
+ * @throws RangeError when `weight` returns a negative or non-finite 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.
+ * @param projection - The projection to draw. Keep it stable between renders, for instance one of `model.projections`.
+ * @returns The notation and its view.
+ * @throws Error when a state machine's subject is not a declared entity.
+ */
+declare const useProjection: <I extends IdSpace>(model: Model<I>, projection: Projection<I>) => ProjectedView<I>;
+//#endregion
+//#region ../../ui/graph/react/dist/filter.d.ts
+/**
+ * Which elements to show. Each set constrains one property, and an empty set does not constrain it, so the empty filter shows everything. An element is shown when it passes every set that is not empty.
+ */
+interface ElementFilter {
+  /** Statuses to show. */
+  readonly statuses: ReadonlySet<Status>;
+  /** Actors to show the work of, by participant id. An element with no actor, such as a start or end, never matches a non-empty set. */
+  readonly actors: ReadonlySet<string>;
+  /** Sources to show the work of, by `sourceScope`. An element bound to no source never matches a non-empty set. */
+  readonly sources: ReadonlySet<string>;
+}
+/** The filter that shows every element. */
+declare const emptyFilter: ElementFilter;
+/**
+ * The collection a source-qualified identifier belongs to: the identifier up to its item separator, so `github:org/repo#12` is in `github:org/repo`. An identifier with no item separator is its own collection.
+ * @param source - A source-qualified identifier.
+ * @returns The identifier's collection.
+ */
+declare const sourceScope: (source: string) => string;
+/**
+ * The actors an element's work belongs to: the actor of an activity or decision, and both ends of a message.
+ * @param element - The element.
+ * @returns Its actors' participant ids.
+ */
+declare const actorsOf: <I extends IdSpace>(element: Element<I["element"], I>) => readonly I["actor"][];
+/**
+ * Whether an element passes a filter.
+ * @param element - The element.
+ * @param status - The element's status in the run.
+ * @param filter - The filter.
+ * @returns True when the element is shown.
+ */
+declare const matchesFilter: <I extends IdSpace>(element: Element<I["element"], I>, status: Status, filter: ElementFilter) => boolean;
+/**
+ * The elements a filter shows.
+ * @param model - The model.
+ * @param statuses - Each element's status, from `useStatuses`.
+ * @param filter - The filter.
+ * @returns The shown elements' ids, in model order.
+ */
+declare const filterElements: <I extends IdSpace>(model: Model<I>, statuses: ReadonlyMap<I["element"], Status>, filter: ElementFilter) => readonly I["element"][];
+/** A value a filter can select, and the text it is shown with. */
+interface FilterOption<V extends string = string> {
+  readonly value: V;
+  readonly label: string;
+}
+/** What a model's elements can be filtered by, beyond status. */
+interface FilterOptions {
+  /** The roles and systems that are some element's actor, in declaration order. */
+  readonly actors: readonly FilterOption[];
+  /** The source collections of the model's bound activities, in order of first appearance. */
+  readonly sources: readonly FilterOption[];
+}
+/**
+ * The actors and sources a model's elements can be filtered by.
+ * @param model - The model.
+ * @returns The options, each labelled for display.
+ */
+declare const filterOptions: <I extends IdSpace>(model: Model<I>) => FilterOptions;
+/** A filter and the operations that change it. */
+interface ElementFilterState {
+  readonly filter: ElementFilter;
+  /** Adds the status to the filter, or removes it when it is there. */
+  readonly toggleStatus: (status: Status) => void;
+  /** Adds the actor to the filter, or removes it when it is there. */
+  readonly toggleActor: (actor: string) => void;
+  /** Adds the source collection to the filter, or removes it when it is there. */
+  readonly toggleSource: (source: string) => void;
+  /** Clears every constraint. */
+  readonly clear: () => void;
+}
+/**
+ * Filter state for a view: which statuses, actors and sources to show.
+ * @param initial - The filter to start with. Defaults to `emptyFilter`.
+ * @returns The filter and its operations, each stable between renders.
+ */
+declare const useElementFilter: (initial?: ElementFilter) => ElementFilterState;
+//#endregion
+//#region ../../ui/graph/react/dist/selection.d.ts
+/** Props for the element that holds the selectable items: a listbox that moves the selection with the keyboard. */
+interface SelectionContainerProps {
+  readonly role: "listbox";
+  readonly onKeyDown: (event: KeyboardEvent<HTMLElement>) => void;
+}
+/** Props for one selectable item: an option with a roving tab stop, selected by a click. */
+interface SelectionItemProps {
+  readonly role: "option";
+  readonly ref: RefCallback<HTMLElement>;
+  readonly tabIndex: 0 | -1;
+  readonly "aria-selected": boolean;
+  readonly onClick: () => void;
+}
+/** The selected element of a view, how to change it, and the props that make a set of items keyboard navigable. */
+interface GraphSelection<Id extends string> {
+  /** The selected element, or `undefined` when none is or the selected one is no longer in `order`. */
+  readonly selected: Id | undefined;
+  readonly select: (id: Id | undefined) => void;
+  readonly containerProps: SelectionContainerProps;
+  /** The props for the item of one element, to spread on it. */
+  readonly itemProps: (id: Id) => SelectionItemProps;
+}
+/** How a selection starts and what it tells its owner. */
+interface GraphSelectionOptions<Id extends string> {
+  /** The element selected at first, when the hook keeps the selection itself. */
+  readonly initial?: Id | undefined;
+  /**
+   * The selected element, when the owner keeps the selection: give this key, even as `undefined`, and the hook reads the selection from it and keeps none of its own, reporting each change a click or key asks for through `onChange`. Several views of one model then share one selection. Leave the key out for the hook to keep the selection, starting from `initial`.
+   */
+  readonly selected?: Id | undefined;
+  /** Called with each new selection a click or key makes, so a parent can follow it. */
+  readonly onChange?: ((id: Id | undefined) => void) | undefined;
+  /** Focuses the item of an element after a keyboard move. Defaults to focusing the element `itemProps` was spread on; a renderer that draws its own focusable items, such as a canvas, passes its own. */
+  readonly focus?: ((id: Id) => void) | undefined;
+}
+/**
+ * Selection state with keyboard navigation over the elements of a view, following the listbox pattern of the WAI-ARIA Authoring Practices: the arrow keys move the selection to the next or previous element in `order`, wrapping at either end; Home and End move to the first and last; Escape clears it. Only one item is a tab stop: the selected one, or the first when none is. A keyboard move also focuses the item it selects.
+ * @param order - The navigable elements, in the order the keys move through them: the elements on show, after filtering.
+ * @param options - The initial selection or the owner's selection, a listener for changes and how to focus an item.
+ * @returns The selection, a setter, and the container and item props.
+ */
+declare const useGraphSelection: <Id extends string>(order: readonly Id[], options?: GraphSelectionOptions<Id>) => GraphSelection<Id>;
+//#endregion
+//#region ../../ui/graph/react/dist/labels.d.ts
+/** The text each status is shown with, so every component names a status the same way. */
+declare const statusLabels: Readonly<Record<Status, string>>;
+/** One sentence per status rule, saying why an element has the status that rule decided. */
+declare const ruleDescriptions: Readonly<Record<StatusRule, string>>;
+/**
+ * The text an element is shown with: its own label, or for a pseudo-state the name of its role.
+ * @param element - The element to name.
+ * @returns The element's display label.
+ */
+declare const elementLabel: <I extends IdSpace>(element: Element<I["element"], I>) => string;
+//#endregion
+//#region ../../ui/graph/react/dist/status-badge.d.ts
+interface StatusBadgeProps {
+  readonly status: Status;
+  readonly className?: string | undefined;
+}
+/**
+ * A status as text, carrying the status in `data-status` so a stylesheet can colour it.
+ * @param props - The status and an optional class.
+ * @returns A `span` naming the status.
+ */
+declare const StatusBadge: (props: StatusBadgeProps) => ReactElement;
+//#endregion
+//#region ../../ui/graph/react/dist/element-card.d.ts
+/** The parts of an element card a class can be given to. */
+type ElementCardPart = "root" | "label" | "status" | "critical" | "blockers";
+/** Another element named by a card, by id and display label. */
+interface NamedElement {
+  readonly id: string;
+  readonly label: string;
+}
+interface ElementCardProps<I extends IdSpace> {
+  readonly element: Element<I["element"], I>;
+  readonly status: Status;
+  /** Whether the element is on the critical path. */
+  readonly critical?: boolean | undefined;
+  /** The open work the element waits on, shown when it is not empty. */
+  readonly blockedBy?: readonly NamedElement[] | undefined;
+  /** The props from `useGraphSelection().itemProps`, when the card is a navigable item. */
+  readonly item?: SelectionItemProps | undefined;
+  readonly classNames?: Partial<Record<ElementCardPart, string>> | undefined;
+}
+/**
+ * One element: its label, its status, whether it is on the critical path, and what it is blocked by. The root carries `data-element-id`, `data-kind`, `data-status` and, on the critical path, `data-critical`.
+ * @param props - The element, its status and what to show beside it.
+ * @returns The card.
+ */
+declare const ElementCard: <I extends IdSpace>(props: ElementCardProps<I>) => ReactElement;
+//#endregion
+//#region ../../ui/graph/react/dist/transition-item.d.ts
+/** The parts of a transition item a class can be given to. */
+type TransitionItemPart = "root" | "from" | "to" | "label";
+interface TransitionItemProps {
+  /** The transition, or for an edge standing for several, the first. */
+  readonly id: string;
+  /** The source element's display label. */
+  readonly from: string;
+  /** The target element's display label. */
+  readonly to: string;
+  /** The guard or message label, when there is one. */
+  readonly label?: string | undefined;
+  /** Whether the transition passes work between actors. */
+  readonly handoff?: boolean | undefined;
+  /** Whether both ends are on the critical path. */
+  readonly critical?: boolean | undefined;
+  readonly classNames?: Partial<Record<TransitionItemPart, string>> | undefined;
+}
+/**
+ * One transition as a list item: where it comes from, where it goes and its label. The item carries `data-transition-id` and, as applicable, `data-handoff` and `data-critical`; a hand-off says so in its text.
+ * @param props - The transition's ends and label.
+ * @returns An `li`, to place in a list.
+ */
+declare const TransitionItem: (props: TransitionItemProps) => ReactElement;
+//#endregion
+//#region ../../ui/graph/react/dist/lane.d.ts
+/** The parts of a lane a class can be given to. */
+type LanePart = "root" | "heading" | "body";
+interface LaneProps {
+  /** The participant the lane belongs to. */
+  readonly participant: string;
+  readonly label: string;
+  readonly children?: ReactNode;
+  readonly classNames?: Partial<Record<LanePart, string>> | undefined;
+}
+/**
+ * A swimlane: a group named by its heading, holding the work of one participant. The group carries `data-lane` with the participant's id.
+ * @param props - The participant, its label and the lane's content.
+ * @returns The lane.
+ */
+declare const Lane: (props: LaneProps) => ReactElement;
+//#endregion
+//#region ../../ui/graph/react/dist/legend.d.ts
+/** The parts of a legend a class can be given to. */
+type LegendPart = "root" | "item" | "swatch" | "label";
+interface LegendProps {
+  /** The statuses to explain. Defaults to every status. */
+  readonly statuses?: readonly Status[] | undefined;
+  /** Whether to explain the critical path marking too. */
+  readonly critical?: boolean | undefined;
+  readonly classNames?: Partial<Record<LegendPart, string>> | undefined;
+}
+/**
+ * A key to the statuses a view colours: a labelled list with a swatch per status. Each item and its swatch carry `data-status`, or `data-critical` for the critical path entry, so a stylesheet colours the swatch by attribute.
+ * @param props - The statuses to list and the classes to give its parts.
+ * @returns The legend.
+ */
+declare const Legend: (props: LegendProps) => ReactElement;
+//#endregion
+//#region ../../ui/graph/react/dist/filter-panel.d.ts
+/** The parts of a filter panel a class can be given to. */
+type FilterPanelPart = "root" | "group" | "legend" | "option" | "checkbox" | "clear";
+interface FilterPanelProps {
+  readonly filter: ElementFilter;
+  /** The actors and sources to offer, from `filterOptions`. A group with no options is not shown. */
+  readonly options: FilterOptions;
+  /** The statuses to offer. Defaults to every status. */
+  readonly statuses?: readonly Status[] | undefined;
+  readonly onToggleStatus: (status: Status) => void;
+  readonly onToggleActor: (actor: string) => void;
+  readonly onToggleSource: (source: string) => void;
+  readonly onClear: () => void;
+  readonly classNames?: Partial<Record<FilterPanelPart, string>> | undefined;
+}
+/**
+ * Checkboxes for filtering a view by status, actor and source, and a button that clears them. Each group is a `fieldset` carrying `data-filter` with `status`, `actor` or `source`.
+ * @param props - The current filter, what to offer, and the handlers that change it.
+ * @returns A search form.
+ */
+declare const FilterPanel: (props: FilterPanelProps) => ReactElement;
+//#endregion
+//#region ../../ui/graph/react/dist/detail-panel.d.ts
+/** The parts of a detail panel a class can be given to. */
+type DetailPanelPart = "root" | "heading" | "status" | "reason" | "section" | "sectionHeading" | "list";
+interface DetailPanelProps<I extends IdSpace> {
+  readonly element: Element<I["element"], I>;
+  /** Why the element has its status, from `useWhyStatus`. */
+  readonly explanation: StatusExplanation<I>;
+  /** The open work at the end of its blocked chain, from `useBlockedChain`. */
+  readonly blockers: readonly I["element"][];
+  /** The live work that depends on it, from `useImpact`. */
+  readonly impact: readonly I["element"][];
+  /** The display label of another element. */
+  readonly labelOf: (id: I["element"]) => string;
+  readonly classNames?: Partial<Record<DetailPanelPart, string>> | undefined;
+}
+/**
+ * The details of one element: its status, the rule that decided it, what it is blocked by and what depends on it. The root is a complementary region named by the element's label; each list is a section carrying `data-section` with `blocked-by` or `impact`, shown only when it is not empty.
+ * @param props - The element, its explanation, blockers and impact.
+ * @returns The panel.
+ */
+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 };

package/dist/index.d.ts

@@ -1,4 +1,111 @@
-export * from "@exadev/process-graph-schema";
-export * from "@exadev/process-graph-projection";
-export * from "@exadev/process-graph-domain";
-export * as dag from "@exadev/process-graph-dag";
+import { A as UnsupportedConditionError, C as CriticalPath, D as UnknownReference, E as NodeId, F as Status, I as statuses, M as elementStatusKey, N as evaluateBranches, O as buildDag, P as Branch, S as loopTransitions, T as Dag, _ 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 artefactKey, k as Facts, 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 } from "./index-CCfe0csl.js";
+import { A as Views, B as messageModes, C as Extensions, D as Point, E as Participant, F as OverlayStatus, G as IdSpace, H as overlayStatuses, I as ParticipantKind, K as OpenIds, L as PseudoRole, M as FragmentOperator, N as MessageMode, O as Projection, P as Notation, R as elementKinds, S as EventDef, T as FragmentOperand, U as participantKinds, V as notations, W as pseudoRoles, _ as ModelParts, a as Overlay, b as ArtefactDef, c as overlaySchema, d as Issue, f as IssueCode, g as Model, h as outputsOf, i as modelSchema, j as ElementKind, k as Transition, l as parseOverlay, m as inputsOf, n as ModelParseError, o as OverlayIssue, p as validate, r as parseModel, s as OverlayParseError, t as ModelIssue, u as validateOverlay, v as defineModel, w as Fragment, x as Element, y as ActionDef, z as fragmentOperators } from "./index-CmZOswkx.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-CoA6vXqe.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.
+ */
+declare class CycleError<Id extends NodeId> extends Error {
+  /**
+   * One closed path per strongly connected component that contains a cycle, exactly as `findCycles` reports them.
+   */
+  readonly cycles: readonly (readonly Id[])[];
+  /**
+   * @param cycles - The cycles found, as returned by `findCycles`. Must not be empty.
+   */
+  constructor(cycles: readonly (readonly Id[])[]);
+}
+/**
+ * Thrown when an operation is asked about an id that is not a node of the graph it was given.
+ */
+declare class UnknownNodeError<Id extends NodeId> extends Error {
+  /**
+   * The id that is not a node of the graph.
+   */
+  readonly id: Id;
+  /**
+   * @param id - The id that is not a node of the graph.
+   */
+  constructor(id: Id);
+}
+//#endregion
+//#region ../../core/graph/dag/dist/layers.d.ts
+/**
+ * The result of layering a graph by dependency depth.
+ */
+interface TopologicalLayers<Id extends NodeId> {
+  /** Each layered node's level: the length of the longest `needs` chain below it, so a node with no needs is 0 and every other node is one more than its highest-level need. */
+  readonly levels: ReadonlyMap<Id, number>;
+  /** Nodes grouped by level, index 0 first. Within a layer, nodes are in node order. Every node of a layer needs only nodes of earlier layers, and nothing in one layer needs anything in the same layer. */
+  readonly layers: readonly (readonly Id[])[];
+  /** The nodes that have no level because they lie on a cycle or transitively need a node that does, in node order. Empty exactly when the graph is acyclic. */
+  readonly unlayered: readonly Id[];
+}
+/**
+ * Layers the graph by the longest `needs` chain below each node, so everything in one layer can run once the earlier layers are done.
+ *
+ * Defined on the acyclic part of the graph: a node on a cycle, or one that needs such a node directly or transitively, has no finite chain length and is reported in `unlayered` rather than being given a level. Every other node is layered exactly as in an acyclic graph. Unknown references are not edges and contribute nothing to a level. Iterative (Kahn's algorithm), so depth cannot overflow the call stack.
+ */
+declare function topologicalLayers<Id extends NodeId>(dag: Dag<Id>): TopologicalLayers<Id>;
+//#endregion
+//#region ../../core/graph/dag/dist/reachability.d.ts
+/**
+ * Every node `id` depends on, directly or through other nodes: the transitive closure of `needs` from `id`, in node order.
+ *
+ * `id` itself is included exactly when it lies on a cycle, since it then depends on itself. Unknown references are not edges. Iterative, so depth cannot overflow the call stack.
+ * @throws UnknownNodeError when `id` is not a node of the graph.
+ */
+declare function ancestorsOf<Id extends NodeId>(dag: Dag<Id>, id: Id): readonly Id[];
+/**
+ * Every node that depends on `id`, directly or through other nodes: the transitive closure of the inverse of `needs` from `id`, in node order.
+ *
+ * `id` itself is included exactly when it lies on a cycle. Iterative, so depth cannot overflow the call stack.
+ * @throws UnknownNodeError when `id` is not a node of the graph.
+ */
+declare function descendantsOf<Id extends NodeId>(dag: Dag<Id>, id: Id): readonly Id[];
+//#endregion
+//#region ../../core/graph/dag/dist/cycles.d.ts
+/**
+ * Every strongly connected component of the graph: the maximal sets of nodes in which each node reaches every other along `needs` edges. Every node is in exactly one component, and a node on no cycle is a component of its own. Found by Tarjan's algorithm with an explicit stack, so depth is bounded by memory, not by the call stack, and each node and edge is visited once.
+ *
+ * A component lists its nodes in the order Tarjan's algorithm completes them, its root last. Components come out in reverse topological order of the condensed graph along `needs`: a component appears before every component that needs it. Since mutual reachability is symmetric, the components are the same whichever direction the edges are read in.
+ * @param dag - The graph to partition.
+ * @returns Every component, each a non-empty list of nodes.
+ */
+declare function stronglyConnectedComponents<Id extends NodeId>(dag: Dag<Id>): readonly (readonly Id[])[];
+/**
+ * Reports every cycle in the graph: exactly one closed path per strongly connected component that contains a cycle (more than one node, or a node that needs itself).
+ *
+ * A path lists nodes such that each needs the next and the last needs the first, which is repeated at the end: `[a, b, c, a]` means a needs b, b needs c and c needs a. A self-loop is `[a, a]`. The path is a shortest cycle through the component's first node in node order, ties going to the earliest needs. Paths are ordered by the position of their first node. A component can contain more cycles than the one reported; removing the reported cycle's edges and calling again finds the rest.
+ *
+ * Returns an empty array exactly when the graph is acyclic. Iterative, so a deep graph cannot overflow the call stack.
+ */
+declare function findCycles<Id extends NodeId>(dag: Dag<Id>): readonly (readonly Id[])[];
+//#endregion
+//#region ../../core/graph/dag/dist/dominators.d.ts
+/**
+ * The immediate dominator of every node reachable from `root` along `needs` edges. A node `d` dominates `n` when every path from `root` to `n` passes through `d`; the immediate dominator is the dominator closest to `n` other than `n` itself. Read with `needs` edges pointing from a step to the steps before it and `root` a virtual end every last step needs, this gives post-dominators: where every way forward from a step meets again.
+ *
+ * Found by the Lengauer-Tarjan algorithm with path compression, so the work is the number of reachable nodes and edges times a slowly growing factor, and every walk uses an explicit stack, so depth is bounded by memory, not the call stack. Cycles are allowed.
+ * @param dag - The graph to read.
+ * @param root - Where every path starts.
+ * @returns Each node reachable from `root` other than `root`, mapped to its immediate dominator, in the order a depth-first walk from `root` first reaches the nodes. A node `root` does not reach has no entry.
+ * @throws UnknownNodeError when `root` is not a node of `dag`.
+ */
+declare function immediateDominators<Id extends NodeId>(dag: Dag<Id>, root: Id): ReadonlyMap<Id, Id>;
+//#endregion
+//#region ../../core/graph/dag/dist/reduction.d.ts
+/**
+ * The transitive reduction: the same nodes with every redundant edge removed, so a node keeps a direct need only when no other need of it already depends on that node, transitively.
+ *
+ * Defined for acyclic graphs, where it is unique and has exactly the same ancestors and descendants as the input. Each node's remaining needs keep the order they had. Unknown references are carried over unchanged; they are not edges and take no part in reduction.
+ *
+ * Builds each node's full set of ancestors, so memory grows with the size of the transitive closure.
+ * @throws CycleError when the graph contains a cycle: with one the reduction is not unique, so nothing is guessed.
+ */
+declare function transitiveReduction<Id extends NodeId>(dag: Dag<Id>): Dag<Id>;
+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 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 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, evaluateBranches, explainStatus, fragmentOperators, handoffs, illegalCycles, impact, inputsOf, loopTransitions, messageModes, modelSchema, notations, outputsOf, overlaySchema, overlayStatuses, parseModel, parseOverlay, participantKinds, pseudoRoles, readySet, statusRules, statuses, toFlowchart, toSequence, toStateMachine, toSwimlane, unmetOutputs, validate, validateOverlay, whatIfDone };