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

package/lib/Git/RepoObject.js

@@ -289,7 +289,7 @@ export const parseUploadPackRequest = (pkts) => Effect.suspend(() => {
                 }
             }
             if (!isOid(rest)) {
-                return Effect.fail(new WireProtocolError({ reason: `malformed want line: ${text}` }));
+                return Effect.fail(WireProtocolError.make({ reason: `malformed want line: ${text}` }));
             }
             wants.push(rest);
             continue;
@@ -303,7 +303,7 @@ export const parseUploadPackRequest = (pkts) => Effect.suspend(() => {
         if (text.startsWith("shallow ")) {
             const oid = text.slice(8);
             if (!isOid(oid)) {
-                return Effect.fail(new WireProtocolError({
+                return Effect.fail(WireProtocolError.make({
                     reason: `malformed shallow line: ${text}`,
                 }));
             }
@@ -313,23 +313,23 @@ export const parseUploadPackRequest = (pkts) => Effect.suspend(() => {
         if (text.startsWith("deepen ")) {
             const n = Number.parseInt(text.slice(7), 10);
             if (!Number.isInteger(n) || n <= 0) {
-                return Effect.fail(new WireProtocolError({ reason: `malformed deepen line: ${text}` }));
+                return Effect.fail(WireProtocolError.make({ reason: `malformed deepen line: ${text}` }));
             }
             depth = n;
             continue;
         }
         if (text.startsWith("deepen-since ") || text.startsWith("deepen-not ")) {
-            return Effect.fail(new WireProtocolError({
+            return Effect.fail(WireProtocolError.make({
                 reason: `${text.split(" ")[0]} is not supported`,
             }));
         }
         if (text.startsWith("filter ")) {
-            return Effect.fail(new WireProtocolError({ reason: "filter is not supported" }));
+            return Effect.fail(WireProtocolError.make({ reason: "filter is not supported" }));
         }
         // ignore unknown lines defensively
     }
     if (wants.length === 0) {
-        return Effect.fail(new WireProtocolError({ reason: "upload-pack request has no wants" }));
+        return Effect.fail(WireProtocolError.make({ reason: "upload-pack request has no wants" }));
     }
     return Effect.succeed({
         wants,
@@ -364,13 +364,13 @@ export const parseReceivePackRequest = (body) => Effect.suspend(() => {
                     probe: true,
                 });
             }
-            return Effect.fail(new WireProtocolError({
+            return Effect.fail(WireProtocolError.make({
                 reason: "receive-pack request ended before flush",
             }));
         }
         const r = readPktLineAt(body, pos);
         if (r._tag === "incomplete" || r._tag === "invalid") {
-            return Effect.fail(new WireProtocolError({
+            return Effect.fail(WireProtocolError.make({
                 reason: r._tag === "invalid" ? r.reason : "truncated receive-pack request",
             }));
         }
@@ -405,7 +405,7 @@ export const parseReceivePackRequest = (body) => Effect.suspend(() => {
             text[40] !== " " ||
             text[81] !== " " ||
             !REF_NAME_REGEX.test(ref)) {
-            return Effect.fail(new WireProtocolError({ reason: `malformed command line: ${text}` }));
+            return Effect.fail(WireProtocolError.make({ reason: `malformed command line: ${text}` }));
         }
         commands.push({ oldOid, newOid, ref });
     }
@@ -517,7 +517,7 @@ export const ingestPackFrom = (source, options) => Effect.gen(function* () {
     const record = Effect.fn(function* (oid, type, content) {
         switch (type) {
             case ObjectType.commit: {
-                const parsed = yield* parseCommit(content).pipe(Effect.mapError((error) => new PackIngestError({
+                const parsed = yield* parseCommit(content).pipe(Effect.mapError((error) => PackIngestError.make({
                     reason: `bad commit ${oid}: ${error.reason}`,
                 })));
                 commits.push({
@@ -532,7 +532,7 @@ export const ingestPackFrom = (source, options) => Effect.gen(function* () {
                 return;
             }
             case ObjectType.tree: {
-                const parsed = yield* parseTree(content).pipe(Effect.mapError((error) => new PackIngestError({
+                const parsed = yield* parseTree(content).pipe(Effect.mapError((error) => PackIngestError.make({
                     reason: `bad tree ${oid}: ${error.reason}`,
                 })));
                 for (const entry of parsed) {
@@ -543,7 +543,7 @@ export const ingestPackFrom = (source, options) => Effect.gen(function* () {
                 return;
             }
             case ObjectType.tag: {
-                const parsed = yield* parseTag(content).pipe(Effect.mapError((error) => new PackIngestError({
+                const parsed = yield* parseTag(content).pipe(Effect.mapError((error) => PackIngestError.make({
                     reason: `bad tag ${oid}: ${error.reason}`,
                 })));
                 referenced.add(parsed.object);
@@ -643,7 +643,7 @@ export const ingestPackFrom = (source, options) => Effect.gen(function* () {
             }
             if (entry.type !== ObjectType.blob) {
                 if (entry.content === undefined) {
-                    return yield* new PackIngestError({
+                    return yield* PackIngestError.make({
                         reason: `no content for ${entry.oid} (type ${entry.type})`,
                     });
                 }
@@ -664,7 +664,7 @@ export const ingestPackFrom = (source, options) => Effect.gen(function* () {
         const partBytes = options.partBytes ?? (spill === undefined ? HASH_PART_BYTES : SPILL_PART_BYTES);
         const wanted = hasher.chunkBytes ?? partBytes;
         const hashBytes = wanted < partBytes && partBytes % wanted === 0 ? wanted : partBytes;
-        const asIngest = (error) => new PackIngestError({
+        const asIngest = (error) => PackIngestError.make({
             reason: `${error._tag}${error.reason === undefined ? "" : `: ${error.reason}`}`,
         });
         const header = yield* source.read(0, 12);
@@ -673,7 +673,7 @@ export const ingestPackFrom = (source, options) => Effect.gen(function* () {
             header[1] !== 0x41 ||
             header[2] !== 0x43 ||
             header[3] !== 0x4b) {
-            return yield* new PackIngestError({ reason: "bad pack magic" });
+            return yield* PackIngestError.make({ reason: "bad pack magic" });
         }
         const count = new DataView(header.buffer, header.byteOffset).getUint32(8);
         // Trailer SHA-1 over [0, total − 20): hash with a 20-byte lag, so
@@ -800,7 +800,7 @@ export const ingestPackFrom = (source, options) => Effect.gen(function* () {
             const last = chunks[chunks.length - 1];
             return last === undefined ? 12 : last.base + last.payload.length;
         };
-        const dispatch = (payload, opts) => Effect.forkChild(Semaphore.withPermits(gate, 1)(hasher
+        const dispatch = (payload, opts) => hasher
             .hashPart(payload, {
             base: opts.base,
             skip: opts.skip,
@@ -815,7 +815,7 @@ export const ingestPackFrom = (source, options) => Effect.gen(function* () {
                     partNumber: opts.partNumber,
                 },
         })
-            .pipe(Effect.mapError(asIngest))));
+            .pipe(Effect.mapError(asIngest), Semaphore.withPermits(gate, 1), Effect.forkChild);
         const produce = Effect.gen(function* () {
             if (spill === undefined) {
                 // Pack-relative parts from the (in-memory or spilled) source.
@@ -858,9 +858,11 @@ export const ingestPackFrom = (source, options) => Effect.gen(function* () {
                 const partNumber = Math.floor(partStart / partBytes) + 1;
                 const bytes = bytesFrom(partStart - packStart, end - packStart);
                 partStart = end;
-                const fiber = yield* Effect.forkDetach(Semaphore.withPermits(uploadGate, 1)(spill.blobs.uploadPart(spill.key, settled.uploadId, partNumber, bytes).pipe(Effect.mapError((error) => new PackIngestError({
+                const fiber = yield* spill.blobs
+                    .uploadPart(spill.key, settled.uploadId, partNumber, bytes)
+                    .pipe(Effect.mapError((error) => PackIngestError.make({
                     reason: `spill part ${partNumber}: ${error.reason}`,
-                })), Effect.provide(RuntimeContext.phantom))));
+                })), Effect.provide(RuntimeContext.phantom), Semaphore.withPermits(uploadGate, 1), Effect.forkDetach);
                 parts.push(Fiber.join(fiber));
             });
             let index = 0;
@@ -875,7 +877,7 @@ export const ingestPackFrom = (source, options) => Effect.gen(function* () {
                     // ended within the in-memory threshold stays in memory.
                     const ended = spill.feeder.source.ended();
                     if (!(ended && spill.feeder.source.size <= spill.threshold)) {
-                        upload = yield* spill.blobs.multipart(spill.key).pipe(Effect.mapError((error) => new PackIngestError({
+                        upload = yield* spill.blobs.multipart(spill.key).pipe(Effect.mapError((error) => PackIngestError.make({
                             reason: `spill: ${error.reason}`,
                         })), Effect.provide(RuntimeContext.phantom));
                         spill.feeder.expectFallback();
@@ -1114,7 +1116,7 @@ export const ingestPackFrom = (source, options) => Effect.gen(function* () {
         phases.chunks = chunks.length;
         phases.regions = regionCalls;
         if (staged !== count) {
-            return yield* new PackIngestError({
+            return yield* PackIngestError.make({
                 reason: `pack declared ${count} entries, scanned ${staged}`,
             });
         }
@@ -1122,21 +1124,21 @@ export const ingestPackFrom = (source, options) => Effect.gen(function* () {
             ? source.size
             : yield* source.awaitEnd.pipe(Effect.mapError(asIngest));
         if (consumedTo !== total - 20) {
-            return yield* new PackIngestError({
+            return yield* PackIngestError.make({
                 reason: `pack has ${total - 20 - consumedTo} unconsumed bytes after ${count} entries`,
             });
         }
         // Everything read so far went through `feed`; the last part's
         // bytes did too, so the lag now holds the trailer.
         if (lag.length !== 20) {
-            return yield* new PackIngestError({
+            return yield* PackIngestError.make({
                 reason: "truncated pack trailer",
             });
         }
         const expected = bytesToHex(lag);
         const actual = trailerSha.digestHex();
         if (expected !== actual) {
-            return yield* new PackIngestError({
+            return yield* PackIngestError.make({
                 reason: `pack checksum mismatch: expected ${expected}, got ${actual}`,
             });
         }
@@ -1169,7 +1171,7 @@ export const ingestPackFrom = (source, options) => Effect.gen(function* () {
             resolvedBlobs.length = 0;
             const bytes = concatBytes(pieces);
             const writeStarted = Date.now();
-            const writing = yield* Effect.forkDetach(spill.blobs.put(key, bytes).pipe(Effect.mapError((error) => new PackIngestError({
+            const writing = yield* Effect.forkDetach(spill.blobs.put(key, bytes).pipe(Effect.mapError((error) => PackIngestError.make({
                 reason: `resolved pack: ${error.reason}`,
             })), Effect.provide(RuntimeContext.phantom)));
             resolvedKeys.push(key);
@@ -1239,7 +1241,7 @@ export const ingestPackFrom = (source, options) => Effect.gen(function* () {
                 });
             }
             if (ready.length === 0) {
-                return yield* new PackIngestError({
+                return yield* PackIngestError.make({
                     reason: `delta base not found for ${next.length} entries`,
                 });
             }
@@ -1330,7 +1332,7 @@ export const ingestPackFrom = (source, options) => Effect.gen(function* () {
             const uploaded = [];
             for (const part of parts)
                 uploaded.push(yield* part);
-            yield* settled.complete(uploaded).pipe(Effect.mapError((error) => new PackIngestError({
+            yield* settled.complete(uploaded).pipe(Effect.mapError((error) => PackIngestError.make({
                 reason: `spill complete: ${error.reason}`,
             })), Effect.provide(RuntimeContext.phantom));
             spill.feeder.setFallback(blobRandomAccess({
@@ -1362,7 +1364,7 @@ export const ingestPackFrom = (source, options) => Effect.gen(function* () {
             sinkBatch: stage,
         }).pipe(Effect.mapError((error) => error._tag === "StoreError" || error._tag === "PackIngestError"
             ? error
-            : new PackIngestError({ reason: packParserReason(error) })));
+            : PackIngestError.make({ reason: packParserReason(error) })));
     yield* flush();
     if (store.settle !== undefined) {
         const at = yield* Effect.sync(() => performance.now());
@@ -1402,15 +1404,15 @@ const packParserReason = (error) => {
 export const ingestPack = (pack, options) => Effect.gen(function* () {
     const { store, pushId } = options;
     if (pack.length < 12 + 20) {
-        return yield* new PackIngestError({ reason: "pack too small" });
+        return yield* PackIngestError.make({ reason: "pack too small" });
     }
     if (pack[0] !== 0x50 || pack[1] !== 0x41 || pack[2] !== 0x43 || pack[3] !== 0x4b) {
-        return yield* new PackIngestError({ reason: "bad pack signature" });
+        return yield* PackIngestError.make({ reason: "bad pack signature" });
     }
     const view = new DataView(pack.buffer, pack.byteOffset, pack.byteLength);
     const version = view.getUint32(4);
     if (version !== 2) {
-        return yield* new PackIngestError({
+        return yield* PackIngestError.make({
             reason: `unsupported pack version ${version}`,
         });
     }
@@ -1422,7 +1424,7 @@ export const ingestPack = (pack, options) => Effect.gen(function* () {
     sha.update(pack.subarray(0, pack.length - 20));
     const actual = sha.digestHex();
     if (actual !== trailer) {
-        return yield* new PackIngestError({ reason: "pack checksum mismatch" });
+        return yield* PackIngestError.make({ reason: "pack checksum mismatch" });
     }
     const cache = makeContentCache(CACHE_BUDGET);
     const entries = [];
@@ -1435,7 +1437,7 @@ export const ingestPack = (pack, options) => Effect.gen(function* () {
     const recordObject = Effect.fn(function* (oid, type, content) {
         switch (type) {
             case ObjectType.commit: {
-                const parsed = yield* parseCommit(content).pipe(Effect.mapError((error) => new PackIngestError({
+                const parsed = yield* parseCommit(content).pipe(Effect.mapError((error) => PackIngestError.make({
                     reason: `bad commit ${oid}: ${error.reason}`,
                 })));
                 commits.push({
@@ -1451,7 +1453,7 @@ export const ingestPack = (pack, options) => Effect.gen(function* () {
                 return;
             }
             case ObjectType.tree: {
-                const parsed = yield* parseTree(content).pipe(Effect.mapError((error) => new PackIngestError({
+                const parsed = yield* parseTree(content).pipe(Effect.mapError((error) => PackIngestError.make({
                     reason: `bad tree ${oid}: ${error.reason}`,
                 })));
                 for (const entry of parsed) {
@@ -1462,7 +1464,7 @@ export const ingestPack = (pack, options) => Effect.gen(function* () {
                 return;
             }
             case ObjectType.tag: {
-                const parsed = yield* parseTag(content).pipe(Effect.mapError((error) => new PackIngestError({
+                const parsed = yield* parseTag(content).pipe(Effect.mapError((error) => PackIngestError.make({
                     reason: `bad tag ${oid}: ${error.reason}`,
                 })));
                 referenced.add(parsed.object);
@@ -1484,7 +1486,7 @@ export const ingestPack = (pack, options) => Effect.gen(function* () {
     });
     // ── Pass 1: scan entries, stage non-deltas verbatim ─────────────────────
     let offset = 12;
-    const zlibToIngest = (error) => new PackIngestError({ reason: error.reason });
+    const zlibToIngest = (error) => PackIngestError.make({ reason: error.reason });
     for (let i = 0; i < count; i++) {
         const entryStart = offset;
         let header;
@@ -1492,19 +1494,19 @@ export const ingestPack = (pack, options) => Effect.gen(function* () {
             header = decodeTypeSize(pack, offset);
         }
         catch (error) {
-            return yield* new PackIngestError({
+            return yield* PackIngestError.make({
                 reason: `entry ${i}: ${String(error)}`,
             });
         }
         if (!isDeltaType(header.type)) {
             if (header.size > MAX_OBJECT_SIZE) {
-                return yield* new PackIngestError({ reason: "object too large" });
+                return yield* PackIngestError.make({ reason: "object too large" });
             }
             const inflated = yield* Zlib.inflateEntry(pack, header.next, {
                 maxOutput: header.size,
             }).pipe(Effect.mapError(zlibToIngest));
             if (inflated.content.length !== header.size) {
-                return yield* new PackIngestError({
+                return yield* PackIngestError.make({
                     reason: `entry ${i}: size mismatch (${inflated.content.length} != ${header.size})`,
                 });
             }
@@ -1540,13 +1542,13 @@ export const ingestPack = (pack, options) => Effect.gen(function* () {
                     decoded = decodeOfsDeltaOffset(pack, header.next);
                 }
                 catch (error) {
-                    return yield* new PackIngestError({
+                    return yield* PackIngestError.make({
                         reason: `entry ${i}: ${String(error)}`,
                     });
                 }
                 baseOffset = entryStart - decoded.value;
                 if (baseOffset < 12) {
-                    return yield* new PackIngestError({
+                    return yield* PackIngestError.make({
                         reason: `entry ${i}: ofs-delta base offset out of range`,
                     });
                 }
@@ -1554,7 +1556,7 @@ export const ingestPack = (pack, options) => Effect.gen(function* () {
             }
             else {
                 if (header.next + 20 > pack.length) {
-                    return yield* new PackIngestError({
+                    return yield* PackIngestError.make({
                         reason: `entry ${i}: truncated ref-delta base id`,
                     });
                 }
@@ -1581,20 +1583,20 @@ export const ingestPack = (pack, options) => Effect.gen(function* () {
             offset = zstart + inflated.bytesConsumed;
         }
         if (offset > pack.length - 20) {
-            return yield* new PackIngestError({
+            return yield* PackIngestError.make({
                 reason: `entry ${i}: pack truncated`,
             });
         }
     }
     if (offset !== pack.length - 20) {
-        return yield* new PackIngestError({
+        return yield* PackIngestError.make({
             reason: "trailing garbage between entries and pack trailer",
         });
     }
     // ── Pass 2: resolve deltas (bases may chain; thin bases from store) ─────
     const contentOf = (entry, depth) => Effect.gen(function* () {
         if (depth > MAX_DELTA_DEPTH) {
-            return yield* new PackIngestError({ reason: "delta chain too deep" });
+            return yield* PackIngestError.make({ reason: "delta chain too deep" });
         }
         if (entry.oid !== undefined && entry.resolvedType !== undefined) {
             const cached = cache.get(entry.oid);
@@ -1611,11 +1613,11 @@ export const ingestPack = (pack, options) => Effect.gen(function* () {
             return { content: inflated.content, type: entry.type };
         }
         // delta — resolve the base first
-        const base = yield* Effect.gen(function* () {
+        const resolveBase = Effect.gen(function* () {
             if (entry.kind === "ofs") {
                 const baseEntry = byOffset.get(entry.baseOffset);
                 if (baseEntry === undefined) {
-                    return yield* new PackIngestError({
+                    return yield* PackIngestError.make({
                         reason: "ofs-delta base is not an entry boundary",
                     });
                 }
@@ -1628,23 +1630,24 @@ export const ingestPack = (pack, options) => Effect.gen(function* () {
             // Thin base: must exist in the live store.
             const meta = yield* store.getMeta(entry.baseOid);
             if (meta === undefined) {
-                return yield* new PackIngestError({
+                return yield* PackIngestError.make({
                     reason: `missing thin-pack base ${entry.baseOid}`,
                 });
             }
             if (meta.size > MAX_OBJECT_SIZE) {
-                return yield* new PackIngestError({ reason: "object too large" });
+                return yield* PackIngestError.make({ reason: "object too large" });
             }
             const content = yield* store.readContent(entry.baseOid);
             cache.set(entry.baseOid, content);
             return { content, type: meta.type };
         });
+        const base = yield* resolveBase;
         const delta = yield* Zlib.inflateEntry(pack, entry.zstart, {
             maxOutput: entry.declaredSize,
         }).pipe(Effect.mapError(zlibToIngest));
-        const content = yield* applyDelta(base.content, delta.content).pipe(Effect.mapError((error) => new PackIngestError({ reason: error.reason })));
+        const content = yield* applyDelta(base.content, delta.content).pipe(Effect.mapError((error) => PackIngestError.make({ reason: error.reason })));
         if (content.length > MAX_OBJECT_SIZE) {
-            return yield* new PackIngestError({ reason: "object too large" });
+            return yield* PackIngestError.make({ reason: "object too large" });
         }
         return { content, type: base.type };
     });
@@ -1728,7 +1731,7 @@ export const gunzipIfNeeded = (body, contentEncoding) => {
         try: () => new Response(new Response(body).body.pipeThrough(new DecompressionStream("gzip")))
             .arrayBuffer()
             .then((buffer) => new Uint8Array(buffer)),
-        catch: (error) => new PackIngestError({ reason: `gzip decompression failed: ${error}` }),
+        catch: (error) => PackIngestError.make({ reason: `gzip decompression failed: ${error}` }),
     });
 };
 const noCache = { "cache-control": "no-cache" };
@@ -1856,7 +1859,7 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
         const readMeta = readMetaWith(false);
         const readMetaStats = readMetaWith(true);
         const requireFrom = (read) => read.pipe(Effect.flatMap((meta) => meta === undefined
-            ? Effect.fail(new RepoNotFound({ owner: "", repo: "" }))
+            ? Effect.fail(RepoNotFound.make({ owner: "", repo: "" }))
             : Effect.succeed(meta)));
         /** Cheap: config only. `objects` reads as zeros. */
         const requireMeta = requireFrom(readMeta);
@@ -1877,7 +1880,7 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
                     return hops === 0 ? undefined : current;
                 }
                 const content = yield* objects.readContent(current);
-                const parsed = yield* parseTag(content).pipe(Effect.mapError((error) => new StoreError({ reason: error.reason })));
+                const parsed = yield* parseTag(content).pipe(Effect.mapError((error) => StoreError.make({ reason: error.reason })));
                 current = parsed.object;
             }
             return current;
@@ -1899,7 +1902,7 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
                 if (row !== undefined)
                     return row.oid;
             }
-            return yield* new RefNotFound({ ref: refName });
+            return yield* RefNotFound.make({ ref: refName });
         });
         /** Resolves a revision all the way to a COMMIT oid (peels tags). */
         const resolveToCommit = Effect.fn(function* (repoId, defaultBranch, rev) {
@@ -1907,20 +1910,20 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
             const objects = storeFor(repoId);
             const meta = yield* objects.getMeta(oid);
             if (meta === undefined)
-                return yield* new ObjectNotFound({ oid });
+                return yield* ObjectNotFound.make({ oid });
             if (meta.type === ObjectType.commit)
                 return oid;
             if (meta.type === ObjectType.tag) {
                 const peeled = yield* peelOid(repoId, oid);
                 if (peeled === undefined) {
-                    return yield* new ObjectNotFound({ oid });
+                    return yield* ObjectNotFound.make({ oid });
                 }
                 const peeledMeta = yield* objects.getMeta(peeled);
                 if (peeledMeta === undefined) {
-                    return yield* new ObjectNotFound({ oid: peeled });
+                    return yield* ObjectNotFound.make({ oid: peeled });
                 }
                 if (peeledMeta.type !== ObjectType.commit) {
-                    return yield* new WrongObjectType({
+                    return yield* WrongObjectType.make({
                         oid: peeled,
                         expected: "commit",
                         actual: objectTypeName(peeledMeta.type),
@@ -1928,7 +1931,7 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
                 }
                 return peeled;
             }
-            return yield* new WrongObjectType({
+            return yield* WrongObjectType.make({
                 oid,
                 expected: "commit",
                 actual: objectTypeName(meta.type),
@@ -2112,7 +2115,7 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
             if (!full.startsWith("refs/heads/") ||
                 full.length <= "refs/heads/".length ||
                 !REF_NAME_REGEX.test(full)) {
-                return yield* new ValidationError({
+                return yield* ValidationError.make({
                     message: `not a branch name: ${name} (only refs/heads/* is legal)`,
                 });
             }
@@ -2134,7 +2137,7 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
         const loadPull = Effect.fn(function* (number) {
             const row = yield* sql.first(`SELECT * FROM pulls WHERE number = ?`, number);
             if (row === undefined) {
-                return yield* new PullNotFound({ number });
+                return yield* PullNotFound.make({ number });
             }
             return row;
         });
@@ -2220,7 +2223,7 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
         const treeOfCommit = Effect.fn(function* (oid) {
             const row = yield* sql.first(`SELECT tree FROM commits WHERE oid = ?`, oid);
             if (row === undefined) {
-                return yield* new StoreError({
+                return yield* StoreError.make({
                     reason: `commit ${oid} missing from the commit graph`,
                 });
             }
@@ -2313,7 +2316,10 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
                 contentType: resultType,
                 headers: noCache,
             });
-            const parsed = yield* decodePktLines(body).pipe(Effect.flatMap(parseUploadPackRequest), Effect.map(Option.some), Effect.catchTag("PktLineError", (e) => Effect.succeed(Option.none()).pipe(Effect.tap(() => Effect.logWarning(`upload-pack: ${e.reason}`)))), Effect.catchTag("WireProtocolError", (e) => Effect.succeed(Option.none()).pipe(Effect.tap(() => Effect.logWarning(`upload-pack: ${e.reason}`)))));
+            const parsed = yield* decodePktLines(body).pipe(Effect.flatMap(parseUploadPackRequest), Effect.asSome, Effect.catchTags({
+                PktLineError: (e) => Effect.succeed(Option.none()).pipe(Effect.tap(() => Effect.logWarning(`upload-pack: ${e.reason}`))),
+                WireProtocolError: (e) => Effect.succeed(Option.none()).pipe(Effect.tap(() => Effect.logWarning(`upload-pack: ${e.reason}`))),
+            }));
             if (Option.isNone(parsed)) {
                 return errResponse("malformed upload-pack request");
             }
@@ -2355,7 +2361,7 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
                 // whole point of splitting the planes.
                 const found = yield* blobs
                     .head(bundle.key)
-                    .pipe(Effect.mapError((error) => new StoreError({ reason: `bundle: ${error.reason}` })));
+                    .pipe(Effect.mapError((error) => StoreError.make({ reason: `bundle: ${error.reason}` })));
                 if (found !== null) {
                     return HttpServerResponse.empty({
                         status: 200,
@@ -2487,7 +2493,7 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
                 ? undefined
                 : JSON.parse(pendingRaw);
             if (pending !== undefined && Date.now() - pending.at > 60_000) {
-                yield* blobs.delete(pending.keys).pipe(Effect.catch(() => Effect.void));
+                yield* blobs.delete(pending.keys).pipe(Effect.ignore);
                 yield* setConfig("packs_pending_delete", "");
             }
             const outcome = yield* runCompactJob({
@@ -2578,7 +2584,7 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
                 haves: [],
                 clientShallow: [],
                 repoShallow: shallowRoots,
-            }).pipe(Effect.catchTag("ManifestTooLarge", (error) => Effect.fail(new StoreError({ reason: `bundle: ${error._tag}` }))));
+            }).pipe(Effect.catchTag("ManifestTooLarge", (error) => Effect.fail(StoreError.make({ reason: `bundle: ${error._tag}` }))));
             const info = yield* runBundleJob({
                 repoId: meta.repoId,
                 refs: refRows.map((ref) => ({ name: ref.name, oid: ref.oid })),
@@ -2626,7 +2632,7 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
                     store: objects,
                     pushId,
                     allowMissingParents: true,
-                }).pipe(Effect.mapError((error) => new StoreError({
+                }).pipe(Effect.mapError((error) => StoreError.make({
                     reason: error._tag === "PackIngestError"
                         ? `import ingest: ${error.reason}`
                         : error.reason,
@@ -2635,7 +2641,7 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
                 // parent commits (they become walk boundaries).
                 const missing = yield* objects.missingObjects([...ingest.referenced], pushId);
                 if (missing.length > 0) {
-                    return yield* new StoreError({
+                    return yield* StoreError.make({
                         reason: `import produced ${missing.length} dangling objects`,
                     });
                 }
@@ -2666,7 +2672,7 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
             });
             const rejected = results.find((ref) => !ref.ok);
             if (rejected !== undefined) {
-                return yield* new StoreError({
+                return yield* StoreError.make({
                     reason: `import ref ${rejected.ref}: ${rejected.reason}`,
                 });
             }
@@ -2715,9 +2721,9 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
                 blobs,
                 // RuntimeContext is genuinely satisfied here (we run inside the
                 // DO); discharge the coloring so the purge job's deps stay R=never.
-                forkCount: registryStub.bumpForkCount(meta.repoId, 0).pipe(Effect.mapError((error) => new StoreError({ reason: String(error) })), Effect.provide(RuntimeContext.phantom)),
-                deleteAllStorage: state.storage.deleteAll().pipe(Effect.mapError((error) => new StoreError({ reason: String(error) })), Effect.provide(RuntimeContext.phantom)),
-                removeRegistryRow: registryStub.removeRow(meta.repoId).pipe(Effect.mapError((error) => new StoreError({ reason: String(error) })), Effect.provide(RuntimeContext.phantom)),
+                forkCount: registryStub.bumpForkCount(meta.repoId, 0).pipe(Effect.mapError((error) => StoreError.make({ reason: String(error) })), Effect.provide(RuntimeContext.phantom)),
+                deleteAllStorage: state.storage.deleteAll().pipe(Effect.mapError((error) => StoreError.make({ reason: String(error) })), Effect.provide(RuntimeContext.phantom)),
+                removeRegistryRow: registryStub.removeRow(meta.repoId).pipe(Effect.mapError((error) => StoreError.make({ reason: String(error) })), Effect.provide(RuntimeContext.phantom)),
             });
             if (outcome._tag === "continue") {
                 yield* armAlarmAt(Date.now() + (outcome.forkPinned ? 60_000 : 5_000));
@@ -2751,7 +2757,7 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
                 yield* setConfig("status", "deleting");
                 // Kill the DO-less fast path NOW — the prefix drain gets the
                 // rest, but anonymous reads must stop serving immediately.
-                yield* blobs.delete(headKey(meta.repoId)).pipe(Effect.catch(() => Effect.void));
+                yield* blobs.delete(headKey(meta.repoId)).pipe(Effect.ignore);
                 yield* refreshSummary;
                 yield* upsertJob("purge", null);
                 yield* armAlarmAt(Date.now());
@@ -2768,7 +2774,7 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
                 if (patch.defaultBranch !== undefined) {
                     const ref = yield* sql.first(`SELECT name, oid FROM refs WHERE name = ?`, `refs/heads/${patch.defaultBranch}`);
                     if (ref === undefined) {
-                        return yield* new RefNotFound({
+                        return yield* RefNotFound.make({
                             ref: `refs/heads/${patch.defaultBranch}`,
                         });
                     }
@@ -2809,7 +2815,7 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
                 const meta = yield* requireMeta;
                 const row = yield* sql.first(`SELECT name, oid FROM refs WHERE name = ?`, name);
                 if (row === undefined) {
-                    return yield* new RefNotFound({ ref: name });
+                    return yield* RefNotFound.make({ ref: name });
                 }
                 const peeled = name.startsWith("refs/tags/")
                     ? yield* peelOid(meta.repoId, row.oid)
@@ -2821,12 +2827,12 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
             updateRef: Effect.fn(function* (input) {
                 const meta = yield* requireMeta;
                 if (meta.readOnly) {
-                    return yield* new ReadOnlyRepo();
+                    return yield* ReadOnlyRepo.make({});
                 }
                 const objects = storeFor(meta.repoId);
                 const exists = yield* objects.has(input.newOid);
                 if (!exists) {
-                    return yield* new ObjectNotFound({ oid: input.newOid });
+                    return yield* ObjectNotFound.make({ oid: input.newOid });
                 }
                 yield* sql.transactionSync((raw, rollback) => {
                     const rows = raw
@@ -2836,7 +2842,7 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
                     if (input.expectedOid !== undefined) {
                         const expected = input.expectedOid; // string | null
                         if (current !== expected) {
-                            rollback(new RefConflict({
+                            rollback(RefConflict.make({
                                 ref: input.name,
                                 currentOid: current === null ? null : asOid(current),
                             }));
@@ -2851,18 +2857,18 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
             removeRef: Effect.fn(function* (input) {
                 const meta = yield* requireMeta;
                 if (meta.readOnly) {
-                    return yield* new ReadOnlyRepo();
+                    return yield* ReadOnlyRepo.make({});
                 }
                 yield* sql.transactionSync((raw, rollback) => {
                     const rows = raw
                         .exec(`SELECT name, oid FROM refs WHERE name = ?`, input.name)
                         .toArray();
                     if (rows.length === 0) {
-                        rollback(new RefNotFound({ ref: input.name }));
+                        rollback(RefNotFound.make({ ref: input.name }));
                     }
                     const current = rows[0].oid;
                     if (input.expectedOid !== undefined && current !== input.expectedOid) {
-                        rollback(new RefConflict({
+                        rollback(RefConflict.make({
                             ref: input.name,
                             currentOid: asOid(current),
                         }));
@@ -2915,7 +2921,7 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
                         referenced.add(command.newOid);
                 const missing = yield* storeFor(meta.repoId).missingObjects(Array.from(referenced), input.pushId);
                 if (missing.length > 0)
-                    return yield* new StoreError({
+                    return yield* StoreError.make({
                         reason: `missing objects (${missing.length})`,
                     });
             }),
@@ -2923,7 +2929,7 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
                 const meta = yield* requireMeta;
                 const push = yield* sql.first(`SELECT state FROM pushes WHERE push_id = ?`, pushId);
                 if (push?.state !== "staging")
-                    return yield* new StoreError({
+                    return yield* StoreError.make({
                         reason: "push is no longer active",
                     });
                 return yield* storeFor(meta.repoId).readPrepared(pushId, oid, maxBytes);
@@ -3002,11 +3008,11 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
                 const objects = storeFor(meta.repoId);
                 const objectMeta = yield* objects.getMeta(input.oid);
                 if (objectMeta === undefined) {
-                    return yield* new ObjectNotFound({ oid: input.oid });
+                    return yield* ObjectNotFound.make({ oid: input.oid });
                 }
                 const actual = objectTypeName(objectMeta.type);
                 if (input.expect !== undefined && actual !== input.expect) {
-                    return yield* new WrongObjectType({
+                    return yield* WrongObjectType.make({
                         oid: input.oid,
                         expected: input.expect,
                         actual,
@@ -3045,7 +3051,7 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
                 // The start may be a tag — peel to a commit.
                 const startMeta = yield* objects.getMeta(start);
                 if (startMeta === undefined) {
-                    return yield* new RefNotFound({ ref: input.ref ?? "HEAD" });
+                    return yield* RefNotFound.make({ ref: input.ref ?? "HEAD" });
                 }
                 const startCommit = startMeta.type === ObjectType.tag
                     ? yield* peelOid(meta.repoId, start).pipe(Effect.map((peeled) => peeled ?? start))
@@ -3074,7 +3080,7 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
                         break;
                     }
                     const content = yield* objects.readContent(oid);
-                    const parsed = yield* parseCommit(content).pipe(Effect.mapError((error) => new StoreError({ reason: error.reason })));
+                    const parsed = yield* parseCommit(content).pipe(Effect.mapError((error) => StoreError.make({ reason: error.reason })));
                     items.push({
                         oid,
                         tree: parsed.tree,
@@ -3106,17 +3112,17 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
                 const readCommitOrFail = Effect.fn(function* (oid) {
                     const objectMeta = yield* objects.getMeta(oid);
                     if (objectMeta === undefined) {
-                        return yield* new ObjectNotFound({ oid });
+                        return yield* ObjectNotFound.make({ oid });
                     }
                     if (objectMeta.type !== ObjectType.commit) {
-                        return yield* new WrongObjectType({
+                        return yield* WrongObjectType.make({
                             oid,
                             expected: "commit",
                             actual: objectTypeName(objectMeta.type),
                         });
                     }
                     const content = yield* objects.readContent(oid);
-                    return yield* parseCommit(content).pipe(Effect.mapError((error) => new StoreError({ reason: error.reason })));
+                    return yield* parseCommit(content).pipe(Effect.mapError((error) => StoreError.make({ reason: error.reason })));
                 });
                 const commit = yield* readCommitOrFail(input.oid);
                 // First-parent diff (the GitHub default for merge commits).
@@ -3154,7 +3160,7 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
                 for (const oid of new Set([baseOid, headOid])) {
                     const row = yield* rowOf(oid);
                     if (row === undefined) {
-                        return yield* new ObjectNotFound({ oid });
+                        return yield* ObjectNotFound.make({ oid });
                     }
                     heapPush(heap, { oid, gen: row.gen, time: row.commit_time });
                     timeOf.set(oid, row.commit_time);
@@ -3206,7 +3212,7 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
                     }
                 }
                 if (mergeBase === undefined) {
-                    return yield* new NoMergeBase({
+                    return yield* NoMergeBase.make({
                         base: asOid(baseOid),
                         head: asOid(headOid),
                     });
@@ -3217,7 +3223,7 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
                 const commits = [];
                 for (const oid of commitOids) {
                     const content = yield* objects.readContent(oid);
-                    const parsed = yield* parseCommit(content).pipe(Effect.mapError((error) => new StoreError({ reason: error.reason })));
+                    const parsed = yield* parseCommit(content).pipe(Effect.mapError((error) => StoreError.make({ reason: error.reason })));
                     commits.push({
                         oid,
                         tree: parsed.tree,
@@ -3241,7 +3247,7 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
                 const treeOf = Effect.fn(function* (oid) {
                     const row = yield* sql.first(`SELECT tree FROM commits WHERE oid = ?`, oid);
                     if (row === undefined) {
-                        return yield* new StoreError({
+                        return yield* StoreError.make({
                             reason: `commit ${oid} missing from the commit graph`,
                         });
                     }
@@ -3267,49 +3273,50 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
                 const objects = storeFor(meta.repoId);
                 const startOid = yield* resolveRevision(meta.defaultBranch, input.ref);
                 // Resolve start → commit → root tree (peel tags on the way).
-                const rootTree = yield* Effect.gen(function* () {
+                const resolveRootTree = Effect.gen(function* () {
                     let current = startOid;
                     for (let hops = 0; hops < 16; hops++) {
                         const objectMeta = yield* objects.getMeta(current);
                         if (objectMeta === undefined) {
-                            return yield* new ObjectNotFound({ oid: current });
+                            return yield* ObjectNotFound.make({ oid: current });
                         }
                         if (objectMeta.type === ObjectType.tree)
                             return current;
                         const content = yield* objects.readContent(current);
                         if (objectMeta.type === ObjectType.commit) {
-                            const parsed = yield* parseCommit(content).pipe(Effect.mapError((error) => new StoreError({ reason: error.reason })));
+                            const parsed = yield* parseCommit(content).pipe(Effect.mapError((error) => StoreError.make({ reason: error.reason })));
                             return parsed.tree;
                         }
                         if (objectMeta.type === ObjectType.tag) {
-                            const parsed = yield* parseTag(content).pipe(Effect.mapError((error) => new StoreError({ reason: error.reason })));
+                            const parsed = yield* parseTag(content).pipe(Effect.mapError((error) => StoreError.make({ reason: error.reason })));
                             current = parsed.object;
                             continue;
                         }
-                        return yield* new ObjectNotFound({ oid: current });
+                        return yield* ObjectNotFound.make({ oid: current });
                     }
-                    return yield* new ObjectNotFound({ oid: current });
+                    return yield* ObjectNotFound.make({ oid: current });
                 });
+                const rootTree = yield* resolveRootTree;
                 const segments = input.path.split("/").filter(Boolean);
                 if (segments.length === 0) {
-                    return yield* new ObjectNotFound({ oid: rootTree });
+                    return yield* ObjectNotFound.make({ oid: rootTree });
                 }
                 let treeOid = rootTree;
                 for (let i = 0; i < segments.length; i++) {
                     const content = yield* objects.readContent(treeOid);
-                    const entries = yield* parseTree(content).pipe(Effect.mapError((error) => new StoreError({ reason: error.reason })));
+                    const entries = yield* parseTree(content).pipe(Effect.mapError((error) => StoreError.make({ reason: error.reason })));
                     const entry = entries.find((e) => e.name === segments[i]);
                     if (entry === undefined) {
-                        return yield* new ObjectNotFound({ oid: `${input.path}` });
+                        return yield* ObjectNotFound.make({ oid: `${input.path}` });
                     }
                     const kind = treeEntryKind(entry.mode);
                     if (i === segments.length - 1) {
                         if (kind !== "blob") {
-                            return yield* new ObjectNotFound({ oid: input.path });
+                            return yield* ObjectNotFound.make({ oid: input.path });
                         }
                         const blobMeta = yield* objects.getMeta(entry.oid);
                         if (blobMeta === undefined) {
-                            return yield* new ObjectNotFound({ oid: entry.oid });
+                            return yield* ObjectNotFound.make({ oid: entry.oid });
                         }
                         const blob = yield* objects.readContent(entry.oid);
                         return {
@@ -3320,31 +3327,31 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
                         };
                     }
                     if (kind !== "tree") {
-                        return yield* new ObjectNotFound({ oid: input.path });
+                        return yield* ObjectNotFound.make({ oid: input.path });
                     }
                     treeOid = entry.oid;
                 }
                 // unreachable — the loop returns or fails
-                return yield* new ObjectNotFound({ oid: input.path });
+                return yield* ObjectNotFound.make({ oid: input.path });
             }),
             createPull: Effect.fn(function* (input) {
                 yield* requireMeta;
                 const baseRef = yield* normalizeBranchRef(input.base);
                 const headRef = yield* normalizeBranchRef(input.head);
                 if (baseRef === headRef) {
-                    return yield* new ValidationError({
+                    return yield* ValidationError.make({
                         message: "base and head must be different branches",
                     });
                 }
                 for (const ref of [baseRef, headRef]) {
                     const row = yield* sql.first(`SELECT name, oid FROM refs WHERE name = ?`, ref);
                     if (row === undefined) {
-                        return yield* new BranchMissing({ ref });
+                        return yield* BranchMissing.make({ ref });
                     }
                 }
                 const duplicate = yield* sql.first(`SELECT number FROM pulls WHERE state = 'open' AND base_ref = ? AND head_ref = ?`, baseRef, headRef);
                 if (duplicate !== undefined) {
-                    return yield* new PullExists({ number: duplicate.number });
+                    return yield* PullExists.make({ number: duplicate.number });
                 }
                 const now = Date.now();
                 // Allocate the number and insert the row in ONE transaction —
@@ -3494,7 +3501,7 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
                 const row = yield* loadPull(input.number);
                 const current = pullStateOf(row.state);
                 if (input.state !== undefined && current === "merged") {
-                    return yield* new PullStateConflict({
+                    return yield* PullStateConflict.make({
                         number: input.number,
                         state: "merged",
                     });
@@ -3508,12 +3515,12 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
             mergePull: Effect.fn(function* (input) {
                 const meta = yield* requireMeta;
                 if (meta.readOnly) {
-                    return yield* new ReadOnlyRepo();
+                    return yield* ReadOnlyRepo.make({});
                 }
                 const row = yield* loadPull(input.number);
                 const state = pullStateOf(row.state);
                 if (state !== "open") {
-                    return yield* new PullStateConflict({
+                    return yield* PullStateConflict.make({
                         number: input.number,
                         state,
                     });
@@ -3522,29 +3529,29 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
                 // (re)create a deleted base branch.
                 const baseRow = yield* sql.first(`SELECT name, oid FROM refs WHERE name = ?`, row.base_ref);
                 if (baseRow === undefined) {
-                    return yield* new BranchMissing({ ref: row.base_ref });
+                    return yield* BranchMissing.make({ ref: row.base_ref });
                 }
                 const headRow = yield* sql.first(`SELECT name, oid FROM refs WHERE name = ?`, row.head_ref);
                 if (headRow === undefined) {
-                    return yield* new BranchMissing({ ref: row.head_ref });
+                    return yield* BranchMissing.make({ ref: row.head_ref });
                 }
                 const baseTip = baseRow.oid;
                 if (input.expectedBaseOid !== undefined && input.expectedBaseOid !== baseTip) {
-                    return yield* new RefConflict({
+                    return yield* RefConflict.make({
                         ref: row.base_ref,
                         currentOid: asOid(baseTip),
                     });
                 }
                 const headTip = headRow.oid;
                 if (input.expectedHeadOid !== undefined && input.expectedHeadOid !== headTip) {
-                    return yield* new RefConflict({
+                    return yield* RefConflict.make({
                         ref: row.head_ref,
                         currentOid: asOid(headTip),
                     });
                 }
                 const cmp = yield* paintWalk(baseTip, headTip, MAX_PULL_MERGE_WALK);
                 if (cmp.mergeBase === headTip) {
-                    return yield* new NothingToMerge({ number: input.number });
+                    return yield* NothingToMerge.make({ number: input.number });
                 }
                 const now = Date.now();
                 // ── fast-forward: base is an ancestor of head ──────────────────
@@ -3558,7 +3565,7 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
                             .toArray();
                         const currentOid = rows.length > 0 ? rows[0].oid : null;
                         if (currentOid !== baseTip) {
-                            rollback(new RefConflict({
+                            rollback(RefConflict.make({
                                 ref: row.base_ref,
                                 currentOid: currentOid === null ? null : asOid(currentOid),
                             }));
@@ -3584,7 +3591,7 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
                 if (cmp.mergeBase === undefined) {
                     // Unrelated histories (or a saturated walk): conservative
                     // conflict — the server never guesses.
-                    return yield* new MergeConflict({
+                    return yield* MergeConflict.make({
                         number: input.number,
                         paths: [],
                     });
@@ -3597,14 +3604,14 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
                 if (baseChanges.truncated || headChanges.truncated) {
                     // A truncated diff hides changes — conflict detection would be
                     // unsound, so refuse conservatively.
-                    return yield* new MergeConflict({
+                    return yield* MergeConflict.make({
                         number: input.number,
                         paths: [],
                     });
                 }
                 const conflicts = conflictingPaths(baseChanges.files, headChanges.files);
                 if (conflicts.length > 0) {
-                    return yield* new MergeConflict({
+                    return yield* MergeConflict.make({
                         number: input.number,
                         paths: conflicts.slice(0, MAX_CONFLICT_PATHS),
                     });
@@ -3629,14 +3636,14 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
                     author: identity,
                     committer: identity,
                     message,
-                }).pipe(Effect.mapError((e) => new StoreError({ reason: e.reason })));
+                }).pipe(Effect.mapError((e) => StoreError.make({ reason: e.reason })));
                 const mergeOid = yield* hashObject(ObjectType.commit, commitContent);
                 // Stage under a synthetic push id WITH a pushes staging row first,
                 // so the staging-GC alarm reaps the objects if we crash (or the
                 // CAS below loses) — the exact crash-safety story of a push.
                 const pushId = `pr-${input.number}-${yield* ulid()}`;
                 yield* sql.run(`INSERT INTO pushes (push_id, started_at, state) VALUES (?, ?, 'staging')`, pushId, now);
-                const zlibToStore = (error) => new StoreError({ reason: error.reason });
+                const zlibToStore = (error) => StoreError.make({ reason: error.reason });
                 const staged = [];
                 for (const tree of applied.newTrees) {
                     staged.push({
@@ -3681,7 +3688,7 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
                     // Base moved between the pre-check and the transaction. The
                     // staged objects stay parked under `pushId` for the GC alarm.
                     const current = yield* sql.first(`SELECT name, oid FROM refs WHERE name = ?`, row.base_ref);
-                    return yield* new RefConflict({
+                    return yield* RefConflict.make({
                         ref: row.base_ref,
                         currentOid: current === undefined ? null : asOid(current.oid),
                     });
@@ -3726,10 +3733,13 @@ export const GitRepoLive = GitRepo.make(Effect.gen(function* () {
                     return yield* handleUploadPack(request, meta);
                 }
                 return HttpServerResponse.text("not found", { status: 404 });
-            }).pipe(Effect.catchTag("StoreError", (error) => Effect.as(Effect.logError("git wire: storage failure", error), HttpServerResponse.text("internal error", { status: 500 }))), Effect.catchTag("PackIngestError", (error) => Effect.succeed(HttpServerResponse.uint8Array(errPkt(error.reason), {
-                status: 200,
-                headers: noCache,
-            })))),
+            }).pipe(Effect.catchTags({
+                StoreError: (error) => Effect.as(Effect.logError("git wire: storage failure", error), HttpServerResponse.text("internal error", { status: 500 })),
+                PackIngestError: (error) => Effect.succeed(HttpServerResponse.uint8Array(errPkt(error.reason), {
+                    status: 200,
+                    headers: noCache,
+                })),
+            })),
             alarm: () => Effect.gen(function* () {
                 const jobs = yield* sql.all(`SELECT * FROM jobs WHERE state = 'running'`);
                 // `purge` runs FIRST and every job is individually isolated: a