@shivaedev/github 0.0.0 → 0.5.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ShivaeDev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,240 @@
 # @shivaedev/github
 
-Placeholder. Real releases start above 0.0.0.
+GitHub integrations should share one client instead of repeating token headers, page loops and quota handling in every application. This package turns GitHub REST responses into Schema-decoded Effects and streams while keeping rate limits typed.
+
+## Read GitHub with less application code
+
+Describe the response you need and read it. Unchanged responses reuse their decoded value after ETag revalidation; paged lists fetch as you consume them.
+
+```ts
+import { Schema } from "effect";
+import { read } from "@shivaedev/github/GitHub.ts";
+
+const Repository = Schema.Struct({ name: Schema.String });
+const repository = read("/repos/acme/widgets", Repository);
+```
+
+## Using the client
+
+`GitHub` is a native Context service declared with `defineService`. Its Layer owns the conditional response cache and resource observations. Provide an Effect `HttpClient` and a `GitHubToken` once, then use the Schema-aware `read`, `list` and `write` functions. Schema decoding services remain visible in their requirements.
+
+```ts
+import { Effect, Layer, Schema, Stream } from "effect";
+import { FetchHttpClient } from "effect/http";
+import { GitHub, list, read, write } from "@shivaedev/github/GitHub.ts";
+import { GitHubToken } from "@shivaedev/github/GitHubToken.ts";
+
+const github = GitHub.layer.pipe(
+  Layer.provide(FetchHttpClient.layer),
+  Layer.provide(GitHubToken.fromEnv),
+);
+const Issue = Schema.Struct({ number: Schema.Number, title: Schema.String });
+const program = Effect.gen(function* () {
+  const issue = yield* read("/repos/acme/widgets/issues/1", Issue);
+  const first = yield* list("/repos/acme/widgets/issues", Issue).pipe(
+    Stream.take(1),
+    Stream.runCollect,
+  );
+  const created = yield* write("POST", "/repos/acme/widgets/issues", { title: "A new issue" }, Issue);
+  return { issue, first, created };
+});
+
+await Effect.runPromise(program.pipe(Effect.provide(github)));
+```
+
+`GitHubToken.fromEnv` reads `GH_TOKEN`, then `GITHUB_TOKEN`, through Effect Config. If neither is set, requests are unauthenticated. To supply a token directly, provide `GitHubToken` with `Option.some(Redacted.make(token))`; use `Option.none()` for anonymous access. Requests send `Accept: application/vnd.github+json` and `X-GitHub-Api-Version: 2022-11-28`.
+
+The default base URL is `https://api.github.com`. Provide `GitHubConfig` from `@shivaedev/github/GitHubConfig.ts` with `{ apiUrl }` for another GitHub API endpoint.
+
+`read(path, schema)` decodes a JSON response. `list(path, itemSchema)` returns a Stream of decoded items across GitHub's Link pages, and stops fetching when consumption stops. `write(method, path, body, schema)` sends JSON with `POST` or `PATCH` and decodes its response. JSON response bodies default to a 1 MiB cap. Set `GitHubConfig.responseByteLimit` once for a client or pass a trailing byte-limit argument to these helpers for one request. The cap applies to each list page and is enforced while reading, before Schema decoding; exceeding it fails with typed `ResponseBodyTooLarge` without buffering the complete body. The conditional cache holds up to 1000 representations and keeps decoded values separate for each Schema.
+
+For large comparisons and listings, allow up to 16 MiB through the same bounded, Schema-decoded path instead of maintaining a separate fetch, body reader and decoder in the application.
+
+```ts
+import { GitHubConfig } from "@shivaedev/github/GitHubConfig.ts";
+
+const largeGithub = GitHub.layer.pipe(
+  Layer.provide(FetchHttpClient.layer),
+  Layer.provide(GitHubToken.fromEnv),
+  Layer.provide(Layer.succeed(GitHubConfig)({
+    apiUrl: "https://api.github.com",
+    responseByteLimit: 16 * 1024 * 1024,
+  })),
+);
+const Comparison = Schema.Struct({ total_commits: Schema.Number });
+const comparison = read("/repos/acme/widgets/compare/main...feature", Comparison, 16 * 1024 * 1024);
+```
+
+`largeGithub` raises the client default; the final argument on `comparison` overrides the cap for that request, including when using a client with the default cap. A per-request cap can also lower the client default.
+
+For diff text and other raw bodies, obtain the service and call `text(path, accept, byteLimit)` or `bytes(path, accept, byteLimit)`. Both bound the body before returning it and use your chosen media type.
+
+```ts
+const diff = Effect.gen(function* () {
+  const github = yield* GitHub;
+  return yield* github.text("/repos/acme/widgets/pulls/1", "application/vnd.github.diff", 256 * 1024);
+});
+```
+
+The service's `read(path)` and `write(method, path, body)` return a representation with a generic `decode(schema)` method. Its `list(path)` returns an Effect containing a Stream of page representations. These methods accept the same trailing byte limit: `read(path, byteLimit)`, `write(method, path, body, byteLimit)` and `list(path, beforeRequest, byteLimit)`; pass `undefined` for `beforeRequest` when no pacing callback is needed. Prefer the exported functions for Schema-decoded items. A caller with a pacing policy can pass `github.list(path, beforeRequest)`: the callback receives the resource name before each page request, and its typed failure stops the stream. `github.resource(path)` returns the observed resource for that path, defaulting to core or search before the first response.
+
+### Acting as a GitHub App
+
+Provide `githubApp` as the `GitHubToken` Layer. With just the App ID and a PEM private key wrapped in `Redacted`, the client signs App JWTs for App-level requests. Add an installation ID for installation requests. Both use the same Schema-aware `read` and paginated `list` functions.
+
+```ts
+import { Layer, Redacted, Schema, Stream } from "effect";
+import { FetchHttpClient } from "effect/http";
+import { GitHub, list, read } from "@shivaedev/github/GitHub.ts";
+import { githubApp } from "@shivaedev/github/githubApp.ts";
+
+const clients = (privateKey: Redacted.Redacted<string>) => {
+  const credentials = { appId: "123456", privateKey };
+  const client = (auth: ReturnType<typeof githubApp>) => GitHub.layer.pipe(
+    Layer.provide(auth),
+    Layer.provide(FetchHttpClient.layer),
+  );
+  return {
+    app: client(githubApp(credentials)),
+    background: client(githubApp({ ...credentials, installationId: 7 })),
+    accessCheck: client(githubApp({
+      ...credentials, installationId: 7,
+      scope: { repositoryIds: [42], permissions: { metadata: "read" } },
+    })),
+  };
+};
+const appInfo = read("/app", Schema.Struct({ id: Schema.Number, slug: Schema.String }));
+const installations = list("/app/installations", Schema.Struct({ id: Schema.Number })).pipe(Stream.runCollect);
+const repository = read("/repos/acme/widgets", Schema.Struct({ id: Schema.Number, name: Schema.String }));
+```
+
+Provide `clients(privateKey).app` to `appInfo` or `installations`, and `.accessCheck` to `repository`, using `Effect.provide`. The `.background` client receives a full installation token. These Layers replace application-written JWT signing, installation-token exchanges, expiry timers and the resource-401 refresh wrapper; provide the client Layer once around the application or job for each installation and scope to share its token cache.
+
+`scope` accepts `repositoryIds` or `repositories` (repository names), and a `permissions` record of GitHub permission names to `"read"`, `"write"` or `"admin"`. Omit `scope` for the installation's full access. Explicit `{ permissions: { metadata: "read" } }` requests a metadata-only token for access checks. GitHub decides whether the requested scope is allowed.
+
+Alternatively, pass `{ appId, privateKey, owner: "acme", repository: "widgets", scope? }`. The Layer resolves the installation through `GET /repos/{owner}/{repo}/installation` before exchanging the App JWT for an installation token. Signing uses Node's built-in crypto. The RS256 JWT carries the App ID as `iss`, `iat` 60 seconds before the current time, and `exp` ten minutes ahead.
+
+`GitHubToken` accepts a static Option or a lazy Effect returning one; the client resolves it on each request. Code that reads the service directly must evaluate an Effect value before inspecting the Option, using `Effect.isEffect(value) ? yield* value : value`. Custom injection keeps the caller's token lifecycle.
+
+An installation token is fetched on the first request and reused until five minutes before `expires_at`, using Effect's Clock. Concurrent requests through the same Layer share the in-flight exchange, including at refresh. A resource 401 invalidates only the rejected cached token and retries once with a newly exchanged token; simultaneous 401s share that exchange. A second 401 fails with typed `RemoteUnauthorized`. App-level JWTs and custom tokens are not automatically retried.
+
+A rejected exchange fails with `GitHubAppError` from `errors.ts`; a 401 has `{ stage: "exchange", status: 401 }`. Signing failures have `stage: "sign"`. These errors and their logs and spans contain no private key, App JWT or installation token.
+
+### Downloading workflow-artifact archives
+
+Call `downloadArtifactArchive` with the artifact ID and a byte cap. It requests GitHub's ZIP endpoint with the current installation token, reads the 302 Location explicitly, and issues a fresh request to storage without the GitHub Authorization or API-version headers. Fetch requests use manual redirects and omit ambient credentials; provide an HTTP client without automatic redirect middleware.
+
+```ts
+import { Effect } from "effect";
+import { GitHub } from "@shivaedev/github/GitHub.ts";
+
+const archive = Effect.gen(function* () {
+  const github = yield* GitHub;
+  return yield* github.downloadArtifactArchive({
+    owner: "acme", repo: "widgets", artifactId: 7,
+    byteLimit: 10 * 1024 * 1024,
+  });
+});
+```
+
+Provide the same `appClient(privateKey)` Layer shown above. The result is a `Uint8Array` of archive bytes. The package counts bytes while streaming, independently of transport limits, and stops on overflow with `GitHubArtifactTooLarge({ limit })` from `errors.ts`. This replaces application-owned redirect handling and archive body limits. It does not extract the ZIP.
+
+A missing (404) or expired (410) artifact fails with `GitHubArtifactError({ stage: "redirect", status })`. A storage HTTP failure uses the same error with `stage: "download"`. Transport and GitHub rate-limit failures retain their usual typed errors.
+
+### Verifying webhooks
+
+Pass the raw request bytes and the `X-Hub-Signature-256` header to `verifyWebhook` before parsing the body. It checks HMAC SHA-256 with a constant-time comparison, then decodes JSON with your Schema. A missing header, tampered body or wrong secret fails with `GitHubWebhookSignatureError` before Schema decoding.
+
+```ts
+import { Redacted, Schema } from "effect";
+import { verifyWebhook } from "@shivaedev/github/verifyWebhook.ts";
+
+const WorkflowRun = Schema.Struct({
+  action: Schema.String,
+  workflowRun: Schema.Struct({ id: Schema.Number, conclusion: Schema.String }),
+}).pipe(Schema.encodeKeys({ workflowRun: "workflow_run" }));
+const receiveWorkflowRun = (
+  rawBody: Uint8Array,
+  signature: string | undefined,
+  secret: Redacted.Redacted<string>,
+) => verifyWebhook(rawBody, signature, secret, WorkflowRun);
+```
+
+This decodes a signed `workflow_run` delivery with the fields the application needs. Keep the body bytes as received: parsing and reserializing JSON changes what was signed.
+
+### Sticky comments and check runs
+
+Use the service's `upsertStickyComment` to keep a report in one pull-request comment. Pass a marker name; the method prefixes the body with `<!-- name -->`, searches comment pages, and edits the first match. It creates a comment when no match exists. By default the marker can appear anywhere in the existing body. An optional `author` login restricts matching to that author's comments, leaving another author's report alone.
+
+For a GitHub App, pass its numeric `appId`. Matching then requires the body to start with the marker, `performed_via_github_app.id` to equal that App ID, and `user.type` to be `"Bot"`. This replaces an application-owned comment scan and ownership predicate. The optional `author` login further restricts matching when supplied.
+
+```ts
+const report = Effect.gen(function* () {
+  const github = yield* GitHub;
+  return yield* github.upsertStickyComment({
+    owner: "acme", repo: "widgets", number: 1,
+    marker: "coverage", appId: 123456,
+    body: "Coverage: 90%",
+  });
+});
+```
+
+`createCheckRun(owner, repo, input)` creates a check for `headSha` with a name and status. `updateCheckRun(owner, repo, id, input)` moves it to `in_progress` or `completed`; completion requires a conclusion. Output contains `title`, `summary` and optional `text`. Request and response Schemas are exported from `checkRuns.ts`.
+
+```ts
+const check = (headSha: string) => Effect.gen(function* () {
+  const github = yield* GitHub;
+  const created = yield* github.createCheckRun("acme", "widgets", {
+    headSha, name: "Coverage", status: "queued",
+  });
+  yield* github.updateCheckRun("acme", "widgets", created.id, {
+    status: "in_progress", output: { title: "Coverage", summary: "Measuring" },
+  });
+  return yield* github.updateCheckRun("acme", "widgets", created.id, {
+    status: "completed", conclusion: "success",
+    output: { title: "Coverage", summary: "90% covered", text: "All targets measured" },
+  });
+});
+```
+
+### Rendering untrusted text
+
+Use the pure helpers from `markdown.ts` for test names and error messages. `plainText` encodes ASCII punctuation as HTML entities, including HTML delimiters and link syntax, and adds a zero-width separator after `@` and `#` to prevent mentions and issue references. `codeSpan` chooses a backtick fence longer than any run in the input and flattens line endings to spaces. `tableCell` flattens line endings and protects pipes; pass `"code"` for a code span inside a table cell. Emoji are preserved.
+
+```ts
+import { tableCell } from "@shivaedev/github/markdown.ts";
+import { renderRows } from "@shivaedev/github/markdownRows.ts";
+
+const rows = failures.map(({ name, error }) =>
+  `| ${tableCell(name)} | ${tableCell(error, "code")} |`,
+);
+const summary = renderRows(rows, {
+  header: "| Test | Error |\n| --- | --- |",
+  byteLimit: 8_000,
+});
+```
+
+`renderRows` accepts already-rendered rows and a trusted Markdown header. It counts UTF-8 bytes, keeps a prefix of complete rows and, when rows are dropped, appends one `and N more` paragraph. The header and notice count toward the budget; rows, emoji and escapes are never sliced. The default budget is 60,000 bytes. A budget too small for the header and notice throws `RangeError`.
+
+Use the result as a sticky comment body or check-run summary. The budget covers the rendered body; account for any surrounding text, including the sticky comment marker, when choosing a lower total limit.
+
+### Rate limits and failures
+
+`github.observations()` returns the latest `resource`, `limit`, `remaining`, `used` and UTC `reset` from response headers, including conditional and failed responses. Core and search budgets remain separate. A primary or secondary rate limit fails with `GitHubRateLimited` from `@shivaedev/github/errors.ts`; its `retryAt` is a UTC `DateTime` usable directly by a job scheduler. Requests to a blocked resource fail locally until that instant. Each rate-limited failure records a log and span event with the request path and budget, excluding credentials and query strings.
+
+A 403 with `"Resource not accessible by integration"` fails with `GitHubPermissionDenied`; a locked-conversation 403 fails with `GitHubConversationLocked`. Both come from `@shivaedev/github/errors.ts` and carry the request `path`. Rate-limit detection takes precedence. Other 403s remain `RemoteHttpError`. Applications can handle these tags instead of parsing GitHub error messages:
+
+```ts
+const publishReport = report.pipe(
+  Effect.catchTag("GitHubPermissionDenied", ({ path }) =>
+    Effect.succeed({ published: false, reason: "permissions", path }),
+  ),
+  Effect.catchTag("GitHubConversationLocked", ({ path }) =>
+    Effect.succeed({ published: false, reason: "locked", path }),
+  ),
+);
+```
+
+Other HTTP status failures use the typed `RemoteNotFound`, `RemoteUnauthorized` and other errors from `@shivaedev/http/errors.ts`. An oversized body fails with `ResponseBodyTooLarge`; invalid response data fails with `Schema.SchemaError`. Transport failures use `GitHubTransportError`, which contains only the request path.
+
+Install with `pnpm add @shivaedev/github effect`. Choose and provide an Effect HTTP client appropriate to your runtime. Scheduling, retries beyond the single installation-token refresh, and application policy stay with the caller.

package/dist/GitHub.d.ts

@@ -0,0 +1,93 @@
+import { Effect, Schema, Stream } from "effect";
+import { HttpClient } from "effect/http";
+import { GitHubToken } from "#GitHubToken.ts";
+export declare const GitHub: import("effect/Context").Service<"@shivaedev/github/GitHub", Readonly<{
+    readonly downloadArtifactArchive: (options: import("#artifacts.ts").ArtifactArchiveOptions) => Effect.Effect<Uint8Array<ArrayBuffer>, import("./errors.ts").GitHubAppError | import("./errors.ts").GitHubArtifactError | import("./errors.ts").GitHubArtifactTooLarge | import("./errors.ts").GitHubConversationLocked | import("./errors.ts").GitHubPermissionDenied | import("./errors.ts").GitHubRateLimited | import("./errors.ts").GitHubTransportError | import("@shivaedev/http/errors.ts").RemoteHttpError | import("@shivaedev/http/errors.ts").RemoteRateLimited | import("@shivaedev/http/errors.ts").RemoteUnauthorized | import("@shivaedev/http/errors.ts").ResponseBodyTooLarge, never>;
+    readonly list: (path: string, beforeRequest?: ((resource: string) => Effect.Effect<void, import("@shivaedev/errors/taxonomy.ts").ServiceUnavailable>) | undefined, byteLimit?: number | undefined) => Effect.Effect<Stream.Stream<{
+        decode: <TSchema extends Schema.Constraint>(schema: TSchema) => Effect.Effect<TSchema["Type"], Schema.SchemaError, TSchema["DecodingServices"]>;
+    }, import("./errors.ts").GitHubAppError | import("./errors.ts").GitHubConversationLocked | import("./errors.ts").GitHubPermissionDenied | import("./errors.ts").GitHubRateLimited | import("./errors.ts").GitHubTransportError | import("effect/Cause").NoSuchElementError | import("@shivaedev/http/errors.ts").PaginationLinkError | import("@shivaedev/http/errors.ts").ResponseBodyTooLarge | import("@shivaedev/errors/taxonomy.ts").ServiceUnavailable | import("@shivaedev/http/errors.ts").RemoteStatusError, never>, never, never>;
+    readonly read: (path: string, byteLimit?: number | undefined) => Effect.Effect<{
+        decode: <TSchema extends Schema.Constraint>(schema: TSchema) => Effect.Effect<TSchema["Type"], Schema.SchemaError, TSchema["DecodingServices"]>;
+    }, import("./errors.ts").GitHubAppError | import("./errors.ts").GitHubConversationLocked | import("./errors.ts").GitHubPermissionDenied | import("./errors.ts").GitHubRateLimited | import("./errors.ts").GitHubTransportError | import("@shivaedev/http/errors.ts").ResponseBodyTooLarge | import("@shivaedev/http/errors.ts").RemoteStatusError, never>;
+    readonly write: (method: "PATCH" | "POST", path: string, body: unknown, byteLimit?: number | undefined) => Effect.Effect<{
+        decode: <TSchema extends Schema.Constraint>(schema: TSchema) => Effect.Effect<TSchema["Type"], Schema.SchemaError, TSchema["DecodingServices"]>;
+    }, import("./errors.ts").GitHubAppError | import("./errors.ts").GitHubConversationLocked | import("./errors.ts").GitHubPermissionDenied | import("./errors.ts").GitHubRateLimited | import("./errors.ts").GitHubTransportError | import("effect/http/HttpBody").HttpBodyError | import("@shivaedev/http/errors.ts").ResponseBodyTooLarge | import("@shivaedev/http/errors.ts").RemoteStatusError, never>;
+    readonly createCheckRun: (owner: string, repo: string, input: {
+        readonly conclusion?: "action_required" | "cancelled" | "failure" | "neutral" | "skipped" | "stale" | "success" | "timed_out" | undefined;
+        readonly headSha: string;
+        readonly name: string;
+        readonly output?: {
+            readonly summary: string;
+            readonly text?: string | undefined;
+            readonly title: string;
+        } | undefined;
+        readonly status: "completed" | "in_progress" | "queued";
+    }) => Effect.Effect<{
+        readonly conclusion: "action_required" | "cancelled" | "failure" | "neutral" | "skipped" | "stale" | "success" | "timed_out" | null;
+        readonly headSha: string;
+        readonly id: number;
+        readonly name: string;
+        readonly output: {
+            readonly summary: string | null;
+            readonly text: string | null;
+            readonly title: string | null;
+        };
+        readonly status: "completed" | "in_progress" | "queued";
+    }, import("./errors.ts").GitHubAppError | import("./errors.ts").GitHubConversationLocked | import("./errors.ts").GitHubPermissionDenied | import("./errors.ts").GitHubRateLimited | import("./errors.ts").GitHubTransportError | import("effect/http/HttpBody").HttpBodyError | import("@shivaedev/http/errors.ts").ResponseBodyTooLarge | Schema.SchemaError | import("@shivaedev/http/errors.ts").RemoteStatusError, never>;
+    readonly updateCheckRun: (owner: string, repo: string, id: number, input: {
+        readonly output?: {
+            readonly summary: string;
+            readonly text?: string | undefined;
+            readonly title: string;
+        } | undefined;
+        readonly status: "in_progress" | "queued";
+    } | {
+        readonly conclusion: "action_required" | "cancelled" | "failure" | "neutral" | "skipped" | "stale" | "success" | "timed_out";
+        readonly output?: {
+            readonly summary: string;
+            readonly text?: string | undefined;
+            readonly title: string;
+        } | undefined;
+        readonly status: "completed";
+    }) => Effect.Effect<{
+        readonly conclusion: "action_required" | "cancelled" | "failure" | "neutral" | "skipped" | "stale" | "success" | "timed_out" | null;
+        readonly headSha: string;
+        readonly id: number;
+        readonly name: string;
+        readonly output: {
+            readonly summary: string | null;
+            readonly text: string | null;
+            readonly title: string | null;
+        };
+        readonly status: "completed" | "in_progress" | "queued";
+    }, import("./errors.ts").GitHubAppError | import("./errors.ts").GitHubConversationLocked | import("./errors.ts").GitHubPermissionDenied | import("./errors.ts").GitHubRateLimited | import("./errors.ts").GitHubTransportError | import("effect/http/HttpBody").HttpBodyError | import("@shivaedev/http/errors.ts").ResponseBodyTooLarge | Schema.SchemaError | import("@shivaedev/http/errors.ts").RemoteStatusError, never>;
+    readonly upsertStickyComment: (input: {
+        readonly appId?: number | undefined;
+        readonly author?: string | undefined;
+        readonly body: string;
+        readonly marker: string;
+        readonly number: number;
+        readonly owner: string;
+        readonly repo: string;
+    }) => Effect.Effect<{
+        readonly body: string;
+        readonly id: number;
+        readonly performedViaGithubApp?: {
+            readonly id: number;
+        } | null | undefined;
+        readonly user: {
+            readonly login: string;
+            readonly type?: string | undefined;
+        } | null;
+    }, import("./errors.ts").GitHubAppError | import("./errors.ts").GitHubConversationLocked | import("./errors.ts").GitHubPermissionDenied | import("./errors.ts").GitHubRateLimited | import("./errors.ts").GitHubTransportError | import("effect/http/HttpBody").HttpBodyError | import("effect/Cause").NoSuchElementError | import("@shivaedev/http/errors.ts").PaginationLinkError | import("@shivaedev/http/errors.ts").ResponseBodyTooLarge | Schema.SchemaError | import("@shivaedev/errors/taxonomy.ts").ServiceUnavailable | import("@shivaedev/http/errors.ts").RemoteStatusError, never>;
+    readonly bytes: (path: string, accept: string, limit: number) => Effect.Effect<Uint8Array<ArrayBufferLike>, import("./errors.ts").GitHubAppError | import("./errors.ts").GitHubConversationLocked | import("./errors.ts").GitHubPermissionDenied | import("./errors.ts").GitHubRateLimited | import("./errors.ts").GitHubTransportError | import("@shivaedev/http/errors.ts").ResponseBodyTooLarge | import("@shivaedev/http/errors.ts").RemoteStatusError, never>;
+    readonly observations: () => Effect.Effect<import("#rateLimits.ts").RateLimitObservation[], never, never>;
+    readonly resource: (path: string) => Effect.Effect<string, never, never>;
+    readonly text: (path: string, accept: string, limit: number) => Effect.Effect<string, import("./errors.ts").GitHubAppError | import("./errors.ts").GitHubConversationLocked | import("./errors.ts").GitHubPermissionDenied | import("./errors.ts").GitHubRateLimited | import("./errors.ts").GitHubTransportError | import("@shivaedev/http/errors.ts").ResponseBodyTooLarge | import("@shivaedev/http/errors.ts").RemoteStatusError, never>;
+}>> & {
+    readonly layer: import("effect/Layer").Layer<"@shivaedev/github/GitHub", never, GitHubToken | HttpClient.HttpClient>;
+};
+export declare function read<TSchema extends Schema.Constraint>(path: string, schema: TSchema, responseByteLimit?: number): Effect.Effect<TSchema["Type"], import("./errors.ts").GitHubAppError | import("./errors.ts").GitHubConversationLocked | import("./errors.ts").GitHubPermissionDenied | import("./errors.ts").GitHubRateLimited | import("./errors.ts").GitHubTransportError | import("@shivaedev/http/errors.ts").ResponseBodyTooLarge | Schema.SchemaError | import("@shivaedev/http/errors.ts").RemoteStatusError, "@shivaedev/github/GitHub" | TSchema["DecodingServices"]>;
+export declare function list<TSchema extends Schema.Constraint>(path: string, schema: TSchema, responseByteLimit?: number): Stream.Stream<TSchema["Type"], import("./errors.ts").GitHubAppError | import("./errors.ts").GitHubConversationLocked | import("./errors.ts").GitHubPermissionDenied | import("./errors.ts").GitHubRateLimited | import("./errors.ts").GitHubTransportError | import("effect/Cause").NoSuchElementError | import("@shivaedev/http/errors.ts").PaginationLinkError | import("@shivaedev/http/errors.ts").ResponseBodyTooLarge | Schema.SchemaError | import("@shivaedev/errors/taxonomy.ts").ServiceUnavailable | import("@shivaedev/http/errors.ts").RemoteStatusError, "@shivaedev/github/GitHub" | TSchema["DecodingServices"]>;
+export declare function write<TSchema extends Schema.Constraint>(method: "POST" | "PATCH", path: string, body: unknown, schema: TSchema, responseByteLimit?: number): Effect.Effect<TSchema["Type"], import("./errors.ts").GitHubAppError | import("./errors.ts").GitHubConversationLocked | import("./errors.ts").GitHubPermissionDenied | import("./errors.ts").GitHubRateLimited | import("./errors.ts").GitHubTransportError | import("effect/http/HttpBody").HttpBodyError | import("@shivaedev/http/errors.ts").ResponseBodyTooLarge | Schema.SchemaError | import("@shivaedev/http/errors.ts").RemoteStatusError, "@shivaedev/github/GitHub" | TSchema["DecodingServices"]>;
+//# sourceMappingURL=GitHub.d.ts.map

package/dist/GitHub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GitHub.d.ts","sourceRoot":"","sources":["../src/GitHub.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAKzC,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAO9C,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BjB,CAAC;AAEH,wBAAgB,IAAI,CAAC,OAAO,SAAS,MAAM,CAAC,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,CAAC,EAAE,MAAM,icAEhH;AAED,wBAAgB,IAAI,CAAC,OAAO,SAAS,MAAM,CAAC,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,CAAC,EAAE,MAAM,omBAKhH;AAED,wBAAgB,KAAK,CAAC,OAAO,SAAS,MAAM,CAAC,UAAU,EACtD,MAAM,EAAE,MAAM,GAAG,OAAO,EACxB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,OAAO,EACb,MAAM,EAAE,OAAO,EACf,iBAAiB,CAAC,EAAE,MAAM,gfAK1B"}

package/dist/GitHub.js

@@ -0,0 +1,53 @@
+import { Effect, Schema, Stream } from "effect";
+import { HttpClient } from "effect/http";
+import { defineService } from "@shivaedev/service/defineService.ts";
+import { artifacts } from "#artifacts.ts";
+import { checkRuns } from "#checkRuns.ts";
+import { GitHubConfig } from "#GitHubConfig.ts";
+import { GitHubToken } from "#GitHubToken.ts";
+import { rateLimits } from "#rateLimits.ts";
+import { representations } from "#representations.ts";
+import { requests } from "#requests.ts";
+import { stickyComments } from "#stickyComments.ts";
+import { TokenRefresh } from "#TokenRefresh.ts";
+export const GitHub = defineService({
+    id: "@shivaedev/github/GitHub",
+    initialize: Effect.gen(function* () {
+        const config = yield* GitHubConfig;
+        const rates = rateLimits();
+        const client = yield* HttpClient.HttpClient;
+        const token = yield* GitHubToken;
+        const refresh = yield* TokenRefresh;
+        return {
+            apiUrl: config.apiUrl,
+            archive: artifacts(config.apiUrl, client, token, rates, refresh),
+            rates,
+            request: requests(client, token, rates, refresh),
+            responseByteLimit: config.responseByteLimit,
+        };
+    }),
+    methods: ({ apiUrl, archive, rates, request, responseByteLimit }) => {
+        const { get, ...client } = representations(apiUrl, request, rates.resource, responseByteLimit);
+        return {
+            bytes: (path, accept, limit) => Effect.map(request(get(path, accept), limit), (entry) => entry.bytes),
+            ...client,
+            ...archive,
+            ...stickyComments(client),
+            ...checkRuns(client),
+            observations: () => Effect.sync(() => [...rates.observations.values()]),
+            resource: (path) => Effect.sync(() => rates.resource(new URL(path, apiUrl).pathname)),
+            text: (path, accept, limit) => Effect.map(request(get(path, accept), limit), (entry) => new TextDecoder().decode(entry.bytes)),
+        };
+    },
+    requires: [HttpClient.HttpClient, GitHubToken],
+});
+export function read(path, schema, responseByteLimit) {
+    return Effect.flatMap(GitHub, (github) => Effect.flatMap(github.read(path, responseByteLimit), (response) => response.decode(schema)));
+}
+export function list(path, schema, responseByteLimit) {
+    return Stream.unwrap(Effect.flatMap(GitHub, (github) => github.list(path, undefined, responseByteLimit))).pipe(Stream.mapEffect((response) => response.decode(Schema.Array(schema))), Stream.flatMap(Stream.fromIterable));
+}
+export function write(method, path, body, schema, responseByteLimit) {
+    return Effect.flatMap(GitHub, (github) => Effect.flatMap(github.write(method, path, body, responseByteLimit), (response) => response.decode(schema)));
+}
+//# sourceMappingURL=GitHub.js.map

package/dist/GitHub.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GitHub.js","sourceRoot":"","sources":["../src/GitHub.ts"],"names":[],"mappings":"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"}

package/dist/GitHubConfig.d.ts

@@ -0,0 +1,6 @@
+import { Context } from "effect";
+export declare const GitHubConfig: Context.Reference<{
+    readonly apiUrl: string;
+    readonly responseByteLimit?: number;
+}>;
+//# sourceMappingURL=GitHubConfig.d.ts.map

package/dist/GitHubConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GitHubConfig.d.ts","sourceRoot":"","sources":["../src/GitHubConfig.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AAEjC,eAAO,MAAM,YAAY;qBAAwC,MAAM;iCAA+B,MAAM;EAE1G,CAAC"}

package/dist/GitHubConfig.js

@@ -0,0 +1,5 @@
+import { Context } from "effect";
+export const GitHubConfig = Context.Reference("@shivaedev/github/GitHubConfig", {
+    defaultValue: () => ({ apiUrl: "https://api.github.com" }),
+});
+//# sourceMappingURL=GitHubConfig.js.map

package/dist/GitHubConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GitHubConfig.js","sourceRoot":"","sources":["../src/GitHubConfig.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AAEjC,MAAM,CAAC,MAAM,YAAY,GAAG,OAAO,CAAC,SAAS,CAAmE,gCAAgC,EAAE;IACjJ,YAAY,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,wBAAwB,EAAE,CAAC;CAC1D,CAAC,CAAC"}

package/dist/GitHubToken.d.ts

@@ -0,0 +1,9 @@
+import { Config, Context, Effect, Layer, type Option, type Redacted } from "effect";
+import type { GitHubAppError } from "./errors.ts";
+type Token = Option.Option<Redacted.Redacted<string>>;
+declare const GitHubToken_base: Context.ServiceClass<GitHubToken, "@shivaedev/github/GitHubToken", Effect.Effect<Token, GitHubAppError, never> | Token>;
+export declare class GitHubToken extends GitHubToken_base {
+    static readonly fromEnv: Layer.Layer<GitHubToken, Config.ConfigError, never>;
+}
+export {};
+//# sourceMappingURL=GitHubToken.d.ts.map

package/dist/GitHubToken.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GitHubToken.d.ts","sourceRoot":"","sources":["../src/GitHubToken.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,MAAM,EAAE,KAAK,QAAQ,EAAE,MAAM,QAAQ,CAAC;AACpF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD,KAAK,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;;AAEtD,qBAAa,WAAY,SAAQ,gBAA6G;IAC7I,MAAM,CAAC,QAAQ,CAAC,OAAO,sDAQrB;CACF"}

package/dist/GitHubToken.js

@@ -0,0 +1,8 @@
+import { Config, Context, Effect, Layer } from "effect";
+export class GitHubToken extends Context.Service()("@shivaedev/github/GitHubToken") {
+    static fromEnv = Layer.effect(GitHubToken)(Effect.gen(function* () {
+        const token = yield* Config.Redacted("GH_TOKEN").pipe(Config.orElse(() => Config.Redacted("GITHUB_TOKEN")), Config.option);
+        return token;
+    }));
+}
+//# sourceMappingURL=GitHubToken.js.map

package/dist/GitHubToken.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GitHubToken.js","sourceRoot":"","sources":["../src/GitHubToken.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAA8B,MAAM,QAAQ,CAAC;AAKpF,MAAM,OAAO,WAAY,SAAQ,OAAO,CAAC,OAAO,EAA6D,CAAC,+BAA+B,CAAC;IAC7I,MAAM,CAAU,OAAO,GAAG,KAAK,CAAC,MAAM,CAAC,WAAW,CAAC,CAClD,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;QACnB,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,IAAI,CACpD,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC,EACpD,MAAM,CAAC,MAAM,CACb,CAAC;QACF,OAAO,KAAK,CAAC;IACd,CAAC,CAAC,CACF,CAAC;CACF"}

package/dist/TokenRefresh.d.ts

@@ -0,0 +1,5 @@
+import { Context, type Effect, type Option, type Redacted } from "effect";
+type Refresh = (rejected: Option.Option<Redacted.Redacted<string>>) => Effect.Effect<unknown>;
+export declare const TokenRefresh: Context.Reference<Refresh | undefined>;
+export {};
+//# sourceMappingURL=TokenRefresh.d.ts.map

package/dist/TokenRefresh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TokenRefresh.d.ts","sourceRoot":"","sources":["../src/TokenRefresh.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,MAAM,EAAE,KAAK,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAE1E,KAAK,OAAO,GAAG,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;AAE9F,eAAO,MAAM,YAAY,wCAEvB,CAAC"}

package/dist/TokenRefresh.js

@@ -0,0 +1,5 @@
+import { Context } from "effect";
+export const TokenRefresh = Context.Reference("@shivaedev/github/TokenRefresh", {
+    defaultValue: () => undefined,
+});
+//# sourceMappingURL=TokenRefresh.js.map

package/dist/TokenRefresh.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TokenRefresh.js","sourceRoot":"","sources":["../src/TokenRefresh.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAA2C,MAAM,QAAQ,CAAC;AAI1E,MAAM,CAAC,MAAM,YAAY,GAAG,OAAO,CAAC,SAAS,CAAsB,gCAAgC,EAAE;IACpG,YAAY,EAAE,GAAG,EAAE,CAAC,SAAS;CAC7B,CAAC,CAAC"}

package/dist/appJwt.d.ts

@@ -0,0 +1,8 @@
+import { Effect, Redacted } from "effect";
+import { GitHubAppError } from "#errors.ts";
+export interface AppCredentials {
+    readonly appId: string;
+    readonly privateKey: Redacted.Redacted<string>;
+}
+export declare const appJwt: (options: AppCredentials) => Effect.Effect<Redacted.Redacted<string>, GitHubAppError, never>;
+//# sourceMappingURL=appJwt.d.ts.map

package/dist/appJwt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"appJwt.d.ts","sourceRoot":"","sources":["../src/appJwt.ts"],"names":[],"mappings":"AACA,OAAO,EAAS,MAAM,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE5C,MAAM,WAAW,cAAc;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;CAC/C;AAED,eAAO,MAAM,MAAM,8FAWjB,CAAC"}

package/dist/appJwt.js

@@ -0,0 +1,16 @@
+import { sign } from "node:crypto";
+import { Clock, Effect, Redacted } from "effect";
+import { GitHubAppError } from "#errors.ts";
+export const appJwt = Effect.fnUntraced(function* (options) {
+    const now = Math.floor((yield* Clock.currentTimeMillis) / 1000);
+    return yield* Effect.try({
+        catch: () => new GitHubAppError({ stage: "sign" }),
+        try: () => {
+            const header = Buffer.from(JSON.stringify({ alg: "RS256", typ: "JWT" })).toString("base64url");
+            const payload = Buffer.from(JSON.stringify({ exp: now + 600, iat: now - 60, iss: options.appId })).toString("base64url");
+            const input = `${header}.${payload}`;
+            return Redacted.make(`${input}.${sign("RSA-SHA256", Buffer.from(input), Redacted.value(options.privateKey)).toString("base64url")}`);
+        },
+    });
+});
+//# sourceMappingURL=appJwt.js.map

package/dist/appJwt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"appJwt.js","sourceRoot":"","sources":["../src/appJwt.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACnC,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAO5C,MAAM,CAAC,MAAM,MAAM,GAAG,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,OAAuB;IACzE,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,iBAAiB,CAAC,GAAG,IAAI,CAAC,CAAC;IAChE,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;QACxB,KAAK,EAAE,GAAG,EAAE,CAAC,IAAI,cAAc,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;QAClD,GAAG,EAAE,GAAG,EAAE;YACT,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;YAC/F,MAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,EAAE,GAAG,EAAE,GAAG,GAAG,EAAE,EAAE,GAAG,EAAE,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;YACzH,MAAM,KAAK,GAAG,GAAG,MAAM,IAAI,OAAO,EAAE,CAAC;YACrC,OAAO,QAAQ,CAAC,IAAI,CAAC,GAAG,KAAK,IAAI,IAAI,CAAC,YAAY,EAAE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;QACtI,CAAC;KACD,CAAC,CAAC;AACJ,CAAC,CAAC,CAAC"}

package/dist/artifacts.d.ts

@@ -0,0 +1,16 @@
+import { Effect } from "effect";
+import { HttpClient } from "effect/http";
+import { GitHubArtifactError, GitHubArtifactTooLarge, GitHubTransportError } from "./errors.ts";
+import type { GitHubToken } from "./GitHubToken.ts";
+import type { RateLimits } from "./rateLimits.ts";
+import type { TokenRefresh } from "./TokenRefresh.ts";
+export interface ArtifactArchiveOptions {
+    readonly artifactId: number;
+    readonly byteLimit: number;
+    readonly owner: string;
+    readonly repo: string;
+}
+export declare function artifacts(apiUrl: string, client: HttpClient.HttpClient, token: GitHubToken["Service"], rates: RateLimits, refresh?: typeof TokenRefresh.Service): {
+    downloadArtifactArchive: (options: ArtifactArchiveOptions) => Effect.Effect<Uint8Array<ArrayBuffer>, import("./errors.ts").GitHubAppError | GitHubArtifactError | GitHubArtifactTooLarge | import("./errors.ts").GitHubConversationLocked | import("./errors.ts").GitHubPermissionDenied | import("./errors.ts").GitHubRateLimited | GitHubTransportError | import("@shivaedev/http/errors.ts").RemoteHttpError | import("@shivaedev/http/errors.ts").RemoteRateLimited | import("@shivaedev/http/errors.ts").RemoteUnauthorized | import("@shivaedev/http/errors.ts").ResponseBodyTooLarge, never>;
+};
+//# sourceMappingURL=artifacts.d.ts.map

package/dist/artifacts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifacts.d.ts","sourceRoot":"","sources":["../src/artifacts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAmB,UAAU,EAAqB,MAAM,aAAa,CAAC;AAG7E,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAChG,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD,MAAM,WAAW,sBAAsB;IACtC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,SAAS,CACxB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,UAAU,CAAC,UAAU,EAC7B,KAAK,EAAE,WAAW,CAAC,SAAS,CAAC,EAC7B,KAAK,EAAE,UAAU,EACjB,OAAO,GAAE,OAAO,YAAY,CAAC,OAAmB;IAK/C,uBAAuB,YAAY,sBAAsB;EA8B1D"}

package/dist/artifacts.js

@@ -0,0 +1,31 @@
+import { Effect } from "effect";
+import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/http";
+import { readBoundedBody } from "@shivaedev/http/body.ts";
+import { authenticatedRequest } from "./authenticatedRequest.js";
+import { GitHubArtifactError, GitHubArtifactTooLarge, GitHubTransportError } from "./errors.js";
+export function artifacts(apiUrl, client, token, rates, refresh = undefined) {
+    const send = authenticatedRequest(HttpClient.withScope(client), token, rates, refresh);
+    const download = HttpClient.withScope(client);
+    return {
+        downloadArtifactArchive: (options) => Effect.scoped(Effect.gen(function* () {
+            const path = `/repos/${encodeURIComponent(options.owner)}/${encodeURIComponent(options.repo)}/actions/artifacts/${options.artifactId}/zip`;
+            const redirect = yield* send(HttpClientRequest.get(new URL(path, apiUrl).href, { accept: "application/vnd.github+json" }), "manual").pipe(Effect.catchTags({
+                RemoteGone: (error) => Effect.fail(new GitHubArtifactError({ stage: "redirect", status: error.status })),
+                RemoteNotFound: (error) => Effect.fail(new GitHubArtifactError({ stage: "redirect", status: error.status })),
+            }));
+            const location = redirect.headers.location;
+            if (redirect.status !== 302 || location === undefined) {
+                return yield* new GitHubArtifactError({ stage: "redirect", status: redirect.status });
+            }
+            const response = yield* download.get(location).pipe(Effect.provideService(FetchHttpClient.RequestInit, { credentials: "omit", redirect: "manual" }), Effect.mapError(() => new GitHubTransportError({ path })));
+            if (response.status < 200 || response.status >= 300) {
+                return yield* new GitHubArtifactError({ stage: "download", status: response.status });
+            }
+            return yield* readBoundedBody(response, options.byteLimit).pipe(Effect.catchTags({
+                HttpClientError: () => Effect.fail(new GitHubTransportError({ path })),
+                ResponseBodyTooLarge: ({ limit }) => Effect.fail(new GitHubArtifactTooLarge({ limit })),
+            }));
+        })),
+    };
+}
+//# sourceMappingURL=artifacts.js.map

package/dist/artifacts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifacts.js","sourceRoot":"","sources":["../src/artifacts.ts"],"names":[],"mappings":"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"}