@alchemy.run/pkg 2.0.0-beta.80 → 2.0.0-beta.81

package/src/Registry/GitHub.ts

@@ -1,3 +1,4 @@
+import * as crypto from "node:crypto";
 import * as Github from "@distilled.cloud/github";
 import * as Actions from "@distilled.cloud/github/actions";
 import * as Apps from "@distilled.cloud/github/apps";
@@ -12,19 +13,16 @@ import * as DateTime from "effect/DateTime";
 import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
 import { Base64Url } from "effect/encoding";
+import * as HttpClient from "effect/http/HttpClient";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Redacted from "effect/Redacted";
 import * as Schema from "effect/Schema";
 import * as Stream from "effect/Stream";
-import * as HttpClient from "effect/http/HttpClient";
-import * as crypto from "node:crypto";
 import { COMMENT_MARKER, RegistryConfig } from "./Bindings.ts";
 import * as KVCache from "./KVCache.ts";
 
-export class CryptoError extends Data.TaggedError("CryptoError")<{
-  readonly message: string;
-}> {}
+export class CryptoError extends Data.TaggedError("CryptoError")<{ readonly message: string }> {}
 
 export class AppNotInstalled extends Data.TaggedError("AppNotInstalled")<{
   readonly repo: string;
@@ -38,20 +36,14 @@ export class AppNotInstalled extends Data.TaggedError("AppNotInstalled")<{
 export const importPrivateKey = (pem: string) =>
   Effect.try({
     try: () => crypto.createPrivateKey({ key: pem }),
-    catch: (cause) =>
-      new CryptoError({ message: `invalid private key: ${cause}` }),
+    catch: (cause) => new CryptoError({ message: `invalid private key: ${cause}` }),
   });
 
 /** Sign a compact RS256 JWT, used to authenticate as the GitHub App. */
-export const signJwt = (
-  claims: Record<string, unknown>,
-  key: crypto.KeyObject,
-) =>
+export const signJwt = (claims: Record<string, unknown>, key: crypto.KeyObject) =>
   Effect.try({
     try: () => {
-      const header = Base64Url.encode(
-        JSON.stringify({ alg: "RS256", typ: "JWT" }),
-      );
+      const header = Base64Url.encode(JSON.stringify({ alg: "RS256", typ: "JWT" }));
       const payload = Base64Url.encode(JSON.stringify(claims));
       const input = `${header}.${payload}`;
       const signature = crypto.sign("sha256", Buffer.from(input), key);
@@ -69,21 +61,14 @@ export const renderInstalls = (
   packages: ReadonlyArray<{ name: string; group: string; url: string }>,
   groups: ReadonlyArray<{ name: string; collapsed: boolean }>,
 ) => {
-  const collapsed = new Set(
-    groups.filter((g) => g.collapsed).map((g) => g.name),
-  );
+  const collapsed = new Set(groups.filter((g) => g.collapsed).map((g) => g.name));
   // One code block per package so each command has its own copy button, in
   // the order the manifest lists them, which is the order they were given
   // to `pkg pack`. Blank lines around the markdown inside `<details>` are
   // what make GitHub render it.
   return Object.entries(Arr.groupBy(packages, (pkg) => pkg.group))
     .flatMap(([group, members]) => {
-      const installs = members.flatMap(({ url }) => [
-        "```sh",
-        `pnpm install ${url}`,
-        "```",
-        "",
-      ]);
+      const installs = members.flatMap(({ url }) => ["```sh", `pnpm install ${url}`, "```", ""]);
       return collapsed.has(group)
         ? [
             "<details>",
@@ -177,10 +162,7 @@ const make = Effect.gen(function* () {
     const pem = yield* config.github.privateKey;
     const key = yield* importPrivateKey(Redacted.value(pem));
     const now = Math.floor((yield* Clock.currentTimeMillis) / 1000);
-    return yield* signJwt(
-      { iat: now - 60, exp: now + 540, iss: yield* config.github.appId },
-      key,
-    );
+    return yield* signJwt({ iat: now - 60, exp: now + 540, iss: yield* config.github.appId }, key);
   });
 
   // Failures are not kept: the next call retries the mint.
@@ -190,17 +172,12 @@ const make = Effect.gen(function* () {
     (repo) =>
       Effect.gen(function* () {
         const jwt = yield* appJwt;
-        const installation = yield* as(
-          jwt,
-          Apps.getRepoInstallation(split(repo)),
-        ).pipe(
+        const installation = yield* as(jwt, Apps.getRepoInstallation(split(repo))).pipe(
           Effect.catchTag("NotFound", () => new AppNotInstalled({ repo })),
         );
         const access = yield* as(
           jwt,
-          Apps.createInstallationAccessToken({
-            installation_id: installation.id,
-          }),
+          Apps.createInstallationAccessToken({ installation_id: installation.id }),
         );
         const now = yield* Clock.currentTimeMillis;
         return {
@@ -214,17 +191,12 @@ const make = Effect.gen(function* () {
   );
 
   /** A GitHub operation run as the App's installation on `repo`. */
-  const asInstallation = <A, E, R>(
-    repo: string,
-    operation: Effect.Effect<A, E, R>,
-  ) => Effect.flatMap(tokens(repo), (token) => as(token, operation));
+  const asInstallation = <A, E, R>(repo: string, operation: Effect.Effect<A, E, R>) =>
+    Effect.flatMap(tokens(repo), (token) => as(token, operation));
 
   return {
     getRun: (repo: string, runId: number) =>
-      asInstallation(
-        repo,
-        Actions.getWorkflowRun({ ...split(repo), run_id: runId }),
-      ),
+      asInstallation(repo, Actions.getWorkflowRun({ ...split(repo), run_id: runId })),
 
     /**
      * Artifacts named `name` uploaded to a run so far, including by jobs
@@ -233,12 +205,7 @@ const make = Effect.gen(function* () {
     listRunArtifacts: (repo: string, runId: number, name: string) =>
       asInstallation(
         repo,
-        Actions.listWorkflowRunArtifacts({
-          ...split(repo),
-          run_id: runId,
-          name,
-          per_page: 100,
-        }),
+        Actions.listWorkflowRunArtifacts({ ...split(repo), run_id: runId, name, per_page: 100 }),
       ).pipe(Effect.map((page) => page.artifacts)),
 
     /**
@@ -246,12 +213,7 @@ const make = Effect.gen(function* () {
      * repository the commit was pushed to. Commit-associated PR lookups can
      * return no results for forks, so discover candidates by owner and branch.
      */
-    pullRequestsForCommit: (
-      repo: string,
-      headRepo: string,
-      headBranch: string,
-      sha: string,
-    ) =>
+    pullRequestsForCommit: (repo: string, headRepo: string, headBranch: string, sha: string) =>
       asInstallation(
         repo,
         Pulls.list({
@@ -309,28 +271,16 @@ const make = Effect.gen(function* () {
      * Create or update the comment on `issue` whose body starts with
      * `marker`, looking through the first five pages of comments.
      */
-    upsertComment: (
-      repo: string,
-      issue: number,
-      marker: string,
-      body: string,
-    ) =>
+    upsertComment: (repo: string, issue: number, marker: string, body: string) =>
       Effect.gen(function* () {
         const comments = Stream.paginate(1, (page) =>
           asInstallation(
             repo,
-            Issues.listComments({
-              ...split(repo),
-              issue_number: issue,
-              per_page: 100,
-              page,
-            }),
+            Issues.listComments({ ...split(repo), issue_number: issue, per_page: 100, page }),
           ).pipe(
             Effect.map((comments) => [
               comments,
-              comments.length < 100 || page >= 5
-                ? Option.none()
-                : Option.some(page + 1),
+              comments.length < 100 || page >= 5 ? Option.none() : Option.some(page + 1),
             ]),
           ),
         );
@@ -344,29 +294,20 @@ const make = Effect.gen(function* () {
           onNone: () =>
             asInstallation(
               repo,
-              Issues.createComment({
-                ...split(repo),
-                issue_number: issue,
-                body,
-              }),
+              Issues.createComment({ ...split(repo), issue_number: issue, body }),
             ),
           onSome: (comment) =>
             asInstallation(
               repo,
-              Issues.updateComment({
-                ...split(repo),
-                comment_id: comment.id,
-                body,
-              }),
+              Issues.updateComment({ ...split(repo), comment_id: comment.id, body }),
             ),
         });
       }),
   };
 });
 
-export class GitHubApp extends Context.Service<
-  GitHubApp,
-  Effect.Success<typeof make>
->()("@alchemy.run/pkg/GitHubApp") {}
+export class GitHubApp extends Context.Service<GitHubApp, Effect.Success<typeof make>>()(
+  "@alchemy.run/pkg/GitHubApp",
+) {}
 
 export const GitHubAppLive = Layer.effect(GitHubApp, make);

package/src/Registry/Handler.ts

@@ -5,17 +5,17 @@ import * as Clock from "effect/Clock";
 import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
 import { Hex } from "effect/encoding";
-import * as Layer from "effect/Layer";
-import * as Path from "effect/Path";
-import * as Result from "effect/Result";
-import * as Schema from "effect/Schema";
+import * as HttpApiBuilder from "effect/http-api/HttpApiBuilder";
 import * as Etag from "effect/http/Etag";
 import * as FetchHttpClient from "effect/http/FetchHttpClient";
 import * as HttpPlatform from "effect/http/HttpPlatform";
 import * as HttpRouter from "effect/http/HttpRouter";
 import { HttpServerRequest } from "effect/http/HttpServerRequest";
 import * as HttpServerResponse from "effect/http/HttpServerResponse";
-import * as HttpApiBuilder from "effect/http-api/HttpApiBuilder";
+import * as Layer from "effect/Layer";
+import * as Path from "effect/Path";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
 import { ManifestJson, type ManifestPackage } from "../Manifest.ts";
 import {
   BadRequest,
@@ -28,14 +28,7 @@ import {
   RunRef,
   Upstream,
 } from "../Protocol.ts";
-import {
-  Bucket,
-  Cache,
-  COMMENT_MARKER,
-  Database,
-  RegistryConfig,
-  tarballKey,
-} from "./Bindings.ts";
+import { Bucket, Cache, COMMENT_MARKER, Database, RegistryConfig, tarballKey } from "./Bindings.ts";
 import * as GitHub from "./GitHub.ts";
 import * as KVCache from "./KVCache.ts";
 import { sweep } from "./Sweep.ts";
@@ -98,9 +91,7 @@ export const tagsFor = (run: Run): string[] => {
 
 /** The tag install commands are written against. */
 export const installTag = (run: Run) =>
-  run.pr !== null
-    ? `pr:${run.pr}:${run.headSha.slice(0, SHORT)}`
-    : run.headSha.slice(0, SHORT);
+  run.pr !== null ? `pr:${run.pr}:${run.headSha.slice(0, SHORT)}` : run.headSha.slice(0, SHORT);
 
 const upstream = (e: { readonly _tag: string; readonly message?: string }) =>
   new Upstream({ message: GitHub.describe(e) });
@@ -123,9 +114,7 @@ const lookupRun = Effect.fn("lookupRun")(function* (ref: RunRef) {
   if (!policy.repos.includes(ref.repo)) {
     return yield* new Forbidden({ message: `${ref.repo} may not publish` });
   }
-  const data = yield* github
-    .getRun(ref.repo, ref.runId)
-    .pipe(Effect.mapError(upstream));
+  const data = yield* github.getRun(ref.repo, ref.runId).pipe(Effect.mapError(upstream));
   if (
     data.status !== "in_progress" ||
     (data.run_attempt !== undefined && data.run_attempt !== ref.attempt)
@@ -151,12 +140,7 @@ const lookupRun = Effect.fn("lookupRun")(function* (ref: RunRef) {
     // repository already published; matching the head repository keeps a
     // run's publication on its own pull request.
     const pulls = yield* github
-      .pullRequestsForCommit(
-        ref.repo,
-        headRepo,
-        data.head_branch,
-        data.head_sha,
-      )
+      .pullRequestsForCommit(ref.repo, headRepo, data.head_branch, data.head_sha)
       .pipe(Effect.mapError(upstream));
     const first = pulls[0];
     if (first === undefined) {
@@ -185,10 +169,7 @@ const lookupRun = Effect.fn("lookupRun")(function* (ref: RunRef) {
  * run, and GitHub reports the run's artifacts to the App, so a matching
  * name means this run vouched for exactly this manifest text.
  */
-const requireVouched = Effect.fn("requireVouched")(function* (
-  run: Run,
-  manifestText: string,
-) {
+const requireVouched = Effect.fn("requireVouched")(function* (run: Run, manifestText: string) {
   const github = yield* GitHub.GitHubApp;
   const expected = manifestArtifactName(yield* sha256(manifestText));
   const artifacts = yield* github
@@ -201,22 +182,15 @@ const requireVouched = Effect.fn("requireVouched")(function* (
   }
 });
 
-const publish = Effect.fn("publish")(function* (
-  run: Run,
-  manifestText: string,
-) {
+const publish = Effect.fn("publish")(function* (run: Run, manifestText: string) {
   const { policy } = yield* RegistryConfig;
   const r2 = yield* Cloudflare.R2.ReadWriteBucket(Bucket);
   const github = yield* GitHub.GitHubApp;
   const base = yield* origin;
 
   yield* requireVouched(run, manifestText);
-  const manifest = yield* Schema.decodeUnknownEffect(ManifestJson)(
-    manifestText,
-  ).pipe(
-    Effect.mapError(
-      (e) => new BadRequest({ message: `invalid manifest: ${String(e)}` }),
-    ),
+  const manifest = yield* Schema.decodeUnknownEffect(ManifestJson)(manifestText).pipe(
+    Effect.mapError((e) => new BadRequest({ message: `invalid manifest: ${String(e)}` })),
   );
   // The run vouched for the manifest, but the tags come from the run's
   // head, so the packed checkout has to be that commit: a `pull_request`
@@ -230,9 +204,7 @@ const publish = Effect.fn("publish")(function* (
   const packages = manifest.packages;
   const maxSize = policy.maxPackageSize;
   const tooLarge =
-    maxSize === undefined
-      ? undefined
-      : packages.find((pkg) => BigInt(pkg.size) > maxSize);
+    maxSize === undefined ? undefined : packages.find((pkg) => BigInt(pkg.size) > maxSize);
   if (tooLarge !== undefined) {
     return yield* new PackageTooLarge({
       message: `${tooLarge.name} exceeds ${maxSize} bytes`,
@@ -242,15 +214,9 @@ const publish = Effect.fn("publish")(function* (
   const missing = yield* Effect.filter(
     packages,
     (pkg) =>
-      r2
-        .head(tarballKey(pkg.name, pkg.sha256))
-        .pipe(Effect.map((object) => object === null)),
+      r2.head(tarballKey(pkg.name, pkg.sha256)).pipe(Effect.map((object) => object === null)),
     { concurrency: 8 },
-  ).pipe(
-    Effect.map((packages) =>
-      packages.map(({ name, sha256 }) => ({ name, sha256 })),
-    ),
-  );
+  ).pipe(Effect.map((packages) => packages.map(({ name, sha256 }) => ({ name, sha256 }))));
   if (missing.length > 0) {
     return yield* new MissingTarballs({ missing });
   }
@@ -297,9 +263,7 @@ const publish = Effect.fn("publish")(function* (
     })
     .pipe(
       Effect.catch((e) =>
-        Effect.logWarning(
-          `check run on ${run.repo}@${run.headSha} failed: ${GitHub.describe(e)}`,
-        ),
+        Effect.logWarning(`check run on ${run.repo}@${run.headSha} failed: ${GitHub.describe(e)}`),
       ),
     );
   if (run.pr !== null) {
@@ -311,9 +275,7 @@ const publish = Effect.fn("publish")(function* (
       .upsertComment(run.repo, run.pr, COMMENT_MARKER, body)
       .pipe(
         Effect.catch((e) =>
-          Effect.logWarning(
-            `comment on ${run.repo}#${run.pr} failed: ${GitHub.describe(e)}`,
-          ),
+          Effect.logWarning(`comment on ${run.repo}#${run.pr} failed: ${GitHub.describe(e)}`),
         ),
       );
   }
@@ -353,11 +315,7 @@ const uploadTarball = Effect.fn("uploadTarball")(function* (
       // The params schema already constrained this to 64 hex chars.
       sha256: Result.getOrThrow(Hex.decode(sha256)),
     })
-    .pipe(
-      Effect.mapError(
-        (e) => new BadRequest({ message: `upload rejected: ${String(e)}` }),
-      ),
-    );
+    .pipe(Effect.mapError((e) => new BadRequest({ message: `upload rejected: ${String(e)}` })));
   return { name, sha256, size: contentLength, uploaded: true };
 });
 
@@ -380,9 +338,7 @@ export const parseInstallPath = (
     // Malformed percent-encoding is a path nothing can be published under.
     return undefined;
   }
-  const tarball = path.match(
-    /^(@[^/]+\/[^/@]+|[^/@]+)\/-\/([a-f0-9]{64})\.tgz$/,
-  );
+  const tarball = path.match(/^(@[^/]+\/[^/@]+|[^/@]+)\/-\/([a-f0-9]{64})\.tgz$/);
   if (tarball) {
     return {
       kind: "tarball",
@@ -403,8 +359,7 @@ export const parseInstallPath = (
 const qualify = (name: string, scope: string | undefined) =>
   scope !== undefined && !name.startsWith("@") ? `${scope}/${name}` : name;
 
-const notFound = (message: string) =>
-  HttpServerResponse.json({ error: message }, { status: 404 });
+const notFound = (message: string) => HttpServerResponse.json({ error: message }, { status: 404 });
 
 /**
  * Install URLs: `/<name>/<tag>` redirects to the immutable tarball URL,
@@ -417,16 +372,10 @@ const install = Effect.gen(function* () {
   const r2 = yield* Cloudflare.R2.ReadWriteBucket(Bucket);
 
   if (request.method !== "GET" && request.method !== "HEAD") {
-    return yield* HttpServerResponse.json(
-      { error: "method not allowed" },
-      { status: 405 },
-    );
+    return yield* HttpServerResponse.json({ error: "method not allowed" }, { status: 405 });
   }
   const host = request.headers.host ?? "localhost";
-  const target = parseInstallPath(
-    new URL(request.url, `https://${host}`).pathname,
-    aliases[host],
-  );
+  const target = parseInstallPath(new URL(request.url, `https://${host}`).pathname, aliases[host]);
   if (target === undefined) {
     return yield* notFound("not found");
   }
@@ -490,9 +439,7 @@ export const handler = Effect.gen(function* () {
 
   // Built once per isolate. The D1 client memoizes its connection on each
   // event's scope, so its layer is safe to share.
-  const github = yield* GitHub.GitHubApp.pipe(
-    Effect.provide(GitHub.GitHubAppLive),
-  );
+  const github = yield* GitHub.GitHubApp.pipe(Effect.provide(GitHub.GitHubAppLive));
   const services = Layer.mergeAll(
     Cloudflare.R2.ReadWriteBucketBinding,
     Cloudflare.KV.ReadWriteNamespaceBinding,
@@ -509,23 +456,20 @@ export const handler = Effect.gen(function* () {
     (ref) => Effect.map(lookupRun(ref), (value) => ({ value, ttl: RUN_CACHE })),
   );
 
-  yield* Cloudflare.Workers.cron(config.cron, () =>
-    sweep.pipe(Effect.provide(services)),
-  );
+  yield* Cloudflare.Workers.cron(config.cron, () => sweep.pipe(Effect.provide(services)));
 
   const registry = HttpApiBuilder.group(PkgApi, "Registry", (handlers) =>
     handlers
       .handle("publish", ({ payload }) =>
-        Effect.flatMap(runs(payload.run), (run) =>
-          publish(run, payload.manifest),
-        ).pipe(Effect.catchTag(storageFailures, (e) => Effect.die(e))),
+        Effect.flatMap(runs(payload.run), (run) => publish(run, payload.manifest)).pipe(
+          Effect.catchTag(storageFailures, (e) => Effect.die(e)),
+        ),
       )
       // Raw so the body streams into R2 instead of being buffered.
       .handleRaw("uploadTarball", ({ query, params, request }) =>
-        Effect.andThen(
-          runs(query),
-          uploadTarball(request, params.name, params.sha256),
-        ).pipe(Effect.catchTag("R2Error", (e) => Effect.die(e))),
+        Effect.andThen(runs(query), uploadTarball(request, params.name, params.sha256)).pipe(
+          Effect.catchTag("R2Error", (e) => Effect.die(e)),
+        ),
       ),
   );
 

package/src/Registry/KVCache.ts

@@ -7,8 +7,7 @@ import { Cache } from "./Bindings.ts";
 /** KV's floor for both `expirationTtl` and `cacheTtl`. */
 const MIN_TTL = Duration.minutes(1);
 
-const seconds = (duration: Duration.Duration) =>
-  Math.floor(Duration.toSeconds(duration));
+const seconds = (duration: Duration.Duration) => Math.floor(Duration.toSeconds(duration));
 
 /**
  * A lookup-through cache on the registry's KV namespace, shared by every
@@ -28,9 +27,7 @@ const seconds = (duration: Duration.Duration) =>
 export const make = <K, A, I, E, R>(
   key: (input: K) => string,
   value: Schema.Codec<A, I>,
-  lookup: (
-    input: K,
-  ) => Effect.Effect<{ value: A; ttl: Duration.Duration }, E, R>,
+  lookup: (input: K) => Effect.Effect<{ value: A; ttl: Duration.Duration }, E, R>,
 ) => {
   const json = Schema.fromJsonString(value);
   const decode = Schema.decodeUnknownEffect(json);
@@ -40,13 +37,9 @@ export const make = <K, A, I, E, R>(
       const kv = yield* Cloudflare.KV.ReadWriteNamespace(Cache);
       const id = key(input);
       const hit = yield* kv.get(id, { cacheTtl: seconds(MIN_TTL) }).pipe(
-        Effect.flatMap((text) =>
-          text === null ? Effect.succeed(undefined) : decode(text),
-        ),
+        Effect.flatMap((text) => (text === null ? Effect.succeed(undefined) : decode(text))),
         Effect.catch((e) =>
-          Effect.logWarning(`cache read of ${id} failed: ${e}`).pipe(
-            Effect.as(undefined),
-          ),
+          Effect.logWarning(`cache read of ${id} failed: ${e}`).pipe(Effect.as(undefined)),
         ),
       );
       if (hit !== undefined) {
@@ -55,12 +48,8 @@ export const make = <K, A, I, E, R>(
       const fresh = yield* lookup(input);
       if (Duration.isGreaterThanOrEqualTo(fresh.ttl, MIN_TTL)) {
         yield* encode(fresh.value).pipe(
-          Effect.flatMap((text) =>
-            kv.put(id, text, { expirationTtl: seconds(fresh.ttl) }),
-          ),
-          Effect.catch((e) =>
-            Effect.logWarning(`cache write of ${id} failed: ${e}`),
-          ),
+          Effect.flatMap((text) => kv.put(id, text, { expirationTtl: seconds(fresh.ttl) })),
+          Effect.catch((e) => Effect.logWarning(`cache write of ${id} failed: ${e}`)),
         );
       }
       return fresh.value;

package/src/Registry/Sweep.ts

@@ -4,13 +4,7 @@ import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import * as Stream from "effect/Stream";
-import {
-  Bucket,
-  ORPHAN_GRACE,
-  RegistryConfig,
-  SWEEP_LOOKAHEAD,
-  tarballKey,
-} from "./Bindings.ts";
+import { Bucket, ORPHAN_GRACE, RegistryConfig, SWEEP_LOOKAHEAD, tarballKey } from "./Bindings.ts";
 import * as GitHub from "./GitHub.ts";
 import * as Tags from "./Tags.ts";
 
@@ -37,15 +31,13 @@ export const sweep = Effect.gen(function* () {
       const [repo, number] = ref.split("#");
       return github.getPullRequest(repo!, Number(number)).pipe(
         Effect.map((pr) =>
-          pr.state === "open"
-            ? undefined
-            : Date.parse(pr.merged_at ?? pr.closed_at ?? "") || now,
+          pr.state === "open" ? undefined : Date.parse(pr.merged_at ?? pr.closed_at ?? "") || now,
         ),
         Effect.map((closedAt) => [ref, { closedAt }] as const),
         Effect.catch((e) =>
-          Effect.logWarning(
-            `pull request ${ref} lookup failed: ${GitHub.describe(e)}`,
-          ).pipe(Effect.as([ref, undefined] as const)),
+          Effect.logWarning(`pull request ${ref} lookup failed: ${GitHub.describe(e)}`).pipe(
+            Effect.as([ref, undefined] as const),
+          ),
         ),
       );
     },
@@ -85,20 +77,15 @@ export const sweep = Effect.gen(function* () {
   );
 
   // Uploads that never got tagged.
-  const orphans = yield* Stream.paginate(
-    undefined as string | undefined,
-    (cursor) =>
-      r2
-        .list({ cursor, limit: 500 })
-        .pipe(
-          Effect.map(
-            (page) =>
-              [
-                page.objects,
-                page.truncated ? Option.some(page.cursor) : Option.none(),
-              ] as const,
-          ),
+  const orphans = yield* Stream.paginate(undefined as string | undefined, (cursor) =>
+    r2
+      .list({ cursor, limit: 500 })
+      .pipe(
+        Effect.map(
+          (page) =>
+            [page.objects, page.truncated ? Option.some(page.cursor) : Option.none()] as const,
         ),
+      ),
   ).pipe(
     Stream.filter((object) => {
       const match = object.key.match(/^(.+)\/([a-f0-9]{64})\.tgz$/);

package/src/Registry/Tags.ts

@@ -71,9 +71,7 @@ export const resolve = (pkg: string, tag: string) =>
   Effect.map(get(pkg, tag), (row) => row?.sha256);
 
 /** Rows tied to pull requests whose expiry falls before `before`. */
-export const dueLinked = Effect.fn("Tags.dueLinked")(function* (
-  before: number,
-) {
+export const dueLinked = Effect.fn("Tags.dueLinked")(function* (before: number) {
   const sql = yield* SqlClient.SqlClient;
   return yield* decodeTags(
     yield* sql`
@@ -94,9 +92,7 @@ export const setExpiry = Effect.fn("Tags.setExpiry")(function* (
 });
 
 /** Delete every expired row and return the tarballs those rows pointed at. */
-export const deleteExpired = Effect.fn("Tags.deleteExpired")(function* (
-  now: number,
-) {
+export const deleteExpired = Effect.fn("Tags.deleteExpired")(function* (now: number) {
   const sql = yield* SqlClient.SqlClient;
   return yield* decodeTarballs(
     yield* sql`
@@ -106,12 +102,8 @@ export const deleteExpired = Effect.fn("Tags.deleteExpired")(function* (
 });
 
 /** Every tarball some tag still points at, as `<package>/<sha256>`. */
-export const referencedTarballs = Effect.fn("Tags.referencedTarballs")(
-  function* () {
-    const sql = yield* SqlClient.SqlClient;
-    const rows = yield* decodeTarballs(
-      yield* sql`SELECT DISTINCT package, sha256 FROM tags`,
-    );
-    return new Set(rows.map((row) => `${row.package}/${row.sha256}`));
-  },
-);
+export const referencedTarballs = Effect.fn("Tags.referencedTarballs")(function* () {
+  const sql = yield* SqlClient.SqlClient;
+  const rows = yield* decodeTarballs(yield* sql`SELECT DISTINCT package, sha256 FROM tags`);
+  return new Set(rows.map((row) => `${row.package}/${row.sha256}`));
+});

package/src/Registry.ts

@@ -20,14 +20,7 @@ import {
 } from "./Registry/Bindings.ts";
 import { handler } from "./Registry/Handler.ts";
 
-export {
-  Bucket,
-  Cache,
-  Database,
-  Policy,
-  RegistryConfig,
-  Settings,
-} from "./Registry/Bindings.ts";
+export { Bucket, Cache, Database, Policy, RegistryConfig, Settings } from "./Registry/Bindings.ts";
 
 export interface RegistryOptions {
   /**
@@ -99,9 +92,9 @@ const RegistryConfigFromEnv = Layer.effect(
   RegistryConfig,
   Effect.gen(function* () {
     const env = yield* Cloudflare.Workers.WorkerEnvironment;
-    const settings = yield* Schema.decodeUnknownEffect(Settings)(
-      env[SETTINGS_ENV],
-    ).pipe(Effect.orDie);
+    const settings = yield* Schema.decodeUnknownEffect(Settings)(env[SETTINGS_ENV]).pipe(
+      Effect.orDie,
+    );
     return {
       ...settings,
       worker: {},
@@ -165,10 +158,7 @@ export default RegistryLive.pipe(Layer.provide(RegistryConfigFromEnv));
  * @product Workers
  * @category Workers & Compute
  */
-export const PkgRegistry = <const Id extends string>(
-  id: Id,
-  options: RegistryOptions,
-) =>
+export const PkgRegistry = <const Id extends string>(id: Id, options: RegistryOptions) =>
   Registry.pipe(
     Effect.provide(
       RegistryLive.pipe(