process-graph 1.3.0 → 2.0.0

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-BPT8fmfa.js";
+import { a as parseOverlay, c as elementKinds, d as notations, f as overlayStatuses, i as overlaySchema, l as fragmentOperators, m as pseudoRoles, n as modelSchema, o as validateOverlay, p as participantKinds, r as OverlayParseError, t as boundActivitySchema, u as messageModes } from "./schema-CL95Lyni.js";
 import { t as validate } from "./validate-DF3mQZww.js";
-import { n as parseModel, t as ModelParseError } from "./parse-C1Q1zsGt.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-DcktInd7.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, boundActivitySchema, 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-BC4tmAuQ.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-B2p3mEJ3.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-D4CnOhNf.js";
-import { K as IdSpace, S as Element, _ as Model, k as Projection } from "./index-Dvz_I_uQ.js";
-import { A as Flowchart, E as Swimlane, x as StateMachine } from "./index-D06bcdfw.js";
-import { i as LayoutView, n as LayoutOptions, r as LayoutResult, s as Direction } from "./index-BC4tmAuQ.js";
-import { A as ElementFilter, rt as Run, y as NamedElement } from "./index-9Au8pAmP.js";
+import { B as Status } from "./index-wQnLXJmD.js";
+import { M as Projection, T as Element, Y as IdSpace, b as Model } from "./index-DYl6lZLe.js";
+import { N as Flowchart, k as Swimlane, w as StateMachine } from "./index-DluJZTbT.js";
+import { i as LayoutView, n as LayoutOptions, r as LayoutResult, s as Direction } from "./index-B2p3mEJ3.js";
+import { A as ElementFilter, et as Run, y as NamedElement } from "./index-C-ZNF81j.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.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-9Au8pAmP.js";
+import { a as ProjectedView, o as ViewsByNotation, s as project } from "./index-DluJZTbT.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-C-ZNF81j.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-Dk91O_9p.js → router-DzVcQ28U.js}

@@ -1,5 +1,5 @@
-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 { i as overlaySchema, n as modelSchema } from "./schema-CL95Lyni.js";
+import { A as modelSummarySchema, F as storeChangeSchema, I as storedFactsSchema, L as storedModelSchema, N as relationSchema, O as issueSchema, P as revisionSchema, S as boundItemsSchema, T as factClearingSchema, j as reachSchema, k as modelIdSchema, w as factChangeSchema, x as GraphStoreError } from "./store-CgweIG8J.js";
 import { z } from "zod";
 import { eventIterator, oc } from "@orpc/contract";
 import { implement } from "@orpc/server";

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

@@ -128,19 +128,21 @@ const artefactSchema = record({
 	name: z.string(),
 	deliverable: z.boolean().exactOptional()
 });
+/** The strict object schema of an `activity` element, before it is made read-only: the one definition both the model's activity and a bound activity are built from. */
+const activityObjectSchema = z.strictObject({
+	kind: z.literal("activity"),
+	id,
+	extensions: extensionsSchema.exactOptional(),
+	label: z.string(),
+	actor: actorRef.exactOptional(),
+	action: actionRef.exactOptional(),
+	source: z.string().exactOptional(),
+	affects: z.array(entityRef).readonly().exactOptional(),
+	consumes: z.array(artefactRef).readonly().exactOptional(),
+	produces: z.array(artefactRef).readonly().exactOptional()
+});
 const elementSchema = z.discriminatedUnion("kind", [
-	record({
-		kind: z.literal("activity"),
-		id,
-		extensions: extensionsSchema.exactOptional(),
-		label: z.string(),
-		actor: actorRef.exactOptional(),
-		action: actionRef.exactOptional(),
-		source: z.string().exactOptional(),
-		affects: z.array(entityRef).readonly().exactOptional(),
-		consumes: z.array(artefactRef).readonly().exactOptional(),
-		produces: z.array(artefactRef).readonly().exactOptional()
-	}),
+	activityObjectSchema.readonly(),
 	record({
 		kind: z.literal("decision"),
 		id,
@@ -230,5 +232,14 @@ const modelSchema = z.strictObject({
 	projections: z.array(projectionSchema).readonly(),
 	views: viewsSchema.exactOptional()
 }).readonly();
+/**
+* An activity bound to the external record it stands for: the model's `activity` element with `source` required, where the model leaves it optional, and equal to `id`. The source-qualified identifier (`github:org/repo#12`) is the element's identity, so the same record synced twice, or reached from two places, is the same element.
+*
+* This is the one definition of a bound activity: a source's sync page and a store's upserted items both use it, so what a source emits is exactly what a store accepts.
+*/
+const boundActivitySchema = activityObjectSchema.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();
 //#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 };
+export { parseOverlay as a, elementKinds as c, notations as d, overlayStatuses as f, overlaySchema as i, fragmentOperators as l, pseudoRoles as m, modelSchema as n, validateOverlay as o, participantKinds as p, OverlayParseError as r, toPointer as s, boundActivitySchema as t, messageModes as u };

package/dist/schema-DMXa8gAZ.js

@@ -0,0 +1,117 @@
+import { i as overlaySchema, n as modelSchema, t as boundActivitySchema } from "./schema-CL95Lyni.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 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 (graph-schema's `boundActivitySchema`), the participants they name, the transitions between them, their relations, their run state, and any gaps. A page is a partial view; `assembleSync` merges a whole sync into one model.
+*
+* `next` is the cursor to resume after this page. It is absent on the last page.
+*/
+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 { syncPageSchema as _, orderDirections as a, relationKinds as c, scopeEntrySchema as d, scopeListingSchema as f, syncInputSchema as g, syncFilterSchema as h, gapSchema as i, relationSchema as l, sourceDescriptionSchema as m, filterStates as n, orderFields as o, scopeRootsInputSchema as p, gapReasons as r, participantSchema as s, badRequestReasons as t, scopeChildrenInputSchema as u, transitionSchema as v };

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

@@ -1,4 +1,4 @@
-import { t as GitHubTokenPort } from "../../graphql-BE7xm5dB.js";
+import { t as GitHubTokenPort } from "../../graphql-CGWZ6USe.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-BE7xm5dB.js";
-import { a as GitHubIssuesSourceOptions, i as storedTokenPort, n as StoredTokenPortOptions, o as createGitHubIssuesSource, r as selectStoredToken, t as StoredGitHubToken } from "../index-hri2a13-.js";
+import { $ as transitionSchema, A as SourceDescription, B as orderDirections, C as Relation, D as ScopeListing, E as ScopeEntry, F as SyncPage, G as scopeChildrenInputSchema, H as participantSchema, I as badRequestReasons, J as scopeRootsInputSchema, K as scopeEntrySchema, L as filterStates, M as SourceTransition, N as SyncFilter, O as ScopeListingInput, P as SyncInput, Q as syncPageSchema, R as gapReasons, S as OrderField, T as ScopeChildrenInput, U as relationKinds, V as orderFields, W as relationSchema, X as syncFilterSchema, Y as sourceDescriptionSchema, Z as syncInputSchema, _ as BadRequestReason, a as assembleSync, b as GapReason, c as GraphSourceRouter, d as PageRequest, f as createGraphSourceRouter, g as graphSourceContract, h as GraphSourceClient, i as AssembledSync, j as SourceParticipant, k as ScopeRootsInput, l as GraphSourceScopes, m as GraphSourceFailure, n as FakePage, o as ChildrenRequest, p as GraphSourceError, q as scopeListingSchema, r as createFakeGraphSource, s as GraphSourcePager, t as FakeGraphSourceOptions, u as ListingRequest, v as FilterState, w as RelationKind, x as OrderDirection, y as Gap, z as gapSchema } from "../index-CotF9Lhh.js";
+import { n as GraphqlFetch, r as githubGraphqlEndpoint, t as GitHubTokenPort } from "../graphql-CGWZ6USe.js";
+import { a as GitHubIssuesSourceOptions, i as storedTokenPort, n as StoredTokenPortOptions, o as createGitHubIssuesSource, r as selectStoredToken, t as StoredGitHubToken } from "../index-CiaCmQDP.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.
@@ -46,4 +47,4 @@ export declare const repositoryId: (owner: string, name: string) => string;
 /** The identifier of an account participant, organisation or user: `github:@login`. The `@` keeps it apart from the `github:owner` scope syntax. */
 export declare const accountId: (login: string) => string;
 //#endregion
-export { type AssembledSync, type BadRequestReason, type BoundActivity, type ChildrenRequest, type FakeGraphSourceOptions, type FakePage, type FilterState, type Gap, type GapReason, type GitHubIssuesSourceOptions, type GitHubTokenPort, type GraphSourceClient, GraphSourceError, type GraphSourceFailure, type GraphSourcePager, type GraphSourceRouter, type GraphSourceScopes, type GraphqlFetch, type ListingRequest, type OrderDirection, type OrderField, type PageRequest, type Relation, type RelationKind, type Scope, type ScopeChildrenInput, type ScopeEntry, type ScopeListing, type ScopeListingInput, type ScopeRootsInput, type SourceDescription, type SourceParticipant, type SourceTransition, type StoredGitHubToken, type StoredTokenPortOptions, type SyncFilter, type SyncInput, type SyncPage, assembleSync, badRequestReasons, boundActivitySchema, createFakeGraphSource, createGitHubIssuesSource, createGraphSourceRouter, filterStates, gapReasons, gapSchema, githubGraphqlEndpoint, graphSourceContract, orderDirections, orderFields, participantSchema, relationKinds, relationSchema, scopeChildrenInputSchema, scopeEntrySchema, scopeListingSchema, scopeRootsInputSchema, selectStoredToken, sourceDescriptionSchema, storedTokenPort, syncFilterSchema, syncInputSchema, syncPageSchema, transitionSchema };
+export { type AssembledSync, type BadRequestReason, type ChildrenRequest, type FakeGraphSourceOptions, type FakePage, type FilterState, type Gap, type GapReason, type GitHubIssuesSourceOptions, type GitHubTokenPort, type GraphSourceClient, GraphSourceError, type GraphSourceFailure, type GraphSourcePager, type GraphSourceRouter, type GraphSourceScopes, type GraphqlFetch, type ListingRequest, type OrderDirection, type OrderField, type PageRequest, type Relation, type RelationKind, type Scope, type ScopeChildrenInput, type ScopeEntry, type ScopeListing, type ScopeListingInput, type ScopeRootsInput, type SourceDescription, type SourceParticipant, type SourceTransition, type StoredGitHubToken, type StoredTokenPortOptions, type SyncFilter, type SyncInput, type SyncPage, assembleSync, badRequestReasons, createFakeGraphSource, createGitHubIssuesSource, createGraphSourceRouter, filterStates, gapReasons, gapSchema, githubGraphqlEndpoint, graphSourceContract, orderDirections, orderFields, participantSchema, relationKinds, relationSchema, scopeChildrenInputSchema, scopeEntrySchema, scopeListingSchema, scopeRootsInputSchema, selectStoredToken, sourceDescriptionSchema, storedTokenPort, syncFilterSchema, syncInputSchema, syncPageSchema, transitionSchema };

package/dist/source/github.js

@@ -1,5 +1,42 @@
-import { A as syncPageSchema, C as scopeChildrenInputSchema, D as sourceDescriptionSchema, E as scopeRootsInputSchema, O as syncFilterSchema, S as relationSchema, T as scopeListingSchema, _ as gapSchema, a as ownerScopeId, b as participantSchema, c as githubGraphqlEndpoint, d as paginate, f as graphSourceContract, g as gapReasons, h as filterStates, i as issueId, j as transitionSchema, k as syncInputSchema, l as assembleSync, m as boundActivitySchema, n as accountId, o as parseScope, p as badRequestReasons, r as githubSource, s as repositoryId, t as createGitHubIssuesSource, u as createGraphSourceRouter, v as orderDirections, w as scopeEntrySchema, x as relationKinds, y as orderFields } from "../source-D51N7K3A.js";
+import { _ as syncPageSchema, a as orderDirections, c as relationKinds, d as scopeEntrySchema, f as scopeListingSchema, g as syncInputSchema, h as syncFilterSchema, i as gapSchema, l as relationSchema, m as sourceDescriptionSchema, n as filterStates, o as orderFields, p as scopeRootsInputSchema, r as gapReasons, s as participantSchema, t as badRequestReasons, u as scopeChildrenInputSchema, v as transitionSchema } from "../schema-DMXa8gAZ.js";
+import { a as ownerScopeId, c as githubGraphqlEndpoint, d as graphSourceContract, i as issueId, l as createGraphSourceRouter, n as accountId, o as parseScope, r as githubSource, s as repositoryId, t as createGitHubIssuesSource, u as paginate } from "../source-DM4fLS5P.js";
 import { t as GraphSourceError } from "../errors-BZe5WzCn.js";
+//#region ../../core/graph/source-contract/dist/assemble.js
+const relationKey = (relation) => JSON.stringify([
+	relation.kind,
+	relation.from,
+	relation.to
+]);
+/** Keeps one entry per key, in first-seen order, holding the latest value seen for it. */
+const latestById = (items, keyOf) => {
+	const byKey = /* @__PURE__ */ new Map();
+	for (const item of items) byKey.set(keyOf(item), item);
+	return [...byKey.values()];
+};
+/**
+* Merges the pages of a sync into one model. A record can appear on several pages, for example an issue in another repository reached through a dependency before its own repository is read; identity is the identifier, so it becomes one element, and where pages disagree the later page wins, being the more recent read.
+* @param pages - The pages of one sync, in the order they arrived.
+* @returns The model, overlay, relations and gaps of the whole sync.
+*/
+const assembleSync = (pages) => {
+	const overlay = Object.fromEntries(pages.flatMap((page) => Object.entries(page.overlay)));
+	return {
+		model: {
+			participants: latestById(pages.flatMap((page) => page.participants), (participant) => participant.id),
+			events: [],
+			actions: [],
+			artefacts: [],
+			elements: latestById(pages.flatMap((page) => page.activities), (activity) => activity.id),
+			transitions: latestById(pages.flatMap((page) => page.transitions), (transition) => transition.id),
+			fragments: [],
+			projections: []
+		},
+		overlay,
+		relations: latestById(pages.flatMap((page) => page.relations), relationKey),
+		gaps: pages.flatMap((page) => page.gaps)
+	};
+};
+//#endregion
 //#region ../../core/graph/source-contract/dist/fake.js
 const gapIndex = -1;
 const cursorPattern = /^(?<scope>[^@;]+)@(?<index>-1|0|[1-9]\d*)(?:;(?<filter>.+))?$/u;
@@ -198,4 +235,4 @@ const storedTokenPort = (options) => async (owner, signal) => {
 	return chosen.token;
 };
 //#endregion
-export { GraphSourceError, accountId, assembleSync, badRequestReasons, boundActivitySchema, createFakeGraphSource, createGitHubIssuesSource, createGraphSourceRouter, filterStates, gapReasons, gapSchema, githubGraphqlEndpoint, githubSource, graphSourceContract, issueId, orderDirections, orderFields, ownerScopeId, paginate, parseScope, participantSchema, relationKinds, relationSchema, repositoryId, scopeChildrenInputSchema, scopeEntrySchema, scopeListingSchema, scopeRootsInputSchema, selectStoredToken, sourceDescriptionSchema, storedTokenPort, syncFilterSchema, syncInputSchema, syncPageSchema, transitionSchema };
+export { GraphSourceError, accountId, assembleSync, badRequestReasons, createFakeGraphSource, createGitHubIssuesSource, createGraphSourceRouter, filterStates, gapReasons, gapSchema, githubGraphqlEndpoint, githubSource, graphSourceContract, issueId, orderDirections, orderFields, ownerScopeId, paginate, parseScope, participantSchema, relationKinds, relationSchema, repositoryId, scopeChildrenInputSchema, scopeEntrySchema, scopeListingSchema, scopeRootsInputSchema, selectStoredToken, sourceDescriptionSchema, storedTokenPort, syncFilterSchema, syncInputSchema, syncPageSchema, transitionSchema };

package/dist/{source-D51N7K3A.js → source-DM4fLS5P.js}

@@ -1,132 +1,9 @@
-import { r as overlaySchema, t as modelSchema } from "./schema-BPT8fmfa.js";
+import { _ as syncPageSchema, f as scopeListingSchema, g as syncInputSchema, h as syncFilterSchema, m as sourceDescriptionSchema, p as scopeRootsInputSchema, t as badRequestReasons, u as scopeChildrenInputSchema } from "./schema-DMXa8gAZ.js";
 import { t as GraphSourceError } from "./errors-BZe5WzCn.js";
 import { z } from "zod";
 import { eventIterator, oc } from "@orpc/contract";
 import { withEventMeta } from "@orpc/client";
 import { implement } from "@orpc/server";
-//#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$1 = ["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$1)
-	}).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
 //#region ../../core/graph/source-contract/dist/contract.js
 /**
 * The typed errors every procedure can end with, each carrying its detail as data. The codes are oRPC's common codes, so an HTTP transport answers with the matching status (401, 429, 400) without any per-transport mapping.
@@ -286,42 +163,6 @@ const createGraphSourceRouter = (pager) => os.router({ v1: {
 	}
 } });
 //#endregion
-//#region ../../core/graph/source-contract/dist/assemble.js
-const relationKey = (relation) => JSON.stringify([
-	relation.kind,
-	relation.from,
-	relation.to
-]);
-/** Keeps one entry per key, in first-seen order, holding the latest value seen for it. */
-const latestById = (items, keyOf) => {
-	const byKey = /* @__PURE__ */ new Map();
-	for (const item of items) byKey.set(keyOf(item), item);
-	return [...byKey.values()];
-};
-/**
-* Merges the pages of a sync into one model. A record can appear on several pages, for example an issue in another repository reached through a dependency before its own repository is read; identity is the identifier, so it becomes one element, and where pages disagree the later page wins, being the more recent read.
-* @param pages - The pages of one sync, in the order they arrived.
-* @returns The model, overlay, relations and gaps of the whole sync.
-*/
-const assembleSync = (pages) => {
-	const overlay = Object.fromEntries(pages.flatMap((page) => Object.entries(page.overlay)));
-	return {
-		model: {
-			participants: latestById(pages.flatMap((page) => page.participants), (participant) => participant.id),
-			events: [],
-			actions: [],
-			artefacts: [],
-			elements: latestById(pages.flatMap((page) => page.activities), (activity) => activity.id),
-			transitions: latestById(pages.flatMap((page) => page.transitions), (transition) => transition.id),
-			fragments: [],
-			projections: []
-		},
-		overlay,
-		relations: latestById(pages.flatMap((page) => page.relations), relationKey),
-		gaps: pages.flatMap((page) => page.gaps)
-	};
-};
-//#endregion
 //#region ../../adapters/graph/source-github-issues/dist/cursor.js
 /**
 * Where the next page of a sync starts. A position is plain data, so a cursor resumes in any process.
@@ -1333,4 +1174,4 @@ const createGitHubIssuesSource = (options) => {
 	};
 };
 //#endregion
-export { syncPageSchema as A, scopeChildrenInputSchema as C, sourceDescriptionSchema as D, scopeRootsInputSchema as E, syncFilterSchema as O, relationSchema as S, scopeListingSchema as T, gapSchema as _, ownerScopeId as a, participantSchema as b, githubGraphqlEndpoint as c, paginate as d, graphSourceContract as f, gapReasons as g, filterStates as h, issueId as i, transitionSchema as j, syncInputSchema as k, assembleSync as l, boundActivitySchema as m, accountId as n, parseScope as o, badRequestReasons as p, githubSource as r, repositoryId as s, createGitHubIssuesSource as t, createGraphSourceRouter as u, orderDirections$1 as v, scopeEntrySchema as w, relationKinds as x, orderFields as y };
+export { ownerScopeId as a, githubGraphqlEndpoint as c, graphSourceContract as d, issueId as i, createGraphSourceRouter as l, accountId as n, parseScope as o, githubSource as r, repositoryId as s, createGitHubIssuesSource as t, paginate as u };

package/dist/store/node.d.ts

@@ -1,4 +1,4 @@
-import { w as GraphStore } from "../index-CR8xUK3S.js";
+import { w as GraphStore } from "../index-KhygugOP.js";
 import { DatabaseSyncOptions } from "node:sqlite";
 import { NodeSQLiteDatabase } from "drizzle-orm/node-sqlite";
 //#region ../../adapters/graph/sqlite-node/dist/open.d.ts

package/dist/store/node.js

@@ -1,2 +1,2 @@
-import { i as openNodeGraphStore, n as privateDirectoryMode, r as privateFileMode, t as prepareDataFile } from "../data-file-BVMxkTug.js";
+import { i as openNodeGraphStore, n as privateDirectoryMode, r as privateFileMode, t as prepareDataFile } from "../data-file-B8__c10l.js";
 export { openNodeGraphStore, prepareDataFile, privateDirectoryMode, privateFileMode };

package/dist/store/wasm/worker.js

@@ -1,5 +1,5 @@
-import { I as storeChangeSchema, t as createSqliteGraphStore, y as ChangeFeed } from "../../store-DKzvLGgl.js";
-import { t as createGraphStoreRouter } from "../../router-Dk91O_9p.js";
+import { F as storeChangeSchema, t as createSqliteGraphStore, y as ChangeFeed } from "../../store-CgweIG8J.js";
+import { t as createGraphStoreRouter } from "../../router-DzVcQ28U.js";
 import sqlite3InitModule from "@sqlite.org/sqlite-wasm";
 import { RPCHandler } from "@orpc/server/message-port";
 import { drizzle } from "drizzle-orm/sqlite-proxy";

package/dist/store/wasm.d.ts

@@ -1,4 +1,4 @@
-import { ut as GraphStoreClient } from "../index-CR8xUK3S.js";
+import { ct as GraphStoreClient } from "../index-KhygugOP.js";
 //#region ../../adapters/graph/sqlite-wasm/dist/client.d.ts
 /**
  * A client for the graph store a worker serves with `serveGraphStoreInWorker`. Every procedure of the contract is available, with its abort signal and typed errors, as if the store were in the page.