alchemy 2.0.0-beta.81 → 2.0.0-beta.83

package/src/Git/Server.ts

@@ -160,7 +160,7 @@ const makeCore = Effect.gen(function* () {
       const result = yield* effect;
       const request = yield* HttpServerRequest.HttpServerRequest;
       const host = request.headers.host;
-      return new RepoCreated({
+      return RepoCreated.make({
         repo: result.repo,
         remote:
           host === undefined
@@ -359,7 +359,7 @@ const makeCore = Effect.gen(function* () {
     if (Result.isFailure(bodyResult)) return undefined;
     const req = yield* decodePktLines(new Uint8Array(bodyResult.success)).pipe(
       Effect.flatMap(parseUploadPackRequest),
-      Effect.catch(() => Effect.succeed(undefined)),
+      Effect.orElseSucceed(() => undefined),
     );
     if (req === undefined) return undefined;
     if (
@@ -456,11 +456,12 @@ const makeCore = Effect.gen(function* () {
       );
     }),
   ).pipe(
-    Effect.catchTag("RepoNotFound", () => Effect.succeed(notFound)),
-    Effect.catchTag("StoreError", (error) => Effect.succeed(ReceivePackHttp.failure(error.reason))),
-    Effect.catchTag(["WireProtocolError", "PackIngestError"], (error) =>
-      Effect.succeed(ReceivePackHttp.failure(error.reason)),
-    ),
+    Effect.catchTags({
+      RepoNotFound: () => Effect.succeed(notFound),
+      StoreError: (error) => Effect.succeed(ReceivePackHttp.failure(error.reason)),
+      WireProtocolError: (error) => Effect.succeed(ReceivePackHttp.failure(error.reason)),
+      PackIngestError: (error) => Effect.succeed(ReceivePackHttp.failure(error.reason)),
+    }),
   );
 
   /** Auth + resolve for the raw REST reads; `undefined` = already replied. */
@@ -494,18 +495,19 @@ const makeCore = Effect.gen(function* () {
             contentType: "application/octet-stream",
           }),
         ),
-        Effect.catchTag(["RepoNotFound", "ObjectNotFound"], () =>
-          Effect.succeed(HttpServerResponse.text("not found", { status: 404 })),
-        ),
-        Effect.catchTag("WrongObjectType", (error) =>
-          Effect.succeed(
-            HttpServerResponse.text(
-              `object ${error.oid} is a ${error.actual}, not a ${error.expected}`,
-              { status: 422 },
+        Effect.catchTags({
+          RepoNotFound: () => Effect.succeed(HttpServerResponse.text("not found", { status: 404 })),
+          ObjectNotFound: () =>
+            Effect.succeed(HttpServerResponse.text("not found", { status: 404 })),
+          WrongObjectType: (error) =>
+            Effect.succeed(
+              HttpServerResponse.text(
+                `object ${error.oid} is a ${error.actual}, not a ${error.expected}`,
+                { status: 422 },
+              ),
             ),
-          ),
-        ),
-        Effect.catchTag("StoreError", () => Effect.succeed(internalError)),
+          StoreError: () => Effect.succeed(internalError),
+        }),
       );
   });
 
@@ -635,7 +637,7 @@ const makeCore = Effect.gen(function* () {
     // A plain async writer, like the clone pump: writes settle only as the
     // response is read, and the open stream keeps this invocation alive
     // until the part's upload has finished.
-    const partDone = Effect.runPromise(Fiber.join(upload));
+    const partDone = upload.pipe(Fiber.join, Effect.runPromise);
     yield* Effect.sync(() => {
       void (async () => {
         const writer = writable.getWriter();

package/src/Git/Store/Closure.ts

@@ -205,7 +205,7 @@ export const computeClosure = (options: ClosureOptions) =>
     for (const want of wants) {
       const wantMeta = wantMetas.get(want);
       if (wantMeta === undefined) {
-        return yield* Effect.fail(new StoreError({ reason: `want not found: ${want}` }));
+        return yield* StoreError.make({ reason: `want not found: ${want}` });
       }
       let meta: ObjectMeta = wantMeta;
       let hops = 0;
@@ -227,9 +227,7 @@ export const computeClosure = (options: ClosureOptions) =>
           case 4: {
             hops += 1;
             if (hops > MAX_TAG_CHAIN) {
-              return yield* Effect.fail(
-                new StoreError({ reason: `tag chain too deep at ${meta.oid}` }),
-              );
+              return yield* StoreError.make({ reason: `tag chain too deep at ${meta.oid}` });
             }
             if (!tagSet.has(meta.oid)) {
               tagSet.add(meta.oid);
@@ -237,20 +235,17 @@ export const computeClosure = (options: ClosureOptions) =>
             }
             const content: Uint8Array = yield* objects.readContent(meta.oid);
             const parsed: ParsedTag = yield* parseTag(content).pipe(
-              Effect.mapError(
-                (error) =>
-                  new StoreError({
-                    reason: `bad tag ${meta.oid}: ${error.reason}`,
-                  }),
+              Effect.mapError((error) =>
+                StoreError.make({
+                  reason: `bad tag ${meta.oid}: ${error.reason}`,
+                }),
               ),
             );
             const target: ObjectMeta | undefined = yield* objects.getMeta(parsed.object);
             if (target === undefined) {
-              return yield* Effect.fail(
-                new StoreError({
-                  reason: `tag ${meta.oid} targets missing object ${parsed.object}`,
-                }),
-              );
+              return yield* StoreError.make({
+                reason: `tag ${meta.oid} targets missing object ${parsed.object}`,
+              });
             }
             meta = target;
             break;
@@ -297,9 +292,7 @@ export const computeClosure = (options: ClosureOptions) =>
       for (const oid of frontier) {
         const node = nodes.get(oid);
         if (node === undefined) {
-          return yield* Effect.fail(
-            new StoreError({ reason: `commit graph missing commit ${oid}` }),
-          );
+          return yield* StoreError.make({ reason: `commit graph missing commit ${oid}` });
         }
         candidateOrder.push(node);
         candidateSet.add(oid);
@@ -329,7 +322,7 @@ export const computeClosure = (options: ClosureOptions) =>
         }
       }
       if (candidateOrder.length > cap) {
-        return yield* Effect.fail(new ManifestTooLarge({ count: candidateOrder.length, cap }));
+        return yield* ManifestTooLarge.make({ count: candidateOrder.length, cap });
       }
       frontier = next;
     }
@@ -397,7 +390,7 @@ export const computeClosure = (options: ClosureOptions) =>
     let total = newCommits.length + tagOrder.length;
 
     const failIfOverCap = (count: number) =>
-      count > cap ? Effect.fail(new ManifestTooLarge({ count, cap })) : Effect.void;
+      count > cap ? Effect.fail(ManifestTooLarge.make({ count, cap })) : Effect.void;
 
     for (const blob of wantBlobs) {
       if (!visitedObjects.has(blob)) {
@@ -436,13 +429,11 @@ export const computeClosure = (options: ClosureOptions) =>
       for (const tree of batch) {
         const content = contents.get(tree);
         if (content === undefined) {
-          return yield* Effect.fail(
-            new StoreError({ reason: `tree ${tree} vanished during closure` }),
-          );
+          return yield* StoreError.make({ reason: `tree ${tree} vanished during closure` });
         }
         const entries = yield* parseTree(content).pipe(
-          Effect.mapError(
-            (error) => new StoreError({ reason: `bad tree ${tree}: ${error.reason}` }),
+          Effect.mapError((error) =>
+            StoreError.make({ reason: `bad tree ${tree}: ${error.reason}` }),
           ),
         );
         for (const entry of entries) {
@@ -481,9 +472,7 @@ export const computeClosure = (options: ClosureOptions) =>
     for (const oid of orderedOids) {
       const meta = metas.get(oid);
       if (meta === undefined) {
-        return yield* Effect.fail(
-          new StoreError({ reason: `object ${oid} vanished during closure` }),
-        );
+        return yield* StoreError.make({ reason: `object ${oid} vanished during closure` });
       }
       entries.push(meta);
     }
@@ -505,7 +494,7 @@ export const makeClosureSource = (options: ClosureOptions): ClosureSource => {
       compute(request).pipe(
         Effect.catchTag("ManifestTooLarge", (error) =>
           Effect.fail(
-            new StoreError({
+            StoreError.make({
               reason: `manifest exceeds ${error.cap} objects (v1 cap; got ${error.count})`,
             }),
           ),

package/src/Git/Store/IncomingBody.ts

@@ -62,5 +62,5 @@ export const feedBody = (
       feeder.end();
       return { total };
     },
-    catch: (error) => new StoreError({ reason: `incoming body read: ${String(error)}` }),
+    catch: (error) => StoreError.make({ reason: `incoming body read: ${String(error)}` }),
   }).pipe(Effect.tapError((error) => Effect.sync(() => feeder.fail(error))));

package/src/Git/Store/ObjectStore.ts

@@ -282,7 +282,7 @@ const isObjectType = (type: number): type is ObjectType =>
 const metaFromRow = (row: ObjectMetaRow): Effect.Effect<ObjectMeta, StoreError> => {
   if (!isObjectType(row.type) || !VALID_LOCATIONS.has(row.location)) {
     return Effect.fail(
-      new StoreError({
+      StoreError.make({
         reason: `corrupt objects row for ${row.oid}: type=${row.type} location=${row.location}`,
       }),
     );
@@ -337,12 +337,12 @@ export const makeObjectStore = (options: ObjectStoreOptions): ObjectStore => {
     what: string,
   ): Effect.Effect<A, StoreError> =>
     effect.pipe(
-      Effect.mapError((error) => new StoreError({ reason: `${what}: ${error.reason}` })),
+      Effect.mapError((error) => StoreError.make({ reason: `${what}: ${error.reason}` })),
       Effect.provide(RuntimeContext.phantom),
     );
 
   const zlibToStore = (error: Zlib.ZlibError): StoreError =>
-    new StoreError({ reason: error.reason });
+    StoreError.make({ reason: error.reason });
 
   const readRow = (
     oid: Oid,
@@ -358,7 +358,7 @@ export const makeObjectStore = (options: ObjectStoreOptions): ObjectStore => {
   const requireRow = Effect.fn(function* (oid: Oid, pushId: string | null = null) {
     const row = yield* readRow(oid, pushId);
     if (row === undefined) {
-      return yield* Effect.fail(new StoreError({ reason: `object not found: ${oid}` }));
+      return yield* StoreError.make({ reason: `object not found: ${oid}` });
     }
     return row;
   });
@@ -366,15 +366,13 @@ export const makeObjectStore = (options: ObjectStoreOptions): ObjectStore => {
   /** Fetches the R2 body for an `'r2'`-located row. */
   const r2Body = Effect.fn(function* (oid: Oid, r2Key: string | null) {
     if (r2Key === null) {
-      return yield* Effect.fail(
-        new StoreError({
-          reason: `object ${oid} has location='r2' but no r2_key`,
-        }),
-      );
+      return yield* StoreError.make({
+        reason: `object ${oid} has location='r2' but no r2_key`,
+      });
     }
     const body = yield* runBlob(blobs.get(r2Key), `blob get ${r2Key}`);
     if (body === null) {
-      return yield* Effect.fail(new StoreError({ reason: `R2 object missing: ${r2Key}` }));
+      return yield* StoreError.make({ reason: `R2 object missing: ${r2Key}` });
     }
     return body;
   });
@@ -410,10 +408,10 @@ export const makeObjectStore = (options: ObjectStoreOptions): ObjectStore => {
       `blob window get ${key}`,
     );
     if (body === null) {
-      return yield* Effect.fail(new StoreError({ reason: `pack missing: ${key}` }));
+      return yield* StoreError.make({ reason: `pack missing: ${key}` });
     }
     const bytes = yield* body.bytes.pipe(
-      Effect.mapError((error) => new StoreError({ reason: `R2 read ${key}: ${error.message}` })),
+      Effect.mapError((error) => StoreError.make({ reason: `R2 read ${key}: ${error.message}` })),
     );
     const slab = { start, bytes };
     retainWindow(cacheKey, slab);
@@ -431,11 +429,9 @@ export const makeObjectStore = (options: ObjectStoreOptions): ObjectStore => {
    */
   const packBytes = Effect.fn(function* (oid: Oid, row: ZDataRow) {
     if (row.pack_id === null || row.pack_offset === null) {
-      return yield* Effect.fail(
-        new StoreError({
-          reason: `object ${oid} has location='pack' but no pack coordinates`,
-        }),
-      );
+      return yield* StoreError.make({
+        reason: `object ${oid} has location='pack' but no pack coordinates`,
+      });
     }
     const key = packKeyOf(repoId, row.pack_id);
     const offset = row.pack_offset;
@@ -453,10 +449,10 @@ export const makeObjectStore = (options: ObjectStoreOptions): ObjectStore => {
       `blob ranged get ${key}`,
     );
     if (body === null) {
-      return yield* Effect.fail(new StoreError({ reason: `pack missing: ${key}` }));
+      return yield* StoreError.make({ reason: `pack missing: ${key}` });
     }
     return yield* body.bytes.pipe(
-      Effect.mapError((error) => new StoreError({ reason: `R2 read ${key}: ${error.message}` })),
+      Effect.mapError((error) => StoreError.make({ reason: `R2 read ${key}: ${error.message}` })),
     );
   });
 
@@ -466,33 +462,28 @@ export const makeObjectStore = (options: ObjectStoreOptions): ObjectStore => {
     switch (row.location) {
       case "row": {
         if (row.zdata === null) {
-          return yield* Effect.fail(
-            new StoreError({
-              reason: `object ${oid} has location='row' but NULL zdata`,
-            }),
-          );
+          return yield* StoreError.make({
+            reason: `object ${oid} has location='row' but NULL zdata`,
+          });
         }
         return new Uint8Array(row.zdata);
       }
       case "r2": {
         const body = yield* r2Body(oid, row.r2_key);
         return yield* body.bytes.pipe(
-          Effect.mapError(
-            (error) =>
-              new StoreError({
-                reason: `R2 read ${row.r2_key}: ${error.message}`,
-              }),
+          Effect.mapError((error) =>
+            StoreError.make({
+              reason: `R2 read ${row.r2_key}: ${error.message}`,
+            }),
           ),
         );
       }
       case "pack":
         return yield* packBytes(oid, row);
       default:
-        return yield* Effect.fail(
-          new StoreError({
-            reason: `object ${oid} has unknown location '${row.location}'`,
-          }),
-        );
+        return yield* StoreError.make({
+          reason: `object ${oid} has unknown location '${row.location}'`,
+        });
     }
   });
 
@@ -570,33 +561,28 @@ export const makeObjectStore = (options: ObjectStoreOptions): ObjectStore => {
         switch (row.location) {
           case "row": {
             if (row.zdata === null) {
-              return yield* Effect.fail(
-                new StoreError({
-                  reason: `object ${oid} has location='row' but NULL zdata`,
-                }),
-              );
+              return yield* StoreError.make({
+                reason: `object ${oid} has location='row' but NULL zdata`,
+              });
             }
             return Stream.succeed(new Uint8Array(row.zdata));
           }
           case "r2": {
             const body = yield* r2Body(oid, row.r2_key);
             return body.stream.pipe(
-              Stream.mapError(
-                (error) =>
-                  new StoreError({
-                    reason: `R2 stream ${row.r2_key}: ${error.message}`,
-                  }),
+              Stream.mapError((error) =>
+                StoreError.make({
+                  reason: `R2 stream ${row.r2_key}: ${error.message}`,
+                }),
               ),
             );
           }
           case "pack":
             return Stream.succeed(yield* packBytes(oid, row));
           default:
-            return yield* Effect.fail(
-              new StoreError({
-                reason: `object ${oid} has unknown location '${row.location}'`,
-              }),
-            );
+            return yield* StoreError.make({
+              reason: `object ${oid} has unknown location '${row.location}'`,
+            });
         }
       }),
     );
@@ -761,11 +747,9 @@ export const makeObjectStore = (options: ObjectStoreOptions): ObjectStore => {
             const runs: Array<Run> = [];
             for (const coord of coords) {
               if (coord.pack_id === null || coord.pack_offset === null) {
-                return yield* Effect.fail(
-                  new StoreError({
-                    reason: `object ${coord.oid} is location='pack' without coordinates`,
-                  }),
-                );
+                return yield* StoreError.make({
+                  reason: `object ${coord.oid} is location='pack' without coordinates`,
+                });
               }
               const key = packKeyOf(repoId, coord.pack_id);
               const window = Math.floor(coord.pack_offset / WINDOW_BYTES);
@@ -942,7 +926,7 @@ export const makeObjectStore = (options: ObjectStoreOptions): ObjectStore => {
     readPrepared: (pushId, oid, maxBytes) =>
       Effect.gen(function* () {
         if (!Number.isSafeInteger(maxBytes) || maxBytes < 0)
-          return yield* new StoreError({ reason: "invalid object size limit" });
+          return yield* StoreError.make({ reason: "invalid object size limit" });
         const row = yield* sql.first<ObjectMetaRow>(
           `SELECT oid, type, size, zsize, location FROM objects WHERE oid = ? AND (${LIVE_OBJECTS} OR staged_push = ?)`,
           oid,
@@ -951,7 +935,7 @@ export const makeObjectStore = (options: ObjectStoreOptions): ObjectStore => {
         if (row === undefined) return undefined;
         const meta = yield* metaFromRow(row);
         if (meta.size > maxBytes)
-          return yield* new StoreError({
+          return yield* StoreError.make({
             reason: `object exceeds ${maxBytes} byte read limit`,
           });
         const zdata = yield* readZBytes(oid, pushId);

package/src/Git/Store/PackSource.ts

@@ -55,25 +55,21 @@ export const blobRandomAccess = (options: {
       const body = yield* options.blobs
         .get(options.key, { offset: start, length: windowBytes })
         .pipe(
-          Effect.mapError(
-            (error) =>
-              new StoreError({
-                reason: `incoming pack read ${options.key}: ${error.reason}`,
-              }),
+          Effect.mapError((error) =>
+            StoreError.make({
+              reason: `incoming pack read ${options.key}: ${error.reason}`,
+            }),
           ),
           Effect.provide(RuntimeContext.phantom),
         );
       if (body === null) {
-        return yield* Effect.fail(
-          new StoreError({ reason: `incoming pack missing: ${options.key}` }),
-        );
+        return yield* StoreError.make({ reason: `incoming pack missing: ${options.key}` });
       }
       const bytes = yield* body.bytes.pipe(
-        Effect.mapError(
-          (error) =>
-            new StoreError({
-              reason: `incoming pack read ${options.key}: ${error.reason}`,
-            }),
+        Effect.mapError((error) =>
+          StoreError.make({
+            reason: `incoming pack read ${options.key}: ${error.reason}`,
+          }),
         ),
       );
       const slab = { start, bytes };

package/src/Git/Store/Sql.ts

@@ -372,7 +372,7 @@ export const makeSqlClient = (state: DurableObjectState["Service"]): SqlClient =
     Effect.try({
       try: () => sql.exec<Row>(query, ...bindings).toArray(),
       catch: (cause) =>
-        new StoreError({
+        StoreError.make({
           reason: `sql failed (${query.slice(0, 120)}): ${errorMessage(cause)}`,
         }),
     });
@@ -427,7 +427,7 @@ export const makeSqlClient = (state: DurableObjectState["Service"]): SqlClient =
         catch: (thrown): StoreError | E =>
           thrown instanceof RollbackSignal
             ? (thrown.error as E)
-            : new StoreError({
+            : StoreError.make({
                 reason: `transactionSync failed: ${errorMessage(thrown)}`,
               }),
       }),

package/src/Git/Store/StreamingSource.ts

@@ -181,7 +181,7 @@ export const makeStreamingSource = (options?: {
             : fallback !== undefined
               ? Effect.succeed(fallback)
               : Effect.fail(
-                  new StoreError({
+                  StoreError.make({
                     reason: "streaming source: bytes evicted and no fallback reader",
                   }),
                 ),
@@ -286,9 +286,9 @@ export const makeStreamingSource = (options?: {
     },
     push: (chunk) =>
       Effect.gen(function* () {
-        if (failure !== undefined) return yield* Effect.fail(failure);
+        if (failure !== undefined) return yield* failure;
         if (ended) {
-          return yield* Effect.fail(new StoreError({ reason: "streaming source: push after end" }));
+          return yield* StoreError.make({ reason: "streaming source: push after end" });
         }
         append(chunk);
         wake();

package/src/GitHub/AuthProvider.ts

@@ -1,3 +1,4 @@
+import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Match from "effect/Match";
 import * as ChildProcess from "effect/process/ChildProcess";
@@ -69,9 +70,9 @@ export interface GitHubResolvedCredentials {
 
 export const GITHUB_AUTH_PROVIDER_NAME = "GitHub";
 
-class GhCliError extends Error {
-  readonly _tag = "GhCliError";
-}
+class GhCliError extends Data.TaggedError("GhCliError")<{
+  readonly message: string;
+}> {}
 
 const readEnvTokenFor = (
   baseUrl: string | undefined,
@@ -92,7 +93,7 @@ const readEnvTokenFor = (
         };
       }
     }
-    return yield* new AuthError({
+    return yield* AuthError.make({
       message: `GitHub env credentials not found. Set ${candidates.join(", ")}.`,
     });
   });
@@ -183,29 +184,27 @@ export const makeGitHubAuth = (authOptions?: GitHubAuthOptions) =>
           const [exitCode, stdout, stderr] = yield* Effect.all(
             [
               handle.exitCode,
-              Stream.mkString(Stream.decodeText(handle.stdout)),
-              Stream.mkString(Stream.decodeText(handle.stderr)),
+              handle.stdout.pipe(Stream.decodeText, Stream.mkString),
+              handle.stderr.pipe(Stream.decodeText, Stream.mkString),
             ],
             { concurrency: 3 },
           );
           if (exitCode !== 0) {
-            return yield* Effect.fail(
-              new GhCliError(
-                `gh auth token exited with ${exitCode}: ${stderr.trim() || stdout.trim()}`,
-              ),
-            );
+            return yield* new GhCliError({
+              message: `gh auth token exited with ${exitCode}: ${stderr.trim() || stdout.trim()}`,
+            });
           }
           const token = stdout.trim();
           if (!token) {
-            return yield* Effect.fail(new GhCliError("gh auth token returned empty output"));
+            return yield* new GhCliError({ message: "gh auth token returned empty output" });
           }
           return token;
         }).pipe(
           Effect.scoped,
           Effect.mapError((e) =>
             e instanceof GhCliError
-              ? new AuthError({ message: e.message, cause: e })
-              : new AuthError({
+              ? AuthError.make({ message: e.message, cause: e })
+              : AuthError.make({
                   message:
                     "Could not invoke `gh`. Install GitHub CLI from https://cli.github.com/ and run `gh auth login`.",
                   cause: e,
@@ -263,12 +262,11 @@ export const makeGitHubAuth = (authOptions?: GitHubAuthOptions) =>
                   token,
                   baseUrl,
                 })),
-                Effect.mapError(
-                  (e) =>
-                    new AuthError({
-                      message: `gh CLI not available: ${e.message}`,
-                      cause: e,
-                    }),
+                Effect.mapError((e) =>
+                  AuthError.make({
+                    message: `gh CLI not available: ${e.message}`,
+                    cause: e,
+                  }),
                 ),
               ),
             ),
@@ -279,12 +277,11 @@ export const makeGitHubAuth = (authOptions?: GitHubAuthOptions) =>
 
       const configureCredentials = (profileName: string) =>
         configureInteractive(profileName).pipe(
-          Effect.mapError(
-            (e) =>
-              new AuthError({
-                message: "failed to configure credentials",
-                cause: e,
-              }),
+          Effect.mapError((e) =>
+            AuthError.make({
+              message: "failed to configure credentials",
+              cause: e,
+            }),
           ),
         );
 
@@ -315,14 +312,13 @@ export const makeGitHubAuth = (authOptions?: GitHubAuthOptions) =>
                 (yield* ghCliToken(
                   baseUrl !== undefined ? githubHostname(baseUrl) : undefined,
                 ).pipe(
-                  Effect.mapError(
-                    (cause) =>
-                      new NeedsReauth({
-                        provider: GITHUB_AUTH_PROVIDER_NAME,
-                        profile: profileName,
-                        message: `GitHub CLI credentials need to be refreshed. ${refreshHint(GITHUB_AUTH_PROVIDER_NAME, profileName)}`,
-                        cause,
-                      }),
+                  Effect.mapError((cause) =>
+                    NeedsReauth.make({
+                      provider: GITHUB_AUTH_PROVIDER_NAME,
+                      profile: profileName,
+                      message: `GitHub CLI credentials need to be refreshed. ${refreshHint(GITHUB_AUTH_PROVIDER_NAME, profileName)}`,
+                      cause,
+                    }),
                   ),
                 ));
               if (c.token === undefined && updateConfig !== undefined) {
@@ -347,23 +343,22 @@ export const makeGitHubAuth = (authOptions?: GitHubAuthOptions) =>
         );
 
       const login = (_profileName: string, config: GitHubAuthConfig) =>
-        Match.value(config)
-          .pipe(
-            Match.when({ method: "gh-cli" }, (c) =>
-              effectiveBaseUrl(c).pipe(
-                Effect.flatMap((baseUrl) =>
-                  ghCliToken(baseUrl !== undefined ? githubHostname(baseUrl) : undefined),
-                ),
-                Effect.tap(() =>
-                  interaction.output.success("GitHub: gh CLI authentication available."),
-                ),
-                Effect.map((token) => ({ ...c, token })),
+        Match.value(config).pipe(
+          Match.when({ method: "gh-cli" }, (c) =>
+            effectiveBaseUrl(c).pipe(
+              Effect.flatMap((baseUrl) =>
+                ghCliToken(baseUrl !== undefined ? githubHostname(baseUrl) : undefined),
+              ),
+              Effect.tap(() =>
+                interaction.output.success("GitHub: gh CLI authentication available."),
               ),
+              Effect.map((token) => ({ ...c, token })),
             ),
-            Match.when({ method: "stored" }, (c) => Effect.succeed(c)),
-            Match.exhaustive,
-          )
-          .pipe(Effect.mapError((e) => new AuthError({ message: "login failed", cause: e })));
+          ),
+          Match.when({ method: "stored" }, (c) => Effect.succeed(c)),
+          Match.exhaustive,
+          Effect.mapError((e) => AuthError.make({ message: "login failed", cause: e })),
+        );
 
       const details = (
         profileName: string,
@@ -435,7 +430,7 @@ export const makeGitHubAuth = (authOptions?: GitHubAuthOptions) =>
               ),
             )
           : Effect.fail(
-              new AuthError({
+              AuthError.make({
                 message: `GitHub: unknown method '${input.method}'. Valid methods: stored. (gh-cli is interactive-only.)`,
               }),
             );

package/src/GitHub/BaseUrl.ts

@@ -33,7 +33,7 @@ export const normalizeGitHubBaseUrl = (
       return `${url.protocol}//${url.host}${path === "" ? "/api/v3" : path}`;
     },
     catch: () =>
-      new AuthError({
+      AuthError.make({
         message: `Invalid GitHub base URL: '${input}'. Provide a hostname (github.example.com) or URL (https://github.example.com/api/v3).`,
       }),
   });