forges 0.0.0 → 0.1.0

package/dist/graphql-D7uGzZTf.mjs

@@ -0,0 +1,366 @@
+import { O as toDate } from "./define-D3yEXtKK.mjs";
+import { i as FORGE } from "./github-B0umL8_f.mjs";
+//#region src/github/graphql.ts
+const ACTOR_FIELDS = `__typename login avatarUrl url ... on User { databaseId name } ... on Bot { databaseId }`;
+const USER_FIELDS = `__typename login avatarUrl url databaseId name`;
+const DISCUSSION_FIELDS = `id number title body closed stateReason url createdAt updatedAt closedAt locked
+      author { ${ACTOR_FIELDS} }
+      labels(first: 50) { nodes { name color description } }
+      comments { totalCount }`;
+const DISCUSSION_THREAD = `query DiscussionThread($owner: String!, $name: String!, $number: Int!) {
+  repository(owner: $owner, name: $name) {
+    discussion(number: $number) {
+      ${DISCUSSION_FIELDS}
+    }
+  }
+}`;
+const DISCUSSIONS_LIST = `query DiscussionsList($owner: String!, $name: String!, $first: Int!, $after: String, $field: DiscussionOrderField!, $direction: OrderDirection!) {
+  repository(owner: $owner, name: $name) {
+    discussions(first: $first, after: $after, orderBy: { field: $field, direction: $direction }) {
+      pageInfo { hasNextPage endCursor }
+      nodes {
+        ${DISCUSSION_FIELDS}
+      }
+    }
+  }
+}`;
+const UPDATE_DISCUSSION = `mutation UpdateDiscussion($id: ID!, $title: String, $body: String) {
+  updateDiscussion(input: { discussionId: $id, title: $title, body: $body }) { discussion { ${DISCUSSION_FIELDS} } }
+}`;
+const COMMENT_FIELDS = `id databaseId body createdAt updatedAt url author { ${ACTOR_FIELDS} }`;
+const UPDATE_DISCUSSION_COMMENT = `mutation UpdateDiscussionComment($id: ID!, $body: String!) {
+  updateDiscussionComment(input: { commentId: $id, body: $body }) { comment { ${COMMENT_FIELDS} } }
+}`;
+const DELETE_DISCUSSION_COMMENT = `mutation DeleteDiscussionComment($id: ID!) {
+  deleteDiscussionComment(input: { id: $id }) { comment { id } }
+}`;
+const SUBSCRIPTION_STATE = `query SubscriptionState($owner: String!, $name: String!, $number: Int!, $discussion: Boolean!) {
+  repository(owner: $owner, name: $name) {
+    issueOrPullRequest(number: $number) @skip(if: $discussion) {
+      ... on Issue { id viewerSubscription }
+      ... on PullRequest { id viewerSubscription }
+    }
+    discussion(number: $number) @include(if: $discussion) { id viewerSubscription }
+  }
+}`;
+const UPDATE_SUBSCRIPTION = `mutation UpdateSubscription($id: ID!, $state: SubscriptionState!) {
+  updateSubscription(input: { subscribableId: $id, state: $state }) { subscribable { viewerSubscription } }
+}`;
+const ISSUE_FIELDS = `id number title body state stateReason createdAt updatedAt closedAt url locked
+      author { ${ACTOR_FIELDS} }
+      assignees(first: 20) { nodes { ${USER_FIELDS} } }
+      labels(first: 50) { nodes { name color description } }
+      comments { totalCount }
+      participants(first: 20) { nodes { ${USER_FIELDS} } }
+      milestone { number title state description dueOn url }
+      viewerSubscription`;
+const PULL_FIELDS = `id number title body state isDraft createdAt updatedAt closedAt mergedAt url locked
+      author { ${ACTOR_FIELDS} }
+      assignees(first: 20) { nodes { ${USER_FIELDS} } }
+      labels(first: 50) { nodes { name color description } }
+      comments { totalCount }
+      participants(first: 20) { nodes { ${USER_FIELDS} } }
+      milestone { number title state description dueOn url }
+      viewerSubscription
+      headRefName headRefOid baseRefName baseRefOid
+      headRepository { databaseId name owner { login } }
+      mergeCommit { oid }
+      commits(last: 1) { nodes { commit { statusCheckRollup { state contexts { totalCount checkRunCountsByState { state count } statusContextCountsByState { state count } } } } } }
+      reviewRequests(first: 20) { nodes { requestedReviewer { __typename ... on User { login databaseId avatarUrl url } ... on Bot { login databaseId avatarUrl url } ... on Team { slug databaseId name url } } } }`;
+/** One aliased query reading many issues, pull requests and discussions. */
+function threadsBatchQuery(refs) {
+	const variables = {};
+	const declarations = [];
+	const fields = refs.map((ref, index) => {
+		variables[`o${index}`] = ref.repo.owner;
+		variables[`n${index}`] = ref.repo.name;
+		variables[`k${index}`] = Number(ref.number);
+		declarations.push(`$o${index}: String!`, `$n${index}: String!`, `$k${index}: Int!`);
+		return `t${index}: repository(owner: $o${index}, name: $n${index}) { ${ref.kind === "discussion" ? `discussion(number: $k${index}) { ${DISCUSSION_FIELDS} }` : `issueOrPullRequest(number: $k${index}) { __typename ... on Issue { ${ISSUE_FIELDS} } ... on PullRequest { ${PULL_FIELDS} } }`} }`;
+	});
+	return {
+		query: `query ThreadsBatch(${declarations.join(", ")}) {\n  ${fields.join("\n  ")}\n}`,
+		variables
+	};
+}
+/** A GraphQL milestone as the model holds it. */
+function toGraphQLMilestone(raw) {
+	return raw ? {
+		id: String(raw.number),
+		title: raw.title,
+		state: raw.state === "CLOSED" ? "closed" : "open",
+		description: raw.description ?? void 0,
+		dueOn: toDate(raw.dueOn),
+		url: raw.url,
+		raw
+	} : void 0;
+}
+function toViewerSubscription(value) {
+	return value === "SUBSCRIBED" ? "subscribed" : value === "IGNORED" ? "ignored" : value === "UNSUBSCRIBED" ? "none" : void 0;
+}
+const FAILED_RUNS = /* @__PURE__ */ new Set([
+	"FAILURE",
+	"TIMED_OUT",
+	"CANCELLED",
+	"ACTION_REQUIRED",
+	"STARTUP_FAILURE"
+]);
+const FAILED_STATUSES = /* @__PURE__ */ new Set(["FAILURE", "ERROR"]);
+function toRollupSummary(rollup, url) {
+	const failed = (rollup.contexts.checkRunCountsByState ?? []).filter(({ state }) => FAILED_RUNS.has(state)).reduce((sum, { count }) => sum + count, 0) + (rollup.contexts.statusContextCountsByState ?? []).filter(({ state }) => FAILED_STATUSES.has(state)).reduce((sum, { count }) => sum + count, 0);
+	return {
+		state: rollup.state === "SUCCESS" ? "success" : rollup.state === "FAILURE" || rollup.state === "ERROR" ? "failure" : rollup.state === "PENDING" || rollup.state === "EXPECTED" ? "pending" : "unknown",
+		stateRaw: rollup.state.toLowerCase(),
+		total: rollup.contexts.totalCount,
+		failed,
+		...url ? { url: `${url}/checks` } : {}
+	};
+}
+function toGraphQLThread(ref, raw) {
+	const instance = ref.instance;
+	const isPull = raw.__typename === "PullRequest";
+	const kind = isPull ? "pull_request" : "issue";
+	const state = raw.state === "MERGED" ? "merged" : raw.state === "OPEN" ? "open" : raw.state === "CLOSED" ? "closed" : "unknown";
+	const reviewers = (raw.reviewRequests?.nodes ?? []).flatMap(({ requestedReviewer: reviewer }) => {
+		if (!reviewer) return [];
+		const isTeam = reviewer.__typename === "Team";
+		return [{
+			actor: isTeam ? {
+				forge: FORGE,
+				instance,
+				login: reviewer.slug ?? "",
+				id: String(reviewer.databaseId ?? reviewer.slug),
+				name: reviewer.name,
+				url: reviewer.url,
+				typeRaw: "Team",
+				isBotHint: false
+			} : toGraphQLActor(instance, reviewer),
+			state: "pending",
+			stateRaw: "requested",
+			...isTeam ? { isTeam: true } : {}
+		}];
+	});
+	return {
+		ref: {
+			...ref,
+			kind,
+			externalId: raw.id
+		},
+		kind,
+		title: raw.title,
+		body: raw.body,
+		state,
+		stateRaw: raw.state.toLowerCase(),
+		stateReason: raw.stateReason?.toLowerCase() ?? void 0,
+		isDraft: raw.isDraft ?? false,
+		author: toGraphQLActor(instance, raw.author),
+		assignees: (raw.assignees?.nodes ?? []).flatMap((actor) => toGraphQLActor(instance, actor) ?? []),
+		participants: (raw.participants?.nodes ?? []).flatMap((actor) => toGraphQLActor(instance, actor) ?? []),
+		milestone: toGraphQLMilestone(raw.milestone),
+		subscription: toViewerSubscription(raw.viewerSubscription),
+		reviewers,
+		labels: (raw.labels?.nodes ?? []).map((label) => ({
+			name: label.name,
+			colour: label.color,
+			description: label.description ?? void 0
+		})),
+		url: raw.url,
+		createdAt: toDate(raw.createdAt),
+		updatedAt: toDate(raw.updatedAt),
+		closedAt: toDate(raw.closedAt),
+		lastActivityAt: toDate(raw.updatedAt),
+		locked: raw.locked,
+		commentCount: raw.comments?.totalCount,
+		...isPull && raw.commits?.nodes[0]?.commit.statusCheckRollup ? { checks: toRollupSummary(raw.commits.nodes[0].commit.statusCheckRollup, raw.url) } : {},
+		branches: isPull && raw.headRefName && raw.baseRefName ? {
+			head: {
+				ref: raw.headRefName,
+				sha: raw.headRefOid,
+				repo: raw.headRepository ? {
+					forge: FORGE,
+					instance,
+					owner: raw.headRepository.owner.login,
+					name: raw.headRepository.name,
+					externalId: raw.headRepository.databaseId === void 0 ? void 0 : String(raw.headRepository.databaseId)
+				} : void 0
+			},
+			base: {
+				ref: raw.baseRefName,
+				sha: raw.baseRefOid
+			},
+			mergeCommitSha: raw.mergeCommit?.oid
+		} : void 0,
+		raw
+	};
+}
+/** Lists recent discussions in several repositories at once, for resolving notification subjects. */
+function recentDiscussionsQuery(repos) {
+	const variables = {};
+	const declarations = [];
+	const fields = repos.map((repo, index) => {
+		variables[`o${index}`] = repo.owner;
+		variables[`n${index}`] = repo.name;
+		declarations.push(`$o${index}: String!`, `$n${index}: String!`);
+		return `r${index}: repository(owner: $o${index}, name: $n${index}) { discussions(first: 50, orderBy: { field: UPDATED_AT, direction: DESC }) { nodes { id number title updatedAt } } }`;
+	});
+	return {
+		query: `query RecentDiscussions(${declarations.join(", ")}) {\n  ${fields.join("\n  ")}\n}`,
+		variables
+	};
+}
+const DISCUSSION_COMMENTS = `query DiscussionComments($owner: String!, $name: String!, $number: Int!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    discussion(number: $number) {
+      comments(first: 50, after: $after) {
+        pageInfo { hasNextPage endCursor }
+        nodes {
+          id databaseId body createdAt url
+          author { ${ACTOR_FIELDS} }
+          replies(first: 50) { nodes { id databaseId body createdAt url author { ${ACTOR_FIELDS} } } }
+        }
+      }
+    }
+  }
+}`;
+const ADD_DISCUSSION_COMMENT = `mutation AddDiscussionComment($id: ID!, $body: String!) {
+  addDiscussionComment(input: { discussionId: $id, body: $body }) { comment { ${COMMENT_FIELDS} } }
+}`;
+const CLOSE_DISCUSSION = `mutation CloseDiscussion($id: ID!, $reason: DiscussionCloseReason) {
+  closeDiscussion(input: { discussionId: $id, reason: $reason }) { discussion { id } }
+}`;
+const REOPEN_DISCUSSION = `mutation ReopenDiscussion($id: ID!) {
+  reopenDiscussion(input: { discussionId: $id }) { discussion { id } }
+}`;
+function toGraphQLActor(instance, actor) {
+	if (!actor) return;
+	return {
+		forge: FORGE,
+		instance,
+		login: actor.login,
+		id: String(actor.databaseId ?? actor.login),
+		name: actor.name,
+		avatarUrl: actor.avatarUrl,
+		url: actor.url,
+		typeRaw: actor.__typename,
+		isBotHint: actor.__typename === "Bot" || actor.login.endsWith("[bot]")
+	};
+}
+function toDiscussionThread(ref, raw) {
+	return {
+		ref: {
+			...ref,
+			externalId: raw.id
+		},
+		kind: "discussion",
+		title: raw.title,
+		body: raw.body,
+		state: raw.closed ? "closed" : "open",
+		stateRaw: raw.closed ? "closed" : "open",
+		stateReason: raw.stateReason?.toLowerCase(),
+		isDraft: false,
+		author: toGraphQLActor(ref.instance, raw.author),
+		assignees: [],
+		reviewers: [],
+		lastActivityAt: toDate(raw.updatedAt),
+		url: raw.url,
+		createdAt: toDate(raw.createdAt),
+		updatedAt: toDate(raw.updatedAt),
+		closedAt: toDate(raw.closedAt),
+		labels: (raw.labels?.nodes ?? []).map((label) => ({
+			name: label.name,
+			colour: label.color,
+			description: label.description ?? void 0
+		})),
+		locked: raw.locked,
+		commentCount: raw.comments?.totalCount,
+		raw
+	};
+}
+function toDiscussionCommentEvent(ref, comment, isReply) {
+	const actor = toGraphQLActor(ref.instance, comment.author);
+	return {
+		forge: FORGE,
+		instance: ref.instance,
+		id: comment.id,
+		kind: "comment",
+		kindRaw: isReply ? "DiscussionCommentReply" : "DiscussionComment",
+		summary: `${actor?.login ?? "someone"} ${isReply ? "replied" : "commented"}`,
+		occurredAt: toDate(comment.createdAt) ?? /* @__PURE__ */ new Date(0),
+		actor,
+		repo: ref.repo,
+		thread: ref,
+		source: "poll",
+		payload: comment
+	};
+}
+function toDiscussionComment(thread, raw) {
+	return {
+		ref: {
+			forge: FORGE,
+			instance: thread.instance,
+			thread,
+			id: raw.id
+		},
+		body: raw.body ?? "",
+		author: toGraphQLActor(thread.instance, raw.author),
+		createdAt: toDate(raw.createdAt),
+		updatedAt: toDate(raw.updatedAt),
+		url: raw.url,
+		raw
+	};
+}
+const REPOSITORY_ID = `query RepositoryId($owner: String!, $name: String!) {
+  repository(owner: $owner, name: $name) { id }
+}`;
+const TRANSFER_ISSUE = `mutation TransferIssue($issue: ID!, $repo: ID!) {
+  transferIssue(input: { issueId: $issue, repositoryId: $repo }) { issue { id number } }
+}`;
+const MARK_DUPLICATE = `mutation MarkDuplicate($canonical: ID!, $duplicate: ID!) {
+  closeIssue(input: { issueId: $duplicate, stateReason: DUPLICATE, duplicateIssueId: $canonical }) { issue { __typename } }
+}`;
+const NODE_REACTIONS = `query NodeReactions($id: ID!, $after: String) {
+  node(id: $id) {
+    ... on Reactable {
+      reactions(first: 100, after: $after) {
+        pageInfo { hasNextPage endCursor }
+        nodes { content createdAt user { __typename login databaseId name avatarUrl url } }
+      }
+    }
+  }
+}`;
+const ADD_REACTION = `mutation AddReaction($id: ID!, $content: ReactionContent!) {
+  addReaction(input: { subjectId: $id, content: $content }) { reaction { content } }
+}`;
+const REMOVE_REACTION = `mutation RemoveReaction($id: ID!, $content: ReactionContent!) {
+  removeReaction(input: { subjectId: $id, content: $content }) { reaction { content } }
+}`;
+/** The GraphQL `ReactionContent` enum, by the model's name for each reaction. */
+const REACTION_CONTENT = {
+	"+1": "THUMBS_UP",
+	"-1": "THUMBS_DOWN",
+	"laugh": "LAUGH",
+	"confused": "CONFUSED",
+	"heart": "HEART",
+	"hooray": "HOORAY",
+	"rocket": "ROCKET",
+	"eyes": "EYES"
+};
+/** The model's name for each GraphQL `ReactionContent` value. */
+const GRAPHQL_REACTIONS = Object.fromEntries(Object.entries(REACTION_CONTENT).map(([content, graphql]) => [graphql, content]));
+const REVIEW_THREADS = `query ReviewThreads($owner: String!, $name: String!, $number: Int!) {
+  repository(owner: $owner, name: $name) {
+    pullRequest(number: $number) {
+      reviewThreads(first: 100) {
+        nodes { id isResolved comments(first: 100) { nodes { databaseId } } }
+      }
+    }
+  }
+}`;
+const RESOLVE_REVIEW_THREAD = `mutation ResolveReviewThread($id: ID!) {
+  resolveReviewThread(input: { threadId: $id }) { thread { isResolved } }
+}`;
+const UNRESOLVE_REVIEW_THREAD = `mutation UnresolveReviewThread($id: ID!) {
+  unresolveReviewThread(input: { threadId: $id }) { thread { isResolved } }
+}`;
+//#endregion
+export { ADD_DISCUSSION_COMMENT, ADD_REACTION, CLOSE_DISCUSSION, DELETE_DISCUSSION_COMMENT, DISCUSSIONS_LIST, DISCUSSION_COMMENTS, DISCUSSION_THREAD, GRAPHQL_REACTIONS, MARK_DUPLICATE, NODE_REACTIONS, REACTION_CONTENT, REMOVE_REACTION, REOPEN_DISCUSSION, REPOSITORY_ID, RESOLVE_REVIEW_THREAD, REVIEW_THREADS, SUBSCRIPTION_STATE, TRANSFER_ISSUE, UNRESOLVE_REVIEW_THREAD, UPDATE_DISCUSSION, UPDATE_DISCUSSION_COMMENT, UPDATE_SUBSCRIPTION, recentDiscussionsQuery, threadsBatchQuery, toDiscussionComment, toDiscussionCommentEvent, toDiscussionThread, toGraphQLActor, toGraphQLMilestone, toGraphQLThread, toViewerSubscription };

package/dist/index-BQ6VS31s.d.mts

@@ -0,0 +1,32 @@
+import { M as TokenAuth, P as VerbScopes, a as BasicAuth, m as ForgeOptionsBase, n as AnonymousAuth, q as ForgeVerb } from "./provider-CoZ7cCxp.mjs";
+import { c as ProviderFactoryFunction } from "./define-B2_4ob2i.mjs";
+//#region src/bitbucket/index.d.ts
+/**
+ * Bitbucket Cloud credentials.
+ *
+ * - `token`: an OAuth access token or a repository, project or workspace
+ *   access token, sent as a bearer token.
+ * - `basic`: an Atlassian account email and API token.
+ */
+type BitbucketAuth = TokenAuth | BasicAuth | AnonymousAuth;
+/** Options for `bitbucket()`. */
+interface BitbucketOptions extends ForgeOptionsBase {
+  /**
+   * How to authenticate. Without credentials, only public reads work.
+   * @default { type: 'anonymous' }
+   */
+  auth?: BitbucketAuth;
+  /**
+   * API base.
+   * @default https://api.bitbucket.org/2.0
+   */
+  baseUrl?: string;
+}
+/** Creates a Bitbucket Cloud provider. */
+declare const bitbucket: ProviderFactoryFunction<BitbucketOptions>;
+/** `bitbucket()` without webhook ingestion, for bundles that never receive a delivery. */
+declare const bitbucketLite: ProviderFactoryFunction<BitbucketOptions>;
+/** Bitbucket Cloud scopes, as an app password or OAuth consumer grants them. */
+declare function bitbucketScopesFor(verb: ForgeVerb): VerbScopes;
+//#endregion
+export { bitbucketScopesFor as a, bitbucketLite as i, BitbucketOptions as n, bitbucket as r, BitbucketAuth as t };

package/dist/index-C-jz9Mo3.d.mts

@@ -0,0 +1,16 @@
+import { c as ProviderFactoryFunction } from "./define-B2_4ob2i.mjs";
+import { i as ForgejoProfile, r as ForgejoOptions } from "./index-DIuS0EOy.mjs";
+//#region src/gitea/index.d.ts
+/** Options for `gitea()`, the same as for `forgejo()`. */
+type GiteaOptions = ForgejoOptions;
+/**
+ * Gitea shares Forgejo's REST API. It differs in its default instance, its
+ * webhook headers (`X-Gitea-*` only) and its capability profile.
+ */
+declare const GITEA_PROFILE: ForgejoProfile;
+/** Creates a Gitea provider for gitea.com or any self-hosted Gitea instance. */
+declare const gitea: ProviderFactoryFunction<GiteaOptions>;
+/** `gitea()` without webhook ingestion, for bundles that never receive a delivery. */
+declare const giteaLite: ProviderFactoryFunction<GiteaOptions>;
+//#endregion
+export { giteaLite as i, GiteaOptions as n, gitea as r, GITEA_PROFILE as t };

package/dist/index-C4fYzmK3.d.mts

@@ -0,0 +1,102 @@
+import { Ln as ThreadKind, dn as RepoRef, n as FetchLike } from "./fetch-D4pSRvvA.mjs";
+import { m as ForgeOptionsBase, n as AnonymousAuth } from "./provider-CoZ7cCxp.mjs";
+import { c as ProviderFactoryFunction } from "./define-B2_4ob2i.mjs";
+//#region src/tangled/subscribe.d.ts
+/** The subset of the WHATWG `WebSocket` the subscription uses. */
+interface WebSocketLike {
+  /** Registers a listener for a socket event. */
+  addEventListener: (type: "open" | "message" | "error" | "close", listener: (event: {
+    data?: unknown;
+    code?: number;
+    reason?: string;
+  }) => void) => void;
+  /** Closes the socket, optionally with a close code and reason. */
+  close: (code?: number, reason?: string) => void;
+}
+/** Opens a WebSocket for a URL, such as `url => new WebSocket(url)`. */
+type WebSocketFactory = (url: string) => WebSocketLike;
+//#endregion
+//#region src/tangled/index.d.ts
+/**
+ * Credentials for writing records. Reads are public and need none.
+ *
+ * - `app_password` creates a session on the account's PDS.
+ * - `oauth` takes a `fetch` from an atproto OAuth client that already signs
+ *   requests (DPoP) for `pds`.
+ */
+type TangledAuth = AnonymousAuth | {
+  type: "app_password";
+  identifier: string;
+  password: string;
+  pds?: string;
+} | {
+  type: "oauth";
+  did: string;
+  pds: string;
+  fetch: FetchLike;
+};
+/** Options for `tangled()`. */
+interface TangledOptions extends ForgeOptionsBase {
+  /** An app password session, an OAuth client that signs requests, or none for anonymous reads. */
+  auth?: TangledAuth;
+  /**
+   * Appview web root, used for links and as the `instance`.
+   * @default https://tangled.org
+   */
+  baseUrl?: string;
+  /**
+   * Base for `request()`: a Bobbin-compatible XRPC index. Defaults to
+   * `https://api.tangled.org`, Tangled's public instance.
+   */
+  apiUrl?: string;
+  /** PLC directory for `did:plc` resolution. Defaults to the public directory, which is community infrastructure. */
+  plcUrl?: string;
+  /** Constellation-compatible backlink index. */
+  backlinksUrl?: string;
+  /**
+   * Service for `com.atproto.identity.resolveHandle`, so a `RepoRef.owner` can
+   * be a handle. Defaults to `https://public.api.bsky.app`.
+   */
+  handleResolverUrl?: string;
+  /**
+   * Slingshot-compatible record cache, for example
+   * `https://slingshot.microcosm.blue`. By default records are read from each
+   * author's PDS.
+   */
+  recordsUrl?: string;
+  /** Jetstream `subscribe` endpoint. */
+  jetstreamUrl?: string;
+  /** Defaults to the global `WebSocket`. */
+  webSocket?: WebSocketFactory;
+  /**
+   * Base URL of a service implementing the experimental
+   * `org.tangled.temp.notification.*` lexicons (Tangled's deliberi). Its
+   * service DID is derived as `did:web:<host>`. Requires `auth`. The lexicons
+   * live in Tangled's `temp` namespace and may change or disappear, so the
+   * resulting capabilities report `'experimental'`, or `'unverified'`.
+   */
+  notificationsUrl?: string;
+  /**
+   * Maps a per-repo display number (as carried by webhooks) to the thread's
+   * AT-URI. When provided, `webhooks.ingest()` uses it to fill `number`.
+   * Records carry no numbers; the mapping exists only in an index of the
+   * appview's numbering.
+   */
+  resolveDisplayNumber?: (repo: RepoRef, kind: ThreadKind, displayNumber: string) => Promise<string | undefined>;
+  /** Maps a knot host to the host that accepts git over SSH for it. `knot1.tangled.sh` maps to `tangled.org` by default. */
+  sshHosts?: Record<string, string>;
+  /**
+   * Where `threads.list` reads from. `'records'` (the default) reads every
+   * record and computes state with the appview's rule. `'index'` reads the
+   * Bobbin index at `apiUrl` instead: one request per page, but its states may
+   * lag behind the records, and every listing carries an `index_possibly_stale`
+   * warning.
+   */
+  listSource?: "records" | "index";
+}
+/** Creates a Tangled provider. Records are read from PDSes; pushes arrive through Jetstream. */
+declare const tangled: ProviderFactoryFunction<TangledOptions>;
+/** `tangled()` without webhook ingestion, for bundles that never receive a delivery. */
+declare const tangledLite: ProviderFactoryFunction<TangledOptions>;
+//#endregion
+export { WebSocketFactory as a, tangledLite as i, TangledOptions as n, WebSocketLike as o, tangled as r, TangledAuth as t };

package/dist/index-CQiIX4SH.d.mts

@@ -0,0 +1,27 @@
+import { M as TokenAuth, P as VerbScopes, m as ForgeOptionsBase, n as AnonymousAuth, q as ForgeVerb, r as AppAuth } from "./provider-CoZ7cCxp.mjs";
+import { c as ProviderFactoryFunction } from "./define-B2_4ob2i.mjs";
+//#region src/github/auth.d.ts
+/** The credentials GitHub accepts: a token, a GitHub App, or none for anonymous reads. */
+type GitHubAuth = TokenAuth | AppAuth | AnonymousAuth;
+//#endregion
+//#region src/github/index.d.ts
+/** Options for `github()`. */
+interface GitHubOptions extends ForgeOptionsBase {
+  /**
+   * How to authenticate. Without credentials, only public reads work.
+   * @default { type: 'anonymous' }
+   */
+  auth?: GitHubAuth;
+}
+/** Creates a GitHub provider for github.com or a GitHub Enterprise Server instance. */
+declare const github: ProviderFactoryFunction<GitHubOptions>;
+/** `github()` without webhook ingestion, for bundles that never receive a delivery. */
+declare const githubLite: ProviderFactoryFunction<GitHubOptions>;
+/**
+ * Token scopes and fine-grained permissions GitHub documents per endpoint
+ * group. Classic scopes are the ones an OAuth consent screen asks for; the
+ * permissions are the fine-grained token and app equivalents.
+ */
+declare function githubScopesFor(verb: ForgeVerb): VerbScopes;
+//#endregion
+export { GitHubAuth as a, githubScopesFor as i, github as n, githubLite as r, GitHubOptions as t };

package/dist/index-CTj5gQzl.d.mts

@@ -0,0 +1,35 @@
+import { M as TokenAuth, a as BasicAuth, m as ForgeOptionsBase, n as AnonymousAuth } from "./provider-CoZ7cCxp.mjs";
+import { c as ProviderFactoryFunction } from "./define-B2_4ob2i.mjs";
+//#region src/azure-devops/index.d.ts
+/** The REST API version sent with every request; preview endpoints set their own. */
+declare const AZURE_DEVOPS_API_VERSION = "7.1";
+/** A personal access token (sent as basic auth with an empty user name), or explicit basic credentials. */
+type AzureDevOpsAuth = TokenAuth | BasicAuth | AnonymousAuth;
+/** Options for `azureDevOps()`. */
+interface AzureDevOpsOptions extends ForgeOptionsBase {
+  /**
+   * How to authenticate. Without credentials, only public reads work.
+   * @default { type: 'anonymous' }
+   */
+  auth?: AzureDevOpsAuth;
+  /** The organization (or Azure DevOps Server collection) that `repos.list()` lists. */
+  organization: string;
+  /**
+   * For Azure DevOps Server, the server root, for example `https://tfs.example.com/tfs`.
+   * @default https://dev.azure.com
+   */
+  baseUrl?: string;
+  /**
+   * Work item type `threads.create({ kind: 'issue' })` creates. Scrum projects use `Impediment` or `Product Backlog Item`.
+   * @default Issue
+   */
+  issueType?: string;
+  /** `username:password` the service hook subscription sends as basic auth. */
+  webhookSecret?: string;
+}
+/** Creates an Azure DevOps provider for one organization on dev.azure.com, or a collection on Azure DevOps Server. */
+declare const azureDevOps: ProviderFactoryFunction<AzureDevOpsOptions>;
+/** `azureDevOps()` without webhook ingestion, for bundles that never receive a delivery. */
+declare const azureDevOpsLite: ProviderFactoryFunction<AzureDevOpsOptions>;
+//#endregion
+export { azureDevOpsLite as a, azureDevOps as i, AzureDevOpsAuth as n, AzureDevOpsOptions as r, AZURE_DEVOPS_API_VERSION as t };

package/dist/index-CliBWzOF.d.mts

@@ -0,0 +1,23 @@
+import { M as TokenAuth, P as VerbScopes, m as ForgeOptionsBase, n as AnonymousAuth, q as ForgeVerb } from "./provider-CoZ7cCxp.mjs";
+import { c as ProviderFactoryFunction } from "./define-B2_4ob2i.mjs";
+//#region src/gitlab/index.d.ts
+/** Personal, project, group or OAuth access token. */
+type GitLabAuth = TokenAuth | AnonymousAuth;
+/** Options for `gitlab()`. */
+interface GitLabOptions extends ForgeOptionsBase {
+  /**
+   * How to authenticate. Without credentials, only public reads work.
+   * @default { type: 'anonymous' }
+   */
+  auth?: GitLabAuth;
+  /** Instance root, for example `https://gitlab.com`. */
+  baseUrl?: string;
+}
+/** Creates a GitLab provider for gitlab.com or a self-managed instance. */
+declare const gitlab: ProviderFactoryFunction<GitLabOptions>;
+/** `gitlab()` without webhook ingestion, for bundles that never receive a delivery. */
+declare const gitlabLite: ProviderFactoryFunction<GitLabOptions>;
+/** GitLab tokens carry coarse scopes; `api` covers writes and `read_api` reads. */
+declare function gitlabScopesFor(verb: ForgeVerb): VerbScopes;
+//#endregion
+export { gitlabScopesFor as a, gitlabLite as i, GitLabOptions as n, gitlab as r, GitLabAuth as t };

package/dist/index-Cz_y-t3d.d.mts

@@ -0,0 +1,36 @@
+import { M as TokenAuth, m as ForgeOptionsBase, n as AnonymousAuth, r as AppAuth } from "./provider-CoZ7cCxp.mjs";
+import { c as ProviderFactoryFunction } from "./define-B2_4ob2i.mjs";
+//#region src/cursor-origin/auth.d.ts
+/**
+ * A user access token (what the Origin CLI sends, for example
+ * `CURSOR_AUTH_TOKEN`), or an Origin App: its id and Ed25519 PKCS#8 private
+ * key, optionally scoped to one installation. Personal Cursor API keys are
+ * not Origin bearer tokens.
+ */
+type CursorOriginAuth = TokenAuth | AppAuth;
+//#endregion
+//#region src/cursor-origin/index.d.ts
+/** The Origin API version this provider was built against. See `docs/content/4.providers/cursor-origin.md`. */
+declare const ORIGIN_API_VERSION = "v1alpha1";
+/** Options for `cursorOrigin()`. */
+interface CursorOriginOptions extends ForgeOptionsBase {
+  /**
+   * Token or app credentials. Cursor Origin's API has no anonymous access, so
+   * without `auth` the provider only verifies and translates webhook deliveries.
+   */
+  auth?: CursorOriginAuth | AnonymousAuth;
+  /**
+   * API root. `/v1/origin` is appended.
+   * @default https://api.cursor.com
+   */
+  baseUrl?: string;
+}
+/**
+ * Creates a Cursor Origin provider. Experimental: built against the
+ * `v1alpha1` API, which Cursor publishes as Early Beta.
+ */
+declare const cursorOrigin: ProviderFactoryFunction<CursorOriginOptions>;
+/** `cursorOrigin()` without webhook ingestion, for bundles that never receive a delivery. */
+declare const cursorOriginLite: ProviderFactoryFunction<CursorOriginOptions>;
+//#endregion
+export { CursorOriginAuth as a, cursorOriginLite as i, ORIGIN_API_VERSION as n, cursorOrigin as r, CursorOriginOptions as t };