process-graph 1.0.5 → 1.1.0

package/dist/source-DRDpEA8Q.js

@@ -0,0 +1,1316 @@
+import { r as overlaySchema, t as modelSchema } from "./schema-CVnS6HiX.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.
+*/
+const graphSourceErrors = {
+	UNAUTHORIZED: {
+		message: "The source rejected the credentials.",
+		data: z.strictObject({})
+	},
+	TOO_MANY_REQUESTS: {
+		message: "The source is rate limiting requests.",
+		data: z.strictObject({ resetAt: z.iso.datetime().optional() })
+	},
+	BAD_REQUEST: {
+		message: "The cursor or a scope identifier is not valid for this source.",
+		data: z.strictObject({
+			reason: z.enum(badRequestReasons),
+			value: z.string()
+		})
+	}
+};
+/**
+* The scope listings' errors: every procedure's, and `NOT_IMPLEMENTED` for a source that offers no listing, which oRPC's common code answers with HTTP 501 over HTTP.
+*/
+const scopeListingErrors = {
+	...graphSourceErrors,
+	NOT_IMPLEMENTED: {
+		message: "The source does not list its scopes.",
+		data: z.strictObject({})
+	}
+};
+/** The event iterator of pages `sync.stream` returns, typed by name so declarations stay small. */
+const syncPageEvents = eventIterator(syncPageSchema);
+/** The `GraphSource` port: an oRPC router contract, keyed by version. */
+const graphSourceContract = { v1: oc.errors(graphSourceErrors).router({
+	describe: oc.output(sourceDescriptionSchema),
+	sync: {
+		page: oc.input(syncInputSchema).output(syncPageSchema),
+		stream: oc.input(syncInputSchema).output(syncPageEvents)
+	},
+	scopes: {
+		roots: oc.errors(scopeListingErrors).input(scopeRootsInputSchema).output(scopeListingSchema),
+		children: oc.errors(scopeListingErrors).input(scopeChildrenInputSchema).output(scopeListingSchema)
+	}
+}) };
+//#endregion
+//#region ../../core/graph/source-contract/dist/paginate.js
+/**
+* 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.
+*/
+const paginate = (first, read) => ({ [Symbol.asyncIterator]: () => {
+	let after = first;
+	let finished = false;
+	return { next: async () => {
+		if (finished) return {
+			done: true,
+			value: void 0
+		};
+		return read(after).then((page) => {
+			after = page.next;
+			finished = after === void 0;
+			return {
+				done: false,
+				value: page
+			};
+		});
+	} };
+} });
+//#endregion
+//#region ../../core/graph/source-contract/dist/router.js
+const os = implement(graphSourceContract);
+/** Rethrows a pager's `GraphSourceError` as the contract's typed oRPC error; anything else propagates unchanged. */
+const toContractError = (error, errors) => {
+	if (!(error instanceof GraphSourceError)) return error;
+	const { failure } = error;
+	if (failure.kind === "unauthorised") return errors.UNAUTHORIZED({
+		message: failure.message,
+		data: {},
+		cause: error
+	});
+	if (failure.kind === "rate-limited") return errors.TOO_MANY_REQUESTS({
+		message: failure.message,
+		data: failure.resetAt === void 0 ? {} : { resetAt: failure.resetAt },
+		cause: error
+	});
+	return errors.BAD_REQUEST({
+		message: failure.message,
+		data: {
+			reason: failure.reason,
+			value: failure.value
+		},
+		cause: error
+	});
+};
+/** Runs one call into the pager after checking the signal, as the contract's typed error when it fails. */
+const guarded = async (signal, errors, read) => {
+	signal?.throwIfAborted();
+	try {
+		return await read();
+	} catch (error) {
+		throw toContractError(error, errors);
+	}
+};
+/** Reads one page from the pager, as the contract's typed error when it fails. */
+const readPage = async (pager, request, errors) => guarded(request.signal, errors, async () => pager.page(request));
+/** The pager's scope listing, or the contract's `NOT_IMPLEMENTED` when it has none. */
+const listingOf = (pager, errors) => {
+	if (pager.scopes === void 0) throw errors.NOT_IMPLEMENTED({
+		message: `The ${pager.source} source does not list its scopes.`,
+		data: {}
+	});
+	return pager.scopes;
+};
+/**
+* Builds the `GraphSource` router over a pager. Serve it over any oRPC transport, or call it in process with `createRouterClient`.
+* @param pager - The adapter's page reader.
+* @returns The implemented router for `graphSourceContract`.
+*/
+const createGraphSourceRouter = (pager) => os.router({ v1: {
+	describe: os.v1.describe.handler(() => ({ source: pager.source })),
+	sync: {
+		page: os.v1.sync.page.handler(async ({ input, signal, errors }) => readPage(pager, {
+			scope: input.scope,
+			cursor: input.after,
+			signal,
+			filter: input.filter
+		}, errors)),
+		stream: os.v1.sync.stream.handler(async function* ({ input, signal, lastEventId, errors }) {
+			const pages = paginate(input.after ?? lastEventId, async (cursor) => readPage(pager, {
+				scope: input.scope,
+				cursor,
+				signal,
+				filter: input.filter
+			}, errors));
+			for await (const page of pages) yield page.next === void 0 ? page : withEventMeta(page, { id: page.next });
+		})
+	},
+	scopes: {
+		roots: os.v1.scopes.roots.handler(async ({ input, signal, errors }) => {
+			const listing = listingOf(pager, errors);
+			return guarded(signal, errors, async () => listing.roots({
+				cursor: input.after,
+				signal
+			}));
+		}),
+		children: os.v1.scopes.children.handler(async ({ input, signal, errors }) => {
+			const listing = listingOf(pager, errors);
+			return guarded(signal, errors, async () => listing.children({
+				scope: input.scope,
+				cursor: input.after,
+				signal
+			}));
+		})
+	}
+} });
+//#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.
+*
+* - `scope` is the scope identifier being read; a cursor is valid only for a request whose scope list contains it.
+* - For an owner scope, `repositories` is the `after` cursor GitHub gave for the page of the owner's repositories that holds the current one (`null` for the first), and `repository` is its index within that page. Repositories are listed by name, so the same listing page returns the same repositories while the owner is unchanged.
+* - `issues` is the `after` cursor for the next page of the current repository's issues (`null` for the first). Issues are listed by creation time unless a filter orders them otherwise, so new issues append and never shift a position.
+* - For a project scope, `items` is the `after` cursor for the next page of the board's items (`null` for the first).
+*/
+const repositoryPositionSchema = z.strictObject({
+	scope: z.string(),
+	issues: z.string().nullable()
+});
+const ownerPositionSchema = z.strictObject({
+	scope: z.string(),
+	repositories: z.string().nullable(),
+	repository: z.int().nonnegative(),
+	issues: z.string().nullable()
+});
+const projectPositionSchema = z.strictObject({
+	scope: z.string(),
+	items: z.string().nullable()
+});
+const positionSchema = z.union([
+	repositoryPositionSchema,
+	ownerPositionSchema,
+	projectPositionSchema
+]);
+/**
+* The start of a scope.
+* @param scope - The scope.
+* @returns The scope with the position of its first page.
+*/
+const startOf = (scope) => {
+	if (scope.kind === "owner") return {
+		kind: "owner",
+		scope,
+		position: {
+			scope: scope.id,
+			repositories: null,
+			repository: 0,
+			issues: null
+		}
+	};
+	if (scope.kind === "project") return {
+		kind: "project",
+		scope,
+		position: {
+			scope: scope.id,
+			items: null
+		}
+	};
+	return {
+		kind: "repository",
+		scope,
+		position: {
+			scope: scope.id,
+			issues: null
+		}
+	};
+};
+/** The version tag inside every cursor, so a cursor from a later format is rejected rather than misread. */
+const cursorFormat = 1;
+/** A sync cursor: where the next page starts, and the filter it was issued under, absent for none. */
+const envelopeSchema = z.strictObject({
+	format: z.literal(cursorFormat),
+	position: positionSchema,
+	filter: syncFilterSchema.optional()
+});
+/** A listing cursor: the parent scope whose children it pages (`null` for the top-level listing), and GitHub's cursor to read on after. */
+const listingEnvelopeSchema = z.strictObject({
+	format: z.literal(cursorFormat),
+	parent: z.string().nullable(),
+	after: z.string()
+});
+/** A filter's fields in a fixed order, so two filters compare by value whatever order their fields were written in. */
+const filterKey = (filter) => JSON.stringify(filter === void 0 ? null : [
+	filter.states ?? null,
+	filter.labels ?? null,
+	filter.order === void 0 ? null : [filter.order.field, filter.order.direction]
+]);
+/** Base64 of a small JSON envelope, which is printable and free of the line breaks an event-stream id must not contain. */
+const encodeEnvelope = (envelope) => btoa(JSON.stringify(envelope));
+/**
+* Encodes a position as an opaque cursor, together with the filter the sync runs under.
+* @param position - Where the next page starts.
+* @param filter - The sync's filter, or `undefined` for none.
+* @returns The cursor.
+*/
+const encodeCursor = (position, filter) => encodeEnvelope({
+	format: cursorFormat,
+	position,
+	...filter === void 0 ? {} : { filter }
+});
+const invalidCursor = (cursor, message) => new GraphSourceError({
+	kind: "bad-request",
+	message: `"${cursor}" is not a cursor this source issued: ${message}`,
+	reason: "invalid-cursor",
+	value: cursor
+});
+/** Parses JSON from a decoded cursor, reporting malformed text as an invalid cursor. */
+const parseJson = (cursor, text) => {
+	try {
+		return JSON.parse(text);
+	} catch (error) {
+		throw invalidCursor(cursor, error instanceof Error ? error.message : "not JSON");
+	}
+};
+/** Decodes base64, reporting text outside the base64 alphabet as an invalid cursor. */
+const decodeBase64 = (cursor) => {
+	try {
+		return atob(cursor);
+	} catch {
+		throw invalidCursor(cursor, "not base64");
+	}
+};
+/**
+* Decodes a cursor this adapter issued.
+* @param cursor - The cursor from an earlier page's `next`.
+* @param scopes - The scopes of the request it is used with.
+* @param filter - The filter of the request it is used with.
+* @returns The position it encodes, with its scope.
+* @throws GraphSourceError with `bad-request` and `invalid-cursor` when it is not a cursor this adapter issued, was issued under another filter, names a scope the request does not contain, or has the shape of another kind of scope.
+*/
+const decodeCursor = (cursor, scopes, filter) => {
+	const envelope = envelopeSchema.safeParse(parseJson(cursor, decodeBase64(cursor)));
+	if (!envelope.success) throw invalidCursor(cursor, envelope.error.message);
+	if (filterKey(envelope.data.filter) !== filterKey(filter)) throw invalidCursor(cursor, "it was issued under a different filter from the request's");
+	const { position } = envelope.data;
+	const scope = scopes.find((candidate) => candidate.id === position.scope);
+	if (scope === void 0) throw invalidCursor(cursor, `it is for scope ${position.scope}, which the request does not contain`);
+	if (scope.kind === "owner" && "repositories" in position) return {
+		kind: "owner",
+		scope,
+		position
+	};
+	if (scope.kind === "repository" && "issues" in position && !("repositories" in position)) return {
+		kind: "repository",
+		scope,
+		position
+	};
+	if (scope.kind === "project" && "items" in position) return {
+		kind: "project",
+		scope,
+		position
+	};
+	throw invalidCursor(cursor, `it does not fit the ${scope.kind} scope ${scope.id}`);
+};
+/**
+* Encodes where a scope listing resumes.
+* @param parent - The parent scope whose children are listed, or `null` for the top-level listing.
+* @param after - GitHub's cursor to read on after.
+* @returns The cursor.
+*/
+const encodeListingCursor = (parent, after) => encodeEnvelope({
+	format: cursorFormat,
+	parent,
+	after
+});
+/**
+* Decodes a listing cursor this adapter issued.
+* @param cursor - The cursor from an earlier listing page's `next`.
+* @param parent - The parent of the request it is used with, or `null` for the top-level listing.
+* @returns GitHub's cursor to read on after.
+* @throws GraphSourceError with `bad-request` and `invalid-cursor` when it is not a listing cursor this adapter issued, or was issued for another listing.
+*/
+const decodeListingCursor = (cursor, parent) => {
+	const envelope = listingEnvelopeSchema.safeParse(parseJson(cursor, decodeBase64(cursor)));
+	if (!envelope.success) throw invalidCursor(cursor, envelope.error.message);
+	if (envelope.data.parent !== parent) throw invalidCursor(cursor, `it is for the listing of ${envelope.data.parent ?? "the top-level scopes"}`);
+	return envelope.data.after;
+};
+//#endregion
+//#region ../../adapters/graph/source-github-issues/dist/graphql.js
+/** GitHub's GraphQL endpoint. */
+const githubGraphqlEndpoint = "https://api.github.com/graphql";
+const millisecondsPerSecond = 1e3;
+/** GraphQL error types that mean part of the data is absent rather than that the request failed. */
+const problemReasons = {
+	NOT_FOUND: "not-found",
+	FORBIDDEN: "forbidden"
+};
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** The `errors` entries of a GraphQL response body, each with its `type` when GitHub gave one. */
+const errorsOf = (body) => {
+	if (!isRecord(body) || !Array.isArray(body.errors)) return [];
+	return body.errors.filter(isRecord).map((entry) => ({
+		type: typeof entry.type === "string" ? entry.type : void 0,
+		message: typeof entry.message === "string" ? entry.message : "no message given"
+	}));
+};
+/** The `message` of a REST-style error body, which GitHub sends for HTTP-level refusals. */
+const messageOf = (body) => isRecord(body) && typeof body.message === "string" ? body.message : void 0;
+/**
+* When GitHub says its limit resets: `x-ratelimit-reset` (epoch seconds) for the primary limit, `retry-after` (seconds from now) for a secondary limit. `undefined` when it gives neither.
+*/
+const resetAtOf = (headers, now) => {
+	const reset = headers.get("x-ratelimit-reset");
+	if (reset !== null && /^\d+$/u.test(reset)) return (/* @__PURE__ */ new Date(Number(reset) * millisecondsPerSecond)).toISOString();
+	const retryAfter = headers.get("retry-after");
+	if (retryAfter !== null && /^\d+$/u.test(retryAfter)) return new Date(now + Number(retryAfter) * millisecondsPerSecond).toISOString();
+};
+/**
+* Whether a response is GitHub refusing for rate limiting: HTTP 429; HTTP 403 with no requests remaining or naming a secondary rate limit; or a `RATE_LIMITED` GraphQL error, which GitHub sends with HTTP 200.
+*/
+const isRateLimited = (response, body, errors) => {
+	const tooManyRequests = 429;
+	const forbidden = 403;
+	if (response.status === tooManyRequests) return true;
+	if (errors.some((error) => error.type === "RATE_LIMITED")) return true;
+	const message = messageOf(body);
+	return response.status === forbidden && (response.headers.get("x-ratelimit-remaining") === "0" || message !== void 0 && /secondary rate limit/iu.test(message));
+};
+/** Reads a response body as JSON, failing loudly when it is not. */
+const readJson = async (response) => {
+	const text = await response.text();
+	try {
+		return JSON.parse(text);
+	} catch {
+		throw new Error(`GitHub answered HTTP ${String(response.status)} with a body that is not JSON`);
+	}
+};
+/**
+* Sends one GraphQL request and classifies the answer.
+* @param transport - The token, fetch and clock ports.
+* @param request - The document, its variables, the owner whose token to use and the schema for `data`.
+* @param signal - The caller's abort signal, passed to `fetch`.
+* @returns The parsed data and any `NOT_FOUND` or `FORBIDDEN` problems beside it.
+* @throws GraphSourceError with `unauthorised` for HTTP 401, and `rate-limited` (with the reset instant when GitHub gives one) for any form of rate limiting.
+* @throws Error for any other failure: an HTTP error, another GraphQL error type, or data that does not match the schema.
+*/
+const graphql = async (transport, request, signal) => {
+	const token = await transport.token(request.owner, signal);
+	const response = await transport.fetch(githubGraphqlEndpoint, {
+		method: "POST",
+		headers: {
+			authorization: `Bearer ${token}`,
+			"content-type": "application/json"
+		},
+		body: JSON.stringify({
+			query: request.query,
+			variables: request.variables
+		}),
+		signal: signal ?? null
+	});
+	const body = await readJson(response);
+	const errors = errorsOf(body);
+	if (response.status === 401) throw new GraphSourceError({
+		kind: "unauthorised",
+		message: `GitHub rejected the token${request.owner === void 0 ? "" : ` for ${request.owner}`}: ${messageOf(body) ?? "HTTP 401"}`
+	});
+	if (isRateLimited(response, body, errors)) {
+		const resetAt = resetAtOf(response.headers, transport.now());
+		throw new GraphSourceError({
+			kind: "rate-limited",
+			message: resetAt === void 0 ? "GitHub is rate limiting requests" : `GitHub is rate limiting requests until ${resetAt}`,
+			resetAt
+		});
+	}
+	if (!response.ok) throw new Error(`GitHub answered HTTP ${String(response.status)}: ${messageOf(body) ?? "no message given"}`);
+	const problems = errors.map((error) => {
+		const reason = error.type === void 0 ? void 0 : problemReasons[error.type];
+		if (reason === void 0) throw new Error(`GitHub GraphQL error${error.type === void 0 ? "" : ` ${error.type}`}: ${error.message}`);
+		return {
+			reason,
+			message: error.message
+		};
+	});
+	const data = request.schema.safeParse(isRecord(body) ? body.data : void 0);
+	if (!data.success) throw new Error(`GitHub's response does not have the expected shape: ${data.error.message}`);
+	return {
+		data: data.data,
+		problems
+	};
+};
+//#endregion
+//#region ../../adapters/graph/source-github-issues/dist/identifiers.js
+/** The prefix of every identifier this adapter emits and every scope it accepts. */
+const githubSource = "github";
+const prefix = `${githubSource}:`;
+/**
+* A GitHub login or repository name as GitHub allows them: letters, digits, hyphens, underscores and dots. Anything else cannot name an account or repository, so a scope containing it is malformed rather than missing.
+*/
+const namePattern = /^[\w.-]+$/u;
+/** A Projects v2 board's number as its URL shows it: a positive integer with no leading zero. */
+const numberPattern = /^[1-9]\d*$/u;
+/** The path segment between an owner and a board's number in a project scope, as in the board's own URL. */
+const projectsSegment = "projects";
+const invalidScope = (id) => new GraphSourceError({
+	kind: "bad-request",
+	message: `"${id}" is not a GitHub scope; expected github:owner, github:owner/repo or github:owner/projects/number`,
+	reason: "invalid-scope",
+	value: id
+});
+/**
+* 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.
+*/
+const parseScope = (id) => {
+	const [owner, name, number, ...rest] = id.startsWith(prefix) ? id.slice(prefix.length).split("/") : [];
+	if (owner === void 0 || !namePattern.test(owner) || rest.length > 0) throw invalidScope(id);
+	if (name === void 0) return {
+		kind: "owner",
+		id,
+		owner
+	};
+	if (number === void 0 && namePattern.test(name)) return {
+		kind: "repository",
+		id,
+		owner,
+		name
+	};
+	if (name === projectsSegment && number !== void 0 && numberPattern.test(number)) return {
+		kind: "project",
+		id,
+		owner,
+		number: Number(number)
+	};
+	throw invalidScope(id);
+};
+/** The scope identifier of an owner: `github:owner`. */
+const ownerScopeId = (login) => `${prefix}${login}`;
+/** The identifier of an issue: `github:owner/repo#number`, which is also its element identifier. */
+const issueId = (owner, name, number) => `${prefix}${owner}/${name}#${String(number)}`;
+/** The identifier of a repository participant: `github:owner/repo`. */
+const repositoryId = (owner, name) => `${prefix}${owner}/${name}`;
+/** The identifier of an account participant, organisation or user: `github:@login`. The `@` keeps it apart from the `github:owner` scope syntax. */
+const accountId = (login) => `${prefix}@${login}`;
+//#endregion
+//#region ../../adapters/graph/source-github-issues/dist/page-builder.js
+/**
+* Starts an empty page.
+* @returns A builder whose `build` returns the page.
+*/
+const createPageBuilder = () => {
+	const participants = /* @__PURE__ */ new Map();
+	const activities = /* @__PURE__ */ new Map();
+	const transitions = /* @__PURE__ */ new Map();
+	const relations = /* @__PURE__ */ new Map();
+	const overlay = /* @__PURE__ */ new Map();
+	const gaps = [];
+	const relate = (relation) => {
+		relations.set(JSON.stringify([
+			relation.kind,
+			relation.from,
+			relation.to
+		]), relation);
+	};
+	const account = (owner) => {
+		const id = accountId(owner.login);
+		participants.set(id, {
+			id,
+			label: owner.login,
+			kind: owner.__typename === "Organization" ? "system" : "role"
+		});
+		return id;
+	};
+	const repository = (owner, name) => {
+		const ownerParticipant = account(owner);
+		const id = repositoryId(owner.login, name);
+		participants.set(id, {
+			id,
+			label: `${owner.login}/${name}`,
+			kind: "system"
+		});
+		relate({
+			kind: "part-of",
+			from: id,
+			to: ownerParticipant
+		});
+		return id;
+	};
+	/** The transition from a prerequisite to the work that waits on it, identified by both ends so either side's read gives the same one. */
+	const depend = (source, target) => {
+		const id = `${source}->${target}`;
+		transitions.set(id, {
+			id,
+			source,
+			target
+		});
+	};
+	const issue = (ref) => {
+		const { owner, name } = ref.repository;
+		const actor = repository(owner, name);
+		const id = issueId(owner.login, name, ref.number);
+		activities.set(id, {
+			kind: "activity",
+			id,
+			source: id,
+			label: ref.title,
+			actor
+		});
+		overlay.set(id, ref.state === "OPEN" ? "open" : "done");
+		return id;
+	};
+	return {
+		account,
+		repository,
+		issue,
+		assignee: (issueIdentifier, user) => {
+			const id = accountId(user.login);
+			participants.set(id, {
+				id,
+				label: user.login,
+				kind: "role"
+			});
+			relate({
+				kind: "assigned-to",
+				from: issueIdentifier,
+				to: id
+			});
+		},
+		blockedBy: (issueIdentifier, blocker) => {
+			depend(issue(blocker), issueIdentifier);
+		},
+		blocking: (issueIdentifier, blocked) => {
+			depend(issueIdentifier, issue(blocked));
+		},
+		subIssue: (parent, child) => {
+			relate({
+				kind: "child-of",
+				from: issue(child),
+				to: parent
+			});
+		},
+		gap: (gap) => {
+			gaps.push(gap);
+		},
+		build: (next) => {
+			const page = {
+				participants: [...participants.values()],
+				activities: [...activities.values()],
+				transitions: [...transitions.values()],
+				relations: [...relations.values()],
+				overlay: Object.fromEntries(overlay),
+				gaps: [...gaps]
+			};
+			return next === void 0 ? page : {
+				...page,
+				next
+			};
+		}
+	};
+};
+//#endregion
+//#region ../../adapters/graph/source-github-issues/dist/queries.js
+const pageInfoSchema = z.object({
+	hasNextPage: z.boolean(),
+	endCursor: z.string().nullable()
+});
+const accountSchema = z.object({
+	__typename: z.enum(["Organization", "User"]),
+	login: z.string()
+});
+const repositoryRefSchema = z.object({
+	name: z.string(),
+	owner: accountSchema
+});
+/** An issue reached from another one: a blocker or a sub-issue, possibly in another repository or organisation. */
+const issueRefSchema = z.object({
+	number: z.int(),
+	title: z.string(),
+	state: z.enum(["OPEN", "CLOSED"]),
+	repository: repositoryRefSchema
+});
+const connectionOf = (node) => z.object({
+	pageInfo: pageInfoSchema,
+	nodes: z.array(node.nullable())
+});
+const userSchema = z.object({ login: z.string() });
+const issueSchema = issueRefSchema.extend({
+	assignees: connectionOf(userSchema),
+	blockedBy: connectionOf(issueRefSchema),
+	blocking: connectionOf(issueRefSchema),
+	subIssues: connectionOf(issueRefSchema)
+});
+const accountFields = "__typename login";
+const issueRefFields = `number title state repository { name owner { ${accountFields} } }`;
+const pageInfoFields = "pageInfo { hasNextPage endCursor }";
+/** An issue with the first page of each of its connections: assignees, the issues blocking it, the issues it blocks, and its sub-issues. */
+const issueFields = `${issueRefFields}
+        assignees(first: $first) { ${pageInfoFields} nodes { login } }
+        blockedBy(first: $first) { ${pageInfoFields} nodes { ${issueRefFields} } }
+        blocking(first: $first) { ${pageInfoFields} nodes { ${issueRefFields} } }
+        subIssues(first: $first) { ${pageInfoFields} nodes { ${issueRefFields} } }`;
+/** A page of one repository's issues, in the states, labels and order the variables give, each with the first page of its connections. */
+const repositoryIssuesQuery = `query RepositoryIssues($owner: String!, $name: String!, $first: Int!, $after: String, $states: [IssueState!]!, $labels: [String!], $orderBy: IssueOrder!) {
+  repository(owner: $owner, name: $name) {
+    name
+    owner { ${accountFields} }
+    issues(first: $first, after: $after, states: $states, labels: $labels, orderBy: $orderBy) {
+      ${pageInfoFields}
+      nodes {
+        ${issueFields}
+      }
+    }
+  }
+}`;
+const repositoryIssuesSchema = z.object({ repository: z.object({
+	name: z.string(),
+	owner: accountSchema,
+	issues: connectionOf(issueSchema)
+}).nullable() });
+/** A page of the repositories an account owns, by name, with what a scope picker shows of each. A sync reads the names; a scope listing reads the rest too, so both share one request. */
+const ownerRepositoriesQuery = `query OwnerRepositories($login: String!, $first: Int!, $after: String) {
+  repositoryOwner(login: $login) {
+    ${accountFields}
+    repositories(first: $first, after: $after, ownerAffiliations: [OWNER], orderBy: { field: NAME, direction: ASC }) {
+      ${pageInfoFields}
+      nodes { name description url isArchived }
+    }
+  }
+}`;
+const repositoryEntrySchema = z.object({
+	name: z.string(),
+	description: z.string().nullable(),
+	url: z.url(),
+	isArchived: z.boolean()
+});
+const ownerRepositoriesSchema = z.object({ repositoryOwner: z.object({
+	__typename: z.enum(["Organization", "User"]),
+	login: z.string(),
+	repositories: connectionOf(repositoryEntrySchema)
+}).nullable() });
+/** The viewer's own account and a page of the organisations it belongs to, as a scope picker shows them. */
+const viewerScopesQuery = `query ViewerScopes($first: Int!, $after: String) {
+  viewer {
+    login
+    name
+    url
+    organizations(first: $first, after: $after) {
+      ${pageInfoFields}
+      nodes { login name description url archivedAt }
+    }
+  }
+}`;
+const organisationEntrySchema = z.object({
+	login: z.string(),
+	name: z.string().nullable(),
+	description: z.string().nullable(),
+	url: z.url(),
+	archivedAt: z.string().nullable()
+});
+const viewerScopesSchema = z.object({ viewer: z.object({
+	login: z.string(),
+	name: z.string().nullable(),
+	url: z.url(),
+	organizations: connectionOf(organisationEntrySchema)
+}) });
+/** A page of a Projects v2 board's items, each issue with the first page of its connections. Other kinds of item (pull requests, draft issues) are named only by type, since they are not issues. */
+const projectItemsQuery = `query ProjectItems($login: String!, $number: Int!, $first: Int!, $after: String) {
+  repositoryOwner(login: $login) {
+    ${accountFields}
+    ... on ProjectV2Owner {
+      projectV2(number: $number) {
+        items(first: $first, after: $after) {
+          ${pageInfoFields}
+          nodes {
+            content {
+              __typename
+              ... on Issue {
+                ${issueFields}
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}`;
+/** An item's content: an issue, or another kind of item named only by its type. */
+const itemContentSchema = z.union([issueSchema.extend({ __typename: z.literal("Issue") }), z.object({ __typename: z.enum(["PullRequest", "DraftIssue"]) })]);
+const projectItemsSchema = z.object({ repositoryOwner: z.object({
+	__typename: z.enum(["Organization", "User"]),
+	login: z.string(),
+	projectV2: z.object({ items: connectionOf(z.object({ content: itemContentSchema.nullable() })) }).nullable()
+}).nullable() });
+/** The rest of one issue connection after `after`. */
+const issueConnectionQuery = (connection) => {
+	return `query IssueConnection($owner: String!, $name: String!, $number: Int!, $first: Int!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    issue(number: $number) {
+      ${connection}(first: $first, after: $after) { ${pageInfoFields} nodes { ${connection === "assignees" ? "login" : issueRefFields} } }
+    }
+  }
+}`;
+};
+/** The data of an `issueConnectionQuery` response, for the connection `shape` names. */
+const issueConnectionDataSchema = (shape) => z.object({ repository: z.object({ issue: z.object(shape).nullable() }).nullable() });
+const assigneesConnectionSchema = issueConnectionDataSchema({ assignees: connectionOf(userSchema) });
+const blockedByConnectionSchema = issueConnectionDataSchema({ blockedBy: connectionOf(issueRefSchema) });
+const blockingConnectionSchema = issueConnectionDataSchema({ blocking: connectionOf(issueRefSchema) });
+const subIssuesConnectionSchema = issueConnectionDataSchema({ subIssues: connectionOf(issueRefSchema) });
+//#endregion
+//#region ../../adapters/graph/source-github-issues/dist/source.js
+/** GitHub's largest allowed `first` on a connection; the API rejects larger values. */
+const githubMaxPageSize = 100;
+/**
+* Issues per page, and items per request of each issue's assignees, blockers and sub-issues. Half of GitHub's limit keeps a page's GraphQL cost and response moderate while needing few requests; Graphle used the same size.
+*/
+const defaultPageSize = githubMaxPageSize / 2;
+/** GitHub's `IssueState` for each run state a filter selects by: an issue closed for any reason is done. */
+const issueStates = {
+	open: "OPEN",
+	done: "CLOSED"
+};
+/** GitHub's `IssueOrderField` for each order field a filter names. */
+const issueOrderFields = {
+	created: "CREATED_AT",
+	updated: "UPDATED_AT",
+	comments: "COMMENTS"
+};
+/** GitHub's `OrderDirection` for each direction a filter names. */
+const orderDirections = {
+	ascending: "ASC",
+	descending: "DESC"
+};
+/**
+* The issue listing's variables for a filter. With no filter, or where it says nothing, every issue is listed, oldest first: creation order keeps a cursor's position valid as new issues are opened.
+*/
+const issueListing = (filter) => ({
+	states: (filter?.states ?? ["open", "done"]).map((state) => issueStates[state]),
+	labels: filter?.labels ?? null,
+	orderBy: filter?.order === void 0 ? {
+		field: issueOrderFields.created,
+		direction: orderDirections.ascending
+	} : {
+		field: issueOrderFields[filter.order.field],
+		direction: orderDirections[filter.order.direction]
+	}
+});
+const present = (connection) => connection.nodes.filter((node) => node !== null);
+const endCursorOf = (pageInfo) => pageInfo.hasNextPage && pageInfo.endCursor !== null ? pageInfo.endCursor : void 0;
+/** A list a listing's gaps are recorded into. */
+const gapList = () => {
+	const gaps = [];
+	return {
+		gaps,
+		sink: { gap: (gap) => {
+			gaps.push(gap);
+		} }
+	};
+};
+/** Records the problems of a response as one gap on `target`, when there are any. */
+const recordProblems = (builder, target, problems) => {
+	const [first] = problems;
+	if (first !== void 0) builder.gap({
+		target,
+		reason: first.reason,
+		message: problems.map((problem) => problem.message).join("; ")
+	});
+};
+/**
+* Records a scope GitHub answered with null as a gap. GitHub nulls a lookup with a `NOT_FOUND` or `FORBIDDEN` error when it can say why, and with no error at all for an owner login that does not exist, which is equally not found.
+*/
+const recordAbsence = (builder, target, problems) => {
+	if (problems.length === 0) builder.gap({
+		target,
+		reason: "not-found",
+		message: `${target} does not exist or is not visible to the token`
+	});
+	else recordProblems(builder, target, problems);
+};
+/**
+* The GitHub issues `GraphSourcePager`. A page is one page of one repository's issues, or of one board's items: each issue becomes a bound activity (`github:owner/repo#n`) whose actor is its repository, each `blockedBy` and `blocking` entry a transition from the blocker to the blocked issue (one transition, whichever side it is read from), each sub-issue a `child-of` relation, each assignee an `assigned-to` relation, and the repository `part-of` its owner. Blockers, blocked issues and sub-issues in other repositories or organisations are included with their own repository and owner. Open issues are `open` in the overlay and closed ones `done`.
+*
+* Scopes are read in request order, each once: `github:owner/repo` for one repository, `github:owner` for every repository the account owns, by name, and `github:owner/projects/number` for the issues on an organisation's or user's Projects v2 board, in the board's order (its pull requests and draft issues are not issues, so they are passed over). A repository, owner or board that does not exist or that the token cannot see is a gap, and the sync continues. A filter narrows and orders each repository's issue listing on GitHub's side; a board has no such listing, so a filter with a board scope is a `bad-request` with `invalid-scope`.
+*
+* The pager also lists scopes: the viewer's own account and organisations at the top, and an owner's repositories, by name, inside it.
+* @param options - The token port, and optionally fetch, clock and page size.
+* @returns A pager for `createGraphSourceRouter`.
+* @throws RangeError when `pageSize` is not an integer from 1 to 100.
+*/
+const createGitHubIssuesSource = (options) => {
+	const pageSize = options.pageSize ?? defaultPageSize;
+	if (!Number.isInteger(pageSize) || pageSize < 1 || pageSize > githubMaxPageSize) throw new RangeError(`pageSize must be an integer from 1 to ${String(githubMaxPageSize)}, not ${String(pageSize)}`);
+	const transport = {
+		token: options.token,
+		fetch: options.fetch ?? (async (url, init) => fetch(url, init)),
+		now: options.now ?? Date.now
+	};
+	/** Every node of one issue connection: the page the issue query returned, then the rest read on their own. */
+	const allOf = async (read, signal) => {
+		const { key, connection, first, schema, extract } = read;
+		const after = endCursorOf(first.pageInfo);
+		if (after === void 0) return present(first);
+		const rest = paginate(after, async (cursor) => {
+			const { data } = await graphql(transport, {
+				query: issueConnectionQuery(connection),
+				variables: {
+					...key,
+					first: pageSize,
+					after: cursor
+				},
+				owner: key.owner,
+				schema
+			}, signal);
+			const page = extract(data);
+			if (page === null || page === void 0) throw new Error(`${issueId(key.owner, key.name, key.number)} was not returned while its ${connection} were read`);
+			const next = endCursorOf(page.pageInfo);
+			return next === void 0 ? { nodes: present(page) } : {
+				nodes: present(page),
+				next
+			};
+		});
+		const nodes = [...present(first)];
+		for await (const page of rest) nodes.push(...page.nodes);
+		return nodes;
+	};
+	const addIssue = async (builder, issue, signal) => {
+		const id = builder.issue(issue);
+		const key = {
+			owner: issue.repository.owner.login,
+			name: issue.repository.name,
+			number: issue.number
+		};
+		const [assignees, blockers, blocked, children] = await Promise.all([
+			allOf({
+				key,
+				connection: "assignees",
+				first: issue.assignees,
+				schema: assigneesConnectionSchema,
+				extract: (data) => data.repository?.issue?.assignees
+			}, signal),
+			allOf({
+				key,
+				connection: "blockedBy",
+				first: issue.blockedBy,
+				schema: blockedByConnectionSchema,
+				extract: (data) => data.repository?.issue?.blockedBy
+			}, signal),
+			allOf({
+				key,
+				connection: "blocking",
+				first: issue.blocking,
+				schema: blockingConnectionSchema,
+				extract: (data) => data.repository?.issue?.blocking
+			}, signal),
+			allOf({
+				key,
+				connection: "subIssues",
+				first: issue.subIssues,
+				schema: subIssuesConnectionSchema,
+				extract: (data) => data.repository?.issue?.subIssues
+			}, signal)
+		]);
+		for (const user of assignees) builder.assignee(id, user);
+		for (const blocker of blockers) builder.blockedBy(id, blocker);
+		for (const issueBlocked of blocked) builder.blocking(id, issueBlocked);
+		for (const child of children) builder.subIssue(id, child);
+	};
+	/**
+	* Adds one page of a repository's issues to the page.
+	* @returns The issues' page info, or `undefined` when the repository was a gap.
+	*/
+	const readRepository = async (builder, read, signal) => {
+		const { target, repository, after, filter } = read;
+		const { data, problems } = await graphql(transport, {
+			query: repositoryIssuesQuery,
+			variables: {
+				...repository,
+				first: pageSize,
+				after,
+				...issueListing(filter)
+			},
+			owner: repository.owner,
+			schema: repositoryIssuesSchema
+		}, signal);
+		if (data.repository === null) {
+			recordAbsence(builder, target, problems);
+			return;
+		}
+		recordProblems(builder, target, problems);
+		builder.repository(data.repository.owner, data.repository.name);
+		await Promise.all(present(data.repository.issues).map(async (issue) => addIssue(builder, issue, signal)));
+		return data.repository.issues.pageInfo;
+	};
+	/**
+	* Adds one page of a board's items to the page: each issue on it, with its connections.
+	* @returns The items' page info, or `undefined` when the owner or board was a gap.
+	*/
+	const readProject = async (builder, project, after, signal) => {
+		const { data, problems } = await graphql(transport, {
+			query: projectItemsQuery,
+			variables: {
+				login: project.owner,
+				number: project.number,
+				first: pageSize,
+				after
+			},
+			owner: project.owner,
+			schema: projectItemsSchema
+		}, signal);
+		const board = data.repositoryOwner?.projectV2;
+		if (board === null || board === void 0) {
+			recordAbsence(builder, project.id, problems);
+			return;
+		}
+		recordProblems(builder, project.id, problems);
+		const issues = present(board.items).flatMap(({ content }) => content?.__typename === "Issue" ? [content] : []);
+		await Promise.all(issues.map(async (issue) => addIssue(builder, issue, signal)));
+		return board.items.pageInfo;
+	};
+	const read = async ({ scope, cursor, signal, filter }) => {
+		const scopes = [...new Set(scope)].map(parseScope);
+		const [firstScope] = scopes;
+		if (firstScope === void 0) throw new Error("unreachable: the contract requires at least one scope");
+		const board = scopes.find((candidate) => candidate.kind === "project");
+		if (filter !== void 0 && board !== void 0) throw new GraphSourceError({
+			kind: "bad-request",
+			message: `"${board.id}" is a Projects v2 board, which lists its items in the board's own order and cannot be filtered; sync it without a filter`,
+			reason: "invalid-scope",
+			value: board.id
+		});
+		const located = cursor === void 0 ? startOf(firstScope) : decodeCursor(cursor, scopes, filter);
+		const following = scopes[scopes.indexOf(located.scope) + 1];
+		const nextScope = following === void 0 ? void 0 : startOf(following).position;
+		const builder = createPageBuilder();
+		const build = (next) => builder.build(next === void 0 ? void 0 : encodeCursor(next, filter));
+		if (located.kind === "project") {
+			const { scope: current, position } = located;
+			const items = await readProject(builder, current, position.items, signal);
+			const after = items === void 0 ? void 0 : endCursorOf(items);
+			return build(after === void 0 ? nextScope : {
+				scope: current.id,
+				items: after
+			});
+		}
+		if (located.kind === "repository") {
+			const { scope: current, position } = located;
+			const issues = await readRepository(builder, {
+				target: current.id,
+				repository: {
+					owner: current.owner,
+					name: current.name
+				},
+				after: position.issues,
+				filter
+			}, signal);
+			const after = issues === void 0 ? void 0 : endCursorOf(issues);
+			return build(after === void 0 ? nextScope : {
+				scope: current.id,
+				issues: after
+			});
+		}
+		const { scope: current, position } = located;
+		const { data, problems } = await graphql(transport, {
+			query: ownerRepositoriesQuery,
+			variables: {
+				login: current.owner,
+				first: pageSize,
+				after: position.repositories
+			},
+			owner: current.owner,
+			schema: ownerRepositoriesSchema
+		}, signal);
+		const owner = data.repositoryOwner;
+		if (owner === null) {
+			recordAbsence(builder, current.id, problems);
+			return build(nextScope);
+		}
+		recordProblems(builder, current.id, problems);
+		builder.account(owner);
+		const listed = present(owner.repositories);
+		const listingAfter = endCursorOf(owner.repositories.pageInfo);
+		const afterListing = listingAfter === void 0 ? nextScope : {
+			scope: current.id,
+			repositories: listingAfter,
+			repository: 0,
+			issues: null
+		};
+		const repository = listed[position.repository];
+		if (repository === void 0) return build(afterListing);
+		const issues = await readRepository(builder, {
+			target: `${current.id}/${repository.name}`,
+			repository: {
+				owner: owner.login,
+				name: repository.name
+			},
+			after: position.issues,
+			filter
+		}, signal);
+		const issuesAfter = issues === void 0 ? void 0 : endCursorOf(issues);
+		const afterRepository = position.repository + 1 < listed.length ? {
+			...position,
+			repository: position.repository + 1,
+			issues: null
+		} : afterListing;
+		return build(issuesAfter === void 0 ? afterRepository : {
+			...position,
+			issues: issuesAfter
+		});
+	};
+	/** A listing page from its entries, gaps and GitHub's page info, resuming under `parent`. */
+	const listingOf = (parent, entries, gaps, pageInfo) => {
+		const after = pageInfo === void 0 ? void 0 : endCursorOf(pageInfo);
+		return after === void 0 ? {
+			entries,
+			gaps
+		} : {
+			entries,
+			gaps,
+			next: encodeListingCursor(parent, after)
+		};
+	};
+	/** A scope entry, with the description only when GitHub has one. */
+	const entryOf = (scope, label, details) => ({
+		scope,
+		label,
+		...details.description === null ? {} : { description: details.description },
+		url: details.url,
+		archived: details.archived
+	});
+	const organisationEntry = (organisation) => entryOf(ownerScopeId(organisation.login), organisation.name ?? organisation.login, {
+		description: organisation.description,
+		url: organisation.url,
+		archived: organisation.archivedAt !== null
+	});
+	const repositoryEntry = (owner, repository) => entryOf(repositoryId(owner, repository.name), repository.name, {
+		description: repository.description,
+		url: repository.url,
+		archived: repository.isArchived
+	});
+	return {
+		source: githubSource,
+		page: read,
+		scopes: {
+			roots: async ({ cursor, signal }) => {
+				const after = cursor === void 0 ? null : decodeListingCursor(cursor, null);
+				const { data, problems } = await graphql(transport, {
+					query: viewerScopesQuery,
+					variables: {
+						first: pageSize,
+						after
+					},
+					owner: void 0,
+					schema: viewerScopesSchema
+				}, signal);
+				const { viewer } = data;
+				const { gaps, sink } = gapList();
+				recordProblems(sink, ownerScopeId(viewer.login), problems);
+				const own = after === null ? [entryOf(ownerScopeId(viewer.login), viewer.name ?? viewer.login, {
+					description: null,
+					url: viewer.url,
+					archived: false
+				})] : [];
+				return listingOf(null, [...own, ...present(viewer.organizations).map(organisationEntry)], gaps, viewer.organizations.pageInfo);
+			},
+			children: async ({ scope, cursor, signal }) => {
+				const parent = parseScope(scope);
+				if (parent.kind !== "owner") {
+					if (cursor !== void 0) throw new GraphSourceError({
+						kind: "bad-request",
+						message: `"${cursor}" is not a cursor this source issued: ${scope} has no scopes inside it`,
+						reason: "invalid-cursor",
+						value: cursor
+					});
+					return {
+						entries: [],
+						gaps: []
+					};
+				}
+				const after = cursor === void 0 ? null : decodeListingCursor(cursor, scope);
+				const { data, problems } = await graphql(transport, {
+					query: ownerRepositoriesQuery,
+					variables: {
+						login: parent.owner,
+						first: pageSize,
+						after
+					},
+					owner: parent.owner,
+					schema: ownerRepositoriesSchema
+				}, signal);
+				const { gaps, sink } = gapList();
+				const owner = data.repositoryOwner;
+				if (owner === null) {
+					recordAbsence(sink, scope, problems);
+					return {
+						entries: [],
+						gaps
+					};
+				}
+				recordProblems(sink, scope, problems);
+				return listingOf(scope, present(owner.repositories).map((repository) => repositoryEntry(owner.login, repository)), gaps, owner.repositories.pageInfo);
+			}
+		}
+	};
+};
+//#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 };