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

package/src/Registry/GitHub.ts

@@ -4,7 +4,6 @@ import * as Apps from "@distilled.cloud/github/apps";
 import * as Checks from "@distilled.cloud/github/checks";
 import * as Issues from "@distilled.cloud/github/issues";
 import * as Pulls from "@distilled.cloud/github/pulls";
-import * as Repos from "@distilled.cloud/github/repos";
 import * as Arr from "effect/Array";
 import * as Clock from "effect/Clock";
 import * as Context from "effect/Context";
@@ -12,13 +11,13 @@ import * as Data from "effect/Data";
 import * as DateTime from "effect/DateTime";
 import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
-import * as Encoding from "effect/Encoding";
+import { Base64Url } from "effect/encoding";
 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/unstable/http/HttpClient";
+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";
@@ -50,13 +49,13 @@ export const signJwt = (
 ) =>
   Effect.try({
     try: () => {
-      const header = Encoding.encodeBase64Url(
+      const header = Base64Url.encode(
         JSON.stringify({ alg: "RS256", typ: "JWT" }),
       );
-      const payload = Encoding.encodeBase64Url(JSON.stringify(claims));
+      const payload = Base64Url.encode(JSON.stringify(claims));
       const input = `${header}.${payload}`;
       const signature = crypto.sign("sha256", Buffer.from(input), key);
-      return `${input}.${Encoding.encodeBase64Url(new Uint8Array(signature))}`;
+      return `${input}.${Base64Url.encode(new Uint8Array(signature))}`;
     },
     catch: (cause) => new CryptoError({ message: `signing failed: ${cause}` }),
   });
@@ -243,15 +242,22 @@ const make = Effect.gen(function* () {
       ).pipe(Effect.map((page) => page.artifacts)),
 
     /**
-     * Pull requests against `repo` whose head is `sha` in `headRepo`, the
-     * repository the commit was pushed to.
+     * Open pull requests against `repo` whose head is `sha` in `headRepo`, the
+     * 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, sha: string) =>
+    pullRequestsForCommit: (
+      repo: string,
+      headRepo: string,
+      headBranch: string,
+      sha: string,
+    ) =>
       asInstallation(
         repo,
-        Repos.listPullRequestsAssociatedWithCommit({
+        Pulls.list({
           ...split(repo),
-          commit_sha: sha,
+          head: `${split(headRepo).owner}:${headBranch}`,
+          state: "open",
           per_page: 100,
         }),
       ).pipe(
@@ -259,6 +265,7 @@ const make = Effect.gen(function* () {
           pulls.filter(
             (pr) =>
               pr.head.sha === sha &&
+              pr.head.ref === headBranch &&
               pr.head.repo?.full_name === headRepo &&
               pr.base.repo.full_name === repo,
           ),

package/src/Registry/Handler.ts

@@ -4,18 +4,18 @@ import { sha256 } from "alchemy/Util/sha256";
 import * as Clock from "effect/Clock";
 import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
-import * as Encoding from "effect/Encoding";
+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 Etag from "effect/unstable/http/Etag";
-import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
-import * as HttpPlatform from "effect/unstable/http/HttpPlatform";
-import * as HttpRouter from "effect/unstable/http/HttpRouter";
-import { HttpServerRequest } from "effect/unstable/http/HttpServerRequest";
-import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
-import * as HttpApiBuilder from "effect/unstable/httpapi/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 { ManifestJson, type ManifestPackage } from "../Manifest.ts";
 import {
   BadRequest,
@@ -81,24 +81,26 @@ const isFork = (run: Run) => run.headRepo !== run.repo;
 /**
  * Tags every package in a publication receives, all derived from the run.
  * Runs on the repository's own commits get the head commit, the short
- * commit, `branch:<name>`, and `pr:N` for pull requests. A fork's run gets
- * only `pr:N`: commit tags are shared by every publisher, and a fork can
+ * commit, `branch:<name>`, and `pr:N` plus `pr:N:<short-sha>` for pull requests.
+ * A fork's run gets only `pr:N:<short-sha>`: commit tags are shared by every publisher, and a fork can
  * run any commit it likes, including one already published from the
  * repository, so letting it write them would let it repoint them.
  */
 export const tagsFor = (run: Run): string[] => {
   if (isFork(run)) {
-    return run.pr === null ? [] : [`pr:${run.pr}`];
+    return run.pr === null ? [] : [installTag(run)];
   }
   const tags = [run.headSha, run.headSha.slice(0, SHORT)];
-  if (run.pr !== null) tags.push(`pr:${run.pr}`);
+  if (run.pr !== null) tags.push(`pr:${run.pr}`, installTag(run));
   if (run.headBranch) tags.push(`branch:${run.headBranch}`);
   return tags;
 };
 
 /** The tag install commands are written against. */
 export const installTag = (run: Run) =>
-  isFork(run) ? `pr:${run.pr}` : 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) });
@@ -138,18 +140,28 @@ const lookupRun = Effect.fn("lookupRun")(function* (ref: RunRef) {
   const headRepo = data.head_repository?.full_name ?? data.repository.full_name;
   let pr: number | null = null;
   if (data.event === "pull_request") {
+    if (data.head_branch === null) {
+      return yield* new BadRequest({
+        message: `pull request run ${ref.runId} has no head branch`,
+      });
+    }
     // The pull request whose head is this run's head, from the repository
     // the run's head lives in. The same commit can head several pull
     // requests, including one opened from a fork against a commit the
     // 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_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({
-        message: `no pull request from ${headRepo} has head ${data.head_sha}`,
+        message: `no open pull request from ${headRepo} has head ${data.head_sha}`,
       });
     }
     pr = first.number;
@@ -339,7 +351,7 @@ const uploadTarball = Effect.fn("uploadTarball")(function* (
     .put(key, request.stream, {
       contentLength,
       // The params schema already constrained this to 64 hex chars.
-      sha256: Result.getOrThrow(Encoding.decodeHex(sha256)),
+      sha256: Result.getOrThrow(Hex.decode(sha256)),
     })
     .pipe(
       Effect.mapError(
@@ -444,7 +456,7 @@ const install = Effect.gen(function* () {
 
 const banner = Effect.map(origin, (base) =>
   HttpServerResponse.text(
-    `Preview package registry. Install with: bun add ${base}/<package>/<commit|branch:name|pr:N>\n`,
+    `Preview package registry. Install with: bun add ${base}/<package>/<commit|branch:name|pr:N|pr:N:short-sha>\n`,
   ),
 );
 

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.

package/src/cli/bin.ts

@@ -2,15 +2,10 @@
 import { PlatformServices, runMain } from "alchemy/Util/PlatformServices";
 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/unstable/cli";
-import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import { CliConfig, CliError, Command, Flag, GlobalFlag } from "effect/cli";
+import * as FetchHttpClient from "effect/http/FetchHttpClient";
 import pkg from "../../package.json" with { type: "json" };
 import { Group, pack } from "./pack.ts";
 import { publish } from "./publish.ts";
@@ -38,11 +33,41 @@ 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(

package/src/cli/pack.ts

@@ -8,7 +8,7 @@ import * as Path from "effect/Path";
 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 * as ChildProcess from "effect/process/ChildProcess";
 import { exec } from "alchemy/Util/exec";
 import { sha256 } from "alchemy/Util/sha256";
 import { packTar, unpackTar, type TarHeader } from "modern-tar";
@@ -140,6 +140,73 @@ 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.
@@ -418,18 +485,21 @@ 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 (
@@ -442,7 +512,7 @@ const pullRequestHead = Effect.gen(function* () {
   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 +520,9 @@ export interface PackOptions {
   readonly groups: ReadonlyArray<Group>;
   readonly registry: string;
   readonly out: string;
+  readonly since?: string;
+  readonly all?: boolean;
+  readonly rebuildAllPaths?: ReadonlyArray<string>;
 }
 
 /**
@@ -470,7 +543,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 +552,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
@@ -506,6 +576,38 @@ export const pack = Effect.fn("pack")(function* (options: PackOptions) {
       ),
     );
   }
+  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
@@ -594,9 +696,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

@@ -5,7 +5,7 @@ import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
 import * as Schema from "effect/Schema";
-import * as HttpApiClient from "effect/unstable/httpapi/HttpApiClient";
+import * as HttpApiClient from "effect/http-api/HttpApiClient";
 import { MANIFEST_FILE, ManifestJson, type Manifest } from "../Manifest.ts";
 import { PkgApi, type TarballRef } from "../Protocol.ts";
 
@@ -71,6 +71,11 @@ export const publish = Effect.fn("publish")(function* (
     });
   }
 
+  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));