process-graph 1.0.5 → 1.1.0

package/dist/selection-BW_xXWOy.js

@@ -0,0 +1,314 @@
+import { c as deriveStatuses, i as readySet, n as criticalPath, r as impact, s as explainStatus, t as blockedBy } from "./queries-CCexJAE2.js";
+import { useCallback, useMemo, useRef, useState } from "react";
+//#region ../../ui/graph/react/dist/analysis.js
+/**
+* The status of every element in a run, derived by `deriveStatuses`.
+* @param run - The model, overlay and facts.
+* @returns Each element's status, in model order.
+* @throws CycleError when the model has an illegal cycle, so an error boundary shows it.
+*/
+const useStatuses = (run) => {
+	const { model, overlay, facts } = run;
+	return useMemo(() => deriveStatuses(model, overlay, facts), [
+		model,
+		overlay,
+		facts
+	]);
+};
+/**
+* The work that can start now, by `readySet`.
+* @param run - The model, overlay and facts.
+* @returns The ready elements, in model order.
+*/
+const useReadySet = (run) => {
+	const { model, overlay, facts } = run;
+	return useMemo(() => readySet(model, overlay, facts), [
+		model,
+		overlay,
+		facts
+	]);
+};
+/**
+* Why an element has its status, by `explainStatus`.
+* @param run - The model, overlay and facts.
+* @param id - The element asked about, or `undefined` when nothing is.
+* @returns The explanation, or `undefined` when `id` is.
+* @throws UnknownNodeError when `id` is not an element of the model.
+*/
+const useWhyStatus = (run, id) => {
+	const { model, overlay, facts } = run;
+	return useMemo(() => id === void 0 ? void 0 : explainStatus(model, overlay, facts, id), [
+		model,
+		overlay,
+		facts,
+		id
+	]);
+};
+/**
+* The unfinished work holding an element back: the whole chain and the blockers at its end.
+* @param run - The model, overlay and facts.
+* @param id - The element asked about, or `undefined` when nothing is.
+* @returns The chain and its blockers; both empty when `id` is `undefined`.
+* @throws UnknownNodeError when `id` is not an element of the model.
+*/
+const useBlockedChain = (run, id) => {
+	const explanation = useWhyStatus(run, id);
+	return useMemo(() => {
+		if (explanation === void 0) return {
+			chain: [],
+			blockers: []
+		};
+		const [, ...behind] = explanation.chain;
+		return {
+			chain: explanation.chain,
+			blockers: behind.filter((link) => link.waitingOn.length === 0).map((link) => link.element)
+		};
+	}, [explanation]);
+};
+/**
+* What every blocked element is blocked by, by `blockedBy`, for a view that shows each element's blockers beside it.
+* @param run - The model, overlay and facts.
+* @returns The open work at the end of each blocked element's chain, keyed by the blocked element, in model order. Elements that are not blocked are absent.
+*/
+const useBlockers = (run) => {
+	const statuses = useStatuses(run);
+	const { model, overlay, facts } = run;
+	return useMemo(() => new Map([...statuses].filter(([, status]) => status === "blocked").map(([id]) => [id, blockedBy(model, overlay, facts, id)])), [
+		statuses,
+		model,
+		overlay,
+		facts
+	]);
+};
+/**
+* The live work that transitively depends on an element, by `impact`.
+* @param run - The model, overlay and facts.
+* @param id - The element asked about, or `undefined` when nothing is.
+* @returns The impacted elements; empty when `id` is `undefined`.
+* @throws UnknownNodeError when `id` is not an element of the model.
+*/
+const useImpact = (run, id) => {
+	const { model, overlay, facts } = run;
+	return useMemo(() => id === void 0 ? [] : impact(model, overlay, facts, id), [
+		model,
+		overlay,
+		facts,
+		id
+	]);
+};
+/**
+* Every element weighs one step, so the critical path is the longest chain of work still ahead.
+* @returns One.
+*/
+const stepWeight = () => 1;
+/**
+* The heaviest chain through the work still ahead, by `criticalPath`.
+* @param run - The model, overlay and facts.
+* @param weight - The cost of an element, finite and not negative. Keep it stable between renders. Defaults to `stepWeight`.
+* @returns The path in dependency order and its total weight; empty when nothing is live.
+* @throws RangeError when `weight` returns a negative or non-finite number.
+*/
+const useCriticalPath = (run, weight = stepWeight) => {
+	const { model, overlay, facts } = run;
+	return useMemo(() => criticalPath(model, overlay, facts, weight), [
+		model,
+		overlay,
+		facts,
+		weight
+	]);
+};
+//#endregion
+//#region ../../ui/graph/react/dist/filter.js
+/** The filter that shows every element. */
+const emptyFilter = {
+	statuses: /* @__PURE__ */ new Set(),
+	actors: /* @__PURE__ */ new Set(),
+	sources: /* @__PURE__ */ new Set()
+};
+/** The separator between a source-qualified identifier's collection and its item, as in `github:org/repo#12`. */
+const itemSeparator = "#";
+/**
+* The collection a source-qualified identifier belongs to: the identifier up to its item separator, so `github:org/repo#12` is in `github:org/repo`. An identifier with no item separator is its own collection.
+* @param source - A source-qualified identifier.
+* @returns The identifier's collection.
+*/
+const sourceScope = (source) => {
+	const at = source.lastIndexOf(itemSeparator);
+	return at === -1 ? source : source.slice(0, at);
+};
+/**
+* The actors an element's work belongs to: the actor of an activity or decision, and both ends of a message.
+* @param element - The element.
+* @returns Its actors' participant ids.
+*/
+const actorsOf = (element) => {
+	if (element.kind === "message") return [element.from, element.to];
+	return (element.kind === "activity" || element.kind === "decision") && element.actor !== void 0 ? [element.actor] : [];
+};
+const passes = (allowed, values) => allowed.size === 0 || values.some((value) => allowed.has(value));
+/**
+* Whether an element passes a filter.
+* @param element - The element.
+* @param status - The element's status in the run.
+* @param filter - The filter.
+* @returns True when the element is shown.
+*/
+const matchesFilter = (element, status, filter) => passes(filter.statuses, [status]) && passes(filter.actors, actorsOf(element)) && passes(filter.sources, element.kind === "activity" && element.source !== void 0 ? [sourceScope(element.source)] : []);
+/**
+* The elements a filter shows.
+* @param model - The model.
+* @param statuses - Each element's status, from `useStatuses`.
+* @param filter - The filter.
+* @returns The shown elements' ids, in model order.
+*/
+const filterElements = (model, statuses, filter) => model.elements.flatMap((element) => {
+	const status = statuses.get(element.id);
+	return status !== void 0 && matchesFilter(element, status, filter) ? [element.id] : [];
+});
+/**
+* The actors and sources a model's elements can be filtered by.
+* @param model - The model.
+* @returns The options, each labelled for display.
+*/
+const filterOptions = (model) => {
+	const acting = new Set(model.elements.flatMap(actorsOf));
+	const sources = new Set(model.elements.flatMap((element) => element.kind === "activity" && element.source !== void 0 ? [sourceScope(element.source)] : []));
+	return {
+		actors: model.participants.filter((participant) => acting.has(participant.id)).map((participant) => ({
+			value: participant.id,
+			label: participant.label
+		})),
+		sources: [...sources].map((source) => ({
+			value: source,
+			label: source
+		}))
+	};
+};
+const toggled = (set, value) => {
+	const next = new Set(set);
+	if (!next.delete(value)) next.add(value);
+	return next;
+};
+/**
+* Filter state for a view: which statuses, actors and sources to show.
+* @param initial - The filter to start with. Defaults to `emptyFilter`.
+* @returns The filter and its operations, each stable between renders.
+*/
+const useElementFilter = (initial = emptyFilter) => {
+	const [filter, setFilter] = useState(initial);
+	const toggleStatus = useCallback((status) => {
+		setFilter((current) => ({
+			...current,
+			statuses: toggled(current.statuses, status)
+		}));
+	}, []);
+	const toggleActor = useCallback((actor) => {
+		setFilter((current) => ({
+			...current,
+			actors: toggled(current.actors, actor)
+		}));
+	}, []);
+	const toggleSource = useCallback((source) => {
+		setFilter((current) => ({
+			...current,
+			sources: toggled(current.sources, source)
+		}));
+	}, []);
+	const clear = useCallback(() => {
+		setFilter(emptyFilter);
+	}, []);
+	return useMemo(() => ({
+		filter,
+		toggleStatus,
+		toggleActor,
+		toggleSource,
+		clear
+	}), [
+		filter,
+		toggleStatus,
+		toggleActor,
+		toggleSource,
+		clear
+	]);
+};
+//#endregion
+//#region ../../ui/graph/react/dist/selection.js
+/** What each navigation key does, given the items in order and the index of the selected one (-1 when none is). */
+const moves = {
+	ArrowDown: (count, at) => (at + 1) % count,
+	ArrowRight: (count, at) => (at + 1) % count,
+	ArrowUp: (count, at) => (at <= 0 ? count : at) - 1,
+	ArrowLeft: (count, at) => (at <= 0 ? count : at) - 1,
+	Home: () => 0,
+	End: (count) => count - 1,
+	Escape: () => void 0
+};
+/**
+* Selection state with keyboard navigation over the elements of a view, following the listbox pattern of the WAI-ARIA Authoring Practices: the arrow keys move the selection to the next or previous element in `order`, wrapping at either end; Home and End move to the first and last; Escape clears it. Only one item is a tab stop: the selected one, or the first when none is. A keyboard move also focuses the item it selects.
+* @param order - The navigable elements, in the order the keys move through them: the elements on show, after filtering.
+* @param options - The initial selection or the owner's selection, a listener for changes and how to focus an item.
+* @returns The selection, a setter, and the container and item props.
+*/
+const useGraphSelection = (order, options = {}) => {
+	const { initial, onChange, focus } = options;
+	const controlled = "selected" in options;
+	const [kept, setKept] = useState(initial);
+	const chosen = controlled ? options.selected : kept;
+	const items = useRef(/* @__PURE__ */ new Map());
+	const select = useCallback((id) => {
+		if (!controlled) setKept(id);
+		onChange?.(id);
+	}, [controlled, onChange]);
+	const selected = chosen !== void 0 && order.includes(chosen) ? chosen : void 0;
+	const stop = selected ?? order[0];
+	const onKeyDown = useCallback((event) => {
+		const move = moves[event.key];
+		if (move === void 0 || order.length === 0) return;
+		event.preventDefault();
+		const index = move(order.length, selected === void 0 ? -1 : order.indexOf(selected));
+		const next = index === void 0 ? void 0 : order[index];
+		select(next);
+		if (next === void 0) return;
+		if (focus === void 0) items.current.get(next)?.focus();
+		else focus(next);
+	}, [
+		order,
+		selected,
+		select,
+		focus
+	]);
+	const itemProps = useCallback((id) => ({
+		role: "option",
+		ref: (element) => {
+			if (element !== null) items.current.set(id, element);
+			return () => {
+				items.current.delete(id);
+			};
+		},
+		tabIndex: id === stop ? 0 : -1,
+		"aria-selected": id === selected,
+		onClick: () => {
+			select(id);
+		}
+	}), [
+		selected,
+		stop,
+		select
+	]);
+	return useMemo(() => ({
+		selected,
+		select,
+		containerProps: {
+			role: "listbox",
+			onKeyDown
+		},
+		itemProps
+	}), [
+		selected,
+		select,
+		onKeyDown,
+		itemProps
+	]);
+};
+//#endregion
+export { filterOptions as a, useElementFilter as c, useBlockers as d, useCriticalPath as f, useWhyStatus as g, useStatuses as h, filterElements as i, stepWeight as l, useReadySet as m, actorsOf as n, matchesFilter as o, useImpact as p, emptyFilter as r, sourceScope as s, useGraphSelection as t, useBlockedChain as u };

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

@@ -0,0 +1,16 @@
+import { t as GitHubTokenPort } from "../../graphql-C1j5wQFz.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 {
+  /** The environment to read `GITHUB_TOKEN` from; `process.env` when absent. */
+  readonly env?: Readonly<Record<string, string | undefined>>;
+  /** Runs `gh auth token`; the GitHub CLI when absent. */
+  readonly runGh?: () => Promise<string>;
+}
+/**
+ * A token port for Node that uses `GITHUB_TOKEN` when it is set and not empty, and otherwise the token the GitHub CLI holds (`gh auth token`), asked for once and reused. The same token serves every owner. The token is never logged, and an error from the CLI is reported without its output.
+ * @param options - The environment and the CLI runner, for tests.
+ * @returns The token port.
+ */
+export declare const githubTokenFromEnvironment: (options?: EnvironmentTokenOptions) => GitHubTokenPort;
+//#endregion

package/dist/source/github/node.js

@@ -0,0 +1,2 @@
+import { t as githubTokenFromEnvironment } from "../../node-AchI1T-K.js";
+export { githubTokenFromEnvironment };

package/dist/source/github.d.ts

@@ -0,0 +1,49 @@
+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";
+//#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.
+ * @param first - The cursor to start after, or `undefined` for the first page.
+ * @param read - Reads the page after a cursor.
+ * @returns The pages, in order.
+ */
+export declare const paginate: <Page extends {
+  readonly next?: string;
+}>(first: string | undefined, read: (after: string | undefined) => Promise<Page>) => AsyncIterable<Page>;
+//#endregion
+//#region ../../adapters/graph/source-github-issues/dist/identifiers.d.ts
+/** The prefix of every identifier this adapter emits and every scope it accepts. */
+export declare const githubSource = "github";
+/** What one scope identifier selects. */
+type Scope = {
+  readonly kind: "owner";
+  readonly id: string;
+  readonly owner: string;
+} | {
+  readonly kind: "repository";
+  readonly id: string;
+  readonly owner: string;
+  readonly name: string;
+} | {
+  readonly kind: "project";
+  readonly id: string;
+  readonly owner: string;
+  readonly number: number;
+};
+/**
+ * Parses a scope identifier: `github:owner` selects every repository the account owns, `github:owner/repo` one repository, and `github:owner/projects/number` the issues on an organisation's or user's Projects v2 board. A repository name cannot hold a slash, so the three forms never overlap.
+ * @param id - The scope identifier.
+ * @returns The parsed scope.
+ * @throws GraphSourceError with `bad-request` and `invalid-scope` when it is none of the forms.
+ */
+export declare const parseScope: (id: string) => Scope;
+/** The scope identifier of an owner: `github:owner`. */
+export declare const ownerScopeId: (login: string) => string;
+/** The identifier of an issue: `github:owner/repo#number`, which is also its element identifier. */
+export declare const issueId: (owner: string, name: string, number: number) => string;
+/** The identifier of a repository participant: `github:owner/repo`. */
+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 };

package/dist/source/github.js

@@ -0,0 +1,201 @@
+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-DRDpEA8Q.js";
+import { t as GraphSourceError } from "../errors-BZe5WzCn.js";
+//#region ../../core/graph/source-contract/dist/fake.js
+const gapIndex = -1;
+const cursorPattern = /^(?<scope>[^@;]+)@(?<index>-1|0|[1-9]\d*)(?:;(?<filter>.+))?$/u;
+/** A filter as one string with its fields in a fixed order, so the same filter always gives the same cursor and two filters compare by value. */
+const filterKey = (filter) => filter === void 0 ? void 0 : encodeURIComponent(JSON.stringify([
+	filter.states ?? null,
+	filter.labels ?? null,
+	filter.order === void 0 ? null : [filter.order.field, filter.order.direction]
+]));
+const encodeCursor = (position, filter) => `${encodeURIComponent(position.scope)}@${String(position.index)}${filter === void 0 ? "" : `;${filter}`}`;
+/**
+* Applies a filter to a page as though the source had listed only the activities it keeps: an activity is kept when its run state is one of `states` and it carries one of `labels`. The fake's activities carry no labels, so a filter naming labels keeps none. What a dropped activity was part of (transitions, relations, run state) is dropped with it. `order` does not change the fake's fixed page order.
+*/
+const filtered = (page, filter) => {
+	if (filter === void 0) return page;
+	const { states, labels } = filter;
+	const kept = new Set(page.activities.filter((activity) => {
+		const state = page.overlay[activity.id];
+		return (states === void 0 || state !== void 0 && states.some((wanted) => wanted === state)) && labels === void 0;
+	}).map((activity) => activity.id));
+	const dropped = new Set(page.activities.map((activity) => activity.id).filter((id) => !kept.has(id)));
+	return {
+		...page,
+		activities: page.activities.filter((activity) => kept.has(activity.id)),
+		transitions: page.transitions.filter((transition) => !dropped.has(transition.source) && !dropped.has(transition.target)),
+		relations: page.relations.filter((relation) => !dropped.has(relation.from) && !dropped.has(relation.to)),
+		overlay: Object.fromEntries(Object.entries(page.overlay).filter(([id]) => !dropped.has(id)))
+	};
+};
+/** The cursor of a listing page: which listing (`roots`, or the encoded parent scope, which always holds an encoded colon) and the offset of the next entry. */
+const listingCursorPattern = /^(?<listing>[^@]+)@(?<offset>[1-9]\d*)$/u;
+const rootsListing = "roots";
+const samePosition = (a, b) => a.scope === b.scope && a.index === b.index;
+/**
+* The reference in-memory `GraphSourcePager`: a fixed set of pages per scope, served in scope order. A scope that is well formed but unknown yields one page holding a `not-found` gap, so a sync over several scopes still returns the rest. Cursors encode the scope identifier, page index and filter, so they are stable, resume in any instance built from the same pages, and are refused under a different filter. A filter is applied to each page as described at `filtered`.
+*
+* Its scope listing serves `roots` and `children` from the options, `listingPageSize` entries a page.
+* @param options - The source prefix and the pages of each scope.
+* @returns A pager for `createGraphSourceRouter`.
+*/
+const createFakeGraphSource = (options) => {
+	const { source, scopes } = options;
+	const prefix = `${source}:`;
+	const positionsOf = (scope) => [...new Set(scope)].flatMap((id) => {
+		if (!id.startsWith(prefix) || id.length === prefix.length) throw new GraphSourceError({
+			kind: "bad-request",
+			message: `"${id}" is not a ${source} scope identifier`,
+			reason: "invalid-scope",
+			value: id
+		});
+		const pages = scopes[id];
+		if (pages === void 0) return [{
+			scope: id,
+			index: gapIndex
+		}];
+		return pages.length === 0 ? [{
+			scope: id,
+			index: 0
+		}] : pages.map((_, index) => ({
+			scope: id,
+			index
+		}));
+	});
+	const startOf = (positions, cursor, filter) => {
+		if (cursor === void 0) return 0;
+		const groups = cursorPattern.exec(cursor)?.groups;
+		const after = groups?.scope === void 0 || groups.index === void 0 || groups.filter !== filter ? void 0 : {
+			scope: decodeURIComponent(groups.scope),
+			index: Number(groups.index)
+		};
+		const found = after === void 0 ? -1 : positions.findIndex((position) => samePosition(position, after));
+		if (found === -1 || found === positions.length - 1) throw new GraphSourceError({
+			kind: "bad-request",
+			message: `"${cursor}" is not a cursor for this scope`,
+			reason: "invalid-cursor",
+			value: cursor
+		});
+		return found + 1;
+	};
+	const pageAt = (position) => {
+		const page = scopes[position.scope]?.[position.index];
+		if (page !== void 0) return page;
+		return {
+			participants: [],
+			activities: [],
+			transitions: [],
+			relations: [],
+			overlay: {},
+			gaps: position.index === gapIndex ? [{
+				target: position.scope,
+				reason: "not-found",
+				message: `${position.scope} does not exist`
+			}] : []
+		};
+	};
+	const read = ({ scope, cursor, signal, filter }) => {
+		signal?.throwIfAborted();
+		const key = filterKey(filter);
+		const positions = positionsOf(scope);
+		const start = startOf(positions, cursor, key);
+		const position = positions[start];
+		if (position === void 0) throw new Error("unreachable: startOf returns an index within the positions");
+		const page = filtered(pageAt(position), filter);
+		return start === positions.length - 1 ? page : {
+			...page,
+			next: encodeCursor(position, key)
+		};
+	};
+	const listingPageSize = options.listingPageSize;
+	if (listingPageSize !== void 0 && (!Number.isInteger(listingPageSize) || listingPageSize < 1)) throw new RangeError(`listingPageSize must be a positive integer, not ${String(listingPageSize)}`);
+	const roots = options.roots ?? [];
+	const children = options.children ?? {};
+	/** One page of `entries` from the cursor's offset, after checking the cursor belongs to `listing`. */
+	const listingPage = (listing, entries, { cursor, signal }) => {
+		signal?.throwIfAborted();
+		const size = listingPageSize ?? Math.max(entries.length, 1);
+		const groups = cursor === void 0 ? void 0 : listingCursorPattern.exec(cursor)?.groups;
+		const offset = cursor === void 0 ? 0 : groups?.listing === listing && groups.offset !== void 0 ? Number(groups.offset) : void 0;
+		if (offset === void 0 || offset % size !== 0 || offset > 0 && offset >= entries.length) throw new GraphSourceError({
+			kind: "bad-request",
+			message: `"${String(cursor)}" is not a cursor for this listing`,
+			reason: "invalid-cursor",
+			value: String(cursor)
+		});
+		const end = offset + size;
+		const page = {
+			entries: entries.slice(offset, end),
+			gaps: []
+		};
+		return end < entries.length ? {
+			...page,
+			next: `${listing}@${String(end)}`
+		} : page;
+	};
+	return {
+		source,
+		page: async (request) => Promise.resolve(read(request)),
+		scopes: {
+			roots: async (request) => Promise.resolve(request).then(() => listingPage(rootsListing, roots, request)),
+			children: async (request) => Promise.resolve(request).then(() => {
+				const { scope } = request;
+				if (!scope.startsWith(prefix) || scope.length === prefix.length) throw new GraphSourceError({
+					kind: "bad-request",
+					message: `"${scope}" is not a ${source} scope identifier`,
+					reason: "invalid-scope",
+					value: scope
+				});
+				if (!(Object.hasOwn(children, scope) || Object.hasOwn(scopes, scope) || roots.some((entry) => entry.scope === scope)) && request.cursor === void 0) {
+					request.signal?.throwIfAborted();
+					return {
+						entries: [],
+						gaps: [{
+							target: scope,
+							reason: "not-found",
+							message: `${scope} does not exist`
+						}]
+					};
+				}
+				return listingPage(encodeURIComponent(scope), children[scope] ?? [], request);
+			})
+		}
+	};
+};
+//#endregion
+//#region ../../adapters/graph/source-github-issues/dist/tokens.js
+/** Orders tokens most recently used first, a token never used last. ISO 8601 instants in UTC order as text. */
+const byRecency = (left, right) => (right.lastUsedAt ?? "").localeCompare(left.lastUsedAt ?? "");
+/**
+* Picks the stored token for a request about one owner. A token scoped to that owner wins over one scoped to any owner; among owner-scoped tokens the one naming the fewest owners wins, being the most specific, then the most recently used; among tokens for any owner the most recently used wins. A request about the token's own holder (`owner` undefined) can only use a token for any owner. Logins match without regard to case, as GitHub's do.
+* @param tokens - The stored tokens.
+* @param owner - The login the request is about, or `undefined` for the token's own holder.
+* @returns The token to use, or `undefined` when none fits.
+*/
+const selectStoredToken = (tokens, owner) => {
+	const login = owner?.toLowerCase();
+	const [best] = tokens.flatMap((candidate) => candidate.owners !== "any" && login !== void 0 && candidate.owners.some((named) => named.toLowerCase() === login) ? [{
+		candidate,
+		breadth: candidate.owners.length
+	}] : []).sort((left, right) => left.breadth - right.breadth || byRecency(left.candidate, right.candidate));
+	if (best !== void 0) return best.candidate;
+	return tokens.filter((candidate) => candidate.owners === "any").sort(byRecency).at(0);
+};
+/**
+* A token port over tokens a host keeps, choosing one per request with `selectStoredToken`.
+* @param options - How to read the stored tokens, and how to report one being used.
+* @returns The token port.
+* @throws GraphSourceError with `unauthorised`, from the port, when no stored token fits the owner; the message names the owner and never a token.
+*/
+const storedTokenPort = (options) => async (owner, signal) => {
+	const chosen = selectStoredToken(await options.list(signal), owner);
+	if (chosen === void 0) throw new GraphSourceError({
+		kind: "unauthorised",
+		message: owner === void 0 ? "no stored GitHub token serves any owner, which a request about the token's holder needs" : `no stored GitHub token is for ${owner} or for any owner`
+	});
+	options.used?.(chosen);
+	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 };