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

package/src/Git/Hasher/Hasher.ts

@@ -154,11 +154,10 @@ export const makeInlineHasher = (blobs: BlobStoreShape): HasherShape => ({
           ? undefined
           : yield* Effect.forkDetach(
               blobs.uploadPart(spill.key, spill.uploadId, spill.partNumber, payload).pipe(
-                Effect.mapError(
-                  (error) =>
-                    new HashError({
-                      reason: `spill part ${spill.partNumber}: ${error.reason}`,
-                    }),
+                Effect.mapError((error) =>
+                  HashError.make({
+                    reason: `spill part ${spill.partNumber}: ${error.reason}`,
+                  }),
                 ),
                 Effect.provide(RuntimeContext.phantom),
               ),
@@ -241,14 +240,14 @@ export const HasherSelf: Layer.Layer<Hasher, never, WorkerEnvironment | BlobStor
               },
               body: body as unknown as BodyInit,
             }),
-          catch: (error) => new HashError({ reason: `hash part fetch: ${String(error)}` }),
+          catch: (error) => HashError.make({ reason: `hash part fetch: ${String(error)}` }),
         });
         if (response.status !== 200 || response.body === null) {
           const text = yield* Effect.tryPromise({
             try: () => response.text(),
-            catch: () => new HashError({ reason: "hash part: unreadable" }),
+            catch: () => HashError.make({ reason: "hash part: unreadable" }),
           });
-          return yield* new HashError({
+          return yield* HashError.make({
             reason: `hash part: status ${response.status}: ${text.slice(0, 200)}`,
           });
         }
@@ -259,7 +258,7 @@ export const HasherSelf: Layer.Layer<Hasher, never, WorkerEnvironment | BlobStor
         const next = yield* send(url, body);
         const first = yield* next();
         if (first === undefined) {
-          return yield* new HashError({ reason: "hash part: empty response" });
+          return yield* HashError.make({ reason: "hash part: empty response" });
         }
         return decodeScanResult(first);
       });
@@ -277,7 +276,7 @@ export const HasherSelf: Layer.Layer<Hasher, never, WorkerEnvironment | BlobStor
           );
           const first = yield* next();
           if (first === undefined) {
-            return yield* new HashError({
+            return yield* HashError.make({
               reason: "hash part: empty response",
             });
           }
@@ -287,7 +286,7 @@ export const HasherSelf: Layer.Layer<Hasher, never, WorkerEnvironment | BlobStor
           const part = next().pipe(
             Effect.flatMap((bytes) =>
               bytes === undefined
-                ? Effect.fail(new HashError({ reason: "hash part: no part frame" }))
+                ? Effect.fail(HashError.make({ reason: "hash part: no part frame" }))
                 : Effect.succeed(JSON.parse(new TextDecoder().decode(bytes)) as UploadedPart),
             ),
           );
@@ -306,7 +305,7 @@ export const HasherSelf: Layer.Layer<Hasher, never, WorkerEnvironment | BlobStor
           );
           const first = yield* next();
           if (first === undefined) {
-            return yield* new HashError({
+            return yield* HashError.make({
               reason: "delta batch: empty response",
             });
           }

package/src/Git/Hasher/Lambda.ts

@@ -38,26 +38,24 @@ export const HasherLambda = (
           const response = yield* invoke({
             Payload: JSON.stringify(encodeHashEvent(payload, options)),
           }).pipe(
-            Effect.mapError(
-              (error) =>
-                new HashError({
-                  reason: `lambda invoke: ${error._tag}${"message" in error ? `: ${String(error.message)}` : ""}`,
-                }),
+            Effect.mapError((error) =>
+              HashError.make({
+                reason: `lambda invoke: ${error._tag}${"message" in error ? `: ${String(error.message)}` : ""}`,
+              }),
             ),
           );
           if (response.FunctionError !== undefined) {
-            return yield* new HashError({
+            return yield* HashError.make({
               reason: `lambda hasher: ${response.FunctionError}`,
             });
           }
           const chunks = response.Payload
             ? Array.from(
                 yield* Stream.runCollect(response.Payload).pipe(
-                  Effect.mapError(
-                    (error) =>
-                      new HashError({
-                        reason: `lambda response: ${String(error)}`,
-                      }),
+                  Effect.mapError((error) =>
+                    HashError.make({
+                      reason: `lambda response: ${String(error)}`,
+                    }),
                   ),
                 ),
               )
@@ -65,7 +63,7 @@ export const HasherLambda = (
           const text = new TextDecoder().decode(chunks.length === 1 ? chunks[0] : concat(chunks));
           const parsed = yield* Effect.try({
             try: () => JSON.parse(text) as HashResponse,
-            catch: () => new HashError({ reason: `lambda response: not JSON` }),
+            catch: () => HashError.make({ reason: `lambda response: not JSON` }),
           });
           return yield* decodeHashResponse(parsed);
         });
@@ -77,7 +75,7 @@ export const HasherLambda = (
           // cannot fit the invoke payload: hash it here without the trip.
           (payload.length > LAMBDA_CHUNK_BYTES
             ? Effect.fail(
-                new HashError({
+                HashError.make({
                   reason: `payload of ${payload.length} bytes exceeds the invoke limit`,
                 }),
               )

package/src/Git/Hasher/LambdaEvent.ts

@@ -120,5 +120,5 @@ export const handleHashEvent = (event: HashEvent): Effect.Effect<HashResponse> =
 /** Decodes a response into the pump's scan result (or a typed error). */
 export const decodeHashResponse = (response: HashResponse): Effect.Effect<ScanResult, HashError> =>
   "error" in response
-    ? Effect.fail(new HashError({ reason: `lambda hasher: ${response.error}` }))
+    ? Effect.fail(HashError.make({ reason: `lambda hasher: ${response.error}` }))
     : Effect.succeed(decodeScanResult(fromBase64(response.scan)));

package/src/Git/Hasher/Protocol.ts

@@ -195,7 +195,7 @@ export const makeFrameReader = (body: ReadableStream<Uint8Array>) => {
           pendingBytes += value.length;
         }
       },
-      catch: (error) => new HashError({ reason: `hash part body: ${String(error)}` }),
+      catch: (error) => HashError.make({ reason: `hash part body: ${String(error)}` }),
     });
 };
 

package/src/Git/Hasher/WorkerLoader.ts

@@ -95,19 +95,19 @@ export const HasherWorkerLoader = (
                     ),
                   )
                   .pipe(
-                    Effect.mapError(
-                      (error) => new HashError({ reason: `dynamic hasher: ${String(error)}` }),
+                    Effect.mapError((error) =>
+                      HashError.make({ reason: `dynamic hasher: ${String(error)}` }),
                     ),
                   );
                 const bytes = new Uint8Array(
                   yield* response.arrayBuffer.pipe(
-                    Effect.mapError(
-                      (error) => new HashError({ reason: `dynamic hasher body: ${String(error)}` }),
+                    Effect.mapError((error) =>
+                      HashError.make({ reason: `dynamic hasher body: ${String(error)}` }),
                     ),
                   ),
                 );
                 if (response.status !== 200) {
-                  return yield* new HashError({
+                  return yield* HashError.make({
                     reason: `dynamic hasher: status ${response.status}: ${new TextDecoder().decode(bytes.subarray(0, 200))}`,
                   });
                 }

package/src/Git/Hasher/WorkerLoaderModule.ts

@@ -15,8 +15,9 @@ export default {
     if (query.get("mode") === "deltas") {
       const maxObjectSize = Number(query.get("max"));
       const { bases, jobs } = decodeDeltaBatch(new Uint8Array(await request.arrayBuffer()));
-      const resolved = await Effect.runPromise(
-        Effect.result(resolveDeltas(bases, jobs, { maxObjectSize })),
+      const resolved = await resolveDeltas(bases, jobs, { maxObjectSize }).pipe(
+        Effect.result,
+        Effect.runPromise,
       );
       if (resolved._tag === "Failure") {
         const failure = resolved.failure;
@@ -36,16 +37,12 @@ export default {
       return new Response("bad coordinates", { status: 400 });
     }
     const body = new Uint8Array(await request.arrayBuffer());
-    const result = await Effect.runPromise(
-      Effect.result(
-        scanPart(skip > 0 ? body.subarray(skip) : body, {
-          base,
-          remaining,
-          maxObjectSize,
-          resync: query.get("resync") === "1",
-        }),
-      ),
-    );
+    const result = await scanPart(skip > 0 ? body.subarray(skip) : body, {
+      base,
+      remaining,
+      maxObjectSize,
+      resync: query.get("resync") === "1",
+    }).pipe(Effect.result, Effect.runPromise);
     if (result._tag === "Failure") {
       const failure = result.failure;
       return new Response(`${failure._tag}: ${"reason" in failure ? failure.reason : ""}`, {

package/src/Git/Http/ReceivePack.ts

@@ -32,13 +32,13 @@ export const probeResponse = () => HttpServerResponse.empty({ status: 200, heade
 export const decode = (request: HttpServerRequest.HttpServerRequest) =>
   Effect.gen(function* () {
     const web = yield* HttpServerRequest.toWeb(request).pipe(
-      Effect.mapError((error) => new StoreError({ reason: `incoming body: ${error.message}` })),
+      Effect.mapError((error) => StoreError.make({ reason: `incoming body: ${error.message}` })),
     );
     const feeder = makeStreamingSource();
     const gzip = /\bgzip\b/i.test(request.headers["content-encoding"] ?? "");
     const body =
       gzip && web.body !== null ? web.body.pipeThrough(new DecompressionStream("gzip")) : web.body;
-    const receiving = yield* Effect.forkScoped(Effect.result(feedBody(body, feeder)));
+    const receiving = yield* feedBody(body, feeder).pipe(Effect.result, Effect.forkScoped);
     const state = {
       feeder,
       receiving,
@@ -50,13 +50,13 @@ export const decode = (request: HttpServerRequest.HttpServerRequest) =>
     yield* Effect.addFinalizer(() =>
       Effect.gen(function* () {
         state.active = false;
-        feeder.fail(new StoreError({ reason: "push scope closed" }));
+        feeder.fail(StoreError.make({ reason: "push scope closed" }));
         yield* Fiber.interrupt(receiving);
       }),
     );
     const head = yield* feeder.source.read(0, HEAD_BYTES);
     if (!gzip && head[0] === 0x1f && head[1] === 0x8b) {
-      return yield* new StoreError({
+      return yield* StoreError.make({
         reason: "gzip-encoded push without content-encoding",
       });
     }

package/src/Git/Jobs/Bundle.ts

@@ -136,8 +136,8 @@ export const runBundleJob = (
         { contentLength: size },
       )
       .pipe(
-        Effect.mapError(
-          (error: BlobStoreError) => new StoreError({ reason: `blob put ${key}: ${error.reason}` }),
+        Effect.mapError((error: BlobStoreError) =>
+          StoreError.make({ reason: `blob put ${key}: ${error.reason}` }),
         ),
         Effect.provide(RuntimeContext.phantom),
       );
@@ -155,11 +155,10 @@ export const runBundleJob = (
         { contentLength: sidebandFramedLength(size) },
       )
       .pipe(
-        Effect.mapError(
-          (error: BlobStoreError) =>
-            new StoreError({
-              reason: `blob put ${sidebandKey}: ${error.reason}`,
-            }),
+        Effect.mapError((error: BlobStoreError) =>
+          StoreError.make({
+            reason: `blob put ${sidebandKey}: ${error.reason}`,
+          }),
         ),
         Effect.provide(RuntimeContext.phantom),
       );

package/src/Git/Jobs/Compact.ts

@@ -111,7 +111,7 @@ const runR2 =
   (what: string) =>
   <A>(effect: Effect.Effect<A, BlobStoreError, RuntimeContext>): 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),
     );
 
@@ -405,7 +405,7 @@ export const runGeometricMergeJob = (options: {
         let at = bodyOffset;
         for (const row of rows) {
           if (row.pack_offset + row.zsize > bytes.length) {
-            return yield* new StoreError({
+            return yield* StoreError.make({
               reason: `merge: ${row.oid} points past the end of wire pack ${source.id}`,
             });
           }
@@ -427,7 +427,7 @@ export const runGeometricMergeJob = (options: {
         bytes[2] !== 0x43 ||
         bytes[3] !== 0x4b
       ) {
-        return yield* new StoreError({
+        return yield* StoreError.make({
           reason: `merge: pack ${source.id} is not a packfile`,
         });
       }

package/src/Git/Jobs/Fork.ts

@@ -90,7 +90,7 @@ const decodeZData = (row: SnapshotObjectRow): Effect.Effect<Uint8Array, StoreErr
   const decoded = Base64.decode(row.zdata ?? "");
   return Result.isSuccess(decoded)
     ? Effect.succeed(decoded.success)
-    : Effect.fail(new StoreError({ reason: `fork: corrupt zdata for ${row.oid}` }));
+    : Effect.fail(StoreError.make({ reason: `fork: corrupt zdata for ${row.oid}` }));
 };
 
 /** Config keys that transfer from parent to fork. */
@@ -317,8 +317,8 @@ export interface ForkJobOptions {
  */
 export const runForkJob = (options: ForkJobOptions): Effect.Effect<number, StoreError> =>
   options.snapshot.pipe(
-    Stream.mapError(
-      (error) => new StoreError({ reason: `fork snapshot stream failed: ${String(error)}` }),
+    Stream.mapError((error) =>
+      StoreError.make({ reason: `fork snapshot stream failed: ${String(error)}` }),
     ),
     Stream.runFoldEffect(
       () => 0,

package/src/Git/Jobs/Import.ts

@@ -106,10 +106,10 @@ const tokenize = (buf: Uint8Array): Effect.Effect<ReadonlyArray<Token>, ImportCl
     while (pos < buf.length) {
       const r = readPktLineAt(buf, pos);
       if (r._tag === "incomplete") {
-        return Effect.fail(new ImportClientError({ reason: "truncated advertisement" }));
+        return Effect.fail(ImportClientError.make({ reason: "truncated advertisement" }));
       }
       if (r._tag === "invalid") {
-        return Effect.fail(new ImportClientError({ reason: r.reason }));
+        return Effect.fail(ImportClientError.make({ reason: r.reason }));
       }
       if (r.pkt._tag === "flush") {
         out.push({ _tag: "flush" });
@@ -138,7 +138,7 @@ export const parseAdvertisement = Effect.fn(function* (body: Uint8Array) {
     const text = token.text;
     if (text.startsWith("#")) continue; // "# service=git-upload-pack"
     if (text.startsWith("ERR ")) {
-      return yield* new ImportClientError({
+      return yield* ImportClientError.make({
         reason: `remote error: ${text.slice(4)}`,
       });
     }
@@ -198,15 +198,15 @@ export const fetchAdvertisement = Effect.fn(function* (url: string) {
   const response = yield* client
     .get(`${normalizeBase(url)}/info/refs?service=git-upload-pack`)
     .pipe(
-      Effect.mapError((error) => new ImportClientError({ reason: `info/refs failed: ${error}` })),
+      Effect.mapError((error) => ImportClientError.make({ reason: `info/refs failed: ${error}` })),
     );
   if (response.status !== 200) {
-    return yield* new ImportClientError({
+    return yield* ImportClientError.make({
       reason: `info/refs returned HTTP ${response.status}`,
     });
   }
   const body = yield* response.arrayBuffer.pipe(
-    Effect.mapError((error) => new ImportClientError({ reason: `info/refs body read: ${error}` })),
+    Effect.mapError((error) => ImportClientError.make({ reason: `info/refs body read: ${error}` })),
   );
   return yield* parseAdvertisement(new Uint8Array(body));
 });
@@ -254,13 +254,13 @@ export const parseUploadPackResponse = Effect.fn(function* (body: Uint8Array) {
   let pos = 0;
   for (;;) {
     if (pos >= body.length) {
-      return yield* new ImportClientError({
+      return yield* ImportClientError.make({
         reason: "upload-pack response ended before NAK/ACK",
       });
     }
     const r = readPktLineAt(body, pos);
     if (r._tag === "incomplete" || r._tag === "invalid") {
-      return yield* new ImportClientError({
+      return yield* ImportClientError.make({
         reason: r._tag === "invalid" ? r.reason : "truncated upload-pack response",
       });
     }
@@ -274,7 +274,7 @@ export const parseUploadPackResponse = Effect.fn(function* (body: Uint8Array) {
     }
     if (text.startsWith("unshallow ")) continue;
     if (text.startsWith("ERR ")) {
-      return yield* new ImportClientError({
+      return yield* ImportClientError.make({
         reason: `remote error: ${text.slice(4)}`,
       });
     }
@@ -312,31 +312,30 @@ export const fetchPack = Effect.fn(function* (
   const response = yield* client
     .execute(request)
     .pipe(
-      Effect.mapError(
-        (error) => new ImportClientError({ reason: `git-upload-pack failed: ${error}` }),
+      Effect.mapError((error) =>
+        ImportClientError.make({ reason: `git-upload-pack failed: ${error}` }),
       ),
     );
   if (response.status !== 200) {
-    return yield* new ImportClientError({
+    return yield* ImportClientError.make({
       reason: `git-upload-pack returned HTTP ${response.status}`,
     });
   }
   const body = yield* response.arrayBuffer.pipe(
-    Effect.mapError(
-      (error) =>
-        new ImportClientError({
-          reason: `git-upload-pack body read: ${error}`,
-        }),
+    Effect.mapError((error) =>
+      ImportClientError.make({
+        reason: `git-upload-pack body read: ${error}`,
+      }),
     ),
   );
   if (body.byteLength > maxPack + 65536) {
-    return yield* new ImportClientError({
+    return yield* ImportClientError.make({
       reason: `source pack exceeds the ${maxPack} byte import cap`,
     });
   }
   const parsed = yield* parseUploadPackResponse(new Uint8Array(body));
   if (parsed.pack.byteLength > maxPack) {
-    return yield* new ImportClientError({
+    return yield* ImportClientError.make({
       reason: `source pack exceeds the ${maxPack} byte import cap`,
     });
   }
@@ -374,7 +373,7 @@ export const runImport = Effect.fn(function* (options: ImportOptions) {
 
   const selected = selectRefs(advertisement.refs, source.ref);
   if (selected === undefined) {
-    return yield* new ImportClientError({
+    return yield* ImportClientError.make({
       reason: `ref '${source.ref}' not found on the remote`,
     });
   }

package/src/Git/Jobs/Purge.ts

@@ -64,7 +64,7 @@ const r2ToStore =
   (what: string) =>
   <A>(effect: Effect.Effect<A, BlobStoreError, RuntimeContext>): 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),
     );
 
@@ -100,13 +100,11 @@ export const runPurgeJob = (options: PurgeJobOptions): Effect.Effect<PurgeOutcom
     // from the listing stream, delete in 1000-key batches, and treat a
     // short take as fully drained.
     const cap = MAX_PAGES_PER_RUN * 1000;
-    const keys = yield* r2ToStore(`blob list ${prefix}`)(
-      Stream.runCollect(
-        options.blobs.list(prefix).pipe(
-          Stream.take(cap),
-          Stream.map((meta) => meta.key),
-        ),
-      ),
+    const keys = yield* options.blobs.list(prefix).pipe(
+      Stream.take(cap),
+      Stream.map((meta) => meta.key),
+      Stream.runCollect,
+      r2ToStore(`blob list ${prefix}`),
     );
     for (let at = 0; at < keys.length; at += 1000) {
       yield* r2ToStore(`blob delete under ${prefix}`)(