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

package/src/Registry/Tags.ts

@@ -1,6 +1,6 @@
 import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
-import * as SqlClient from "effect/unstable/sql/SqlClient";
+import * as SqlClient from "effect/sql/SqlClient";
 
 /**
  * The `tags` table: one row per `(package, tag)` pointing at a tarball hash.
@@ -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,16 +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 FetchHttpClient from "effect/http/FetchHttpClient";
 import * as Layer from "effect/Layer";
-import {
-  CliConfig,
-  CliError,
-  Command,
-  Flag,
-  GlobalFlag,
-} from "effect/unstable/cli";
-import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+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,11 +33,37 @@ const outFlag = Flag.String("out").pipe(
 
 export const packCommand = Command.make(
   "pack",
-  { group: groupFlag, registry: registryFlag, out: outFlag },
-  ({ group, registry, out }) =>
+  {
+    group: groupFlag,
+    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.optional,
+    ),
+    all: Flag.Boolean("all").pipe(
+      Flag.withDefault(false),
+      Flag.withDescription("Pack every configured package regardless of changes"),
+    ),
+    rebuildAllPaths: Flag.String("rebuild-all-path").pipe(
+      Flag.withDescription(
+        "Additional exact path or directory/** forcing all packages (repeatable)",
+      ),
+      Flag.atLeast(0),
+    ),
+  },
+  ({ group, registry, out, since, all, rebuildAllPaths }) =>
     Effect.gen(function* () {
       const cwd = yield* Effect.sync(() => process.cwd());
-      yield* pack({ cwd, groups: group, registry, out });
+      yield* pack({
+        cwd,
+        groups: group,
+        registry,
+        out,
+        since: Option.getOrUndefined(since),
+        all,
+        rebuildAllPaths,
+      });
     }),
 ).pipe(
   Command.withDescription(
@@ -73,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: [] })),
 ).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]),
 );
 
@@ -92,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,

package/src/cli/pack.ts

@@ -1,3 +1,6 @@
+import { gunzipSync, gzipSync } from "node:zlib";
+import { exec } from "alchemy/Util/exec";
+import { sha256 } from "alchemy/Util/sha256";
 import * as Config from "effect/Config";
 import * as Console from "effect/Console";
 import * as Data from "effect/Data";
@@ -5,14 +8,11 @@ import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Option from "effect/Option";
 import * as Path from "effect/Path";
+import * as ChildProcess from "effect/process/ChildProcess";
 import * as Schema from "effect/Schema";
 import * as SchemaIssue from "effect/SchemaIssue";
 import * as SchemaTransformation from "effect/SchemaTransformation";
-import * as ChildProcess from "effect/unstable/process/ChildProcess";
-import { exec } from "alchemy/Util/exec";
-import { sha256 } from "alchemy/Util/sha256";
 import { packTar, unpackTar, type TarHeader } from "modern-tar";
-import { gunzipSync, gzipSync } from "node:zlib";
 import {
   GroupName,
   MANIFEST_FILE,
@@ -48,8 +48,7 @@ export const Group = Schema.String.pipe(
           .split(",")
           .map((attribute) => attribute.trim())
           .filter((attribute) => attribute.length > 0);
-        return match &&
-          attributes.every((attribute) => attribute === "Collapsed")
+        return match && attributes.every((attribute) => attribute === "Collapsed")
           ? Effect.succeed({
               name: match[1]!,
               pattern: match[3]!,
@@ -64,9 +63,7 @@ export const Group = Schema.String.pipe(
             );
       },
       encode: (group) =>
-        Effect.succeed(
-          `${group.name}${group.collapsed ? "[Collapsed]" : ""}=${group.pattern}`,
-        ),
+        Effect.succeed(`${group.name}${group.collapsed ? "[Collapsed]" : ""}=${group.pattern}`),
     }),
   ),
 );
@@ -86,9 +83,7 @@ export const DEPENDENCY_SECTIONS = [
   "optionalDependencies",
 ] as const;
 
-const DependencyMap = Schema.optionalKey(
-  Schema.Record(Schema.String, Schema.String),
-);
+const DependencyMap = Schema.optionalKey(Schema.Record(Schema.String, Schema.String));
 
 export const DependencySections = Schema.Struct({
   dependencies: DependencyMap,
@@ -140,6 +135,70 @@ export interface WorkspacePackage {
   readonly group: string;
 }
 
+/** Shared inputs that invalidate every configured package. */
+export const REBUILD_ALL_PATHS = [
+  "package.json",
+  "pnpm-lock.yaml",
+  "pnpm-workspace.yaml",
+  "package-lock.json",
+  "yarn.lock",
+  "bun.lock",
+  "bun.lockb",
+  "tsconfig.json",
+  "tsconfig.base.json",
+  "turbo.json",
+  ".github/workflows/pkg.yml",
+  ".github/workflows/pr-package.yml",
+];
+
+/** Select dependents first, then dependencies, without pulling in unrelated siblings. */
+export const selectPackages = (
+  packages: ReadonlyArray<WorkspacePackage>,
+  dependencies: ReadonlyMap<string, ReadonlySet<string>>,
+  changedFiles: ReadonlyArray<string>,
+  rebuildAllPaths: ReadonlyArray<string> = [],
+) => {
+  if (
+    changedFiles.some((file) =>
+      [...REBUILD_ALL_PATHS, ...rebuildAllPaths].some((pattern) =>
+        pattern.endsWith("/**")
+          ? file === pattern.slice(0, -3) || file.startsWith(pattern.slice(0, -2))
+          : file === pattern,
+      ),
+    )
+  )
+    return [...packages];
+
+  const selected = new Set(
+    packages
+      .filter((pkg) =>
+        changedFiles.some(
+          (file) =>
+            file === pkg.dir || file.startsWith(`${pkg.dir}/`) || pkg.dir.startsWith(`${file}/`),
+        ),
+      )
+      .map((pkg) => pkg.name),
+  );
+  // A changed gitlink selects the packages nested inside that submodule.
+  let size: number;
+  do {
+    size = selected.size;
+    for (const [name, deps] of dependencies) {
+      if ([...deps].some((dep) => selected.has(dep))) selected.add(name);
+    }
+  } while (selected.size !== size);
+  const pending = [...selected];
+  for (const name of pending) {
+    for (const dep of dependencies.get(name) ?? []) {
+      if (!selected.has(dep)) {
+        selected.add(dep);
+        pending.push(dep);
+      }
+    }
+  }
+  return packages.filter((pkg) => selected.has(pkg.name));
+};
+
 /**
  * Expand one level of `{a,b,c}` alternatives into plain patterns, so
  * `./packages/{alchemy,pkg}` lists exactly those two directories.
@@ -151,9 +210,7 @@ export const expandBraces = (pattern: string): string[] => {
     .split(",")
     .map((alternative) => alternative.trim())
     .filter((alternative) => alternative.length > 0)
-    .flatMap((alternative) =>
-      expandBraces(`${match[1]}${alternative}${match[3]}`),
-    );
+    .flatMap((alternative) => expandBraces(`${match[1]}${alternative}${match[3]}`));
 };
 
 /**
@@ -169,10 +226,7 @@ const expand = Effect.fn("expandGlob")(function* (cwd: string, glob: string) {
   return [...new Set(results)];
 });
 
-const expandPattern = Effect.fn("expandPattern")(function* (
-  cwd: string,
-  pattern: string,
-) {
+const expandPattern = Effect.fn("expandPattern")(function* (cwd: string, pattern: string) {
   const fs = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
   if (pattern.includes("**")) {
@@ -257,10 +311,7 @@ export class GitError extends Data.TaggedError("GitError")<{
 }
 
 /** Run `git` in `cwd` and return trimmed stdout. */
-export const git = Effect.fn("git")(function* (
-  cwd: string,
-  args: ReadonlyArray<string>,
-) {
+export const git = Effect.fn("git")(function* (cwd: string, args: ReadonlyArray<string>) {
   const { exitCode, stdout, stderr } = yield* exec(
     ChildProcess.make("git", [...args], { cwd, shell: false }),
   ).pipe(Effect.scoped);
@@ -271,8 +322,7 @@ export const git = Effect.fn("git")(function* (
 });
 
 /** Absolute path of the repository (or submodule) that owns `cwd`. */
-export const toplevel = (cwd: string) =>
-  git(cwd, ["rev-parse", "--show-toplevel"]);
+export const toplevel = (cwd: string) => git(cwd, ["rev-parse", "--show-toplevel"]);
 
 /** Full HEAD SHA of the repository that owns `cwd`. */
 const gitHead = (cwd: string) => git(cwd, ["rev-parse", "HEAD"]);
@@ -282,24 +332,17 @@ export class PackError extends Data.TaggedError("PackError")<{
   readonly message: string;
 }> {}
 
-const PnpmPackOutput = Schema.fromJsonString(
-  Schema.Struct({ filename: Schema.String }),
-);
+const PnpmPackOutput = Schema.fromJsonString(Schema.Struct({ filename: Schema.String }));
 
 /**
  * Rewrite every dependency on a package in `links` to that package's
  * tarball URL. Returns the rewritten manifest text and the rewrites made.
  */
-export const rewriteDependencies = (
-  manifestText: string,
-  links: ReadonlyMap<string, string>,
-) =>
+export const rewriteDependencies = (manifestText: string, links: ReadonlyMap<string, string>) =>
   Effect.gen(function* () {
     const manifest = yield* Schema.decodeUnknownEffect(
       Schema.fromJsonString(
-        Schema.StructWithRest(DependencySections, [
-          Schema.Record(Schema.String, Schema.Unknown),
-        ]),
+        Schema.StructWithRest(DependencySections, [Schema.Record(Schema.String, Schema.Unknown)]),
       ),
     )(manifestText);
     // Preserve source key order after validation: it contributes to the tarball hash.
@@ -387,16 +430,12 @@ export const packPackage = Effect.fn("packPackage")(function* (options: {
 
   let rewrites: PackedTarball["rewrites"] = [];
   const normalized: Array<{ header: TarHeader; data: Uint8Array }> = [];
-  for (const entry of entries.sort((a, b) =>
-    a.header.name.localeCompare(b.header.name),
-  )) {
+  for (const entry of entries.sort((a, b) => a.header.name.localeCompare(b.header.name))) {
     let data = entry.data ?? new Uint8Array();
     if (entry.header.name === "package/package.json") {
       const text = yield* Effect.sync(() => new TextDecoder().decode(data));
       const result = yield* rewriteDependencies(text, options.links).pipe(
-        Effect.mapError(
-          (e) => new PackError({ dir: options.absDir, message: String(e) }),
-        ),
+        Effect.mapError((e) => new PackError({ dir: options.absDir, message: String(e) })),
       );
       rewrites = result.rewrites;
       data = yield* Effect.sync(() => new TextEncoder().encode(result.text));
@@ -418,31 +457,31 @@ export const packPackage = Effect.fn("packPackage")(function* (options: {
 const PullRequestEvent = Schema.fromJsonString(
   Schema.Struct({
     pull_request: Schema.optionalKey(
-      Schema.Struct({ head: Schema.Struct({ sha: Schema.String }) }),
+      Schema.Struct({
+        head: Schema.Struct({ sha: Schema.String }),
+        base: Schema.Struct({ sha: Schema.String }),
+      }),
     ),
   }),
 );
 
 /**
- * The pull request head commit when running under a GitHub Actions
- * `pull_request` event, read from the event payload. `undefined` elsewhere.
+ * Pull request metadata from the GitHub Actions event payload.
+ * `undefined` outside pull request events.
  * On that event the default checkout is a synthetic merge commit, which the
  * registry would reject because it does not match the run's head.
  */
-const pullRequestHead = Effect.gen(function* () {
+const pullRequest = Effect.gen(function* () {
   const event = yield* Config.option(Config.String("GITHUB_EVENT_NAME"));
   const eventPath = yield* Config.option(Config.String("GITHUB_EVENT_PATH"));
-  if (
-    Option.getOrUndefined(event) !== "pull_request" ||
-    Option.isNone(eventPath)
-  ) {
+  if (Option.getOrUndefined(event) !== "pull_request" || Option.isNone(eventPath)) {
     return undefined;
   }
   const fs = yield* FileSystem.FileSystem;
   const payload = yield* fs
     .readFileString(eventPath.value)
     .pipe(Effect.flatMap(Schema.decodeUnknownEffect(PullRequestEvent)));
-  return payload.pull_request?.head.sha;
+  return payload.pull_request;
 });
 
 export interface PackOptions {
@@ -450,6 +489,9 @@ export interface PackOptions {
   readonly groups: ReadonlyArray<Group>;
   readonly registry: string;
   readonly out: string;
+  readonly since?: string;
+  readonly all?: boolean;
+  readonly rebuildAllPaths?: ReadonlyArray<string>;
 }
 
 /**
@@ -457,8 +499,7 @@ export interface PackOptions {
  * replaced by `+`, a character package names cannot contain, so `@a/b-c`
  * and `@a-b/c` get distinct files.
  */
-export const tarballFile = (name: string) =>
-  `${name.replace(/^@/, "").replace("/", "+")}.tgz`;
+export const tarballFile = (name: string) => `${name.replace(/^@/, "").replace("/", "+")}.tgz`;
 
 /**
  * Pack every discovered package into `out` with a manifest describing each
@@ -470,7 +511,8 @@ export const pack = Effect.fn("pack")(function* (options: PackOptions) {
 
   const root = yield* toplevel(options.cwd);
   const head = yield* gitHead(root);
-  const prHead = yield* pullRequestHead;
+  const pr = yield* pullRequest;
+  const prHead = pr?.head.sha;
   if (prHead !== undefined && prHead !== head) {
     return yield* new WorkspaceError({
       message:
@@ -478,11 +520,7 @@ export const pack = Effect.fn("pack")(function* (options: PackOptions) {
         "Check out github.event.pull_request.head.sha before packing so tarballs are addressed by a commit that exists on the pull request.",
     });
   }
-  const packages = yield* discover(options.cwd, options.groups);
-  if (packages.length === 0) {
-    yield* Console.log("No publishable packages matched.");
-    return undefined;
-  }
+  let packages = yield* discover(options.cwd, options.groups);
 
   // Dependencies between packed packages are rewritten to the dependency's
   // immutable tarball URL, so a package is packed only after everything it
@@ -492,31 +530,55 @@ export const pack = Effect.fn("pack")(function* (options: PackOptions) {
   for (const pkg of packages) {
     const manifest = yield* fs
       .readFileString(path.join(pkg.absDir, "package.json"))
-      .pipe(
-        Effect.flatMap(
-          Schema.decodeUnknownEffect(Schema.fromJsonString(DependencySections)),
-        ),
-      );
+      .pipe(Effect.flatMap(Schema.decodeUnknownEffect(Schema.fromJsonString(DependencySections))));
     dependencies.set(
       pkg.name,
       new Set(
-        DEPENDENCY_SECTIONS.flatMap((section) =>
-          Object.keys(manifest[section] ?? {}),
-        ).filter((name) => name !== pkg.name && byName.has(name)),
+        DEPENDENCY_SECTIONS.flatMap((section) => Object.keys(manifest[section] ?? {})).filter(
+          (name) => name !== pkg.name && byName.has(name),
+        ),
       ),
     );
   }
+  const since = options.all ? undefined : (options.since ?? pr?.base.sha);
+  if (since !== undefined) {
+    // Disable rename detection so moves affect both the old and new packages.
+    const changed = (yield* git(root, [
+      "diff",
+      "--name-only",
+      "--no-renames",
+      "-z",
+      since,
+      head,
+      "--",
+    ]))
+      .split("\0")
+      .filter(Boolean);
+    const selected = selectPackages(
+      packages.map((pkg) => ({
+        ...pkg,
+        dir: path.relative(root, pkg.absDir).split(path.sep).join("/"),
+      })),
+      dependencies,
+      changed,
+      options.rebuildAllPaths,
+    );
+    const names = new Set(selected.map((pkg) => pkg.name));
+    packages = packages.filter((pkg) => names.has(pkg.name));
+    for (const name of dependencies.keys()) {
+      if (!names.has(name)) dependencies.delete(name);
+    }
+    yield* Console.log(
+      `Selected ${packages.length} package(s) changed since ${since}, including dependents and dependencies.`,
+    );
+  }
   const levels = yield* dependencyLevels(dependencies);
 
   // The output directory is replaced wholesale, so it has to be a proper
   // subdirectory of the workspace: `--out .` would otherwise delete it.
   const outDir = path.resolve(options.cwd, options.out);
   const relative = path.relative(options.cwd, outDir);
-  if (
-    relative === "" ||
-    relative.startsWith("..") ||
-    path.isAbsolute(relative)
-  ) {
+  if (relative === "" || relative.startsWith("..") || path.isAbsolute(relative)) {
     return yield* new WorkspaceError({
       message: `--out must be a subdirectory of ${options.cwd}, got ${outDir}`,
     });
@@ -555,10 +617,7 @@ export const pack = Effect.fn("pack")(function* (options: PackOptions) {
       { concurrency: 4 },
     );
     for (const entry of packedLevel) {
-      links.set(
-        entry.name,
-        tarballUrl(options.registry, entry.name, entry.sha256),
-      );
+      links.set(entry.name, tarballUrl(options.registry, entry.name, entry.sha256));
       packedByName.set(entry.name, entry);
     }
   }
@@ -568,10 +627,7 @@ export const pack = Effect.fn("pack")(function* (options: PackOptions) {
   // One entry per distinct group name, in the order the groups were given.
   const groups = [
     ...new Map(
-      options.groups.map((group) => [
-        group.name,
-        { name: group.name, collapsed: group.collapsed },
-      ]),
+      options.groups.map((group) => [group.name, { name: group.name, collapsed: group.collapsed }]),
     ).values(),
   ];
   const manifest: Manifest = {
@@ -594,9 +650,13 @@ export const pack = Effect.fn("pack")(function* (options: PackOptions) {
   const artifact = manifestArtifactName(yield* sha256(manifestText));
   const stepOutput = yield* Config.option(Config.String("GITHUB_OUTPUT"));
   if (Option.isSome(stepOutput)) {
-    yield* fs.writeFileString(stepOutput.value, `artifact-name=${artifact}\n`, {
-      flag: "a",
-    });
+    yield* fs.writeFileString(
+      stepOutput.value,
+      `artifact-name=${artifact}\npackage-count=${entries.length}\n`,
+      {
+        flag: "a",
+      },
+    );
   }
   yield* Console.log(`Manifest artifact name: ${artifact}`);
   return manifest;

package/src/cli/publish.ts

@@ -3,9 +3,9 @@ import * as Console from "effect/Console";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
+import * as HttpApiClient from "effect/http-api/HttpApiClient";
 import * as Path from "effect/Path";
 import * as Schema from "effect/Schema";
-import * as HttpApiClient from "effect/unstable/httpapi/HttpApiClient";
 import { MANIFEST_FILE, ManifestJson, type Manifest } from "../Manifest.ts";
 import { PkgApi, type TarballRef } from "../Protocol.ts";
 
@@ -25,9 +25,7 @@ export interface PublishOptions {
 const currentRun = Effect.gen(function* () {
   const repo = yield* Config.String("GITHUB_REPOSITORY");
   const runId = yield* Config.Int("GITHUB_RUN_ID");
-  const attempt = yield* Config.Int("GITHUB_RUN_ATTEMPT").pipe(
-    Config.withDefault(1),
-  );
+  const attempt = yield* Config.Int("GITHUB_RUN_ATTEMPT").pipe(Config.withDefault(1));
   return { repo, runId, attempt };
 }).pipe(
   Effect.mapError(
@@ -39,11 +37,10 @@ const currentRun = Effect.gen(function* () {
 );
 
 /** Render a registry or transport failure as a `PublishError`. */
-const failed =
-  (what: string) => (e: { readonly _tag: string; readonly message?: string }) =>
-    new PublishError({
-      message: `${what}: ${e.message ? `${e._tag}: ${e.message}` : e._tag}`,
-    });
+const failed = (what: string) => (e: { readonly _tag: string; readonly message?: string }) =>
+  new PublishError({
+    message: `${what}: ${e.message ? `${e._tag}: ${e.message}` : e._tag}`,
+  });
 
 /**
  * Publish a `pkg pack` directory from the current GitHub Actions job. The
@@ -52,9 +49,7 @@ const failed =
  * through GitHub, then either reports the tarballs it lacks, which are
  * uploaded before trying again, or writes the tags.
  */
-export const publish = Effect.fn("publish")(function* (
-  options: PublishOptions,
-) {
+export const publish = Effect.fn("publish")(function* (options: PublishOptions) {
   const fs = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
   const registry = options.registry.replace(/\/+$/, "");
@@ -63,14 +58,18 @@ export const publish = Effect.fn("publish")(function* (
 
   const dir = path.resolve(options.cwd, options.dir);
   const manifestText = yield* fs.readFileString(path.join(dir, MANIFEST_FILE));
-  const manifest =
-    yield* Schema.decodeUnknownEffect(ManifestJson)(manifestText);
+  const manifest = yield* Schema.decodeUnknownEffect(ManifestJson)(manifestText);
   if (manifest.registry !== registry) {
     return yield* new PublishError({
       message: `artifact was packed for ${manifest.registry}, not ${registry}`,
     });
   }
 
+  if (manifest.packages.length === 0) {
+    yield* Console.log("No affected packages to publish.");
+    return { packages: [] };
+  }
+
   const upload = (pkg: Manifest["packages"][number]) =>
     Effect.gen(function* () {
       const bytes = yield* fs.readFile(path.join(dir, pkg.file));
@@ -91,9 +90,7 @@ export const publish = Effect.fn("publish")(function* (
     ).pipe(
       Effect.andThen(
         Effect.forEach(
-          manifest.packages.filter((pkg) =>
-            wanted.has(`${pkg.name}@${pkg.sha256}`),
-          ),
+          manifest.packages.filter((pkg) => wanted.has(`${pkg.name}@${pkg.sha256}`)),
           upload,
           { concurrency: 4, discard: true },
         ),
@@ -107,9 +104,7 @@ export const publish = Effect.fn("publish")(function* (
   const published = yield* attempt.pipe(
     // The first answer is usually the tarballs to upload; publish once more
     // after uploading them.
-    Effect.catchTag("MissingTarballs", (e) =>
-      Effect.andThen(uploadMissing(e.missing), attempt),
-    ),
+    Effect.catchTag("MissingTarballs", (e) => Effect.andThen(uploadMissing(e.missing), attempt)),
     Effect.catchTag(
       "MissingTarballs",
       (e) =>
@@ -117,9 +112,7 @@ export const publish = Effect.fn("publish")(function* (
           message: `registry still reports missing tarballs after upload: ${e.missing.map((ref) => ref.name).join(", ")}`,
         }),
     ),
-    Effect.mapError((e) =>
-      e._tag === "PublishError" ? e : failed("publish")(e),
-    ),
+    Effect.mapError((e) => (e._tag === "PublishError" ? e : failed("publish")(e))),
   );
 
   for (const pkg of published.packages) {