alchemy 2.0.0-beta.77 → 2.0.0-beta.78

package/lib/Git/Hasher/Hasher.js

@@ -0,0 +1,170 @@
+/**
+ * The pack hasher (DESIGN §22.7): the CPU-heavy half of push ingest —
+ * inflating and hashing entries, applying in-buffer deltas — as a service
+ * the receive-pack pipeline calls per spilled part, so the repo's Durable
+ * Object only receives bytes and stages rows.
+ *
+ * Two layers:
+ *
+ * - {@link HasherInline} runs the scan in the calling isolate — the
+ *   reference assembly. On Cloudflare Workers a service-binding subrequest
+ *   executes on the caller's own thread (measured, DESIGN §22.10), so
+ *   fanning out buys no CPU there; inline avoids the copies and framing.
+ * - {@link HasherSelf} posts each part to the Worker's own
+ *   `/_alchemy/git/hash` route through a `Cloudflare.Workers.Self` service
+ *   binding: the same work in another invocation of the same script. Kept
+ *   for runtimes where such calls do run in parallel, and as the shape a
+ *   remote hasher (a Container running native `index-pack`, a multi-core
+ *   host behind a cross-zone URL) would take.
+ *
+ * The wire protocol is binary both ways (parts are megabytes; JSON would
+ * base64 them): request body = the raw bytes, coordinates in the query;
+ * response = `u32 jsonLength | json | blob area`, where the JSON's entries
+ * reference their content/zdata as `[offset, length]` into the blob area.
+ */
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Redacted from "effect/Redacted";
+import * as Schema from "effect/Schema";
+import * as Fiber from "effect/Fiber";
+import { WorkerEnvironment } from "../../Cloudflare/Workers/Worker.js";
+import { RuntimeContext } from "../../RuntimeContext.js";
+import { Random } from "../../Random.js";
+import { BlobStore, } from "../BlobStore.js";
+import { hashBounds, scanPart, resolveDeltas, } from "../Protocol/PartialScan.js";
+import { ObjectTooLargeError, PackFormatError, } from "../Protocol/PackParser.js";
+export { decodeBoundsRequest, decodeScanResult, encodeBoundsRequest, encodeScanResult, frame, HASH_ROUTE, HashError, makeFrameReader, } from "./Protocol.js";
+import { decodeDeltaResults, decodeScanResult, encodeBoundsRequest, encodeDeltaBatch, frame, HASH_ROUTE, HashError, makeFrameReader, } from "./Protocol.js";
+export class Hasher extends Context.Service()("alchemy/Git/Hasher") {
+}
+/** The in-process hasher: scans here; a requested spill part goes to `blobs`. */
+export const makeInlineHasher = (blobs) => ({
+    writesSpill: true,
+    hashPart: (payload, options) => Effect.gen(function* () {
+        const spill = options.spill;
+        // Detached: the caller's fiber ends with the scan; the part is joined
+        // later, before the multipart upload is completed.
+        const upload = spill === undefined
+            ? 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.provide(RuntimeContext.phantom)));
+        const skip = options.skip ?? 0;
+        const scan = yield* scanPart(skip === 0 ? payload : payload.subarray(skip), options);
+        return {
+            ...scan,
+            part: upload === undefined ? undefined : Fiber.join(upload),
+        };
+    }),
+    resolveDeltas: (bases, jobs, options) => resolveDeltas(bases, jobs, options),
+    hashBoundsPart: (payload, bounds, options) => hashBounds(payload, bounds, options),
+});
+/** Runs the scan in-process (tests, or a deployment without a self binding). */
+export const HasherInline = Layer.effect(Hasher, Effect.map(BlobStore, makeInlineHasher));
+/**
+ * Request framing for the bounds mode: `u32 jsonLength | json(bounds) |
+ * bytes`.
+ */
+/** The `env` name of the self service binding (`GIT_WORKER_OPTIONS`). */
+/**
+ * The secret the push pipeline's internal hash route requires: a
+ * deploy-time random value bound onto the Worker (an `Alchemy.Random`
+ * resource, minted once and stable across deploys). Yielded at layer build
+ * by both the route and the self-calling hasher, so no user credential is
+ * ever involved.
+ */
+export const InternalSecret = Effect.gen(function* () {
+    // Yielding the resource class gives a constructor whose providers are
+    // the host stack's (the same way the Cloudflare `*Http` bindings mint
+    // tokens), so declaring the secret here needs nothing from the caller.
+    const R = yield* Random;
+    const resource = yield* R("GitInternalSecret");
+    return yield* resource.text;
+});
+export const HASHER_BINDING = "GIT_SELF";
+/**
+ * Posts each part to the Worker's own hash route through the self service
+ * binding (`GIT_WORKER_OPTIONS` declares it as `GIT_SELF`). The internal
+ * call authenticates with {@link InternalSecret}, a deploy-time random
+ * value no user ever holds. Falls back to {@link HasherInline} when the
+ * binding is absent from the environment.
+ */
+export const HasherSelf = Layer.effect(Hasher, Effect.gen(function* () {
+    const env = yield* WorkerEnvironment;
+    const blobs = yield* BlobStore;
+    const fetcher = env[HASHER_BINDING];
+    if (fetcher === undefined) {
+        return makeInlineHasher(blobs);
+    }
+    const secret = yield* InternalSecret;
+    const send = (url, body) => Effect.gen(function* () {
+        const token = Redacted.value(yield* secret);
+        const response = yield* Effect.tryPromise({
+            try: () => fetcher.fetch(url, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/octet-stream",
+                    authorization: `Bearer ${token}`,
+                },
+                body: body,
+            }),
+            catch: (error) => new HashError({ 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" }),
+            });
+            return yield* new HashError({
+                reason: `hash part: status ${response.status}: ${text.slice(0, 200)}`,
+            });
+        }
+        return makeFrameReader(response.body);
+    });
+    const post = (url, body) => Effect.gen(function* () {
+        const next = yield* send(url, body);
+        const first = yield* next();
+        if (first === undefined) {
+            return yield* new HashError({ reason: "hash part: empty response" });
+        }
+        return decodeScanResult(first);
+    });
+    return {
+        writesSpill: true,
+        hashPart: (payload, opts) => Effect.gen(function* () {
+            const spill = opts.spill === undefined
+                ? ""
+                : `&key=${encodeURIComponent(opts.spill.key)}&uploadId=${encodeURIComponent(opts.spill.uploadId)}&part=${opts.spill.partNumber}`;
+            const next = yield* send(`https://self${HASH_ROUTE}?base=${opts.base}&remaining=${opts.remaining}&max=${opts.maxObjectSize}${opts.resync ? "&resync=1" : ""}${opts.skip ? `&skip=${opts.skip}` : ""}${spill}`, payload);
+            const first = yield* next();
+            if (first === undefined) {
+                return yield* new HashError({
+                    reason: "hash part: empty response",
+                });
+            }
+            const scan = decodeScanResult(first);
+            if (opts.spill === undefined)
+                return scan;
+            // The part frame arrives once the hasher's upload has finished.
+            const part = next().pipe(Effect.flatMap((bytes) => bytes === undefined
+                ? Effect.fail(new HashError({ reason: "hash part: no part frame" }))
+                : Effect.succeed(JSON.parse(new TextDecoder().decode(bytes)))));
+            return { ...scan, part };
+        }),
+        hashBoundsPart: (payload, bounds, opts) => post(`https://self${HASH_ROUTE}?mode=bounds&base=${opts.base}&max=${opts.maxObjectSize}`, encodeBoundsRequest(payload, bounds)),
+        resolveDeltas: (bases, jobs, opts) => Effect.gen(function* () {
+            const next = yield* send(`https://self${HASH_ROUTE}?mode=deltas&max=${opts.maxObjectSize}`, encodeDeltaBatch(bases, jobs));
+            const first = yield* next();
+            if (first === undefined) {
+                return yield* new HashError({
+                    reason: "delta batch: empty response",
+                });
+            }
+            return decodeDeltaResults(first);
+        }),
+    };
+}));
+//# sourceMappingURL=Hasher.js.map

package/lib/Git/Hasher/Hasher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Hasher.js","sourceRoot":"","sources":["../../../src/Git/Hasher/Hasher.ts"],"names":[],"mappings":"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"}

package/lib/Git/Hasher/Lambda.d.ts

@@ -0,0 +1,18 @@
+/**
+ * `Hasher` over an AWS Lambda (DESIGN §22.11). Each chunk is one
+ * `InvokeFunction` call — a JSON payload with the chunk in base64 — signed
+ * from the Worker with the cross-cloud identity `AWS.Lambda.InvokeFunctionHttp`
+ * provisions for a Worker host (an IAM user, key and assume-role Role,
+ * once per Worker). Chunks are 4 MiB (the 6 MB invoke limit) and the pump
+ * writes the spill parts itself (`writesSpill: false`). Any failure on the
+ * Lambda side — throttling, a cold-start timeout, an oversize response —
+ * falls back to hashing that chunk inline, so a push never fails because
+ * the hasher did.
+ */
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { InvokeFunction } from "../../AWS/Lambda/InvokeFunction.ts";
+import type { Function as LambdaFunction } from "../../AWS/Lambda/Function.ts";
+import { Hasher } from "./Hasher.ts";
+export declare const HasherLambda: (fn: LambdaFunction | Effect.Effect<LambdaFunction, any, any>) => Layer.Layer<Hasher, never, InvokeFunction>;
+//# sourceMappingURL=Lambda.d.ts.map

package/lib/Git/Hasher/Lambda.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Lambda.d.ts","sourceRoot":"","sources":["../../../src/Git/Hasher/Lambda.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACpE,OAAO,KAAK,EAAE,QAAQ,IAAI,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAM/E,OAAO,EAAE,MAAM,EAA+B,MAAM,aAAa,CAAC;AAQlE,eAAO,MAAM,YAAY,OACnB,cAAc,GAAG,MAAM,CAAC,MAAM,CAAC,cAAc,EAAE,GAAG,EAAE,GAAG,CAAC,KAC3D,KAAK,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,EAAE,cAAc,CAoFzC,CAAC"}

package/lib/Git/Hasher/Lambda.js

@@ -0,0 +1,81 @@
+/**
+ * `Hasher` over an AWS Lambda (DESIGN §22.11). Each chunk is one
+ * `InvokeFunction` call — a JSON payload with the chunk in base64 — signed
+ * from the Worker with the cross-cloud identity `AWS.Lambda.InvokeFunctionHttp`
+ * provisions for a Worker host (an IAM user, key and assume-role Role,
+ * once per Worker). Chunks are 4 MiB (the 6 MB invoke limit) and the pump
+ * writes the spill parts itself (`writesSpill: false`). Any failure on the
+ * Lambda side — throttling, a cold-start timeout, an oversize response —
+ * falls back to hashing that chunk inline, so a push never fails because
+ * the hasher did.
+ */
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Stream from "effect/Stream";
+import { InvokeFunction } from "../../AWS/Lambda/InvokeFunction.js";
+import { hashBounds, resolveDeltas, scanPart, } from "../Protocol/PartialScan.js";
+import { Hasher, HashError } from "./Hasher.js";
+import { decodeHashResponse, encodeHashEvent, LAMBDA_CHUNK_BYTES, } from "./LambdaEvent.js";
+export const HasherLambda = (fn) => Layer.effect(Hasher, Effect.gen(function* () {
+    // A class-style declaration (`HasherFunction`) is yielded here — at
+    // deploy that registers the function, at runtime it resolves it.
+    const func = Effect.isEffect(fn)
+        ? yield* fn
+        : fn;
+    const invoke = yield* InvokeFunction(func);
+    const remote = (payload, options) => Effect.gen(function* () {
+        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)}` : ""}`,
+        })));
+        if (response.FunctionError !== undefined) {
+            return yield* new HashError({
+                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)}`,
+            }))))
+            : [];
+        const text = new TextDecoder().decode(chunks.length === 1 ? chunks[0] : concat(chunks));
+        const parsed = yield* Effect.try({
+            try: () => JSON.parse(text),
+            catch: () => new HashError({ reason: `lambda response: not JSON` }),
+        });
+        return yield* decodeHashResponse(parsed);
+    });
+    return {
+        writesSpill: false,
+        chunkBytes: LAMBDA_CHUNK_BYTES,
+        hashPart: (payload, options) => 
+        // A region larger than a chunk (a big object straddling parts)
+        // cannot fit the invoke payload: hash it here without the trip.
+        (payload.length > LAMBDA_CHUNK_BYTES
+            ? Effect.fail(new HashError({
+                reason: `payload of ${payload.length} bytes exceeds the invoke limit`,
+            }))
+            : remote(payload, options)).pipe(Effect.catchTag("HashError", (error) => {
+            if (payload.length <= LAMBDA_CHUNK_BYTES) {
+                console.warn(`[hasher] ${error.reason}; hashing inline`);
+            }
+            const skip = options.skip ?? 0;
+            return scanPart(skip > 0 ? payload.subarray(skip) : payload, options);
+        })),
+        // Delta batches stay on the receiver for now: a batch would need the
+        // same base64 event budget as a chunk.
+        resolveDeltas: (bases, jobs, options) => resolveDeltas(bases, jobs, options),
+        hashBoundsPart: (payload, bounds, options) => hashBounds(payload, bounds, options),
+    };
+}));
+const concat = (chunks) => {
+    const out = new Uint8Array(chunks.reduce((n, c) => n + c.length, 0));
+    let at = 0;
+    for (const c of chunks) {
+        out.set(c, at);
+        at += c.length;
+    }
+    return out;
+};
+//# sourceMappingURL=Lambda.js.map

package/lib/Git/Hasher/Lambda.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Lambda.js","sourceRoot":"","sources":["../../../src/Git/Hasher/Lambda.ts"],"names":[],"mappings":"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"}

package/lib/Git/Hasher/LambdaEvent.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The hash event a {@link HasherFunction} answers (DESIGN §22.11): one pack
+ * chunk, base64 in a JSON invoke payload (Lambda invokes are JSON; a 4 MiB
+ * chunk encodes to ~5.6 MB, under the 6 MB payload limit), answered with
+ * the encoded scan — bounded to the same limit by demoting the largest
+ * delta-resolved entries back to `unresolved` (the receiver resolves those
+ * itself from its retained bytes) and by omitting non-blob content (the
+ * receiver inflates it).
+ */
+import * as Effect from "effect/Effect";
+import { HashError, type HashPartOptions } from "./Hasher.ts";
+import { type ScanResult } from "../Protocol/PartialScan.ts";
+/** Chunk size the Lambda hasher asks the pump for (4 MiB → ~5.6 MB base64). */
+export declare const LAMBDA_CHUNK_BYTES: number;
+/** Raw bytes the encoded scan may carry before demotion (base64 adds a third). */
+export declare const RESPONSE_BUDGET_BYTES: number;
+export interface HashEvent {
+    readonly alchemyGitHash: 1;
+    readonly base: number;
+    readonly remaining: number;
+    readonly max: number;
+    readonly resync: boolean;
+    readonly skip: number;
+    /** The chunk, base64. */
+    readonly payload: string;
+}
+export type HashResponse = {
+    readonly scan: string;
+} | {
+    readonly error: string;
+};
+export declare const isHashEvent: (event: unknown) => event is HashEvent;
+export declare const encodeHashEvent: (payload: Uint8Array, options: HashPartOptions) => HashEvent;
+export declare const fromBase64: (text: string) => Uint8Array;
+/**
+ * Bounds a scan to `budget` raw bytes: strips non-blob content, then
+ * demotes delta-resolved entries — largest first — to `unresolved` until
+ * the fresh zdata fits. Every demoted entry keeps its base reference.
+ */
+export declare const boundScan: (scan: ScanResult, budget: number) => ScanResult;
+/** Answers one hash event: scan, bound, encode. Pure — the Lambda's body. */
+export declare const handleHashEvent: (event: HashEvent) => Effect.Effect<HashResponse>;
+/** Decodes a response into the pump's scan result (or a typed error). */
+export declare const decodeHashResponse: (response: HashResponse) => Effect.Effect<ScanResult, HashError>;
+//# sourceMappingURL=LambdaEvent.d.ts.map

package/lib/Git/Hasher/LambdaEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LambdaEvent.d.ts","sourceRoot":"","sources":["../../../src/Git/Hasher/LambdaEvent.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,EAGL,SAAS,EACT,KAAK,eAAe,EACrB,MAAM,aAAa,CAAC;AACrB,OAAO,EAEL,KAAK,UAAU,EAEhB,MAAM,4BAA4B,CAAC;AAEpC,+EAA+E;AAC/E,eAAO,MAAM,kBAAkB,QAAkB,CAAC;AAClD,kFAAkF;AAClF,eAAO,MAAM,qBAAqB,QAAkB,CAAC;AAErD,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,cAAc,EAAE,CAAC,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,yBAAyB;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,MAAM,YAAY,GACpB;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACzB;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAE/B,eAAO,MAAM,WAAW,UAAW,OAAO,KAAG,KAAK,IAAI,SAIQ,CAAC;AAE/D,eAAO,MAAM,eAAe,YACjB,UAAU,WACV,eAAe,KACvB,SAQD,CAAC;AASH,eAAO,MAAM,UAAU,SAAU,MAAM,KAAG,UAGe,CAAC;AAE1D;;;;GAIG;AACH,eAAO,MAAM,SAAS,SAAU,UAAU,UAAU,MAAM,KAAG,UAkC5D,CAAC;AAEF,6EAA6E;AAC7E,eAAO,MAAM,eAAe,UACnB,SAAS,KACf,MAAM,CAAC,MAAM,CAAC,YAAY,CAuBzB,CAAC;AAEL,yEAAyE;AACzE,eAAO,MAAM,kBAAkB,aACnB,YAAY,KACrB,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,SAAS,CAG2B,CAAC"}

package/lib/Git/Hasher/LambdaEvent.js

@@ -0,0 +1,99 @@
+/**
+ * The hash event a {@link HasherFunction} answers (DESIGN §22.11): one pack
+ * chunk, base64 in a JSON invoke payload (Lambda invokes are JSON; a 4 MiB
+ * chunk encodes to ~5.6 MB, under the 6 MB payload limit), answered with
+ * the encoded scan — bounded to the same limit by demoting the largest
+ * delta-resolved entries back to `unresolved` (the receiver resolves those
+ * itself from its retained bytes) and by omitting non-blob content (the
+ * receiver inflates it).
+ */
+import * as Effect from "effect/Effect";
+import { decodeScanResult, encodeScanResult, HashError, } from "./Hasher.js";
+import { scanPart, } from "../Protocol/PartialScan.js";
+/** Chunk size the Lambda hasher asks the pump for (4 MiB → ~5.6 MB base64). */
+export const LAMBDA_CHUNK_BYTES = 4 * 1024 * 1024;
+/** Raw bytes the encoded scan may carry before demotion (base64 adds a third). */
+export const RESPONSE_BUDGET_BYTES = 4 * 1024 * 1024;
+export const isHashEvent = (event) => typeof event === "object" &&
+    event !== null &&
+    event.alchemyGitHash === 1 &&
+    typeof event.payload === "string";
+export const encodeHashEvent = (payload, options) => ({
+    alchemyGitHash: 1,
+    base: options.base,
+    remaining: options.remaining,
+    max: options.maxObjectSize,
+    resync: options.resync === true,
+    skip: options.skip ?? 0,
+    payload: toBase64(payload),
+});
+const toBase64 = (bytes) => typeof Buffer !== "undefined"
+    ? Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64")
+    : btoa(String.fromCharCode(...bytes));
+export const fromBase64 = (text) => typeof Buffer !== "undefined"
+    ? new Uint8Array(Buffer.from(text, "base64"))
+    : Uint8Array.from(atob(text), (c) => c.charCodeAt(0));
+/**
+ * Bounds a scan to `budget` raw bytes: strips non-blob content, then
+ * demotes delta-resolved entries — largest first — to `unresolved` until
+ * the fresh zdata fits. Every demoted entry keeps its base reference.
+ */
+export const boundScan = (scan, budget) => {
+    const entries = scan.entries.map((e) => e.content === undefined ? e : { ...e, content: undefined });
+    let bytes = entries.length * 120;
+    for (const e of entries)
+        bytes += e.zdata?.byteLength ?? 0;
+    if (bytes <= budget) {
+        return { ...scan, entries };
+    }
+    const order = entries
+        .map((e, i) => ({ i, z: e.zdata?.byteLength ?? 0 }))
+        .filter((x) => x.z > 0)
+        .sort((a, b) => b.z - a.z);
+    const demoted = new Set();
+    const unresolved = [...scan.unresolved];
+    for (const { i, z } of order) {
+        if (bytes <= budget)
+            break;
+        const e = entries[i];
+        demoted.add(i);
+        bytes -= z;
+        unresolved.push({
+            offset: e.offset,
+            dataOffset: e.dataOffset,
+            span: e.span,
+            baseOffset: e.baseOffset,
+            baseOid: e.baseOid,
+            size: e.size,
+        });
+    }
+    return {
+        ...scan,
+        entries: entries.filter((_, i) => !demoted.has(i)),
+        unresolved,
+    };
+};
+/** Answers one hash event: scan, bound, encode. Pure — the Lambda's body. */
+export const handleHashEvent = (event) => Effect.gen(function* () {
+    const payload = fromBase64(event.payload);
+    const result = yield* scanPart(event.skip > 0 ? payload.subarray(event.skip) : payload, {
+        base: event.base,
+        remaining: event.remaining,
+        maxObjectSize: event.max,
+        resync: event.resync,
+    }).pipe(Effect.result);
+    if (result._tag === "Failure") {
+        const failure = result.failure;
+        return {
+            error: `${failure._tag}${"reason" in failure ? `: ${failure.reason}` : ""}`,
+        };
+    }
+    return {
+        scan: toBase64(encodeScanResult(boundScan(result.success, RESPONSE_BUDGET_BYTES))),
+    };
+});
+/** Decodes a response into the pump's scan result (or a typed error). */
+export const decodeHashResponse = (response) => "error" in response
+    ? Effect.fail(new HashError({ reason: `lambda hasher: ${response.error}` }))
+    : Effect.succeed(decodeScanResult(fromBase64(response.scan)));
+//# sourceMappingURL=LambdaEvent.js.map

package/lib/Git/Hasher/LambdaEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LambdaEvent.js","sourceRoot":"","sources":["../../../src/Git/Hasher/LambdaEvent.ts"],"names":[],"mappings":"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"}

package/lib/Git/Hasher/LambdaFunction.d.ts

@@ -0,0 +1,7 @@
+import * as Effect from "effect/Effect";
+import * as Lambda from "../../AWS/Lambda/Function.ts";
+declare const HasherFunction_base: Effect.Effect<Lambda.Function & import("../../Rpc.ts").Rpc<HasherFunction>, never, import("../../AWS/Providers.ts").Providers> & import("../../Named.ts").Named<"GitHasher"> & (new (_: never) => import("../../Named.ts").Named<"GitHasher"> & import("../../Named.ts").Tag<"AWS.Lambda.Function">);
+export default class HasherFunction extends HasherFunction_base {
+}
+export {};
+//# sourceMappingURL=LambdaFunction.d.ts.map

package/lib/Git/Hasher/LambdaFunction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LambdaFunction.d.ts","sourceRoot":"","sources":["../../../src/Git/Hasher/LambdaFunction.ts"],"names":[],"mappings":"AAyBA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,MAAM,MAAM,8BAA8B,CAAC;;AAGvD,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,mBAgB3C;CAAG"}

package/lib/Git/Hasher/LambdaFunction.js

@@ -0,0 +1,41 @@
+/**
+ * The pack hasher as an AWS Lambda (DESIGN §22.11): an Effect-native
+ * Function that answers {@link HashEvent}s — the same scan the Worker runs
+ * inline, on a core several times faster and, above all, on as many cores
+ * as there are chunks in flight. Declare it in the same stack as the Git
+ * Worker (the stack needs both provider sets) and hand it to
+ * {@link HasherLambda}.
+ *
+ * **Example:** A Git host that hashes pushes on Lambda
+ * ```typescript
+ * import * as Git from "alchemy/Git";
+ * import * as GitHasher from "alchemy/Git/Hasher";
+ *
+ * const GitLive = Git.ApiLive.pipe(
+ *   Layer.provide(Git.ApiHandlersLive),
+ *   Layer.provide(Authentication.layer),
+ *   Layer.provide(Git.ReposDurableObject),
+ *   Layer.provide(Git.RegistryDurableObject),
+ *   Layer.provide(GitHasher.HasherLambda(GitHasher.HasherFunction)),
+ *   Layer.provide(AWS.Lambda.InvokeFunctionHttp),
+ *   Layer.provide(Git.BlobStoreR2(GitObjects)),
+ * );
+ * ```
+ */
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Lambda from "../../AWS/Lambda/Function.js";
+import { handleHashEvent, isHashEvent } from "./LambdaEvent.js";
+export default class HasherFunction extends Lambda.Function()("GitHasher", {
+    main: import.meta.url,
+    // CPU scales with memory on Lambda; 3 GB is the fastest single-thread
+    // tier and a chunk needs well under that.
+    memorySize: 3008,
+    timeout: Duration.seconds(60),
+}, Effect.gen(function* () {
+    const fn = yield* Lambda.Function;
+    yield* fn.listen((event) => isHashEvent(event) ? handleHashEvent(event) : undefined);
+    return {};
+})) {
+}
+//# sourceMappingURL=LambdaFunction.js.map

package/lib/Git/Hasher/LambdaFunction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LambdaFunction.js","sourceRoot":"","sources":["../../../src/Git/Hasher/LambdaFunction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAC;AAC5C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,MAAM,MAAM,8BAA8B,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEhE,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,MAAM,CAAC,QAAQ,EAAkB,CAC3E,WAAW,EACX;IACE,IAAI,EAAE,OAAO,IAAI,CAAC,GAAG;IACrB,sEAAsE;IACtE,0CAA0C;IAC1C,UAAU,EAAE,IAAI;IAChB,OAAO,EAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;CAC9B,EACD,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,MAAM,EAAE,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;IAClC,KAAK,CAAC,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,KAAc,EAAE,EAAE,CAClC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CACxD,CAAC;IACF,OAAO,EAAE,CAAC;AACZ,CAAC,CAAC,CACH;CAAG"}

package/lib/Git/Hasher/Protocol.d.ts

@@ -0,0 +1,46 @@
+/**
+ * The hasher wire protocol (DESIGN §22.7, §22.9) — the part of `Hasher.ts`
+ * a hasher isolate needs and nothing more: no Cloudflare provider imports,
+ * so a dynamic worker bundling it stays small.
+ *
+ * Request: the raw part bytes, coordinates in the query string. Response:
+ * `u32 len | frame` repeated — the scan first (`encodeScanResult`: `u32
+ * jsonLength | json | blob area`, entries referencing content/zdata as
+ * `[offset, length]` into the blob area), then, when a spill was
+ * requested, the uploaded part as JSON.
+ */
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import type { DeltaBase, DeltaJob, DeltaResolved, EntryBounds, ScanResult } from "../Protocol/PartialScan.ts";
+declare const HashError_base: Schema.Class<HashError, Schema.TaggedStruct<"HashError", {
+    readonly reason: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class HashError extends HashError_base {
+}
+export declare const encodeBoundsRequest: (payload: Uint8Array, bounds: ReadonlyArray<EntryBounds>) => Uint8Array;
+export declare const decodeBoundsRequest: (body: Uint8Array) => {
+    readonly bounds: ReadonlyArray<EntryBounds>;
+    readonly payload: Uint8Array;
+};
+/** The internal route the self-binding layer posts to. */
+export declare const HASH_ROUTE = "/_alchemy/git/hash";
+export declare const encodeScanResult: (result: ScanResult) => Uint8Array;
+export declare const decodeScanResult: (bytes: Uint8Array) => ScanResult;
+/**
+ * Response framing of the hash route: `u32 len | frame` repeated — the
+ * scan first, then (spill only) the uploaded part as JSON once its upload
+ * has finished. The client acts on the scan without waiting for the part.
+ */
+export declare const frame: (bytes: Uint8Array) => Uint8Array;
+/** Reads length-prefixed frames off a response body, one at a time. */
+export declare const makeFrameReader: (body: ReadableStream<Uint8Array>) => () => Effect.Effect<Uint8Array | undefined, HashError>;
+/** `u32 jsonLen | json | blobs` with bases and deltas referenced as [offset, length]. */
+export declare const encodeDeltaBatch: (bases: ReadonlyArray<DeltaBase>, jobs: ReadonlyArray<DeltaJob>) => Uint8Array;
+export declare const decodeDeltaBatch: (bytes: Uint8Array) => {
+    readonly bases: Array<DeltaBase>;
+    readonly jobs: Array<DeltaJob>;
+};
+export declare const encodeDeltaResults: (results: ReadonlyArray<DeltaResolved>) => Uint8Array;
+export declare const decodeDeltaResults: (bytes: Uint8Array) => Array<DeltaResolved>;
+export {};
+//# sourceMappingURL=Protocol.d.ts.map

package/lib/Git/Hasher/Protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Protocol.d.ts","sourceRoot":"","sources":["../../../src/Git/Hasher/Protocol.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,EACV,SAAS,EACT,QAAQ,EACR,aAAa,EACb,WAAW,EACX,UAAU,EACX,MAAM,4BAA4B,CAAC;;;;AAEpC,qBAAa,SAAU,SAAQ,cAE7B;CAAG;AAEL,eAAO,MAAM,mBAAmB,YACrB,UAAU,UACX,aAAa,CAAC,WAAW,CAAC,KACjC,UAOF,CAAC;AAEF,eAAO,MAAM,mBAAmB,SACxB,UAAU,KACf;IACD,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC;IAC5C,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;CAO9B,CAAC;AAEF,0DAA0D;AAC1D,eAAO,MAAM,UAAU,uBAAuB,CAAC;AAwB/C,eAAO,MAAM,gBAAgB,WAAY,UAAU,KAAG,UAqCrD,CAAC;AAEF,eAAO,MAAM,gBAAgB,UAAW,UAAU,KAAG,UA0BpD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,KAAK,UAAW,UAAU,KAAG,UAKzC,CAAC;AAEF,uEAAuE;AACvE,eAAO,MAAM,eAAe,SAAU,cAAc,CAAC,UAAU,CAAC,WA0BnD,MAAM,CAAC,MAAM,CAAC,UAAU,GAAG,SAAS,EAAE,SAAS,CAkB3D,CAAC;AAIF,yFAAyF;AACzF,eAAO,MAAM,gBAAgB,UACpB,aAAa,CAAC,SAAS,CAAC,QACzB,aAAa,CAAC,QAAQ,CAAC,KAC5B,UAuBF,CAAC;AAEF,eAAO,MAAM,gBAAgB,UACpB,UAAU,KAChB;IAAE,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;CAoBpE,CAAC;AAEF,eAAO,MAAM,kBAAkB,YACpB,aAAa,CAAC,aAAa,CAAC,KACpC,UA0BF,CAAC;AAEF,eAAO,MAAM,kBAAkB,UAAW,UAAU,KAAG,KAAK,CAAC,aAAa,CAqBzE,CAAC"}