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

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,12 +91,10 @@ 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) });
+  Upstream.make({ message: GitHub.describe(e) });
 
 /**
  * Storage failures are not part of the protocol: they are defects, which
@@ -121,19 +112,17 @@ const lookupRun = Effect.fn("lookupRun")(function* (ref: RunRef) {
   const github = yield* GitHub.GitHubApp;
 
   if (!policy.repos.includes(ref.repo)) {
-    return yield* new Forbidden({ message: `${ref.repo} may not publish` });
+    return yield* Forbidden.make({ 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)
   ) {
-    return yield* new RunNotInProgress({ message: "run is not in progress" });
+    return yield* RunNotInProgress.make({ message: "run is not in progress" });
   }
   if (data.event !== "push" && data.event !== "pull_request") {
-    return yield* new BadRequest({
+    return yield* BadRequest.make({
       message: `unsupported event ${data.event}`,
     });
   }
@@ -141,7 +130,7 @@ const lookupRun = Effect.fn("lookupRun")(function* (ref: RunRef) {
   let pr: number | null = null;
   if (data.event === "pull_request") {
     if (data.head_branch === null) {
-      return yield* new BadRequest({
+      return yield* BadRequest.make({
         message: `pull request run ${ref.runId} has no head branch`,
       });
     }
@@ -151,22 +140,17 @@ 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) {
-      return yield* new BadRequest({
+      return yield* BadRequest.make({
         message: `no open pull request from ${headRepo} has head ${data.head_sha}`,
       });
     }
     pr = first.number;
   } else if (headRepo !== ref.repo) {
-    return yield* new BadRequest({
+    return yield* BadRequest.make({
       message: `push run ${ref.runId} is for ${headRepo}, not ${ref.repo}`,
     });
   }
@@ -185,56 +169,44 @@ 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
     .listRunArtifacts(run.repo, run.runId, expected)
     .pipe(Effect.mapError(upstream));
   if (!artifacts.some((a) => a.name === expected && !a.expired)) {
-    return yield* new Forbidden({
+    return yield* Forbidden.make({
       message: `run ${run.runId} has not vouched for this manifest (no artifact ${expected})`,
     });
   }
 });
 
-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) => BadRequest.make({ 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`
   // job that packs the synthetic merge commit would otherwise publish bytes
   // built from a commit that exists nowhere under the commit's name.
   if (manifest.head !== run.headSha) {
-    return yield* new BadRequest({
+    return yield* BadRequest.make({
       message: `manifest was packed at ${manifest.head}, but the run's head is ${run.headSha}`,
     });
   }
   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({
+    return yield* PackageTooLarge.make({
       message: `${tooLarge.name} exceeds ${maxSize} bytes`,
     });
   }
@@ -242,17 +214,11 @@ 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 });
+    return yield* MissingTarballs.make({ missing });
   }
 
   const now = yield* Clock.currentTimeMillis;
@@ -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)}`),
         ),
       );
   }
@@ -334,11 +296,11 @@ const uploadTarball = Effect.fn("uploadTarball")(function* (
 
   const contentLength = Number(request.headers["content-length"] ?? 0);
   if (!Number.isSafeInteger(contentLength) || contentLength <= 0) {
-    return yield* new BadRequest({ message: "Content-Length is required" });
+    return yield* BadRequest.make({ message: "Content-Length is required" });
   }
   const maxSize = policy.maxPackageSize;
   if (maxSize !== undefined && BigInt(contentLength) > maxSize) {
-    return yield* new PackageTooLarge({
+    return yield* PackageTooLarge.make({
       message: `tarball exceeds ${maxSize} bytes`,
     });
   }
@@ -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) => BadRequest.make({ 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

@@ -9,7 +9,7 @@ import * as SqlClient from "effect/sql/SqlClient";
  * D1 binding.
  */
 
-const LinkedPrs = Schema.fromJsonString(Schema.Array(Schema.String));
+const LinkedPrs = Schema.String.pipe(Schema.Array, Schema.fromJsonString);
 
 export const TagRow = Schema.Struct({
   package: Schema.String,
@@ -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(

package/src/cli/bin.ts

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import { PlatformServices, runMain } from "alchemy/Util/PlatformServices";
+import { CliConfig, CliError, Command, Flag, GlobalFlag } from "effect/cli";
 import * as Config from "effect/Config";
 import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
-import * as Layer from "effect/Layer";
-import { CliConfig, CliError, Command, Flag, GlobalFlag } from "effect/cli";
 import * as FetchHttpClient from "effect/http/FetchHttpClient";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
 import pkg from "../../package.json" with { type: "json" };
 import { Group, pack } from "./pack.ts";
 import { publish } from "./publish.ts";
@@ -38,16 +38,12 @@ export const packCommand = Command.make(
     registry: registryFlag,
     out: outFlag,
     since: Flag.String("since").pipe(
-      Flag.withDescription(
-        "Compare HEAD with this Git ref; defaults to the PR base in Actions",
-      ),
+      Flag.withDescription("Compare HEAD with this Git ref; defaults to the PR base in Actions"),
       Flag.optional,
     ),
     all: Flag.Boolean("all").pipe(
       Flag.withDefault(false),
-      Flag.withDescription(
-        "Pack every configured package regardless of changes",
-      ),
+      Flag.withDescription("Pack every configured package regardless of changes"),
     ),
     rebuildAllPaths: Flag.String("rebuild-all-path").pipe(
       Flag.withDescription(
@@ -98,17 +94,13 @@ export const publishCommand = Command.make(
   Command.withDescription(
     "Publish a pkg pack directory from the current GitHub Actions job, after its manifest artifact has been uploaded",
   ),
-  Command.withExamples([
-    { command: "pkg publish --registry https://pkg.alchemy.run" },
-  ]),
+  Command.withExamples([{ command: "pkg publish --registry https://pkg.alchemy.run" }]),
 );
 
 export const root = Command.make("pkg", {}, () =>
-  Effect.fail(new CliError.ShowHelp({ commandPath: ["pkg"], errors: [] })),
+  Effect.fail(CliError.ShowHelp.make({ commandPath: ["pkg"], errors: [] })),
 ).pipe(
-  Command.withDescription(
-    "Pack and publish preview packages for pull requests.",
-  ),
+  Command.withDescription("Pack and publish preview packages for pull requests."),
   Command.withSubcommands([packCommand, publishCommand]),
 );
 
@@ -117,9 +109,7 @@ Command.run(root, { version: pkg.version }).pipe(
     Layer.mergeAll(
       PlatformServices,
       FetchHttpClient.layer,
-      CliConfig.layer({
-        builtIns: [GlobalFlag.Help, GlobalFlag.Version],
-      }),
+      CliConfig.layer({ builtIns: [GlobalFlag.Help, GlobalFlag.Version] }),
     ),
   ),
   runMain,