process-graph 1.2.0 → 1.4.0

package/dist/index-DoMIav3D.d.ts

@@ -0,0 +1,118 @@
+import { P as SyncFilter, b as Gap, h as GraphSourceClient } from "./index-Cs1CWlEg.js";
+import { ut as GraphStoreClient } from "./index-CR8xUK3S.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-CmZOswkx.d.ts → index-Dvz_I_uQ.d.ts}

@@ -282,12 +282,8 @@ declare const validateOverlay: <I extends IdSpace>(model: Model<I>, overlay: Rea
 declare const parseOverlay: (input: unknown) => Overlay<OpenIds>;
 //#endregion
 //#region ../../core/graph/schema/dist/schema.d.ts
-/**
- * The open (runtime) shape of a model: identifiers are plain strings, so references are not checked here. `validate` checks what the shape cannot, and `parseModel` runs both.
- *
- * Every object is strict. The inferred type is exactly `Model<OpenIds>`, which a type-level test pins in both directions.
- */
-declare const modelSchema: z.ZodReadonly<z.ZodObject<{
+/** The strict object schema inside `modelSchema`, before it is made read-only. */
+declare const modelObjectSchema: z.ZodObject<{
   participants: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
     id: z.ZodString;
     label: z.ZodString;
@@ -476,7 +472,20 @@ declare const modelSchema: z.ZodReadonly<z.ZodObject<{
     x: z.ZodNumber;
     y: z.ZodNumber;
   }, z.core.$strict>>>>>>>;
-}, z.core.$strict>>;
+}, z.core.$strict>;
+/**
+ * The type of `modelSchema`, declared by name so that a declaration file that embeds the schema, such as a consumer's `z.object({ model: modelSchema })` under `declaration: true`, refers to `ModelSchema` rather than writing out the whole model schema with every record and trilean's JSON value inline, which can exceed the length the compiler will serialise (TS7056).
+ */
+interface ModelSchema extends z.ZodReadonly<typeof modelObjectSchema> {
+  /** The strict object schema inside, whose `shape` holds each record's own schema. */
+  readonly unwrap: () => typeof modelObjectSchema;
+}
+/**
+ * The open (runtime) shape of a model: identifiers are plain strings, so references are not checked here. `validate` checks what the shape cannot, and `parseModel` runs both.
+ *
+ * Every object is strict. The inferred type is exactly `Model<OpenIds>`, which a type-level test pins in both directions.
+ */
+declare const modelSchema: ModelSchema;
 //#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. */
@@ -509,4 +518,4 @@ declare class ModelParseError extends Error {
  */
 declare const parseModel: (input: unknown) => Model<OpenIds>;
 //#endregion
-export { Views as A, messageModes as B, Extensions as C, Point as D, Participant as E, OverlayStatus as F, IdSpace as G, overlayStatuses as H, ParticipantKind as I, OpenIds as K, PseudoRole as L, FragmentOperator as M, MessageMode as N, Projection as O, Notation as P, elementKinds as R, EventDef as S, FragmentOperand as T, participantKinds as U, notations as V, pseudoRoles as W, ModelParts as _, Overlay as a, ArtefactDef as b, overlaySchema as c, Issue as d, IssueCode as f, Model as g, outputsOf as h, modelSchema as i, ElementKind as j, Transition as k, parseOverlay as l, inputsOf as m, ModelParseError as n, OverlayIssue as o, validate as p, parseModel as r, OverlayParseError as s, ModelIssue as t, validateOverlay as u, defineModel as v, Fragment as w, Element as x, ActionDef as y, fragmentOperators as z };
+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 };

package/dist/{index-BUheRLdG.d.ts → index-LWdwpjZG.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-BH1aFqkJ.js";
-import { G as IdSpace, O as Projection, a as Overlay, g as Model, x as Element } from "./index-CmZOswkx.js";
-import { K as StoredModel, ut as GraphStoreClient } from "./index-DxWOY8f9.js";
-import { A as Flowchart, E as Swimlane, g as SequenceDiagram, x as StateMachine } from "./index-CoA6vXqe.js";
+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 ProjectedView } from "./index-4f4PVH7K.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-CrM5qWUA.d.ts → index-RwwlDYZ7.d.ts}

@@ -1,5 +1,5 @@
-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";
+import { K as IdSpace, j as Views } from "./index-Dvz_I_uQ.js";
+import { N as Flowchart, k as Swimlane, w as StateMachine } from "./index-4f4PVH7K.js";
 //#region ../../core/graph/layout/dist/engine.d.ts
 /** A box with a fixed size, which the engine places. */
 interface EngineLeaf {

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-BH1aFqkJ.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";
+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 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-4f4PVH7K.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-Bb90VKMc.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 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 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, 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 };

package/dist/index.js

@@ -1,9 +1,10 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { a as validateOverlay, c as fragmentOperators, d as overlayStatuses, f as participantKinds, i as parseOverlay, l as messageModes, n as OverlayParseError, p as pseudoRoles, r as overlaySchema, s as elementKinds, t as modelSchema, u as notations } from "./schema-CVnS6HiX.js";
+import { a as validateOverlay, c as fragmentOperators, d as overlayStatuses, f as participantKinds, i as parseOverlay, l as messageModes, n as OverlayParseError, p as pseudoRoles, r as overlaySchema, s as elementKinds, t as modelSchema, u as notations } from "./schema-BPT8fmfa.js";
 import { t as validate } from "./validate-DF3mQZww.js";
-import { n as parseModel, t as ModelParseError } from "./parse-CuipC_2K.js";
+import { a as stateMachineToDot, c as sequenceToMermaid, d as isUnsafeCharacter, f as terminalJson, h as parseModel, i as sequenceToDot, l as stateMachineToMermaid, m as ModelParseError, n as viewText, o as swimlaneToDot, p as terminalText, r as flowchartToDot, s as flowchartToMermaid, t as exportFormats, u as swimlaneToMermaid } from "./view-DTeNUhGG.js";
 import { _ as criticalPath$1, a as unmetOutputs, b as actorMap, c as deriveStatuses, d as stateMachineParts, f as toStateMachine, g as handoffs, h as toFlowchart, i as readySet, l as statusRules, m as flowchartParts, n as criticalPath, o as whatIfDone, p as toSwimlane, r as impact, s as explainStatus, t as blockedBy, u as toSequence, v as immediateDominators, y as topologicalLayers } from "./queries-C8kIDRiY.js";
 import { S as UnknownNodeError, _ as descendantsOf, a as artefactKey, b as lookup, c as evaluateBranches, f as layeredFacts, g as ancestorsOf, h as stronglyConnectedComponents, i as UnsupportedConditionError, l as factNamesIn, m as findCycles, n as illegalCycles, o as elementStatusKey, p as assertAcyclic, r as loopTransitions, s as emptyFactRecord, t as controlDag, u as factsFrom, v as assembleDag, x as CycleError, y as buildDag } from "./control-DiygoEhm.js";
+import { t as project } from "./project-CP_ye6KI.js";
 import { t as statuses } from "./status-Bm1CGu9C.js";
 //#region ../../core/graph/schema/dist/artefacts.js
 /**
@@ -926,4 +927,4 @@ const diffSequence = (model, scenario, edited) => {
 	};
 };
 //#endregion
-export { ModelParseError, OverlayParseError, UnconfirmedChangeError, UnsupportedConditionError, applyModelDiff, artefactKey, blockedBy, confirmChanges, controlDag, criticalPath, dist_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 };
+export { ModelParseError, OverlayParseError, UnconfirmedChangeError, UnsupportedConditionError, applyModelDiff, artefactKey, blockedBy, confirmChanges, controlDag, criticalPath, dist_exports as dag, defineModel, deriveStatuses, diffFlowchart, diffSequence, diffStateMachine, diffSwimlane, elementKinds, elementStatusKey, emptyFactRecord, evaluateBranches, explainStatus, exportFormats, factNamesIn, factsFrom, flowchartToDot, flowchartToMermaid, fragmentOperators, handoffs, illegalCycles, impact, inputsOf, isUnsafeCharacter, layeredFacts, loopTransitions, messageModes, modelSchema, notations, outputsOf, overlaySchema, overlayStatuses, parseModel, parseOverlay, participantKinds, project, pseudoRoles, readySet, sequenceToDot, sequenceToMermaid, stateMachineToDot, stateMachineToMermaid, statusRules, statuses, swimlaneToDot, swimlaneToMermaid, terminalJson, terminalText, toFlowchart, toSequence, toStateMachine, toSwimlane, unmetOutputs, validate, validateOverlay, viewText, whatIfDone };

package/dist/layout.d.ts

@@ -1,4 +1,4 @@
-import { a as layout, c as EngineBox, d as EngineGroup, f as EngineLeaf, i as LayoutView, l as EngineEdge, m as LayoutEngine, n as LayoutOptions, o as Size, p as EngineNode, r as LayoutResult, s as Direction, t as LaneBounds, u as EngineGraph } from "./index-CrM5qWUA.js";
+import { a as layout, c as EngineBox, d as EngineGroup, f as EngineLeaf, i as LayoutView, l as EngineEdge, m as LayoutEngine, n as LayoutOptions, o as Size, p as EngineNode, r as LayoutResult, s as Direction, t as LaneBounds, u as EngineGraph } from "./index-RwwlDYZ7.js";
 //#region ../../core/graph/layout/dist/elk-engine.d.ts
 /**
  * The default engine: elkjs's layered algorithm, run in the calling context from the bundled build so it needs neither a Worker nor Node-only modules. Groups are laid out together with their children (`INCLUDE_CHILDREN`), so an edge between lanes takes part in layer assignment.

package/dist/project-CP_ye6KI.js

@@ -0,0 +1,27 @@
+import { f as toStateMachine, h as toFlowchart, p as toSwimlane, u as toSequence } from "./queries-C8kIDRiY.js";
+//#region ../../core/graph/projection/dist/project.js
+/**
+* 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.
+*/
+const project = (model, projection) => {
+	if (projection.notation === "stateMachine") return {
+		notation: "stateMachine",
+		view: toStateMachine(model, projection.subject)
+	};
+	if (projection.notation === "sequence") return {
+		notation: "sequence",
+		view: toSequence(model, projection.scenario)
+	};
+	return projection.notation === "swimlane" ? {
+		notation: "swimlane",
+		view: toSwimlane(model)
+	} : {
+		notation: "flowchart",
+		view: toFlowchart(model)
+	};
+};
+//#endregion
+export { project as t };

package/dist/react-flow.d.ts

@@ -1,8 +1,8 @@
-import { B as Status } from "./index-BH1aFqkJ.js";
-import { G as IdSpace, O as Projection, g as Model, x as Element } from "./index-CmZOswkx.js";
-import { A as Flowchart, E as Swimlane, x as StateMachine } from "./index-CoA6vXqe.js";
-import { i as LayoutView, n as LayoutOptions, r as LayoutResult, s as Direction } from "./index-CrM5qWUA.js";
-import { A as ElementFilter, rt as Run, y as NamedElement } from "./index-BUheRLdG.js";
+import { B as Status } from "./index-D4CnOhNf.js";
+import { K as IdSpace, S as Element, _ as Model, k as Projection } from "./index-Dvz_I_uQ.js";
+import { N as Flowchart, k as Swimlane, w as StateMachine } from "./index-4f4PVH7K.js";
+import { i as LayoutView, n as LayoutOptions, r as LayoutResult, s as Direction } from "./index-RwwlDYZ7.js";
+import { A as ElementFilter, et as Run, y as NamedElement } from "./index-LWdwpjZG.js";
 import { ReactElement } from "react";
 import { ColorMode, Edge, EdgeProps, Node, NodeProps } from "@xyflow/react";
 //#region ../../ui/graph/react-flow/dist/use-layout.d.ts

package/dist/react-flow.js

@@ -2,7 +2,7 @@ import { f as toStateMachine, h as toFlowchart, p as toSwimlane, u as toSequence
 import { t as layout } from "./layout-CCM-KBdp.js";
 import { d as useBlockers, f as useCriticalPath, h as useStatuses, i as filterElements, r as emptyFilter, t as useGraphSelection } from "./selection-iet5RAlP.js";
 import { c as elementLabel } from "./detail-panel-B1ZmMuJT.js";
-import { a as Lane, n as ElementCard, s as SequenceDiagram } from "./dist-BpCBmnMl.js";
+import { a as Lane, n as ElementCard, s as SequenceDiagram } from "./dist-arkejVz2.js";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { jsx, jsxs } from "react/jsx-runtime";
 import { BaseEdge, Handle, MarkerType, Position, ReactFlow, getSmoothStepPath } from "@xyflow/react";

package/dist/react.d.ts

@@ -1,2 +1,3 @@
-import { $ as useWhyStatus, A as ElementFilter, B as useElementFilter, C as ruleDescriptions, D as SelectionContainerProps, E as GraphSelectionOptions, F as emptyFilter, G as BlockedChain, H as ViewsByNotation, I as filterElements, J as useBlockers, K as stepWeight, L as filterOptions, M as FilterOption, N as FilterOptions, O as SelectionItemProps, P as actorsOf, Q as useStatuses, R as matchesFilter, S as elementLabel, T as GraphSelection, U as project, V as ProjectedView, W as useProjection, X as useImpact, Y as useCriticalPath, Z as useReadySet, _ as ElementCardPart, a as FilterPanelPart, b as StatusBadge, c as LegendPart, d as LanePart, et as ModelClient, f as LaneProps, g as ElementCard, h as TransitionItemProps, i as FilterPanel, it as noFacts, j as ElementFilterState, k as useGraphSelection, l as LegendProps, m as TransitionItemPart, n as DetailPanelPart, nt as useModel, o as FilterPanelProps, p as TransitionItem, q as useBlockedChain, r as DetailPanelProps, rt as Run, s as Legend, t as DetailPanel, tt as ModelState, u as Lane, v as ElementCardProps, w as statusLabels, x as StatusBadgeProps, y as NamedElement, z as sourceScope } from "./index-BUheRLdG.js";
+import { a as ProjectedView, o as ViewsByNotation, s as project } from "./index-4f4PVH7K.js";
+import { $ as useModel, A as ElementFilter, B as useElementFilter, C as ruleDescriptions, D as SelectionContainerProps, E as GraphSelectionOptions, F as emptyFilter, G as useBlockers, H as BlockedChain, I as filterElements, J as useReadySet, K as useCriticalPath, L as filterOptions, M as FilterOption, N as FilterOptions, O as SelectionItemProps, P as actorsOf, Q as ModelState, R as matchesFilter, S as elementLabel, T as GraphSelection, U as stepWeight, V as useProjection, W as useBlockedChain, X as useWhyStatus, Y as useStatuses, Z as ModelClient, _ as ElementCardPart, a as FilterPanelPart, b as StatusBadge, c as LegendPart, d as LanePart, et as Run, f as LaneProps, g as ElementCard, h as TransitionItemProps, i as FilterPanel, j as ElementFilterState, k as useGraphSelection, l as LegendProps, m as TransitionItemPart, n as DetailPanelPart, o as FilterPanelProps, p as TransitionItem, q as useImpact, r as DetailPanelProps, s as Legend, t as DetailPanel, tt as noFacts, u as Lane, v as ElementCardProps, w as statusLabels, x as StatusBadgeProps, y as NamedElement, z as sourceScope } from "./index-LWdwpjZG.js";
 export { type BlockedChain, DetailPanel, type DetailPanelPart, type DetailPanelProps, ElementCard, type ElementCardPart, type ElementCardProps, type ElementFilter, type ElementFilterState, type FilterOption, type FilterOptions, FilterPanel, type FilterPanelPart, type FilterPanelProps, type GraphSelection, type GraphSelectionOptions, Lane, type LanePart, type LaneProps, Legend, type LegendPart, type LegendProps, type ModelClient, type ModelState, type NamedElement, type ProjectedView, type Run, type SelectionContainerProps, type SelectionItemProps, StatusBadge, type StatusBadgeProps, TransitionItem, type TransitionItemPart, type TransitionItemProps, type ViewsByNotation, actorsOf, elementLabel, emptyFilter, filterElements, filterOptions, matchesFilter, noFacts, project, ruleDescriptions, sourceScope, statusLabels, stepWeight, useBlockedChain, useBlockers, useCriticalPath, useElementFilter, useGraphSelection, useImpact, useModel, useProjection, useReadySet, useStatuses, useWhyStatus };

package/dist/react.js

@@ -1,4 +1,4 @@
-import { f as toStateMachine, h as toFlowchart, p as toSwimlane, u as toSequence } from "./queries-C8kIDRiY.js";
+import { t as project } from "./project-CP_ye6KI.js";
 import { a as filterOptions, c as useElementFilter, d as useBlockers, f as useCriticalPath, g as useWhyStatus, h as useStatuses, i as filterElements, l as stepWeight, m as useReadySet, n as actorsOf, o as matchesFilter, p as useImpact, r as emptyFilter, s as sourceScope, t as useGraphSelection, u as useBlockedChain } from "./selection-iet5RAlP.js";
 import { a as TransitionItem, c as elementLabel, i as Lane, l as ruleDescriptions, n as FilterPanel, o as ElementCard, r as Legend, s as StatusBadge, t as DetailPanel, u as statusLabels } from "./detail-panel-B1ZmMuJT.js";
 import { ORPCError } from "@orpc/client";
@@ -73,29 +73,6 @@ const useModel = (client, modelId) => {
 //#endregion
 //#region ../../ui/graph/react/dist/projection.js
 /**
-* 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.
-*/
-const project = (model, projection) => {
-	if (projection.notation === "stateMachine") return {
-		notation: "stateMachine",
-		view: toStateMachine(model, projection.subject)
-	};
-	if (projection.notation === "sequence") return {
-		notation: "sequence",
-		view: toSequence(model, projection.scenario)
-	};
-	return projection.notation === "swimlane" ? {
-		notation: "swimlane",
-		view: toSwimlane(model)
-	} : {
-		notation: "flowchart",
-		view: toFlowchart(model)
-	};
-};
-/**
 * 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`.

package/dist/{router-DvGGLnNt.js → router-Dk91O_9p.js}

@@ -1,5 +1,5 @@
-import { r as overlaySchema, t as modelSchema } from "./schema-CVnS6HiX.js";
-import { A as modelIdSchema, C as boundItemsSchema, E as factClearingSchema, F as revisionSchema, I as storeChangeSchema, L as storedFactsSchema, M as reachSchema, P as relationSchema, R as storedModelSchema, T as factChangeSchema, j as modelSummarySchema, k as issueSchema, x as GraphStoreError } from "./store-BJILV4JS.js";
+import { r as overlaySchema, t as modelSchema } from "./schema-BPT8fmfa.js";
+import { A as modelIdSchema, C as boundItemsSchema, E as factClearingSchema, F as revisionSchema, I as storeChangeSchema, L as storedFactsSchema, M as reachSchema, P as relationSchema, R as storedModelSchema, T as factChangeSchema, j as modelSummarySchema, k as issueSchema, x as GraphStoreError } from "./store-DKzvLGgl.js";
 import { z } from "zod";
 import { eventIterator, oc } from "@orpc/contract";
 import { implement } from "@orpc/server";

package/dist/{schema-CVnS6HiX.js → schema-BPT8fmfa.js}

@@ -219,7 +219,7 @@ const viewsSchema = z.partialRecord(z.enum(notations), z.partialRecord(z.string(
 *
 * Every object is strict. The inferred type is exactly `Model<OpenIds>`, which a type-level test pins in both directions.
 */
-const modelSchema = record({
+const modelSchema = z.strictObject({
 	participants: z.array(participantSchema).readonly(),
 	events: z.array(eventSchema).readonly(),
 	actions: z.array(actionSchema).readonly(),
@@ -229,6 +229,6 @@ const modelSchema = record({
 	fragments: z.array(fragmentSchema).readonly(),
 	projections: z.array(projectionSchema).readonly(),
 	views: viewsSchema.exactOptional()
-});
+}).readonly();
 //#endregion
 export { validateOverlay as a, fragmentOperators as c, overlayStatuses as d, participantKinds as f, parseOverlay as i, messageModes as l, OverlayParseError as n, toPointer as o, pseudoRoles as p, overlaySchema as r, elementKinds as s, modelSchema as t, notations as u };

package/dist/schema-DVAttrJg.js

@@ -0,0 +1,126 @@
+import { r as overlaySchema, t as modelSchema } from "./schema-BPT8fmfa.js";
+import { z } from "zod";
+//#region ../../core/graph/source-contract/dist/schema.js
+/**
+* The model's own record schemas, taken from `modelSchema` rather than restated, so a page of a sync is exactly a slice of a model and can never drift from it.
+*/
+const modelShape = modelSchema.unwrap().shape;
+/** A participant as the model declares it: an organisation, a repository, a person. */
+const participantSchema = modelShape.participants.unwrap().element;
+/** A transition as the model declares it. A source emits one per dependency, from the prerequisite to the work that waits on it. */
+const transitionSchema = modelShape.transitions.unwrap().element;
+/** The model's `activity` element: the first variant of its element union, pinned by a type test so a reordering of the union is a compile error. */
+const [activityElementSchema] = modelShape.elements.unwrap().element.options;
+/**
+* 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.
+*/
+const boundActivitySchema = activityElementSchema.unwrap().extend({ source: z.string().min(1) }).refine((activity) => activity.id === activity.source, {
+	message: "a bound activity's id must equal its source",
+	path: ["id"]
+}).readonly();
+/** The relation kinds a source reports beside the model's transitions. */
+const relationKinds = [
+	"child-of",
+	"assigned-to",
+	"part-of"
+];
+/**
+* A structural link between two identifiers that the model has no field for: `child-of` from a sub-task activity to its parent activity, `assigned-to` from an activity to a person participant, `part-of` from one participant to the participant that contains it (a repository to its organisation). Relations carry no ordering, so a consumer decides whether a parent waits on its children.
+*/
+const relationSchema = z.strictObject({
+	kind: z.enum(relationKinds),
+	from: z.string().min(1),
+	to: z.string().min(1)
+}).readonly();
+/** Why part of a requested scope is missing from a sync. */
+const gapReasons = ["not-found", "forbidden"];
+/**
+* A part of the requested scope that the source could not read, reported as data so the rest of the sync still arrives. `target` is the source-qualified identifier of what is missing: a scope, a record, or one of a record's connections.
+*/
+const gapSchema = z.strictObject({
+	target: z.string().min(1),
+	reason: z.enum(gapReasons),
+	message: z.string()
+}).readonly();
+/**
+* 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.
+*
+* `next` is the cursor to resume after this page. It is absent on the last page.
+*/
+const syncPageSchema = z.strictObject({
+	participants: z.array(participantSchema).readonly(),
+	activities: z.array(boundActivitySchema).readonly(),
+	transitions: z.array(transitionSchema).readonly(),
+	relations: z.array(relationSchema).readonly(),
+	overlay: overlaySchema,
+	gaps: z.array(gapSchema).readonly(),
+	next: z.string().min(1).exactOptional()
+}).readonly();
+/** The run states a sync filter can select by: whether the work is still open or done. */
+const filterStates = ["open", "done"];
+/** What a sync filter can order the listed records by: when they were created, when they last changed, or how much discussion they have. */
+const orderFields = [
+	"created",
+	"updated",
+	"comments"
+];
+/** Which way a sync filter orders the listed records. */
+const orderDirections = ["ascending", "descending"];
+/**
+* Narrows and orders the records each scope lists, applied on the source's side where the source supports it. Every field is optional, and an absent field does not narrow.
+*
+* - `states` keeps records whose run state is one of those given.
+* - `labels` keeps records carrying at least one of the labels given.
+* - `order` is the order the records are listed in; absent, the source's own stable order.
+*
+* A filter narrows what a scope lists, not what the listed records reach: a blocker of a listed record is read whatever its own state or labels, because it is a dependency of work the filter kept.
+*/
+const syncFilterSchema = z.strictObject({
+	states: z.array(z.enum(filterStates)).min(1).readonly().exactOptional(),
+	labels: z.array(z.string().min(1)).min(1).readonly().exactOptional(),
+	order: z.strictObject({
+		field: z.enum(orderFields),
+		direction: z.enum(orderDirections)
+	}).readonly().exactOptional()
+}).readonly();
+/**
+* What to sync and where to resume. `scope` names what to read as source-qualified scope identifiers (for GitHub, `github:org` for every repository an owner has, or `github:org/repo`), read in the order given. `after` is a cursor from an earlier page's `next`: the sync continues with the page that followed it. A cursor is valid only with the scope list and the filter it was issued for.
+*
+* `filter` narrows and orders what each scope lists (see `syncFilterSchema`).
+*/
+const syncInputSchema = z.strictObject({
+	scope: z.array(z.string().min(1)).min(1).readonly(),
+	after: z.string().min(1).exactOptional(),
+	filter: syncFilterSchema.exactOptional()
+}).readonly();
+/**
+* A scope a person can choose to sync, as a picker lists it. `scope` is the scope identifier to pass to `sync` (for GitHub, `github:org` for an organisation, `github:org/repo` for a repository), `label` its display name, `description` the source's own description when it has one, `url` where it lives in the source's own interface, and `archived` whether the source has archived it.
+*/
+const scopeEntrySchema = z.strictObject({
+	scope: z.string().min(1),
+	label: z.string(),
+	description: z.string().exactOptional(),
+	url: z.url().exactOptional(),
+	archived: z.boolean()
+}).readonly();
+/**
+* One page of a scope listing. `entries` are in the source's stable listing order, `gaps` name a parent the source could not read (it does not exist, or the credentials cannot see it), and `next` is the cursor to resume after this page, absent on the last.
+*/
+const scopeListingSchema = z.strictObject({
+	entries: z.array(scopeEntrySchema).readonly(),
+	gaps: z.array(gapSchema).readonly(),
+	next: z.string().min(1).exactOptional()
+}).readonly();
+/** Where a listing of the top-level scopes resumes: a cursor from an earlier page's `next`. */
+const scopeRootsInputSchema = z.strictObject({ after: z.string().min(1).exactOptional() }).readonly();
+/** The scope whose child scopes to list (for GitHub, the repositories of `github:owner`), and where to resume. A cursor is valid only for the parent it was issued for. */
+const scopeChildrenInputSchema = z.strictObject({
+	scope: z.string().min(1),
+	after: z.string().min(1).exactOptional()
+}).readonly();
+/** What a source says about itself. `source` is the prefix of every identifier it emits, before the colon. */
+const sourceDescriptionSchema = z.strictObject({ source: z.string().regex(/^[a-z][a-z0-9-]*$/u) }).readonly();
+/** Why a request was rejected as malformed. */
+const badRequestReasons = ["invalid-cursor", "invalid-scope"];
+//#endregion
+export { syncInputSchema as _, gapSchema as a, participantSchema as c, scopeChildrenInputSchema as d, scopeEntrySchema as f, syncFilterSchema as g, sourceDescriptionSchema as h, gapReasons as i, relationKinds as l, scopeRootsInputSchema as m, boundActivitySchema as n, orderDirections as o, scopeListingSchema as p, filterStates as r, orderFields as s, badRequestReasons as t, relationSchema as u, syncPageSchema as v, transitionSchema as y };

package/dist/source/github/node.d.ts

@@ -1,4 +1,4 @@
-import { t as GitHubTokenPort } from "../../graphql-C1j5wQFz.js";
+import { t as GitHubTokenPort } from "../../graphql-3DSUSUvL.js";
 //#region ../../adapters/graph/source-github-issues/dist/node.d.ts
 /** Where `githubTokenFromEnvironment` looks. Both are ports, so a test supplies its own. */
 export interface EnvironmentTokenOptions {

package/dist/source/github.d.ts

@@ -1,5 +1,6 @@
-import { $ as scopeRootsInputSchema, A as ScopeEntry, B as badRequestReasons, C as Gap, D as Relation, E as OrderField, F as SourceParticipant, G as orderDirections, H as filterStates, I as SourceTransition, J as relationKinds, K as orderFields, L as SyncFilter, M as ScopeListingInput, N as ScopeRootsInput, O as RelationKind, P as SourceDescription, Q as scopeListingSchema, R as SyncInput, S as FilterState, T as OrderDirection, U as gapReasons, V as boundActivitySchema, W as gapSchema, X as scopeChildrenInputSchema, Y as relationSchema, Z as scopeEntrySchema, _ as GraphSourceFailure, a as FakePage, b as BadRequestReason, c as assembleSync, d as GraphSourceRouter, et as sourceDescriptionSchema, f as GraphSourceScopes, g as GraphSourceError, h as createGraphSourceRouter, i as FakeGraphSourceOptions, it as transitionSchema, j as ScopeListing, k as ScopeChildrenInput, l as ChildrenRequest, m as PageRequest, n as GraphqlFetch, nt as syncInputSchema, o as createFakeGraphSource, p as ListingRequest, q as participantSchema, r as githubGraphqlEndpoint, rt as syncPageSchema, s as AssembledSync, t as GitHubTokenPort, tt as syncFilterSchema, u as GraphSourcePager, v as GraphSourceClient, w as GapReason, x as BoundActivity, y as graphSourceContract, z as SyncPage } from "../graphql-C1j5wQFz.js";
-import { a as GitHubIssuesSourceOptions, i as storedTokenPort, n as StoredTokenPortOptions, o as createGitHubIssuesSource, r as selectStoredToken, t as StoredGitHubToken } from "../index-CptUHq6F.js";
+import { $ as syncInputSchema, A as ScopeRootsInput, B as gapReasons, C as OrderField, D as ScopeEntry, E as ScopeChildrenInput, F as SyncInput, G as relationKinds, H as orderDirections, I as SyncPage, J as scopeEntrySchema, K as relationSchema, L as badRequestReasons, M as SourceParticipant, N as SourceTransition, O as ScopeListing, P as SyncFilter, Q as syncFilterSchema, R as boundActivitySchema, S as OrderDirection, T as RelationKind, U as orderFields, V as gapSchema, W as participantSchema, X as scopeRootsInputSchema, Y as scopeListingSchema, Z as sourceDescriptionSchema, _ as BadRequestReason, a as assembleSync, b as Gap, c as GraphSourceRouter, d as PageRequest, et as syncPageSchema, f as createGraphSourceRouter, g as graphSourceContract, h as GraphSourceClient, i as AssembledSync, j as SourceDescription, k as ScopeListingInput, l as GraphSourceScopes, m as GraphSourceFailure, n as FakePage, o as ChildrenRequest, p as GraphSourceError, q as scopeChildrenInputSchema, r as createFakeGraphSource, s as GraphSourcePager, t as FakeGraphSourceOptions, tt as transitionSchema, u as ListingRequest, v as BoundActivity, w as Relation, x as GapReason, y as FilterState, z as filterStates } from "../index-Cs1CWlEg.js";
+import { n as GraphqlFetch, r as githubGraphqlEndpoint, t as GitHubTokenPort } from "../graphql-3DSUSUvL.js";
+import { a as GitHubIssuesSourceOptions, i as storedTokenPort, n as StoredTokenPortOptions, o as createGitHubIssuesSource, r as selectStoredToken, t as StoredGitHubToken } from "../index-Cp5selgs.js";
 //#region ../../core/graph/source-contract/dist/paginate.d.ts
 /**
  * Pages through a cursor-linked sequence on demand: each `next()` reads one page, starting after `first`, and the sequence ends after the page whose `next` is absent. Nothing is read ahead of the consumer, so a consumer that stops early stops the reads.