alchemy 2.0.0-beta.81 → 2.0.0-beta.82

package/src/Git/Protocol/Delta.ts

@@ -62,8 +62,8 @@ export const readDeltaHeader = (delta: Uint8Array): DeltaHeader => {
       offset: result.next,
     };
   } catch (error) {
-    throw error instanceof ObjectParseError
-      ? new DeltaFormatError({
+    throw Schema.is(ObjectParseError)(error)
+      ? DeltaFormatError.make({
           reason: `truncated delta header: ${error.reason}`,
         })
       : error;
@@ -84,12 +84,14 @@ export const applyDelta = (
       header = readDeltaHeader(delta);
     } catch (error) {
       return Effect.fail(
-        error instanceof DeltaFormatError ? error : new DeltaFormatError({ reason: String(error) }),
+        Schema.is(DeltaFormatError)(error)
+          ? error
+          : DeltaFormatError.make({ reason: String(error) }),
       );
     }
     if (header.baseSize !== base.length) {
       return Effect.fail(
-        new DeltaFormatError({
+        DeltaFormatError.make({
           reason: `delta base size ${header.baseSize} != actual base ${base.length}`,
         }),
       );
@@ -101,7 +103,7 @@ export const applyDelta = (
       const opcode = delta[pos]!;
       pos += 1;
       if (opcode === 0) {
-        return Effect.fail(new DeltaFormatError({ reason: "reserved delta opcode 0x00" }));
+        return Effect.fail(DeltaFormatError.make({ reason: "reserved delta opcode 0x00" }));
       }
       if ((opcode & 0x80) !== 0) {
         // copy instruction
@@ -110,7 +112,7 @@ export const applyDelta = (
         for (let bit = 0; bit < 4; bit++) {
           if ((opcode & (1 << bit)) !== 0) {
             if (pos >= delta.length) {
-              return Effect.fail(new DeltaFormatError({ reason: "truncated copy offset" }));
+              return Effect.fail(DeltaFormatError.make({ reason: "truncated copy offset" }));
             }
             offset += delta[pos]! * 2 ** (8 * bit);
             pos += 1;
@@ -119,7 +121,7 @@ export const applyDelta = (
         for (let bit = 0; bit < 3; bit++) {
           if ((opcode & (1 << (4 + bit))) !== 0) {
             if (pos >= delta.length) {
-              return Effect.fail(new DeltaFormatError({ reason: "truncated copy size" }));
+              return Effect.fail(DeltaFormatError.make({ reason: "truncated copy size" }));
             }
             size += delta[pos]! * 2 ** (8 * bit);
             pos += 1;
@@ -128,14 +130,14 @@ export const applyDelta = (
         if (size === 0) size = 0x10000;
         if (offset + size > base.length) {
           return Effect.fail(
-            new DeltaFormatError({
+            DeltaFormatError.make({
               reason: `copy out of bounds: ${offset}+${size} > base ${base.length}`,
             }),
           );
         }
         if (outPos + size > out.length) {
           return Effect.fail(
-            new DeltaFormatError({
+            DeltaFormatError.make({
               reason: `delta output overflows declared result size ${out.length}`,
             }),
           );
@@ -146,11 +148,11 @@ export const applyDelta = (
         // insert instruction: opcode = literal byte count (1–127)
         const size = opcode;
         if (pos + size > delta.length) {
-          return Effect.fail(new DeltaFormatError({ reason: "truncated insert data" }));
+          return Effect.fail(DeltaFormatError.make({ reason: "truncated insert data" }));
         }
         if (outPos + size > out.length) {
           return Effect.fail(
-            new DeltaFormatError({
+            DeltaFormatError.make({
               reason: `delta output overflows declared result size ${out.length}`,
             }),
           );
@@ -162,7 +164,7 @@ export const applyDelta = (
     }
     if (outPos !== out.length) {
       return Effect.fail(
-        new DeltaFormatError({
+        DeltaFormatError.make({
           reason: `delta produced ${outPos} bytes, expected ${out.length}`,
         }),
       );

package/src/Git/Protocol/GzipBody.ts

@@ -64,7 +64,7 @@ export const gunzipStream = <E>(
         // runtime accepts Uint8Array chunks — bridge the variance mismatch.
         new DecompressionStream("gzip") as unknown as ReadableWritablePair<Uint8Array, Uint8Array>,
       ) as ReadableStream<Uint8Array>,
-    onError: (error) => new GzipBodyError({ reason: `gunzip failed: ${errorReason(error)}` }),
+    onError: (error) => GzipBodyError.make({ reason: `gunzip failed: ${errorReason(error)}` }),
   });
 
 /**
@@ -130,7 +130,7 @@ export const decodeGitBodyStream = <E>(
         ? Stream.empty
         : // `toPull`'s error channel is already Done-free, so ExcludeDone<E> = E;
           // TS cannot reduce the conditional for a generic E, hence the cast.
-          (Stream.fromPull(Effect.succeed(pull)) as Stream.Stream<Uint8Array, E>);
+          (pull.pipe(Effect.succeed, Stream.fromPull) as Stream.Stream<Uint8Array, E>);
       const full: Stream.Stream<Uint8Array, E> =
         length === 0 ? remainder : Stream.concat(Stream.succeed(headBytes), remainder);
       return sniffGzip(headBytes)

package/src/Git/Protocol/ObjectCodec.ts

@@ -159,7 +159,7 @@ export const bytesToHex = (bytes: Uint8Array): string => {
  */
 export const hexToBytes = (hex: string): Uint8Array => {
   if (hex.length % 2 !== 0) {
-    throw new ObjectParseError({
+    throw ObjectParseError.make({
       reason: `odd-length hex string: ${hex.length}`,
     });
   }
@@ -167,7 +167,7 @@ export const hexToBytes = (hex: string): Uint8Array => {
   for (let i = 0; i < out.length; i++) {
     const byte = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
     if (Number.isNaN(byte)) {
-      throw new ObjectParseError({
+      throw ObjectParseError.make({
         reason: `invalid hex at position ${i * 2}`,
       });
     }
@@ -344,7 +344,7 @@ export const parseIdentity = (value: string): Effect.Effect<Identity, ObjectPars
   Effect.suspend(() => {
     const match = IDENTITY_REGEX.exec(value);
     if (match === null) {
-      return Effect.fail(new ObjectParseError({ reason: `malformed identity: ${value}` }));
+      return Effect.fail(ObjectParseError.make({ reason: `malformed identity: ${value}` }));
     }
     return Effect.succeed({
       name: match[1]!,
@@ -402,7 +402,7 @@ export const parseCommit = Effect.fn(function* (content: Uint8Array) {
     switch (key) {
       case "tree":
         if (!isOid(value)) {
-          return yield* new ObjectParseError({
+          return yield* ObjectParseError.make({
             reason: `commit tree is not a valid oid: ${value}`,
           });
         }
@@ -410,7 +410,7 @@ export const parseCommit = Effect.fn(function* (content: Uint8Array) {
         break;
       case "parent":
         if (!isOid(value)) {
-          return yield* new ObjectParseError({
+          return yield* ObjectParseError.make({
             reason: `commit parent is not a valid oid: ${value}`,
           });
         }
@@ -430,15 +430,15 @@ export const parseCommit = Effect.fn(function* (content: Uint8Array) {
     }
   }
   if (tree === undefined) {
-    return yield* new ObjectParseError({ reason: "commit has no tree header" });
+    return yield* ObjectParseError.make({ reason: "commit has no tree header" });
   }
   if (authorRaw === undefined) {
-    return yield* new ObjectParseError({
+    return yield* ObjectParseError.make({
       reason: "commit has no author header",
     });
   }
   if (committerRaw === undefined) {
-    return yield* new ObjectParseError({
+    return yield* ObjectParseError.make({
       reason: "commit has no committer header",
     });
   }
@@ -479,17 +479,17 @@ const TZ_REGEX = /^[+-]\d{4}$/;
 
 const validateIdentity = (role: string, id: Identity): ObjectParseError | undefined => {
   if (/[<>\n]/.test(id.name) || /[<>\n]/.test(id.email)) {
-    return new ObjectParseError({
+    return ObjectParseError.make({
       reason: `commit ${role} name/email must not contain '<', '>' or newline`,
     });
   }
   if (!Number.isInteger(id.when) || id.when < 0) {
-    return new ObjectParseError({
+    return ObjectParseError.make({
       reason: `commit ${role} timestamp is not a non-negative integer: ${id.when}`,
     });
   }
   if (!TZ_REGEX.test(id.tz)) {
-    return new ObjectParseError({
+    return ObjectParseError.make({
       reason: `commit ${role} timezone is not ±hhmm: ${id.tz}`,
     });
   }
@@ -505,7 +505,7 @@ export const encodeCommit = (fields: CommitFields): Effect.Effect<Uint8Array, Ob
   Effect.suspend(() => {
     if (!isOid(fields.tree)) {
       return Effect.fail(
-        new ObjectParseError({
+        ObjectParseError.make({
           reason: `commit tree is not a valid oid: ${fields.tree}`,
         }),
       );
@@ -513,7 +513,7 @@ export const encodeCommit = (fields: CommitFields): Effect.Effect<Uint8Array, Ob
     for (const parent of fields.parents) {
       if (!isOid(parent)) {
         return Effect.fail(
-          new ObjectParseError({
+          ObjectParseError.make({
             reason: `commit parent is not a valid oid: ${parent}`,
           }),
         );
@@ -551,7 +551,7 @@ export const parseTag = Effect.fn(function* (content: Uint8Array) {
     switch (key) {
       case "object":
         if (!isOid(value)) {
-          return yield* new ObjectParseError({
+          return yield* ObjectParseError.make({
             reason: `tag object is not a valid oid: ${value}`,
           });
         }
@@ -560,7 +560,7 @@ export const parseTag = Effect.fn(function* (content: Uint8Array) {
       case "type": {
         const t = objectTypeOf(value);
         if (t === undefined) {
-          return yield* new ObjectParseError({
+          return yield* ObjectParseError.make({
             reason: `tag has invalid target type: ${value}`,
           });
         }
@@ -578,7 +578,7 @@ export const parseTag = Effect.fn(function* (content: Uint8Array) {
     }
   }
   if (object === undefined || targetType === undefined || tag === undefined) {
-    return yield* new ObjectParseError({
+    return yield* ObjectParseError.make({
       reason: "tag is missing object/type/tag header",
     });
   }
@@ -643,7 +643,7 @@ export const parseTree = (
       const spaceIdx = content.indexOf(0x20, pos);
       if (spaceIdx === -1) {
         return Effect.fail(
-          new ObjectParseError({
+          ObjectParseError.make({
             reason: `tree entry at ${pos}: no space after mode`,
           }),
         );
@@ -651,7 +651,7 @@ export const parseTree = (
       const mode = utf8Decode(content.subarray(pos, spaceIdx));
       if (!/^[0-7]{1,6}$/.test(mode)) {
         return Effect.fail(
-          new ObjectParseError({
+          ObjectParseError.make({
             reason: `tree entry at ${pos}: bad mode ${mode}`,
           }),
         );
@@ -659,18 +659,18 @@ export const parseTree = (
       const nulIdx = content.indexOf(0x00, spaceIdx + 1);
       if (nulIdx === -1) {
         return Effect.fail(
-          new ObjectParseError({
+          ObjectParseError.make({
             reason: `tree entry at ${pos}: no NUL after name`,
           }),
         );
       }
       const name = utf8Decode(content.subarray(spaceIdx + 1, nulIdx));
       if (name.length === 0) {
-        return Effect.fail(new ObjectParseError({ reason: `tree entry at ${pos}: empty name` }));
+        return Effect.fail(ObjectParseError.make({ reason: `tree entry at ${pos}: empty name` }));
       }
       if (nulIdx + 21 > content.length) {
         return Effect.fail(
-          new ObjectParseError({
+          ObjectParseError.make({
             reason: `tree entry at ${pos}: truncated sha`,
           }),
         );
@@ -715,12 +715,12 @@ export const encodeTree = (
       for (const entry of sorted) {
         const mode = entry.mode.replace(/^0+(?=\d)/, "");
         if (!/^[0-7]{1,6}$/.test(mode)) {
-          throw new ObjectParseError({
+          throw ObjectParseError.make({
             reason: `invalid tree entry mode: ${entry.mode}`,
           });
         }
         if (!isOid(entry.oid)) {
-          throw new ObjectParseError({
+          throw ObjectParseError.make({
             reason: `invalid tree entry oid: ${entry.oid}`,
           });
         }
@@ -731,9 +731,9 @@ export const encodeTree = (
       }
       return Effect.succeed(concatBytes(parts, total));
     } catch (error) {
-      return error instanceof ObjectParseError
+      return Schema.is(ObjectParseError)(error)
         ? Effect.fail(error)
-        : Effect.fail(new ObjectParseError({ reason: String(error) }));
+        : Effect.fail(ObjectParseError.make({ reason: String(error) }));
     }
   });
 
@@ -760,12 +760,12 @@ export interface TypeSizeHeader {
  */
 export const decodeTypeSize = (buf: Uint8Array, offset: number): TypeSizeHeader => {
   if (offset >= buf.length) {
-    throw new ObjectParseError({ reason: "truncated pack entry header" });
+    throw ObjectParseError.make({ reason: "truncated pack entry header" });
   }
   let b = buf[offset]!;
   const rawType = (b >> 4) & 0x07;
   if (rawType === 0 || rawType === 5) {
-    throw new ObjectParseError({
+    throw ObjectParseError.make({
       reason: `invalid pack entry type ${rawType} at offset ${offset}`,
     });
   }
@@ -775,10 +775,10 @@ export const decodeTypeSize = (buf: Uint8Array, offset: number): TypeSizeHeader
   let i = offset + 1;
   while ((b & 0x80) !== 0) {
     if (i >= buf.length) {
-      throw new ObjectParseError({ reason: "truncated pack entry header" });
+      throw ObjectParseError.make({ reason: "truncated pack entry header" });
     }
     if (shift > 53) {
-      throw new ObjectParseError({ reason: "pack entry size varint overflow" });
+      throw ObjectParseError.make({ reason: "pack entry size varint overflow" });
     }
     b = buf[i]!;
     i += 1;
@@ -827,10 +827,10 @@ export const decodeSizeVarint = (buf: Uint8Array, offset: number): Varint => {
   let i = offset;
   for (;;) {
     if (i >= buf.length) {
-      throw new ObjectParseError({ reason: "truncated size varint" });
+      throw ObjectParseError.make({ reason: "truncated size varint" });
     }
     if (shift > 53) {
-      throw new ObjectParseError({ reason: "size varint overflow" });
+      throw ObjectParseError.make({ reason: "size varint overflow" });
     }
     const b = buf[i]!;
     i += 1;
@@ -872,7 +872,7 @@ export const encodeSizeVarint = (value: number): Uint8Array => {
  */
 export const decodeOfsDeltaOffset = (buf: Uint8Array, offset: number): Varint => {
   if (offset >= buf.length) {
-    throw new ObjectParseError({ reason: "truncated ofs-delta offset" });
+    throw ObjectParseError.make({ reason: "truncated ofs-delta offset" });
   }
   let i = offset;
   let b = buf[i]!;
@@ -880,13 +880,13 @@ export const decodeOfsDeltaOffset = (buf: Uint8Array, offset: number): Varint =>
   let n = b & 0x7f;
   while ((b & 0x80) !== 0) {
     if (i >= buf.length) {
-      throw new ObjectParseError({ reason: "truncated ofs-delta offset" });
+      throw ObjectParseError.make({ reason: "truncated ofs-delta offset" });
     }
     b = buf[i]!;
     i += 1;
     n = (n + 1) * 128 + (b & 0x7f);
     if (!Number.isSafeInteger(n)) {
-      throw new ObjectParseError({ reason: "ofs-delta offset overflow" });
+      throw ObjectParseError.make({ reason: "ofs-delta offset overflow" });
     }
   }
   return { value: n, next: i };

package/src/Git/Protocol/PackParser.ts

@@ -346,13 +346,13 @@ const readU32BE = (buf: Uint8Array, offset: number): number =>
  */
 export const readPackHeader = Effect.fn(function* (source: RandomAccess) {
   if (Number.isFinite(source.size) && source.size < 12 + 20) {
-    return yield* new PackFormatError({
+    return yield* PackFormatError.make({
       reason: `pack too small: ${source.size} bytes`,
     });
   }
   const header = yield* source.read(0, 12);
   if (header.length < 12) {
-    return yield* new PackFormatError({
+    return yield* PackFormatError.make({
       reason: `pack too small: ${header.length} bytes`,
     });
   }
@@ -363,11 +363,11 @@ export const readPackHeader = Effect.fn(function* (source: RandomAccess) {
     header[2] !== 0x43 || // C
     header[3] !== 0x4b // K
   ) {
-    return yield* new PackFormatError({ reason: "bad pack magic" });
+    return yield* PackFormatError.make({ reason: "bad pack magic" });
   }
   const version = readU32BE(header, 4);
   if (version !== 2) {
-    return yield* new PackFormatError({
+    return yield* PackFormatError.make({
       reason: `unsupported pack version ${version}`,
     });
   }
@@ -436,7 +436,7 @@ export const ingestPack = <E, R>(
     const inflateOwn = (entry: IndexedEntry): Effect.Effect<Uint8Array, PackIngestError> =>
       Effect.suspend((): Effect.Effect<Uint8Array, PackIngestError> =>
         source.evictedBeforeEnd?.(entry.dataOffset) === true
-          ? Effect.fail(new BaseEvictedError({ offset: entry.dataOffset }))
+          ? Effect.fail(BaseEvictedError.make({ offset: entry.dataOffset }))
           : source.read(entry.dataOffset, entry.span).pipe(Effect.flatMap((z) => inflate(z))),
       );
 
@@ -459,7 +459,7 @@ export const ingestPack = <E, R>(
           const payload = yield* timed("inflate", inflateOwn(entry));
           const content = yield* timed("delta", applyDelta(base.content, payload));
           if (content.length > maxObjectSize) {
-            return yield* new ObjectTooLargeError({
+            return yield* ObjectTooLargeError.make({
               size: content.length,
               limit: maxObjectSize,
             });
@@ -476,7 +476,7 @@ export const ingestPack = <E, R>(
         if (entry.baseOffset !== undefined) {
           const base = byOffset.get(entry.baseOffset);
           if (base === undefined) {
-            return yield* new PackFormatError({
+            return yield* PackFormatError.make({
               reason: `ofs-delta at ${entry.offset} points at ${entry.baseOffset}, not an entry boundary`,
             });
           }
@@ -491,10 +491,10 @@ export const ingestPack = <E, R>(
         if (cachedThin !== undefined) return cachedThin;
         const live = yield* store.readBase(baseOid);
         if (live === undefined) {
-          return yield* new MissingDeltaBaseError({ baseOid });
+          return yield* MissingDeltaBaseError.make({ baseOid });
         }
         if (live.content.length > maxObjectSize) {
-          return yield* new ObjectTooLargeError({
+          return yield* ObjectTooLargeError.make({
             size: live.content.length,
             limit: maxObjectSize,
             oid: baseOid,
@@ -562,16 +562,15 @@ export const ingestPack = <E, R>(
       try {
         header = decodeTypeSize(window, 0);
       } catch (error) {
-        return new PackFormatError({
-          reason:
-            error instanceof ObjectParseError
-              ? `entry ${i}: ${error.reason}`
-              : `entry ${i}: ${String(error)}`,
+        return PackFormatError.make({
+          reason: Schema.is(ObjectParseError)(error)
+            ? `entry ${i}: ${error.reason}`
+            : `entry ${i}: ${String(error)}`,
         });
       }
       if (isDeltaType(header.type)) return undefined;
       if (header.size > maxObjectSize) {
-        return new ObjectTooLargeError({
+        return ObjectTooLargeError.make({
           size: header.size,
           limit: maxObjectSize,
         });
@@ -584,7 +583,7 @@ export const ingestPack = <E, R>(
       if (inflated === undefined) return undefined;
       const { bytesConsumed, content } = inflated;
       if (content.length !== header.size) {
-        return new PackFormatError({
+        return PackFormatError.make({
           reason: `entry ${i}: inflated ${content.length} bytes, header declared ${header.size}`,
         });
       }
@@ -623,7 +622,7 @@ export const ingestPack = <E, R>(
     let offset = 12;
     for (let i = 0; i < count; i++) {
       if (offset >= dataEnd) {
-        return yield* new PackFormatError({
+        return yield* PackFormatError.make({
           reason: `truncated pack: entry ${i} of ${count} starts past the trailer`,
         });
       }
@@ -653,11 +652,11 @@ export const ingestPack = <E, R>(
           }
           continue;
         }
-        if (next !== undefined) return yield* Effect.fail(next);
+        if (next !== undefined) return yield* next;
       }
       let window = yield* source.read(offset, probeLength);
       if (window.length === 0) {
-        return yield* new PackFormatError({
+        return yield* PackFormatError.make({
           reason: `truncated pack: entry ${i} of ${count} starts past the end`,
         });
       }
@@ -676,11 +675,10 @@ export const ingestPack = <E, R>(
       try {
         header = decodeTypeSize(window, 0);
       } catch (error) {
-        return yield* new PackFormatError({
-          reason:
-            error instanceof ObjectParseError
-              ? `entry ${i}: ${error.reason}`
-              : `entry ${i}: ${String(error)}`,
+        return yield* PackFormatError.make({
+          reason: Schema.is(ObjectParseError)(error)
+            ? `entry ${i}: ${error.reason}`
+            : `entry ${i}: ${String(error)}`,
         });
       }
       let pos = header.next;
@@ -691,30 +689,29 @@ export const ingestPack = <E, R>(
         try {
           ofs = decodeOfsDeltaOffset(window, pos);
         } catch (error) {
-          return yield* new PackFormatError({
-            reason:
-              error instanceof ObjectParseError
-                ? `entry ${i}: ${error.reason}`
-                : `entry ${i}: ${String(error)}`,
+          return yield* PackFormatError.make({
+            reason: Schema.is(ObjectParseError)(error)
+              ? `entry ${i}: ${error.reason}`
+              : `entry ${i}: ${String(error)}`,
           });
         }
         pos = ofs.next;
         baseOffset = offset - ofs.value;
         if (baseOffset < 12) {
-          return yield* new PackFormatError({
+          return yield* PackFormatError.make({
             reason: `entry ${i}: ofs-delta offset ${ofs.value} points before the first entry`,
           });
         }
       } else if (header.type === 7) {
         if (pos + 20 > window.length) {
-          return yield* new PackFormatError({
+          return yield* PackFormatError.make({
             reason: `entry ${i}: truncated ref-delta base id`,
           });
         }
         baseOid = bytesToHex(window.subarray(pos, pos + 20));
         pos += 20;
       } else if (header.size > maxObjectSize) {
-        return yield* new ObjectTooLargeError({
+        return yield* ObjectTooLargeError.make({
           size: header.size,
           limit: maxObjectSize,
         });
@@ -741,11 +738,11 @@ export const ingestPack = <E, R>(
         attempt = yield* Effect.result(inflateEntry(window, pos, inflateOptions));
       }
       if (Result.isFailure(attempt)) {
-        return yield* Effect.fail(attempt.failure);
+        return yield* attempt.failure;
       }
       const { bytesConsumed, content } = attempt.success;
       if (content.length !== header.size) {
-        return yield* new PackFormatError({
+        return yield* PackFormatError.make({
           reason: `entry ${i}: inflated ${content.length} bytes, header declared ${header.size}`,
         });
       }
@@ -790,8 +787,8 @@ export const ingestPack = <E, R>(
         const result = yield* Effect.result(emitDelta(entry));
         if (Result.isFailure(result)) {
           if (
-            result.failure instanceof MissingDeltaBaseError ||
-            result.failure instanceof BaseEvictedError
+            Schema.is(MissingDeltaBaseError)(result.failure) ||
+            Schema.is(BaseEvictedError)(result.failure)
           ) {
             // The base may appear later in the pack (thin ref-delta), or
             // it was evicted from a streaming source and is readable once
@@ -810,7 +807,7 @@ export const ingestPack = <E, R>(
     yield* flushPending;
     if (!Number.isFinite(dataEnd)) {
       if (source.awaitEnd === undefined) {
-        return yield* new PackFormatError({
+        return yield* PackFormatError.make({
           reason: "pack source has unknown size and no awaitEnd",
         });
       }
@@ -827,11 +824,11 @@ export const ingestPack = <E, R>(
       for (const entry of pending) {
         const result = yield* Effect.result(emitDelta(entry));
         if (Result.isFailure(result)) {
-          if (result.failure instanceof MissingDeltaBaseError) {
+          if (Schema.is(MissingDeltaBaseError)(result.failure)) {
             firstMissing ??= result.failure;
             next.push(entry);
-          } else if (result.failure instanceof BaseEvictedError) {
-            return yield* new PackFormatError({
+          } else if (Schema.is(BaseEvictedError)(result.failure)) {
+            return yield* PackFormatError.make({
               reason: `delta base at ${result.failure.offset} unreadable after the body ended`,
             });
           } else {
@@ -841,12 +838,12 @@ export const ingestPack = <E, R>(
       }
       if (next.length === pending.length) {
         // no progress — the base genuinely does not exist anywhere
-        return yield* Effect.fail(firstMissing!);
+        return yield* firstMissing!;
       }
       pending = next;
     }
     if (offset !== dataEnd) {
-      return yield* new PackFormatError({
+      return yield* PackFormatError.make({
         reason: `pack has ${dataEnd - offset} unconsumed bytes after ${count} entries`,
       });
     }
@@ -854,12 +851,12 @@ export const ingestPack = <E, R>(
     // ── trailer verification ─────────────────────────────────────────────────
     const trailer = yield* source.read(dataEnd, 20);
     if (trailer.length < 20) {
-      return yield* new PackFormatError({ reason: "truncated pack trailer" });
+      return yield* PackFormatError.make({ reason: "truncated pack trailer" });
     }
     const expected = bytesToHex(trailer);
     const actual = yield* Effect.sync(() => trailerSha.digestHex());
     if (expected !== actual) {
-      return yield* new PackChecksumMismatch({ expected, actual });
+      return yield* PackChecksumMismatch.make({ expected, actual });
     }
 
     return { count, oids } satisfies IngestSummary;