@shivaedev/github 0.9.0 → 0.10.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.10.0 - 2026-11-02
+
+### Added
+
+- Add typed, byte-capped issue, user, collaborator-permission, commit, comparison and tree reads, plus paged issue, pull-request-file and commit lists on the GitHub service.
+- Let Schema-aware lists select arrays inside envelopes, pace each request and opt into skipping undecodable items. `listPages` reports decoded items and skipped counts for each page; `listBounded` includes the total `skipped` count alongside `items` and `truncated`. Existing numeric byte-limit arguments remain supported, and decoding still fails by default.
+- `GitHubApp.viewerRepositories(account)` accepts a GitHub account ID or login and returns readable and administrable installed repositories, with access results cached for 60 seconds across at most 100 accounts.
+
+### Fixed
+
+- Preserve configured GitHub API path prefixes in representation reads, lists and writes, App installation discovery and token exchange, and artifact API requests. API origins without a path keep their existing behavior.
+- Keep shared App clients independent of a single-installation Layer's repository and permission scope.
+
+### Breaking
+
+- `downloadArtifactArchive` now returns an array of `{ path, bytes }` files instead of raw ZIP bytes. Install the optional `@zip.js/zip.js` peer and consume these validated files instead of passing the result to an application ZIP reader. Extraction refuses unsafe paths, symlinks, duplicate paths and file/directory conflicts, with distinct typed errors. The default caps are 100 MiB of extracted contents and a per-entry compression ratio of 100:1; set `totalSizeLimit` and `compressionRatioLimit` to change them. The existing `byteLimit` still caps the downloaded ZIP.
+- The low-level `artifacts` constructor now takes `(apiUrl, rates)` and returns an Effect. Yield it with `HttpClient`, `GitHubToken` and `TokenRefresh` provided instead of passing those services as arguments.
+
 ## 0.9.0 - 2026-11-02
 
 ### Added

package/README.md

@@ -76,7 +76,7 @@ const diff = Effect.gen(function* () {
 
 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. Each page representation exposes `hasNext`, which reports whether its Link header names a next page without fetching it. 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.
 
-Use `listBounded(path, itemSchema, pageCap, byteLimit?)` to collect a prefix within a positive page cap. It returns `{ items, truncated }`; `truncated` is true exactly when the last fetched page names a next page. It never requests or decodes a page beyond the cap, and uses the same pagination and per-page byte limits as `list`.
+Use `listBounded(path, itemSchema, pageCap, options?)` to collect a prefix within a positive page cap. It returns `{ items, skipped, truncated }`; `truncated` is true exactly when the last fetched page names a next page. It never requests or decodes a page beyond the cap, and uses the same pagination and per-page byte limits as `list`.
 
 ```ts
 import { listBounded } from "@shivaedev/github/GitHub.ts";
@@ -84,6 +84,55 @@ import { listBounded } from "@shivaedev/github/GitHub.ts";
 const issues = listBounded("/repos/acme/widgets/issues", Issue, 2);
 ```
 
+### Enveloped lists and partial decoding
+
+`list`, `listPages` and `listBounded` accept either the existing numeric byte cap or a `ListOptions` object (from `@shivaedev/github/pagedLists.ts`) as their last argument. Set `arrayKey` to read an array inside an envelope, such as `check_runs` or `artifacts`. The options also accept `responseByteLimit` and the service's `beforeRequest` pacing callback. Item Schemas retain their decoding service requirements.
+
+```ts
+const checks = listBounded("/repos/acme/widgets/commits/main/check-runs", CheckRun, 2, {
+	arrayKey: "check_runs",
+	onDecodeError: "skip",
+	responseByteLimit: 2 * 1024 * 1024,
+});
+```
+
+Import `CheckRun` from `@shivaedev/github/checkRuns.ts`. Decoding fails at the first invalid item by default. With `onDecodeError: "skip"`, valid items keep their order and `skipped` counts rejected items across the fetched pages. Invalid JSON, a missing envelope key, a non-array value, HTTP failures and byte-limit failures still fail the read. A page containing only rejected items still follows its next Link. The page cap counts fetched pages, including empty pages, and never counts pages beyond the cap.
+
+`listPages(path, itemSchema, options?)` returns a Stream of `{ items, skipped, hasNext }` pages for consumers that need streaming counts. `list` flattens those pages into items. Both fetch only while consumed.
+
+### Daily repository reads
+
+The `GitHub` service includes Schema-decoded reads for common repository work:
+
+| Method                                                         | Result                                                             |
+| -------------------------------------------------------------- | ------------------------------------------------------------------ |
+| `getIssue(owner, repo, number, byteLimit?)`                    | `Issue`                                                            |
+| `getUser(username, byteLimit?)`                                | `User`                                                             |
+| `getCollaboratorPermission(owner, repo, username, byteLimit?)` | `CollaboratorPermission`                                           |
+| `getCommit(owner, repo, ref, byteLimit?)`                      | `CommitDetail`, including stats and optional files                 |
+| `compareCommits(owner, repo, base, head, byteLimit?)`          | `Comparison`, including commits, optional files and `totalCommits` |
+| `getTree(owner, repo, ref, options?)`                          | `GitTree`, including GitHub's `truncated` flag                     |
+| `listIssues(owner, repo, options?)`                            | Effect containing a Stream of decoded issue pages                  |
+| `listPullRequestFiles(owner, repo, number, options?)`          | Effect containing a Stream of decoded file pages                   |
+| `listCommits(owner, repo, options?)`                           | Effect containing a Stream of decoded commit pages                 |
+
+The Schemas live in `@shivaedev/github/repositorySchemas.ts` and `@shivaedev/github/gitSchemas.ts`. Results use camelCase field names. Commit authors can be null, file patches can be absent for binary files, and renamed files expose `previousFilename`.
+
+```ts
+const review = Effect.gen(function* () {
+	const github = yield* GitHub;
+	const issue = yield* github.getIssue("acme", "widgets", 3);
+	const pages = yield* github.listPullRequestFiles("acme", "widgets", 3, { responseByteLimit: 2 * 1024 * 1024 });
+	const files = yield* pages.pipe(
+		Stream.flatMap((page) => Stream.fromIterable(page.items)),
+		Stream.runCollect,
+	);
+	return { issue, files };
+});
+```
+
+These reads share the client's authentication, conditional representations and body caps. List options accept `query` for GitHub filters such as issue `state` or commit `sha`, along with the decoding and pacing options above. Lists request `per_page=100` unless overridden in `query`. Tree options accept `recursive` and `responseByteLimit`. Refs containing slashes are encoded as path segments. Compare and single-commit reads return one GitHub response; use `totalCommits` and GitHub's endpoint limits when choosing whether the response is sufficient for your application.
+
 ### 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.
@@ -135,6 +184,24 @@ Provide `app(privateKey)` once around `bothInstallations` or the application. Ea
 
 The shared cache holds at most 100 installation clients and evicts the least recently used client when full. Selecting a client renews its 30-minute idle lifetime; a client idle for that interval is replaced on its next selection. Expiry is lazy, with no background timer. Eviction discards the client's token and request state, and its next request exchanges a new token. Keep operations inside `withInstallation` so each selection uses the cache's current client.
 
+### Repositories visible to an account
+
+Pass the GitHub account from your application's session to `GitHubApp.viewerRepositories(account)`. A number is a GitHub account ID; a string is a login. Provide the same `githubApp(credentials)` Layer as above. The package has no dependency on your session or identity service.
+
+```ts
+import { Effect } from "effect";
+import { GitHubApp } from "@shivaedev/github/installationClients.ts";
+
+const access = Effect.gen(function* () {
+	const app = yield* GitHubApp;
+	return yield* app.viewerRepositories(12345);
+});
+```
+
+The result contains `readable` and `administrable` arrays. Each entry has `id`, `name`, `owner.login`, `htmlUrl`, `private` and `installationId`. Only repositories installed for this App are included, across all installation and repository pages. Public repositories are readable even without a collaborator grant. Private repositories require GitHub's `read`, `triage`, `write`, `maintain` or `admin` permission; only `admin` grants administration. A permission lookup returning 404 means no collaborator grant. Other lookup failures fail the operation instead of returning partial access. The App needs repository Metadata read permission for these lookups.
+
+Successful results are cached for 60 seconds, across at most 100 account keys, evicting the least recently used key when full. Login casing shares a key. Reads do not extend the lifetime. After expiry, the next call revalidates installation lists, repository lists and permissions, so revoked access, changed roles and removed repositories remain cached for at most that interval. Failed lookups are immediately eligible for another attempt. These are cached observations of GitHub access; the application chooses its authorization policy.
+
 `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.
@@ -147,26 +214,49 @@ Installation lookups and token exchanges follow the same primary and secondary r
 
 Other App authentication failures use `GitHubAppError` from `errors.ts`. Its string `reason` distinguishes `"sign"` (JWT signing), `"encode"` (request body encoding), `"transport"` (sending or reading the response), `"status"` (an HTTP refusal) and `"response"` (invalid or oversized response data). A refused exchange or installation lookup with HTTP 401 has `{ reason: "status", status: 401 }`. Caught failures remain available as a non-enumerable `cause`, excluded from JSON serialization; causes can contain credentials from the underlying HTTP request, so keep them in trusted diagnostics. The serialized errors, logs and spans exclude the private key, App JWT and installation token.
 
-### Downloading workflow-artifact archives
+### Downloading and extracting workflow artifacts
+
+Install the optional ZIP reader to extract artifacts:
+
+```sh
+pnpm add @zip.js/zip.js
+```
 
-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.
+Call `downloadArtifactArchive` with the artifact ID and a download 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 files = Effect.gen(function* () {
 	const github = yield* GitHub;
 	return yield* github.downloadArtifactArchive({
 		owner: "acme",
 		repo: "widgets",
 		artifactId: 7,
 		byteLimit: 10 * 1024 * 1024,
+		totalSizeLimit: 100 * 1024 * 1024,
+		compressionRatioLimit: 100,
 	});
 });
 ```
 
-Provide an installation client such as `clients(privateKey).background` from the GitHub App example 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.
+Provide an installation client such as `clients(privateKey).background` from the GitHub App example above. The result is an array of `{ path, bytes }` files (`ArtifactFile` from `artifactExtraction.ts`), with relative POSIX paths and `Uint8Array` contents. Directory entries are validated and omitted from the result. Extraction happens in memory and writes no files. The ZIP reader loads on demand; other GitHub operations do not need it.
+
+`byteLimit` caps the downloaded ZIP while streaming and fails with `GitHubArtifactTooLarge({ limit })` from `errors.ts`. Extraction defaults to a `totalSizeLimit` of 100 MiB across all entries and a per-entry `compressionRatioLimit` of 100:1. Both caps are inclusive. The total limit must be a non-negative safe integer; the ratio must be finite and positive. Limits check declared sizes before decompression and emitted bytes before retaining them. No partial file list is returned after a refusal.
+
+Extraction failures come from `artifactErrors.ts`:
+
+| Error                                             | Refusal                                                                                                           |
+| ------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------- |
+| `GitHubArtifactPathTraversal({ path })`           | Absolute paths, drive paths, backslashes, colons, NUL, empty or dot path components, and parent traversal         |
+| `GitHubArtifactSymlink({ path })`                 | Symbolic links                                                                                                    |
+| `GitHubArtifactDuplicateEntry({ path })`          | Duplicate paths and file/directory conflicts                                                                      |
+| `GitHubArtifactCompressionRatio({ path, limit })` | An entry exceeds the ratio cap                                                                                    |
+| `GitHubArtifactExtractedTooLarge({ limit })`      | Combined extracted contents exceed the total cap                                                                  |
+| `GitHubArtifactExtractionError({ reason })`       | Missing reader (`"reader-unavailable"`), malformed ZIP (`"invalid-archive"`) or invalid caps (`"invalid-limits"`) |
+
+Paths remain case-sensitive.
 
 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.
 

package/dist/GitHub.d.ts

@@ -1,8 +1,9 @@
 import { Effect, Schema, Stream } from "effect";
 import { HttpClient } from "effect/http";
 import { GitHubToken } from "#GitHubToken.ts";
+import { type ListOptions } from "#pagedLists.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").InvalidBodyLimit | 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 downloadArtifactArchive: (options: import("#artifacts.ts").ArtifactArchiveOptions) => Effect.Effect<import("./artifactExtraction.ts").ArtifactFile[], import("./errors.ts").GitHubAppError | import("./artifactErrors.ts").GitHubArtifactCompressionRatio | import("./artifactErrors.ts").GitHubArtifactDuplicateEntry | import("./errors.ts").GitHubArtifactError | import("./artifactErrors.ts").GitHubArtifactExtractedTooLarge | import("./artifactErrors.ts").GitHubArtifactExtractionError | import("./artifactErrors.ts").GitHubArtifactPathTraversal | import("./artifactErrors.ts").GitHubArtifactSymlink | 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").InvalidBodyLimit | 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"]>;
         hasNext: boolean;
@@ -146,6 +147,258 @@ export declare const GitHub: import("effect/Context").Service<"@shivaedev/github
         };
         readonly status: "completed" | "in_progress" | "pending" | "queued" | "requested" | "waiting";
     }, 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").InvalidBodyLimit | 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 compareCommits: (owner: string, repo: string, base: string, head: string, byteLimit?: number | undefined) => Effect.Effect<{
+        readonly aheadBy: number;
+        readonly behindBy: number;
+        readonly commits: readonly {
+            readonly author: {
+                readonly avatarUrl: string;
+                readonly htmlUrl: string;
+                readonly id: number;
+                readonly login: string;
+                readonly type: string;
+            } | null;
+            readonly commit: {
+                readonly author: {
+                    readonly date: string;
+                    readonly email: string;
+                    readonly name: string;
+                } | null;
+                readonly committer: {
+                    readonly date: string;
+                    readonly email: string;
+                    readonly name: string;
+                } | null;
+                readonly message: string;
+                readonly tree: {
+                    readonly sha: string;
+                    readonly url: string;
+                };
+            };
+            readonly committer: {
+                readonly avatarUrl: string;
+                readonly htmlUrl: string;
+                readonly id: number;
+                readonly login: string;
+                readonly type: string;
+            } | null;
+            readonly htmlUrl: string;
+            readonly parents: readonly {
+                readonly sha: string;
+                readonly url: string;
+            }[];
+            readonly sha: string;
+        }[];
+        readonly files?: readonly {
+            readonly additions: number;
+            readonly changes: number;
+            readonly deletions: number;
+            readonly filename: string;
+            readonly patch?: string | undefined;
+            readonly previousFilename?: string | undefined;
+            readonly sha: string;
+            readonly status: string;
+        }[] | undefined;
+        readonly status: "ahead" | "behind" | "diverged" | "identical";
+        readonly totalCommits: number;
+    }, 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").InvalidBodyLimit | import("@shivaedev/http/errors.ts").ResponseBodyTooLarge | Schema.SchemaError | import("@shivaedev/http/errors.ts").RemoteStatusError, never>;
+    readonly getCollaboratorPermission: (owner: string, repo: string, username: string, byteLimit?: number | undefined) => Effect.Effect<{
+        readonly permission: string;
+        readonly roleName: string;
+        readonly user: {
+            readonly avatarUrl: string;
+            readonly htmlUrl: string;
+            readonly id: number;
+            readonly login: string;
+            readonly type: 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").InvalidBodyLimit | import("@shivaedev/http/errors.ts").ResponseBodyTooLarge | Schema.SchemaError | import("@shivaedev/http/errors.ts").RemoteStatusError, never>;
+    readonly getCommit: (owner: string, repo: string, ref: string, byteLimit?: number | undefined) => Effect.Effect<{
+        readonly author: {
+            readonly avatarUrl: string;
+            readonly htmlUrl: string;
+            readonly id: number;
+            readonly login: string;
+            readonly type: string;
+        } | null;
+        readonly commit: {
+            readonly author: {
+                readonly date: string;
+                readonly email: string;
+                readonly name: string;
+            } | null;
+            readonly committer: {
+                readonly date: string;
+                readonly email: string;
+                readonly name: string;
+            } | null;
+            readonly message: string;
+            readonly tree: {
+                readonly sha: string;
+                readonly url: string;
+            };
+        };
+        readonly committer: {
+            readonly avatarUrl: string;
+            readonly htmlUrl: string;
+            readonly id: number;
+            readonly login: string;
+            readonly type: string;
+        } | null;
+        readonly htmlUrl: string;
+        readonly parents: readonly {
+            readonly sha: string;
+            readonly url: string;
+        }[];
+        readonly sha: string;
+        readonly files?: readonly {
+            readonly additions: number;
+            readonly changes: number;
+            readonly deletions: number;
+            readonly filename: string;
+            readonly patch?: string | undefined;
+            readonly previousFilename?: string | undefined;
+            readonly sha: string;
+            readonly status: string;
+        }[] | undefined;
+        readonly stats: {
+            readonly additions: number;
+            readonly deletions: number;
+            readonly total: number;
+        };
+    }, 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").InvalidBodyLimit | import("@shivaedev/http/errors.ts").ResponseBodyTooLarge | Schema.SchemaError | import("@shivaedev/http/errors.ts").RemoteStatusError, never>;
+    readonly getIssue: (owner: string, repo: string, number: number, byteLimit?: number | undefined) => Effect.Effect<{
+        readonly body: string | null;
+        readonly closedAt: string | null;
+        readonly createdAt: string;
+        readonly htmlUrl: string;
+        readonly id: number;
+        readonly labels: readonly (string | {
+            readonly name?: string | undefined;
+        })[];
+        readonly number: number;
+        readonly pullRequest?: {
+            readonly url: string;
+        } | undefined;
+        readonly state: "closed" | "open";
+        readonly title: string;
+        readonly updatedAt: string;
+        readonly user: {
+            readonly avatarUrl: string;
+            readonly htmlUrl: string;
+            readonly id: number;
+            readonly login: string;
+            readonly type: string;
+        } | null;
+    }, 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").InvalidBodyLimit | import("@shivaedev/http/errors.ts").ResponseBodyTooLarge | Schema.SchemaError | import("@shivaedev/http/errors.ts").RemoteStatusError, never>;
+    readonly getTree: (owner: string, repo: string, sha: string, options?: {
+        readonly recursive?: boolean;
+        readonly responseByteLimit?: number | undefined;
+    } | undefined) => Effect.Effect<{
+        readonly sha: string;
+        readonly tree: readonly {
+            readonly mode: string;
+            readonly path: string;
+            readonly sha: string;
+            readonly size?: number | undefined;
+            readonly type: "blob" | "commit" | "tree";
+            readonly url?: string | undefined;
+        }[];
+        readonly truncated: boolean;
+        readonly url: 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").InvalidBodyLimit | import("@shivaedev/http/errors.ts").ResponseBodyTooLarge | Schema.SchemaError | import("@shivaedev/http/errors.ts").RemoteStatusError, never>;
+    readonly getUser: (username?: string | undefined, byteLimit?: number | undefined) => Effect.Effect<{
+        readonly avatarUrl: string;
+        readonly htmlUrl: string;
+        readonly id: number;
+        readonly login: string;
+        readonly type: 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").InvalidBodyLimit | import("@shivaedev/http/errors.ts").ResponseBodyTooLarge | Schema.SchemaError | import("@shivaedev/http/errors.ts").RemoteStatusError, never>;
+    readonly listCommits: (owner: string, repo: string, options?: import("#repositoryReads.ts").RepositoryListOptions | undefined) => Effect.Effect<Stream.Stream<{
+        hasNext: boolean;
+        items: {
+            readonly author: {
+                readonly avatarUrl: string;
+                readonly htmlUrl: string;
+                readonly id: number;
+                readonly login: string;
+                readonly type: string;
+            } | null;
+            readonly commit: {
+                readonly author: {
+                    readonly date: string;
+                    readonly email: string;
+                    readonly name: string;
+                } | null;
+                readonly committer: {
+                    readonly date: string;
+                    readonly email: string;
+                    readonly name: string;
+                } | null;
+                readonly message: string;
+                readonly tree: {
+                    readonly sha: string;
+                    readonly url: string;
+                };
+            };
+            readonly committer: {
+                readonly avatarUrl: string;
+                readonly htmlUrl: string;
+                readonly id: number;
+                readonly login: string;
+                readonly type: string;
+            } | null;
+            readonly htmlUrl: string;
+            readonly parents: readonly {
+                readonly sha: string;
+                readonly url: string;
+            }[];
+            readonly sha: string;
+        }[];
+        skipped: number;
+    }, 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").InvalidBodyLimit | 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>, never, never>;
+    readonly listIssues: (owner: string, repo: string, options?: import("#repositoryReads.ts").RepositoryListOptions | undefined) => Effect.Effect<Stream.Stream<{
+        hasNext: boolean;
+        items: {
+            readonly body: string | null;
+            readonly closedAt: string | null;
+            readonly createdAt: string;
+            readonly htmlUrl: string;
+            readonly id: number;
+            readonly labels: readonly (string | {
+                readonly name?: string | undefined;
+            })[];
+            readonly number: number;
+            readonly pullRequest?: {
+                readonly url: string;
+            } | undefined;
+            readonly state: "closed" | "open";
+            readonly title: string;
+            readonly updatedAt: string;
+            readonly user: {
+                readonly avatarUrl: string;
+                readonly htmlUrl: string;
+                readonly id: number;
+                readonly login: string;
+                readonly type: string;
+            } | null;
+        }[];
+        skipped: number;
+    }, 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").InvalidBodyLimit | 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>, never, never>;
+    readonly listPullRequestFiles: (owner: string, repo: string, number: number, options?: import("#repositoryReads.ts").RepositoryListOptions | undefined) => Effect.Effect<Stream.Stream<{
+        hasNext: boolean;
+        items: {
+            readonly additions: number;
+            readonly changes: number;
+            readonly deletions: number;
+            readonly filename: string;
+            readonly patch?: string | undefined;
+            readonly previousFilename?: string | undefined;
+            readonly sha: string;
+            readonly status: string;
+        }[];
+        skipped: number;
+    }, 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").InvalidBodyLimit | 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>, never, never>;
     readonly upsertStickyComment: (input: {
         readonly appId?: number | undefined;
         readonly author?: string | undefined;
@@ -173,9 +426,15 @@ export declare const GitHub: import("effect/Context").Service<"@shivaedev/github
     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").InvalidBodyLimit | 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("@shivaedev/http/errors.ts").InvalidBodyLimit | 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 listBounded<TSchema extends Schema.Constraint>(path: string, schema: TSchema, pageCap: number, responseByteLimit?: number): Effect.Effect<{
+export declare function listPages<TSchema extends Schema.Constraint>(path: string, schema: TSchema, options?: ListOptions | number): Stream.Stream<{
+    hasNext: boolean;
+    items: TSchema["Type"][];
+    skipped: number;
+}, 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").InvalidBodyLimit | 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 list<TSchema extends Schema.Constraint>(path: string, schema: TSchema, options?: ListOptions | 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("@shivaedev/http/errors.ts").InvalidBodyLimit | 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 listBounded<TSchema extends Schema.Constraint>(path: string, schema: TSchema, pageCap: number, options?: ListOptions | number): Effect.Effect<{
     items: TSchema["Type"][];
+    skipped: number;
     truncated: boolean;
 }, 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").InvalidBodyLimit | 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"]>;
 type WriteMethod = "POST" | "PATCH" | "PUT" | "DELETE";

package/dist/GitHub.d.ts.map

@@ -1 +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,wfAEhH;AAED,wBAAgB,IAAI,CAAC,OAAO,SAAS,MAAM,CAAC,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,CAAC,EAAE,MAAM,2pBAKhH;AAED,wBAAgB,WAAW,CAAC,OAAO,SAAS,MAAM,CAAC,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,iBAAiB,CAAC,EAAE,MAAM;;;4nBAOxI;AAED,KAAK,WAAW,GAAG,MAAM,GAAG,OAAO,GAAG,KAAK,GAAG,QAAQ,CAAC;AAEvD,wBAAgB,KAAK,CAAC,OAAO,SAAS,MAAM,CAAC,UAAU,EACtD,MAAM,EAAE,WAAW,EACnB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,OAAO,EACb,MAAM,EAAE,OAAO,EACf,iBAAiB,CAAC,EAAE,MAAM,GACxB,UAAU,CAAC,OAAO,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC;AAC5C,wBAAgB,KAAK,CAAC,MAAM,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;AAK9H,iBAAS,YAAY,CAAC,OAAO,SAAS,MAAM,CAAC,UAAU,EACtD,MAAM,EAAE,WAAW,EACnB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,OAAO,EACb,MAAM,EAAE,OAAO,EACf,iBAAiB,CAAC,EAAE,MAAM,uiBAK1B"}
+{"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;AAC9C,OAAO,EAAgB,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAQhE,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCjB,CAAC;AAEH,wBAAgB,IAAI,CAAC,OAAO,SAAS,MAAM,CAAC,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,CAAC,EAAE,MAAM,wfAEhH;AAED,wBAAgB,SAAS,CAAC,OAAO,SAAS,MAAM,CAAC,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,MAAM;;;;4nBAEzH;AAED,wBAAgB,IAAI,CAAC,OAAO,SAAS,MAAM,CAAC,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,MAAM,2pBAEpH;AAED,wBAAgB,WAAW,CAAC,OAAO,SAAS,MAAM,CAAC,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,MAAM;;;;4nBAU5I;AAED,KAAK,WAAW,GAAG,MAAM,GAAG,OAAO,GAAG,KAAK,GAAG,QAAQ,CAAC;AAEvD,wBAAgB,KAAK,CAAC,OAAO,SAAS,MAAM,CAAC,UAAU,EACtD,MAAM,EAAE,WAAW,EACnB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,OAAO,EACb,MAAM,EAAE,OAAO,EACf,iBAAiB,CAAC,EAAE,MAAM,GACxB,UAAU,CAAC,OAAO,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC;AAC5C,wBAAgB,KAAK,CAAC,MAAM,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;AAK9H,iBAAS,YAAY,CAAC,OAAO,SAAS,MAAM,CAAC,UAAU,EACtD,MAAM,EAAE,WAAW,EACnB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,OAAO,EACb,MAAM,EAAE,OAAO,EACf,iBAAiB,CAAC,EAAE,MAAM,uiBAK1B"}

package/dist/GitHub.js

@@ -5,7 +5,9 @@ import { artifacts } from "#artifacts.ts";
 import { checkRuns } from "#checkRuns.ts";
 import { GitHubConfig } from "#GitHubConfig.ts";
 import { GitHubToken } from "#GitHubToken.ts";
+import { decodedPages } from "#pagedLists.ts";
 import { rateLimits } from "#rateLimits.ts";
+import { repositoryReads } from "#repositoryReads.ts";
 import { representations } from "#representations.ts";
 import { requests } from "#requests.ts";
 import { stickyComments } from "#stickyComments.ts";
@@ -20,7 +22,7 @@ export const GitHub = defineService({
         const refresh = yield* TokenRefresh;
         return {
             apiUrl: config.apiUrl,
-            archive: artifacts(config.apiUrl, client, token, rates, refresh),
+            archive: yield* artifacts(config.apiUrl, rates),
             rates,
             request: requests(client, token, rates, refresh),
             responseByteLimit: config.responseByteLimit,
@@ -34,6 +36,7 @@ export const GitHub = defineService({
             ...archive,
             ...stickyComments(client),
             ...checkRuns(client),
+            ...repositoryReads(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)),
@@ -44,11 +47,18 @@ export const GitHub = defineService({
 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 listPages(path, schema, options) {
+    return Stream.unwrap(Effect.map(GitHub, (github) => decodedPages(github, path, schema, options)));
 }
-export function listBounded(path, schema, pageCap, responseByteLimit) {
-    return Stream.unwrap(Effect.flatMap(GitHub, (github) => github.list(path, undefined, responseByteLimit))).pipe(Stream.take(pageCap), Stream.mapEffect((page) => Effect.map(page.decode(Schema.Array(schema)), (items) => ({ items, truncated: page.hasNext }))), Stream.runCollect, Effect.map((pages) => ({ items: pages.flatMap((page) => page.items), truncated: pages.at(-1)?.truncated ?? false })));
+export function list(path, schema, options) {
+    return listPages(path, schema, options).pipe(Stream.flatMap((page) => Stream.fromIterable(page.items)));
+}
+export function listBounded(path, schema, pageCap, options) {
+    return listPages(path, schema, options).pipe(Stream.take(pageCap), Stream.runCollect, Effect.map((pages) => ({
+        items: pages.flatMap((page) => page.items),
+        skipped: pages.reduce((count, page) => count + page.skipped, 0),
+        truncated: pages.at(-1)?.hasNext ?? false,
+    })));
 }
 export function write(method, path, body, schema = Schema.Void, responseByteLimit) {
     return writeDecoded(method, path, body, schema, responseByteLimit);

package/dist/GitHub.js.map

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

package/dist/adapters/resolveApiUrl.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveApiUrl(apiUrl: string, path: string): string;
+//# sourceMappingURL=resolveApiUrl.d.ts.map

package/dist/adapters/resolveApiUrl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveApiUrl.d.ts","sourceRoot":"","sources":["../../src/adapters/resolveApiUrl.ts"],"names":[],"mappings":"AAAA,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,UAIzD"}

package/dist/adapters/resolveApiUrl.js

@@ -0,0 +1,6 @@
+export function resolveApiUrl(apiUrl, path) {
+    const base = new URL(apiUrl);
+    base.pathname = `${base.pathname.replace(/\/$/u, "")}/`;
+    return new URL(path.replace(/^\/(?!\/)/u, ""), base).href;
+}
+//# sourceMappingURL=resolveApiUrl.js.map

package/dist/adapters/resolveApiUrl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveApiUrl.js","sourceRoot":"","sources":["../../src/adapters/resolveApiUrl.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,aAAa,CAAC,MAAc,EAAE,IAAY;IACzD,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,CAAC;IAC7B,IAAI,CAAC,QAAQ,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,GAAG,CAAC;IACxD,OAAO,IAAI,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC,IAAI,CAAC;AAC3D,CAAC"}

package/dist/adapters/zipEntries.d.ts

@@ -0,0 +1,17 @@
+import { Effect, Stream } from "effect";
+import { GitHubArtifactCompressionRatio, GitHubArtifactExtractedTooLarge, GitHubArtifactExtractionError } from "#artifactErrors.ts";
+interface ReadLimits {
+    readonly compressionRatioLimit: number;
+    readonly remaining: number;
+    readonly totalSizeLimit: number;
+}
+export declare const zipEntries: (bytes: Uint8Array<ArrayBufferLike>) => Effect.Effect<Stream.Stream<{
+    compressedSize: number;
+    directory: boolean;
+    path: string;
+    read: (limits: ReadLimits) => Effect.Effect<Uint8Array<ArrayBuffer>, GitHubArtifactCompressionRatio | GitHubArtifactExtractedTooLarge | GitHubArtifactExtractionError, never>;
+    symlink: boolean;
+    uncompressedSize: number;
+}, GitHubArtifactExtractionError, never>, GitHubArtifactExtractionError, never>;
+export {};
+//# sourceMappingURL=zipEntries.d.ts.map

package/dist/adapters/zipEntries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zipEntries.d.ts","sourceRoot":"","sources":["../../src/adapters/zipEntries.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACxC,OAAO,EAAE,8BAA8B,EAAE,+BAA+B,EAAE,6BAA6B,EAAE,MAAM,oBAAoB,CAAC;AAEpI,UAAU,UAAU;IACnB,QAAQ,CAAC,qBAAqB,EAAE,MAAM,CAAC;IACvC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CAChC;AAuCD,eAAO,MAAM,UAAU;;;;mBAgBL,UAAU;;;+EAK1B,CAAC"}