forges 0.0.0 → 0.1.0

package/dist/index-DEt25E1w.d.mts

@@ -0,0 +1,77 @@
+import { B as Actor, Dt as ForgeOrigin, at as Comment, on as Repo, zn as ThreadRef } from "./fetch-D4pSRvvA.mjs";
+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/pushin/types.d.ts
+interface PushinUser {
+  id?: number | string;
+  login: string;
+  type?: string;
+  name?: string | null;
+  company?: string | null;
+  avatar_url?: string;
+  html_url?: string;
+}
+interface PushinRepository {
+  id: number | string;
+  node_id?: string;
+  name: string;
+  full_name: string;
+  owner?: PushinUser | null;
+  private?: boolean;
+  visibility?: string;
+  description?: string | null;
+  homepage?: string | null;
+  default_branch?: string;
+  url?: string;
+  html_url?: string;
+  clone_url?: string;
+  topics?: string[];
+  created_at?: string;
+  updated_at?: string;
+  forks_count?: number;
+  stargazers_count?: number;
+  watchers_count?: number;
+  permissions?: {
+    admin?: boolean;
+    maintain?: boolean;
+    push?: boolean;
+    triage?: boolean;
+    pull?: boolean;
+  };
+}
+interface PushinComment {
+  id: number | string;
+  user?: PushinUser | null;
+  body: string;
+  created_at?: string;
+  updated_at?: string;
+  in_reply_to_id?: number | string | null;
+}
+//#endregion
+//#region src/pushin/normalise.d.ts
+declare function toActor(origin: ForgeOrigin, user: PushinUser | undefined | null): Actor | undefined;
+declare function toRepo(origin: ForgeOrigin, raw: PushinRepository): Repo;
+declare function toComment(thread: ThreadRef, raw: PushinComment): Comment;
+//#endregion
+//#region src/pushin/index.d.ts
+/** A personal access token created in Settings (`pun_pat_…`), sent as `Authorization: Bearer`. */
+type PushinAuth = TokenAuth | AnonymousAuth;
+/** Options for `pushin()`. */
+interface PushinOptions extends ForgeOptionsBase {
+  /**
+   * How to authenticate. Without credentials, only public reads work.
+   * @default { type: 'anonymous' }
+   */
+  auth?: PushinAuth;
+  /**
+   * Instance root. `/api/v1` is appended.
+   * @default https://pushin.eu
+   */
+  baseUrl?: string;
+}
+/** Creates a Pushin.eu provider. */
+declare const pushin: ProviderFactoryFunction<PushinOptions>;
+/** Scope requirements for a Pushin.eu operation. */
+declare function pushinScopesFor(_verb: ForgeVerb): VerbScopes;
+//#endregion
+export { toActor as a, pushinScopesFor as i, PushinOptions as n, toComment as o, pushin as r, toRepo as s, PushinAuth as t };

package/dist/index-DIuS0EOy.d.mts

@@ -0,0 +1,43 @@
+import { M as TokenAuth, P as VerbScopes, m as ForgeOptionsBase, n as AnonymousAuth, q as ForgeVerb } from "./provider-CoZ7cCxp.mjs";
+import { c as ProviderFactoryFunction, s as ProviderDefinition } from "./define-B2_4ob2i.mjs";
+//#region src/forgejo/webhook-events.d.ts
+/** Header names a deployment signs and labels deliveries with, first match wins. */
+interface WebhookHeaderNames {
+  signature: readonly string[];
+  event: readonly string[];
+  delivery: readonly string[];
+}
+//#endregion
+//#region src/forgejo/index.d.ts
+/** Forgejo and Gitea have no app-installation credential, so only tokens are accepted. */
+type ForgejoAuth = TokenAuth | AnonymousAuth;
+/** Options for `forgejo()`. */
+interface ForgejoOptions extends ForgeOptionsBase {
+  /**
+   * How to authenticate. Without credentials, only public reads work.
+   * @default { type: 'anonymous' }
+   */
+  auth?: ForgejoAuth;
+  /** Instance root, for example `https://codeberg.org`. */
+  baseUrl?: string;
+}
+/** What distinguishes a deployment family sharing the Forgejo implementation. */
+interface ForgejoProfile {
+  forge: "forgejo" | "gitea";
+  defaultBaseUrl: string;
+  headers: WebhookHeaderNames;
+}
+declare const FORGEJO_PROFILE: ForgejoProfile;
+/** The Forgejo implementation for one deployment family. Shared by `forgejo()` and `gitea()`. */
+declare function forgejoDefinition(profile: ForgejoProfile): ProviderDefinition<ForgejoOptions>;
+/** Creates a Forgejo provider for Codeberg or any self-hosted Forgejo instance. */
+declare const forgejo: ProviderFactoryFunction<ForgejoOptions>;
+/** `forgejo()` without webhook ingestion, for bundles that never receive a delivery. */
+declare const forgejoLite: ProviderFactoryFunction<ForgejoOptions>;
+/**
+ * Forgejo and Gitea token scopes, which are per resource group with a
+ * `read:` or `write:` prefix.
+ */
+declare function forgejoScopesFor(verb: ForgeVerb): VerbScopes;
+//#endregion
+export { forgejo as a, forgejoScopesFor as c, ForgejoProfile as i, ForgejoAuth as n, forgejoDefinition as o, ForgejoOptions as r, forgejoLite as s, FORGEJO_PROFILE as t };

package/dist/index-uSpsMCrC.d.mts

@@ -0,0 +1,26 @@
+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/gitee/index.d.ts
+/** A personal access token or OAuth access token, sent as `Authorization: token`. */
+type GiteeAuth = TokenAuth | AnonymousAuth;
+/** Options for `gitee()`. */
+interface GiteeOptions extends ForgeOptionsBase {
+  /**
+   * How to authenticate. Without credentials, only public reads work.
+   * @default { type: 'anonymous' }
+   */
+  auth?: GiteeAuth;
+  /**
+   * Instance root. `/api/v5` is appended.
+   * @default https://gitee.com
+   */
+  baseUrl?: string;
+}
+/** Creates a Gitee provider for gitee.com. The enterprise edition (`e.gitee.com`) is not covered. */
+declare const gitee: ProviderFactoryFunction<GiteeOptions>;
+/** `gitee()` without webhook ingestion, for bundles that never receive a delivery. */
+declare const giteeLite: ProviderFactoryFunction<GiteeOptions>;
+/** Gitee OAuth scopes, one per resource group. */
+declare function giteeScopesFor(verb: ForgeVerb): VerbScopes;
+//#endregion
+export { giteeScopesFor as a, giteeLite as i, GiteeOptions as n, gitee as r, GiteeAuth as t };

package/dist/index.d.mts

@@ -0,0 +1,41 @@
+import { $ as CiRunQuery, $n as WebhookInput, $t as ReactionSummary, A as RateLimitedError, An as SourceKind, At as GetManyResult, B as Actor, Bn as ThreadStack, Bt as Notification, C as ForgeNetworkError, Cn as Reviewer, Ct as ForgeEvent, D as MergeConflictError, Dn as SecurityAlertListOptions, Dt as ForgeOrigin, E as MergeBlockedError, En as SecurityAlertKind, Et as ForgeKind, F as UnresolvedThreadError, Fn as Thread, Ft as LabelInput, G as Check, Gn as TreeOptions, Gt as Page, H as BaseOptions, Hn as ThreadUpdateInput, Ht as NotificationReason, I as UnsupportedOperationError, In as ThreadCreateInput, It as ListOptions, J as CheckState, Jn as User, Jt as PushCommit, K as CheckRef, Kn as UpsertCommentInput, Kt as PageOptions, L as WebhookVerificationError, Ln as ThreadKind, Lt as MergeMethod, M as SubscriptionClosedError, Mn as Support, Mt as InstallationToken, N as TokenRevokedError, Nn as Tag, Nt as KnownForgeKind, O as MergeMethodRequiredError, On as SecurityAlertRef, Ot as ForgeWarning, P as UnknownForgeError, Pn as TextLimits, Pt as Label, Q as CiRun, Qn as WebhookEventType, Qt as ReactionContent, Rn as ThreadQuery, Rt as MergeOptions, S as ForgeErrorContext, Sn as ReviewState, St as FileStatus, T as InsufficientScopeError, Tn as SecurityAlert, Tt as ForgeInstance, U as Branch, Un as TreeEntry, Ut as NotificationRef, V as ApproveAndMergeOptions, Vn as ThreadState, Vt as NotificationListOptions, W as ChangedFile, Wn as TreeEntryType, Wt as NotificationSubject, X as CiJob, Xn as WebhookDeliveryRecord, Xt as RateLimit, Y as ChecksSummary, Yn as Webhook, Yt as REACTION_CONTENTS, Z as CiJobRef, Zn as WebhookDeliveryRef, Zt as Reaction, _ as ContentNotTextError, _n as ReviewComment, _r as threadKey, _t as EventKind, an as ReleaseUpdate, ar as isResolvedThread, at as Comment, b as ForgeApiError, bn as ReviewInput, bt as FileMetadata, c as ForgeRequestOptions, cn as RepoFeatures, cr as notificationKey, ct as CommitQuery, d as RawResponse, dn as RepoRef, dr as parseRepoKey, dt as CommitSignature, en as Release, er as WebhookRef, et as CiRunRef, fn as RepoRole, fr as parseThreadKey, ft as Comparison, g as AuthenticationRequiredError, gn as Review, gr as reviveDates, gt as EventDetail, hn as ResolvedThreadRef, hr as repoSlug, ht as EventAction, in as ReleaseRef, ir as isNamespaceRef, it as Collaborator, j as ReadOnlyError, jn as SubscriptionState, jt as Installation, k as NotFoundError, kn as SecuritySeverity, kt as ForgeWarningCode, l as ForgeResponse, ln as RepoPermissions, lr as notificationThread, lt as CommitRef, mn as RepoVisibility, mr as repoKey, mt as DATE_FIELDS, n as FetchLike, nn as ReleaseAssetRef, nr as commentMarker, nt as CodeMatch, o as ForgeRawRequestOptions, on as Repo, or as namesAreCaseInsensitive, ot as CommentRef, pn as RepoSearchQuery, pt as Cursor, q as CheckReportInput, qn as UpsertCommentResult, qt as PullBranches, rn as ReleaseInput, rr as hasCommentMarker, rt as CodeSearchQuery, s as ForgeRequest, sn as RepoAffiliation, sr as normaliseRepoName, st as Commit, tn as ReleaseAsset, tr as WebhookUpdate, tt as CodeFragment, un as RepoQuery, ur as parseNotificationKey, ut as CommitSearchQuery, v as ForbiddenError, vn as ReviewCommentInput, vr as threadSlug, vt as FileContent, w as ForgeTimeoutError, wn as SearchQuery, x as ForgeError, xn as ReviewRef, xt as FileOptions, y as ForbiddenReason, yn as ReviewEvent, yt as FileEncoding, zn as ThreadRef, zt as Milestone } from "./fetch-D4pSRvvA.mjs";
+import { A as SubscriptionItem, B as ReferenceOptions, C as ReleasesApi, D as SecurityAlertsApi, E as SearchApi, F as WebhookDelivery, I as WebhooksApi, L as createForges, M as TokenAuth, N as UsersApi, O as SourcesApi, P as VerbScopes, S as PerKind, T as ReposApi, V as UrlTarget, W as parseForgeUrl, _ as Forges, a as BasicAuth, b as NotificationWriteOptions, c as CiApi, d as ContentsApi, f as ForgeCapabilities, g as ForgeProviderFactory, h as ForgeProvider, i as AuthKind, j as ThreadsApi, k as SubscribeOptions, l as CloseOptions, m as ForgeOptionsBase, n as AnonymousAuth, o as BulkNotificationOptions, p as ForgeIterable, q as ForgeVerb, r as AppAuth, s as ChecksApi, t as AlertSupport, u as CloseReason, v as InstallationsApi, w as RepoGetOptions, x as NotificationsApi, y as MilestoneListOptions, z as ParsedForgeUrl } from "./provider-CoZ7cCxp.mjs";
+import { c as ProviderFactoryFunction } from "./define-B2_4ob2i.mjs";
+import { a as azureDevOpsLite, i as azureDevOps, n as AzureDevOpsAuth, r as AzureDevOpsOptions, t as AZURE_DEVOPS_API_VERSION } from "./index-CTj5gQzl.mjs";
+import { i as bitbucketLite, n as BitbucketOptions, r as bitbucket, t as BitbucketAuth } from "./index-BQ6VS31s.mjs";
+import { a as CursorOriginAuth, i as cursorOriginLite, n as ORIGIN_API_VERSION, r as cursorOrigin, t as CursorOriginOptions } from "./index-Cz_y-t3d.mjs";
+import { a as forgejo, n as ForgejoAuth, r as ForgejoOptions, s as forgejoLite } from "./index-DIuS0EOy.mjs";
+import { i as giteaLite, n as GiteaOptions, r as gitea } from "./index-C-jz9Mo3.mjs";
+import { i as giteeLite, n as GiteeOptions, r as gitee, t as GiteeAuth } from "./index-uSpsMCrC.mjs";
+import { a as GitHubAuth, n as github, r as githubLite, t as GitHubOptions } from "./index-CQiIX4SH.mjs";
+import { i as gitlabLite, n as GitLabOptions, r as gitlab, t as GitLabAuth } from "./index-CliBWzOF.mjs";
+import { n as PushinOptions, r as pushin, t as PushinAuth } from "./index-DEt25E1w.mjs";
+import { a as WebSocketFactory, i as tangledLite, n as TangledOptions, o as WebSocketLike, r as tangled, t as TangledAuth } from "./index-C4fYzmK3.mjs";
+//#region src/supports.d.ts
+/**
+ * Whether `verb` is supported according to `capabilities`, for `kind` where
+ * support differs by thread kind (or by alert kind for `securityAlerts`).
+ * Without `kind`, a per-kind verb counts as supported when any kind is.
+ * @param capabilities The capabilities of a provider, such as `provider.capabilities`.
+ * @param verb The operation, named by its path on the provider, such as `threads.comment`.
+ * @param kind The thread or alert kind, for an operation whose support differs by kind.
+ * @example
+ * ```ts
+ * if (supports(provider.capabilities, 'threads.merge')) {
+ *   await provider.threads.merge(ref)
+ * }
+ * ```
+ */
+export declare function supports(capabilities: ForgeCapabilities, verb: ForgeVerb, kind?: ThreadKind | SecurityAlertKind): boolean;
+/**
+ * How well `verb` is supported according to `capabilities`: `true`,
+ * `'experimental'`, `'emulated'`, `'unverified'` or `false`, for `kind` where support differs
+ * by thread kind (or by alert kind for `securityAlerts`). Without `kind`, a
+ * per-kind verb reports its strongest level across kinds.
+ * @param capabilities The capabilities of a provider, such as `provider.capabilities`.
+ * @param verb The operation, named by its path on the provider, such as `threads.comment`.
+ * @param kind The thread or alert kind, for an operation whose support differs by kind.
+ */
+export declare function supportOf(capabilities: ForgeCapabilities, verb: ForgeVerb, kind?: ThreadKind | SecurityAlertKind): Support;
+//#endregion
+export { AZURE_DEVOPS_API_VERSION, type Actor, type AlertSupport, type AnonymousAuth, type AppAuth, type ApproveAndMergeOptions, type AuthKind, AuthenticationRequiredError, type AzureDevOpsAuth, type AzureDevOpsOptions, type BaseOptions, type BasicAuth, type BitbucketAuth, type BitbucketOptions, type Branch, type BulkNotificationOptions, type ChangedFile, type Check, type CheckRef, type CheckReportInput, type CheckState, type ChecksApi, type ChecksSummary, type CiApi, type CiJob, type CiJobRef, type CiRun, type CiRunQuery, type CiRunRef, type CloseOptions, type CloseReason, type CodeFragment, type CodeMatch, type CodeSearchQuery, type Collaborator, type Comment, type CommentRef, type Commit, type CommitQuery, type CommitRef, type CommitSearchQuery, type CommitSignature, type Comparison, ContentNotTextError, type ContentsApi, type Cursor, type CursorOriginAuth, type CursorOriginOptions, DATE_FIELDS, type EventAction, type EventDetail, type EventKind, type FetchLike, type FileContent, type FileEncoding, type FileMetadata, type FileOptions, type FileStatus, ForbiddenError, type ForbiddenReason, ForgeApiError, type ForgeCapabilities, ForgeError, type ForgeErrorContext, type ForgeEvent, type ForgeInstance, type ForgeIterable, type ForgeKind, ForgeNetworkError, type ForgeOptionsBase, type ForgeOrigin, type ForgeProvider, type ForgeProviderFactory, type ForgeRawRequestOptions, type ForgeRequest, type ForgeRequestOptions, type ForgeResponse, ForgeTimeoutError, type ForgeVerb, type ForgeWarning, type ForgeWarningCode, type ForgejoAuth, type ForgejoOptions, type Forges, type GetManyResult, type GitHubAuth, type GitHubOptions, type GitLabAuth, type GitLabOptions, type GiteaOptions, type GiteeAuth, type GiteeOptions, type Installation, type InstallationToken, type InstallationsApi, InsufficientScopeError, type KnownForgeKind, type Label, type LabelInput, type ListOptions, MergeBlockedError, MergeConflictError, type MergeMethod, MergeMethodRequiredError, type MergeOptions, type Milestone, type MilestoneListOptions, NotFoundError, type Notification, type NotificationListOptions, type NotificationReason, type NotificationRef, type NotificationSubject, type NotificationWriteOptions, type NotificationsApi, ORIGIN_API_VERSION, type Page, type PageOptions, type ParsedForgeUrl, type PerKind, type ProviderFactoryFunction, type PullBranches, type PushCommit, type PushinAuth, type PushinOptions, REACTION_CONTENTS, type RateLimit, RateLimitedError, type RawResponse, type Reaction, type ReactionContent, type ReactionSummary, ReadOnlyError, type ReferenceOptions, type Release, type ReleaseAsset, type ReleaseAssetRef, type ReleaseInput, type ReleaseRef, type ReleaseUpdate, type ReleasesApi, type Repo, type RepoAffiliation, type RepoFeatures, type RepoGetOptions, type RepoPermissions, type RepoQuery, type RepoRef, type RepoRole, type RepoSearchQuery, type RepoVisibility, type ReposApi, type ResolvedThreadRef, type Review, type ReviewComment, type ReviewCommentInput, type ReviewEvent, type ReviewInput, type ReviewRef, type ReviewState, type Reviewer, type SearchApi, type SearchQuery, type SecurityAlert, type SecurityAlertKind, type SecurityAlertListOptions, type SecurityAlertRef, type SecurityAlertsApi, type SecuritySeverity, type SourceKind, type SourcesApi, type SubscribeOptions, SubscriptionClosedError, type SubscriptionItem, type SubscriptionState, type Support, type Tag, type TangledAuth, type TangledOptions, type TextLimits, type Thread, type ThreadCreateInput, type ThreadKind, type ThreadQuery, type ThreadRef, type ThreadStack, type ThreadState, type ThreadUpdateInput, type ThreadsApi, type TokenAuth, TokenRevokedError, type TreeEntry, type TreeEntryType, type TreeOptions, UnknownForgeError, UnresolvedThreadError, UnsupportedOperationError, type UpsertCommentInput, type UpsertCommentResult, type UrlTarget, type User, type UsersApi, type VerbScopes, type WebSocketFactory, type WebSocketLike, type Webhook, type WebhookDelivery, type WebhookDeliveryRecord, type WebhookDeliveryRef, type WebhookEventType, type WebhookInput, type WebhookRef, type WebhookUpdate, WebhookVerificationError, type WebhooksApi, azureDevOps, azureDevOpsLite, bitbucket, bitbucketLite, commentMarker, createForges, cursorOrigin, cursorOriginLite, forgejo, forgejoLite, gitea, giteaLite, gitee, giteeLite, github, githubLite, gitlab, gitlabLite, hasCommentMarker, isNamespaceRef, isResolvedThread, namesAreCaseInsensitive, normaliseRepoName, notificationKey, notificationThread, parseForgeUrl, parseNotificationKey, parseRepoKey, parseThreadKey, pushin, repoKey, repoSlug, reviveDates, tangled, tangledLite, threadKey, threadSlug };

package/dist/index.mjs

@@ -0,0 +1,13 @@
+import { $ as threadKey, At as UnresolvedThreadError, B as isNamespaceRef, Ct as MergeMethodRequiredError, Dt as SubscriptionClosedError, Et as ReadOnlyError, F as supports, G as notificationThread, H as namesAreCaseInsensitive, I as DATE_FIELDS, J as parseThreadKey, K as parseNotificationKey, L as REACTION_CONTENTS, Mt as WebhookVerificationError, Ot as TokenRevokedError, P as supportOf, Q as reviveDates, R as commentMarker, St as MergeConflictError, Tt as RateLimitedError, U as normaliseRepoName, V as isResolvedThread, W as notificationKey, X as repoKey, Z as repoSlug, _t as ForgeError, a as parseForgeUrl, bt as InsufficientScopeError, et as threadSlug, gt as ForgeApiError, ht as ForbiddenError, jt as UnsupportedOperationError, kt as UnknownForgeError, mt as ContentNotTextError, pt as AuthenticationRequiredError, q as parseRepoKey, vt as ForgeNetworkError, wt as NotFoundError, xt as MergeBlockedError, yt as ForgeTimeoutError, z as hasCommentMarker } from "./define-D3yEXtKK.mjs";
+import { n as azureDevOps, r as azureDevOpsLite, t as AZURE_DEVOPS_API_VERSION } from "./azure-devops-DwQvL4TV.mjs";
+import { n as bitbucketLite, t as bitbucket } from "./bitbucket-CpcfJlYi.mjs";
+import { n as cursorOrigin, r as cursorOriginLite, t as ORIGIN_API_VERSION } from "./cursor-origin-BhqYx2oW.mjs";
+import { i as forgejoLite, n as forgejo } from "./forgejo-BCefbHUN.mjs";
+import { gitea, giteaLite } from "./gitea/index.mjs";
+import { n as giteeLite, t as gitee } from "./gitee-CA-f7Rs8.mjs";
+import { n as githubLite, t as github } from "./github-B0umL8_f.mjs";
+import { n as gitlabLite, t as gitlab } from "./gitlab-Bsr__Z0C.mjs";
+import { t as createForges } from "./provider-Ed1YhkQN.mjs";
+import { t as pushin } from "./pushin-CkxgJ2cU.mjs";
+import { n as tangledLite, t as tangled } from "./tangled-ChdPmiv-.mjs";
+export { AZURE_DEVOPS_API_VERSION, AuthenticationRequiredError, ContentNotTextError, DATE_FIELDS, ForbiddenError, ForgeApiError, ForgeError, ForgeNetworkError, ForgeTimeoutError, InsufficientScopeError, MergeBlockedError, MergeConflictError, MergeMethodRequiredError, NotFoundError, ORIGIN_API_VERSION, REACTION_CONTENTS, RateLimitedError, ReadOnlyError, SubscriptionClosedError, TokenRevokedError, UnknownForgeError, UnresolvedThreadError, UnsupportedOperationError, WebhookVerificationError, azureDevOps, azureDevOpsLite, bitbucket, bitbucketLite, commentMarker, createForges, cursorOrigin, cursorOriginLite, forgejo, forgejoLite, gitea, giteaLite, gitee, giteeLite, github, githubLite, gitlab, gitlabLite, hasCommentMarker, isNamespaceRef, isResolvedThread, namesAreCaseInsensitive, normaliseRepoName, notificationKey, notificationThread, parseForgeUrl, parseNotificationKey, parseRepoKey, parseThreadKey, pushin, repoKey, repoSlug, reviveDates, supportOf, supports, tangled, tangledLite, threadKey, threadSlug };

package/dist/kit.d.mts

@@ -0,0 +1,183 @@
+import { At as GetManyResult, B as Actor, Ct as ForgeEvent, Fn as Thread, Gt as Page, H as BaseOptions, It as ListOptions, J as CheckState, Jt as PushCommit, Kt as PageOptions, Ot as ForgeWarning, R as soleMergeMethod, S as ForgeErrorContext, Sn as ReviewState, Y as ChecksSummary, _t as EventKind, a as FetcherOptions, bt as FileMetadata, f as RequestOptions, gn as Review, h as parseLinkHeader, hn as ResolvedThreadRef, ht as EventAction, i as Fetcher, m as createRequest, p as createFetcher, pr as reactionContent, pt as Cursor, r as FetchResult, t as CreateRequestOptions, u as PaginateOptions, vt as FileContent, wt as ForgeEventInput, xt as FileOptions, z as toMergeError, zn as ThreadRef } from "./fetch-D4pSRvvA.mjs";
+import { F as WebhookDelivery, G as CAPABILITY_TABLE, H as WebLinks, K as CapabilityEntry, M as TokenAuth, R as GitHubShape, U as githubShapedWeb, p as ForgeIterable } from "./provider-CoZ7cCxp.mjs";
+import { a as ProviderBase, c as ProviderFactoryFunction, d as Verb, f as VerbKind, g as verb, h as perKind, i as MergeHooks, l as ProviderSpec, m as defineForgeProvider, n as CapabilityEnv, o as ProviderContext, p as WebhookHandlers, r as KindVerb, s as ProviderDefinition, t as AlertKind, u as SupportInput } from "./define-B2_4ob2i.mjs";
+//#region src/webhooks.d.ts
+/**
+ * Checks a hex HMAC-SHA256 of the raw body, sent in the first of `header`
+ * present, after an optional `prefix` such as `sha256=`. The delivery's own
+ * `secret` takes precedence over the provider's.
+ */
+export declare function verifyHmacSignature(delivery: WebhookDelivery, secret: string | undefined, { header, prefix }: {
+  header: string | readonly string[];
+  prefix?: string;
+}): Promise<boolean>;
+/** Checks a secret sent verbatim in `header`. */
+export declare function verifySharedToken(delivery: WebhookDelivery, secret: string | undefined, header: string): boolean;
+/** One ref update in a push delivery. */
+interface RefChange {
+  /** A full ref such as `refs/heads/main`, or a bare name when `refType` is given. */
+  ref: string;
+  /** Whether the ref is a branch or a tag. */
+  refType?: "branch" | "tag";
+  before?: string;
+  after?: string;
+  created?: boolean;
+  deleted?: boolean;
+  forced?: boolean;
+  commits?: PushCommit[];
+  /** Commits pushed, when the forge reports more than it sends. */
+  commitCount?: number;
+}
+/** The kind, detail and summary of one ref update in a push: a deletion, a creation, or new commits. */
+export declare function refEvent(who: string, change: RefChange): Pick<ForgeEventInput, "kind" | "action" | "detail" | "summary">;
+/** Native event names per normalised kind, as a forge names them in a hook subscription. */
+type NativeEventMap = Partial<Record<EventKind, readonly string[]>>;
+/** The forge's own event names for `events`, plus any `nativeEvents` passed through unchanged. */
+export declare function nativeEventsFor(map: NativeEventMap, events: EventKind[] | undefined, nativeEvents: string[] | undefined): string[];
+//#endregion
+//#region src/contents.d.ts
+/** Decodes base64, tolerating the newlines GitHub and Gitea wrap it in. */
+export declare function fromBase64(value: string): Uint8Array;
+/**
+ * Shapes bytes as the caller asked: UTF-8 text for `as: 'text'`, bytes
+ * otherwise. Rejects with {@link ContentNotTextError} when text was asked for
+ * and the bytes are not valid UTF-8.
+ */
+export declare function toFileContent(bytes: Uint8Array, file: FileMetadata, options: FileOptions | undefined, context?: {
+  forge?: string;
+  instance?: string;
+}): FileContent;
+//#endregion
+//#region src/crypto.d.ts
+/** Base64 for arbitrary bytes, a byte at a time so a large buffer cannot overflow the call stack. */
+export declare function toBase64(bytes: Uint8Array): string;
+/** Lowercase hex HMAC-SHA256 of `body` under `secret`. */
+export declare function hmacSha256Hex(secret: string, body: string | Uint8Array): Promise<string>;
+/** Constant-time comparison of two ASCII strings. */
+export declare function timingSafeEqual(a: string, b: string): boolean;
+/** The claims of a signed JWT. Other claims are passed through. */
+interface JwtClaims {
+  /** The issuer, such as the app ID. */
+  iss: string;
+  /** When the token was issued, in seconds since the epoch. */
+  iat: number;
+  /** When the token expires, in seconds since the epoch. */
+  exp: number;
+  [claim: string]: unknown;
+}
+/** Signs an RS256 JWT with a PEM-encoded RSA private key. */
+export declare function signRs256Jwt(privateKeyPem: string, claims: JwtClaims): Promise<string>;
+/** The value of a header, whatever the casing of `name`, from a `Headers` object or a plain record. */
+export declare function headerValue(headers: Headers | Record<string, string>, name: string): string | undefined;
+/** A request body as text. */
+export declare function bodyText(body: string | Uint8Array): string;
+/** Lowercase hex SHA-256 of `body`. */
+export declare function sha256Hex(body: string | Uint8Array): Promise<string>;
+/** Signs an EdDSA (Ed25519) JWT with a PKCS#8 PEM private key. `kid` goes in the JOSE header. */
+export declare function signEdDsaJwt(privateKeyPem: string, claims: JwtClaims, kid?: string): Promise<string>;
+/** An Ed25519 public key in JWK form, as served from a JWKS endpoint. */
+interface Ed25519Jwk {
+  /** The key type, always `OKP`. */
+  kty: "OKP";
+  /** The curve, always `Ed25519`. */
+  crv: "Ed25519";
+  /** The public key, base64url encoded. */
+  x: string;
+  kid?: string;
+}
+/** Verifies an Ed25519 signature (base64) over `data` with a JWK public key. */
+export declare function verifyEd25519(jwk: Ed25519Jwk, data: string | Uint8Array, signatureBase64: string): Promise<boolean>;
+/** Base64 HMAC-SHA256 of `body` under `secret`. */
+export declare function hmacSha256Base64(secret: string, body: string | Uint8Array): Promise<string>;
+//#endregion
+//#region src/events.d.ts
+/** Normalises a forge-native verb (`closed`, `close`, `synchronize`, ...) into an {@link EventAction}. */
+export declare function eventAction(raw: string | undefined): EventAction | undefined;
+/**
+ * Fills `action` from `actionRaw`, or from the last `.`/`:` segment of
+ * `kindRaw`, falling back to the kind's default verb, then `other`.
+ */
+export declare function completeEvent(event: ForgeEventInput): ForgeEvent;
+/** Normalises a forge-native review verdict (`APPROVED`, `changes_requested`, ...) into a {@link ReviewState}. */
+export declare function reviewState(raw: string | undefined): ReviewState;
+//#endregion
+//#region src/utils.d.ts
+/**
+ * Wraps a generator so warnings it reports are collected on the returned
+ * iterable rather than interrupting iteration.
+ */
+export declare function forgeIterable<T>(run: (warn: (warning: ForgeWarning) => void) => AsyncIterable<T>): ForgeIterable<T>;
+/** Drives a `page()` function until it reports no further cursor, collecting page warnings. */
+export declare function iteratePages<T, O extends {
+  cursor?: Cursor;
+} = ListOptions>(page: (options: O) => Promise<Page<T>>, options?: O): ForgeIterable<T>;
+/** Turns a caught error into a serialisable warning. */
+export declare function toWarning(code: string, error: unknown, subject?: string): ForgeWarning;
+/** Maps with at most `limit` calls in flight, preserving order. */
+export declare function mapConcurrent<T, R>(items: readonly T[], limit: number, fn: (item: T) => Promise<R>): Promise<R[]>;
+/** `threads.getMany` for forges without a batch endpoint. */
+export declare function getManyConcurrently(refs: ThreadRef[], get: (ref: ThreadRef, options?: BaseOptions) => Promise<Thread>, options?: BaseOptions): Promise<GetManyResult[]>;
+/** Compares dotted numeric versions, ignoring any suffix after the numbers. */
+export declare function versionAtLeast(version: string | undefined, minimum: string): boolean;
+/** Reads a timestamp from a forge response, or `undefined` when it is empty or not a date. */
+export declare function toDate(value: string | number | null | undefined): Date | undefined;
+/** The host of `baseUrl`, including the port when there is one. */
+export declare function hostOf(baseUrl: string): string;
+/** Narrows a ref to one a provider can address, or throws {@link UnresolvedThreadError}. */
+export declare function requireThread(ref: ThreadRef, context?: ForgeErrorContext): ResolvedThreadRef;
+/**
+ * Narrows a ref to an issue or pull request, or throws
+ * {@link UnsupportedOperationError} naming the verb that needs one.
+ */
+export declare function requireIssueOrPull(ref: ThreadRef, context: ForgeErrorContext, verb: string): ResolvedThreadRef & {
+  kind: "issue" | "pull_request";
+};
+/** The token in `auth`, read again on every call when it is a function. */
+export declare function resolveToken(auth: TokenAuth): Promise<string>;
+/** A login from either a login string or an actor. */
+export declare function actorLogin(actor: string | Actor): string;
+/** Maps one fetched page into a {@link Page}. The cursor is kept only when there is a next page. */
+export declare function toPage<R, T>(result: FetchResult<R[]>, map: (raw: R) => T | undefined, warnings?: ForgeWarning[]): Page<T>;
+/** Extra options for a listing: the query, how to select the items and map errors, and where to collect warnings. */
+interface ListingExtras extends Pick<PaginateOptions, "query" | "select" | "mapError"> {
+  /** Collects the non-fatal warnings of the listing. */
+  warnings?: ForgeWarning[];
+}
+/** One page of `path` as the model, with `options` mapped onto the forge's page-size parameter. */
+type Listing = <R, T>(path: string, options: PageOptions, map: (raw: R) => T | undefined, extras?: ListingExtras) => Promise<Page<T>>;
+/** Builds a {@link Listing} for a forge that names its page-size parameter `pageParam`. */
+export declare function createListing(fetcher: Fetcher, pageParam: string, defaultPerPage?: number): Listing;
+/**
+ * Chains listings that a forge serves from separate endpoints. The cursor
+ * `token` records which phase is next, ahead of the phase's own token.
+ */
+export declare function phased<T>(phases: Array<(cursor?: Cursor) => Promise<Page<T>>>, cursor?: Cursor): Promise<Page<T>>;
+/** Whether `labels` include every name in `wanted`; true when nothing is wanted. */
+export declare function hasEveryLabel(labels: ReadonlyArray<{
+  name: string;
+}> | undefined, wanted: readonly string[] | undefined): boolean;
+/** Any failure fails, else any pending is pending, else any unknown (or none at all) is unknown, else success. */
+export declare function summariseChecks(states: CheckState[], url?: string): ChecksSummary;
+/**
+ * Caches the result of `load` after its first call. A rejected load is
+ * forgotten so the next call retries; with `ttl` (milliseconds) a resolved
+ * value is reloaded once it is older than that.
+ */
+export declare function memo<T>(load: () => Promise<T>, ttl?: number): () => Promise<T>;
+/** {@link memo} per key. */
+export declare function memoBy<K, T>(load: (key: K) => Promise<T>): (key: K) => Promise<T>;
+/**
+ * A review standing in for an approval, vote or participant state on a forge
+ * that has no review objects. `comments` is `false` because there is nothing
+ * to hang inline comments on.
+ */
+export declare function syntheticReview(thread: ResolvedThreadRef, id: string, state: ReviewState, extras: {
+  author?: Actor;
+  stateRaw?: string;
+  submittedAt?: Date;
+  raw: unknown;
+}): Review;
+/** A label colour as six hex digits, with the `#` prefix the forge expects. `ededed` when none is given. */
+export declare function hexColour(colour: string | undefined, prefix?: "#" | ""): string;
+//#endregion
+export { type AlertKind, CAPABILITY_TABLE, type CapabilityEntry, type CapabilityEnv, type CreateRequestOptions, type Ed25519Jwk, type FetchResult, type Fetcher, type FetcherOptions, type ForgeEventInput, type GitHubShape, type JwtClaims, type KindVerb, type Listing, type ListingExtras, type MergeHooks, type NativeEventMap, type PaginateOptions, type ProviderBase, type ProviderContext, type ProviderDefinition, type ProviderFactoryFunction, type ProviderSpec, type RefChange, type RequestOptions, type SupportInput, type Verb, type VerbKind, type WebLinks, type WebhookHandlers, createFetcher, createRequest, defineForgeProvider, githubShapedWeb, parseLinkHeader, perKind, reactionContent, soleMergeMethod, toMergeError, verb };

package/dist/kit.mjs

@@ -0,0 +1,4 @@
+import { A as toPage, C as requireIssueOrPull, D as syntheticReview, E as summariseChecks, M as versionAtLeast, Nt as soleMergeMethod, O as toDate, Pt as toMergeError, S as phased, T as resolveToken, Y as reactionContent, _ as mapConcurrent, at as parseLinkHeader, ct as eventAction, d as forgeIterable, dt as fromBase64, f as getManyConcurrently, ft as toFileContent, g as iteratePages, h as hostOf, i as githubShapedWeb, it as createRequest, j as toWarning, l as createListing, lt as reviewState, m as hexColour, n as perKind, p as hasEveryLabel, r as verb, rt as createFetcher, s as actorLogin, st as completeEvent, t as defineForgeProvider, ut as CAPABILITY_TABLE, v as memo, w as requireThread, y as memoBy } from "./define-D3yEXtKK.mjs";
+import { a as sha256Hex, c as timingSafeEqual, i as hmacSha256Hex, l as toBase64, n as headerValue, o as signEdDsaJwt, r as hmacSha256Base64, s as signRs256Jwt, t as bodyText, u as verifyEd25519 } from "./crypto-CQNEyYHD.mjs";
+import { a as verifyHmacSignature, i as refEvent, o as verifySharedToken, r as nativeEventsFor } from "./webhooks-rn9-8lxT.mjs";
+export { CAPABILITY_TABLE, actorLogin, bodyText, completeEvent, createFetcher, createListing, createRequest, defineForgeProvider, eventAction, forgeIterable, fromBase64, getManyConcurrently, githubShapedWeb, hasEveryLabel, headerValue, hexColour, hmacSha256Base64, hmacSha256Hex, hostOf, iteratePages, mapConcurrent, memo, memoBy, nativeEventsFor, parseLinkHeader, perKind, phased, reactionContent, refEvent, requireIssueOrPull, requireThread, resolveToken, reviewState, sha256Hex, signEdDsaJwt, signRs256Jwt, soleMergeMethod, summariseChecks, syntheticReview, timingSafeEqual, toBase64, toDate, toFileContent, toMergeError, toPage, toWarning, verb, verifyEd25519, verifyHmacSignature, verifySharedToken, versionAtLeast };