alchemy 2.0.0-beta.76 → 2.0.0-beta.78

package/src/Git/Hasher/Hasher.ts

@@ -0,0 +1,360 @@
+/**
+ * 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.ts";
+import { RuntimeContext } from "../../RuntimeContext.ts";
+import { Random } from "../../Random.ts";
+import {
+  BlobStore,
+  type BlobStoreShape,
+  type UploadedPart,
+} from "../BlobStore.ts";
+import type { Oid, ObjectType } from "../Protocol/ObjectCodec.ts";
+import {
+  type EntryBounds,
+  hashBounds,
+  scanPart,
+  type ScanResult,
+  resolveDeltas,
+  type DeltaBase,
+  type DeltaJob,
+  type DeltaResolved,
+} from "../Protocol/PartialScan.ts";
+import {
+  ObjectTooLargeError,
+  PackFormatError,
+} from "../Protocol/PackParser.ts";
+
+export {
+  decodeBoundsRequest,
+  decodeScanResult,
+  encodeBoundsRequest,
+  encodeScanResult,
+  frame,
+  HASH_ROUTE,
+  HashError,
+  makeFrameReader,
+} from "./Protocol.ts";
+import {
+  decodeDeltaResults,
+  decodeScanResult,
+  encodeBoundsRequest,
+  encodeDeltaBatch,
+  frame,
+  HASH_ROUTE,
+  HashError,
+  makeFrameReader,
+} from "./Protocol.ts";
+
+export interface HashPartOptions {
+  /** Pack-relative offset of `payload[skip]`. */
+  readonly base: number;
+  readonly remaining: number;
+  readonly maxObjectSize: number;
+  /** The payload is a raw chunk: find the first boundary first (DESIGN §22.9). */
+  readonly resync?: boolean | undefined;
+  /**
+   * Scanning starts at `payload[skip]`; the bytes before it (the request's
+   * command section and the pack header, in a body-aligned first part) are
+   * spilled but not scanned.
+   */
+  readonly skip?: number | undefined;
+  /**
+   * Write the WHOLE payload as this part of a multipart upload while
+   * scanning it (DESIGN §22.10): the hasher isolate is the spill's writer,
+   * so the receiver sends each byte out once.
+   */
+  readonly spill?:
+    | {
+        readonly key: string;
+        readonly uploadId: string;
+        readonly partNumber: number;
+      }
+    | undefined;
+}
+
+/**
+ * A scan plus, when a spill was requested, the uploaded part's identity —
+ * DEFERRED: the scan is available as soon as the hasher has it, while the
+ * part's upload to blob storage may still be in flight (DESIGN §22.9).
+ */
+export interface HashPartResult extends ScanResult {
+  readonly part?: Effect.Effect<UploadedPart, HashError> | undefined;
+}
+
+export interface HasherShape {
+  /**
+   * Whether `hashPart` honors `spill` by writing the part itself. A hasher
+   * that cannot reach blob storage (a Lambda) answers false; the pump then
+   * uploads the spill parts from its retained bytes.
+   */
+  readonly writesSpill: boolean;
+  /**
+   * The chunk size this hasher wants (a divisor of the spill part size,
+   * 8 MiB); a Lambda is bounded by its 6 MB invoke payload. Default: the
+   * spill part size.
+   */
+  readonly chunkBytes?: number | undefined;
+  /** Chunks this hasher can verify at once (the pump's dispatch gate). */
+  readonly concurrency?: number | undefined;
+  readonly hashPart: (
+    payload: Uint8Array,
+    options: HashPartOptions,
+  ) => Effect.Effect<
+    HashPartResult,
+    HashError | PackFormatError | ObjectTooLargeError
+  >;
+  /**
+   * Applies a batch of deltas whose bases the caller supplies (DESIGN
+   * §22.13): the cross-chunk and thin deltas the scan left unresolved.
+   */
+  readonly resolveDeltas: (
+    bases: ReadonlyArray<DeltaBase>,
+    jobs: ReadonlyArray<DeltaJob>,
+    options: { readonly maxObjectSize: number },
+  ) => Effect.Effect<
+    Array<DeltaResolved>,
+    HashError | PackFormatError | ObjectTooLargeError
+  >;
+  /**
+   * The parallel half (DESIGN §22.8): hash entries whose spans the caller
+   * already found with `scanBounds`. Parts hashed this way have no chain
+   * between them.
+   */
+  readonly hashBoundsPart: (
+    payload: Uint8Array,
+    bounds: ReadonlyArray<EntryBounds>,
+    options: { readonly base: number; readonly maxObjectSize: number },
+  ) => Effect.Effect<
+    ScanResult,
+    HashError | PackFormatError | ObjectTooLargeError
+  >;
+}
+
+export class Hasher extends Context.Service<Hasher, HasherShape>()(
+  "alchemy/Git/Hasher",
+) {}
+
+/** The in-process hasher: scans here; a requested spill part goes to `blobs`. */
+export const makeInlineHasher = (blobs: BlobStoreShape): HasherShape => ({
+  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.Layer<Hasher, never, BlobStore> = 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.Effect<
+  Effect.Effect<Redacted.Redacted<string>>
+> = 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";
+
+// ── self-binding layer ──────────────────────────────────────────────────────
+
+interface SelfFetcher {
+  readonly fetch: (input: string, init?: RequestInit) => Promise<Response>;
+}
+
+/**
+ * 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.Layer<
+  Hasher,
+  never,
+  WorkerEnvironment | BlobStore
+> = Layer.effect(
+  Hasher,
+  Effect.gen(function* () {
+    const env = yield* WorkerEnvironment;
+    const blobs = yield* BlobStore;
+    const fetcher = (env as Record<string, unknown>)[HASHER_BINDING] as
+      | SelfFetcher
+      | undefined;
+    if (fetcher === undefined) {
+      return makeInlineHasher(blobs);
+    }
+    const secret = yield* InternalSecret;
+    const send = (url: string, body: Uint8Array) =>
+      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 as unknown as BodyInit,
+            }),
+          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: string, body: Uint8Array) =>
+      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)) as UploadedPart,
+                  ),
+            ),
+          );
+          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);
+        }),
+    };
+  }),
+);

package/src/Git/Hasher/Lambda.ts

@@ -0,0 +1,126 @@
+/**
+ * `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.ts";
+import type { Function as LambdaFunction } from "../../AWS/Lambda/Function.ts";
+import {
+  hashBounds,
+  resolveDeltas,
+  scanPart,
+} from "../Protocol/PartialScan.ts";
+import { Hasher, HashError, type HasherShape } from "./Hasher.ts";
+import {
+  decodeHashResponse,
+  encodeHashEvent,
+  LAMBDA_CHUNK_BYTES,
+  type HashResponse,
+} from "./LambdaEvent.ts";
+
+export const HasherLambda = (
+  fn: LambdaFunction | Effect.Effect<LambdaFunction, any, any>,
+): Layer.Layer<Hasher, never, InvokeFunction> =>
+  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 as Effect.Effect<LambdaFunction>
+        : fn;
+      const invoke = yield* InvokeFunction(func);
+      const remote = (
+        payload: Uint8Array,
+        options: Parameters<HasherShape["hashPart"]>[1],
+      ) =>
+        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) as HashResponse,
+            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),
+      } satisfies HasherShape;
+    }),
+  );
+
+const concat = (chunks: ReadonlyArray<Uint8Array>): Uint8Array => {
+  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;
+};

package/src/Git/Hasher/LambdaEvent.ts

@@ -0,0 +1,149 @@
+/**
+ * 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,
+  type HashPartOptions,
+} from "./Hasher.ts";
+import {
+  scanPart,
+  type ScanResult,
+  type UnresolvedDelta,
+} from "../Protocol/PartialScan.ts";
+
+/** 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 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 const isHashEvent = (event: unknown): event is HashEvent =>
+  typeof event === "object" &&
+  event !== null &&
+  (event as { alchemyGitHash?: unknown }).alchemyGitHash === 1 &&
+  typeof (event as { payload?: unknown }).payload === "string";
+
+export const encodeHashEvent = (
+  payload: Uint8Array,
+  options: HashPartOptions,
+): HashEvent => ({
+  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: Uint8Array): string =>
+  typeof Buffer !== "undefined"
+    ? Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString(
+        "base64",
+      )
+    : btoa(String.fromCharCode(...bytes));
+
+export const fromBase64 = (text: string): Uint8Array =>
+  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: ScanResult, budget: number): ScanResult => {
+  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<number>();
+  const unresolved: Array<UnresolvedDelta> = [...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: HashEvent,
+): Effect.Effect<HashResponse> =>
+  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: HashResponse,
+): Effect.Effect<ScanResult, HashError> =>
+  "error" in response
+    ? Effect.fail(new HashError({ reason: `lambda hasher: ${response.error}` }))
+    : Effect.succeed(decodeScanResult(fromBase64(response.scan)));

package/src/Git/Hasher/LambdaFunction.ts

@@ -0,0 +1,46 @@
+/**
+ * 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.ts";
+import { handleHashEvent, isHashEvent } from "./LambdaEvent.ts";
+
+export default class HasherFunction extends Lambda.Function<HasherFunction>()(
+  "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: unknown) =>
+      isHashEvent(event) ? handleHashEvent(event) : undefined,
+    );
+    return {};
+  }),
+) {}