@replayio-app-building/netlify-recorder 0.9.0 → 0.11.0

package/README.md

@@ -46,7 +46,9 @@ const repositoryUrl = execSync("git remote get-url origin", { encoding: "utf-8"
 
 ### 2. Wrap your Netlify function
 
-Use `createRecordingRequestHandler` with `remoteCallbacks()` to wrap your handler with automatic request capture:
+Use `createRecordingRequestHandler` with `remoteCallbacks()` to wrap your handler with automatic request capture.
+
+**v1 handler** (Netlify Functions v1 — `event` with `httpMethod`, `path`, etc.):
 
 ```typescript
 import {
@@ -75,8 +77,39 @@ const handler = createRecordingRequestHandler(
 export { handler };
 ```
 
+**v2 handler** (Netlify Functions v2 — Web API `Request`):
+
+```typescript
+import {
+  createRecordingRequestHandler,
+  remoteCallbacks,
+} from "@replayio-app-building/netlify-recorder";
+
+const RECORDER_URL = "https://netlify-recorder-bm4wmw.netlify.app";
+
+// The wrapper reads the body from a clone — you can still read req.json() etc.
+export default createRecordingRequestHandler(
+  async (req) => {
+    const body = await (req as Request).json();
+    const result = await myBusinessLogic(body);
+
+    return {
+      statusCode: 200,
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(result),
+    };
+  },
+  {
+    callbacks: remoteCallbacks(RECORDER_URL),
+    handlerPath: "netlify/functions/my-handler",
+  }
+);
+```
+
 `createRecordingRequestHandler` automatically captures all outbound network calls and environment variable reads during your handler's execution, then sends the captured data to the Netlify Recorder service. The response includes an `X-Replay-Request-Id` header with the request ID managed by the service.
 
+> **Note:** Always use the response returned by the wrapper (or `finishRequest`), not your original response object. The wrapper adds the `X-Replay-Request-Id` header to the response it returns.
+
 ### 2. Create recordings
 
 When you want to turn a captured request into a Replay recording, POST to the service's `create-recording` endpoint with the request ID:
@@ -204,7 +237,6 @@ const handler: Handler = async (event) => {
 
   const recordingId = await ensureRequestRecording(requestId, {
     repositoryUrl: process.env.APP_REPOSITORY_URL!,
-    replayApiKey: process.env.RECORD_REPLAY_API_KEY!,
     lookupRequest: async (id) => {
       const [row] = await sql`
         SELECT blob_url, commit_sha, branch_name, handler_path
@@ -279,6 +311,10 @@ Self-hosted recording requires these environment variables:
 
 Wraps a Netlify handler function with automatic request recording. This is the recommended way to integrate — it handles `startRequest`/`finishRequest` and error cleanup internally.
 
+**Response timing:** When the Netlify Functions v2 `context` object is available (with `waitUntil`), the response is returned to the client **immediately** with a pre-generated `X-Replay-Request-Id` header. The blob upload and metadata storage continue in the background via `context.waitUntil()`, adding zero latency to the client response.
+
+When `context.waitUntil` is not available (v1 handlers or missing context), the wrapper falls back to awaiting `finishRequest` before returning.
+
 **Parameters:**
 - `handler` — Your async handler function `(event, context?) => Promise<{ statusCode, headers?, body? }>`
 - `options.callbacks` — Either `remoteCallbacks(serviceUrl)` or custom `{ uploadBlob, storeRequestData }` callbacks
@@ -289,12 +325,18 @@ Wraps a Netlify handler function with automatic request recording. This is the r
 
 **Returns:** A wrapped handler function with the same signature.
 
+**Callbacks note:** When using the `waitUntil` flow, `storeRequestData` receives a `requestId` field in its data parameter. Callbacks should use this as the row ID so the stored record matches the ID already sent to the client.
+
 ### `startRequest(event): RequestContext`
 
 Lower-level API. Begins capturing a Netlify handler execution. Patches `globalThis.fetch` and `process.env` to record all outbound network calls and environment variable reads. Use this with `finishRequest` when you need more control than `createRecordingRequestHandler` provides.
 
+Accepts either a **v1** `NetlifyEvent` (has `httpMethod`) or a **v2** Web API `Request` (has `method` + `url`). The version is detected automatically.
+
+For v2 Request inputs, the body is read from a **clone** — the original request body remains consumable by your handler.
+
 **Parameters:**
-- `event` — The Netlify handler event object (passed directly)
+- `event` — A v1 `NetlifyEvent` or v2 `Request` object (passed directly — no need to clone)
 
 **Returns:** A `RequestContext` object to pass to `finishRequest`.
 
@@ -302,6 +344,10 @@ Lower-level API. Begins capturing a Netlify handler execution. Patches `globalTh
 
 Lower-level API. Finalizes the request capture. Restores original `fetch` and `process.env`, serializes the captured data, uploads it via the callbacks, and returns the response with `X-Replay-Request-Id` header set.
 
+**Important:** You must send the returned response to the client — it contains the `X-Replay-Request-Id` header.
+
+Logs a `console.warn` when the total duration exceeds 2 seconds or when individual callback steps (upload, store) exceed 1 second, to help diagnose slow operations.
+
 **Requires** the following environment variables (or equivalent options overrides): `COMMIT_SHA`, `BRANCH_NAME`, `REPLAY_REPOSITORY_URL`. Throws if any are missing.
 
 **Parameters:**
@@ -312,6 +358,7 @@ Lower-level API. Finalizes the request capture. Restores original `fetch` and `p
 - `options.commitSha` — Override `COMMIT_SHA` env var
 - `options.branchName` — Override `BRANCH_NAME` env var
 - `options.repositoryUrl` — Override `REPLAY_REPOSITORY_URL` env var
+- `options.requestId` — Pre-generated request ID (used by `createRecordingRequestHandler` in the `waitUntil` flow)
 
 ### `remoteCallbacks(serviceUrl): FinishRequestCallbacks`
 
@@ -327,7 +374,6 @@ Spawns a container via `@replayio/app-building` to create a Replay recording fro
 **Parameters:**
 - `requestId` — The request to create a recording for
 - `options.repositoryUrl` — Git repository URL for the container to clone
-- `options.replayApiKey` — Replay API key for recording upload
 - `options.lookupRequest(id)` — Fetches `{ blobUrl, commitSha, branchName, handlerPath }` from the database
 - `options.updateStatus(id, status, recordingId?)` — Updates the request status in the database
 

package/dist/index.d.ts

@@ -28,6 +28,27 @@ interface NetlifyEvent {
     rawQuery?: string;
     isBase64Encoded?: boolean;
 }
+/**
+ * Minimal interface for a Netlify Functions v2 Web API Request.
+ *
+ * This is a subset of the standard `Request` interface — only the properties
+ * that `startRequest` actually reads are required. Any spec-compliant
+ * `Request` object (including `new Request(...)`) satisfies this interface.
+ *
+ * `startRequest` reads the body from a **clone**, so the original request
+ * remains consumable by your handler. You do **not** need to clone the
+ * request before passing it in.
+ */
+interface NetlifyV2Request {
+    readonly method: string;
+    readonly url: string;
+    readonly headers: Headers | {
+        forEach(cb: (value: string, key: string) => void): void;
+    };
+    readonly body: ReadableStream<Uint8Array> | null;
+    clone(): NetlifyV2Request;
+    text(): Promise<string>;
+}
 interface RequestContext {
     requestInfo: RequestInfo;
     capturedData: CapturedData;
@@ -74,13 +95,22 @@ interface BlobData {
 interface FinishRequestCallbacks {
     /** Uploads serialized captured data and returns the blob URL. */
     uploadBlob: (data: string) => Promise<string>;
-    /** Stores request metadata in the database and returns the request ID. */
+    /**
+     * Stores request metadata in the database and returns the request ID.
+     *
+     * When `requestId` is provided (from `createRecordingRequestHandler`'s
+     * `waitUntil` flow), the callback should use it as the row ID so the
+     * client-facing header and the stored record match.  When omitted, the
+     * callback generates its own ID (backward-compatible).
+     */
     storeRequestData: (data: {
         blobUrl: string;
         commitSha: string;
         branchName: string;
         repositoryUrl: string;
         handlerPath: string;
+        /** Pre-generated request ID. Use as the row ID when provided. */
+        requestId?: string;
     }) => Promise<string>;
 }
 /**
@@ -105,7 +135,6 @@ interface ContainerInfraConfig {
 }
 interface EnsureRecordingOptions {
     repositoryUrl: string;
-    replayApiKey: string;
     /** Infrastructure credentials for starting the recording container. */
     infraConfig?: ContainerInfraConfig;
     /** Webhook URL the container can POST log entries to (optional). */
@@ -125,18 +154,46 @@ interface EnsureRecordingOptions {
 
 /**
  * Called at the beginning of a Netlify handler execution.
- * Accepts either a Netlify Functions v1 event (HandlerEvent with httpMethod,
- * path, etc.) or a v2 Web API Request.  Extracts all request metadata
- * internally, installs interceptors on globalThis.fetch and process.env to
- * capture outbound network calls and environment variable reads, and returns
- * a request context used by finishRequest.
  *
- * When running inside createRequestRecording (replay mode), the replay
+ * Accepts either a **Netlify Functions v1** event (`NetlifyEvent` — has
+ * `httpMethod`, `path`, etc.) or a **v2 Web API `Request`** object
+ * (`NetlifyV2Request`).  The version is detected automatically: v1 events
+ * have an `httpMethod` property while v2 Request objects have `method` +
+ * `url`.
+ *
+ * **v2 body handling:** For v2 Request inputs the body is read from a
+ * **clone** of the request, so the original `Request` body remains
+ * consumable by your handler. You do **not** need to call `req.clone()`
+ * before passing it in. The body text is resolved asynchronously and
+ * captured when `finishRequest` is called.
+ *
+ * Installs interceptors on `globalThis.fetch` and `process.env` to capture
+ * outbound network calls and environment variable reads, and returns a
+ * request context that must be passed to `finishRequest`.
+ *
+ * When running inside `createRequestRecording` (replay mode), the replay
  * interceptors are already installed.  In that case we skip installing
- * capture interceptors to avoid overwriting the replay layer (which would
- * also crash on Node v16 where Headers/Response don't exist).
+ * capture interceptors to avoid overwriting the replay layer.
+ *
+ * @example
+ * ```typescript
+ * // v1 handler
+ * export async function handler(event: NetlifyEvent) {
+ *   const ctx = startRequest(event);
+ *   // ... your logic ...
+ *   return finishRequest(ctx, callbacks, response);
+ * }
+ *
+ * // v2 handler — no need to clone the request
+ * export default async function handler(req: Request) {
+ *   const ctx = startRequest(req);
+ *   const body = await req.json(); // still works — body was NOT consumed
+ *   // ... your logic ...
+ *   return finishRequest(ctx, callbacks, response);
+ * }
+ * ```
  */
-declare function startRequest(event: NetlifyEvent | /* v2 Request */ Record<string, unknown>): RequestContext;
+declare function startRequest(event: NetlifyEvent | NetlifyV2Request): RequestContext;
 
 interface FullHandlerResponse {
     statusCode: number;
@@ -151,12 +208,29 @@ interface FinishRequestOptions {
     branchName?: string;
     /** Override REPLAY_REPOSITORY_URL env var. */
     repositoryUrl?: string;
+    /**
+     * Pre-generated request ID. When provided, this ID is passed to the
+     * `storeRequestData` callback so the stored row matches the ID already
+     * sent to the client in the `X-Replay-Request-Id` header.
+     *
+     * Used by `createRecordingRequestHandler` in the `waitUntil` flow where
+     * the response is returned before `finishRequest` runs.
+     */
+    requestId?: string;
 }
 /**
  * Called at the end of the handler execution.
  * Restores original globals, serializes all captured data,
  * uploads it as a JSON blob via the provided callback,
  * stores the request metadata, and sets the X-Replay-Request-Id header.
+ *
+ * **Important:** The returned response includes the `X-Replay-Request-Id`
+ * header. You must send the returned response to the client — not the
+ * original response object you passed in.
+ *
+ * Logs a warning to `console.warn` when the total finishRequest time or
+ * individual callback steps exceed their thresholds, to help diagnose
+ * slow blob uploads or database writes.
  */
 declare function finishRequest(requestContext: RequestContext, callbacks: FinishRequestCallbacks, response: FullHandlerResponse, options?: FinishRequestOptions): Promise<FullHandlerResponse>;
 
@@ -175,13 +249,25 @@ interface CreateRecordingRequestHandlerOptions extends FinishRequestOptions {
  * after, capturing all outbound network calls and environment variable reads.
  * On error, interceptors are cleaned up and the error is re-thrown.
  *
- * @example
+ * **Response timing:** When the Netlify Functions v2 `context` object is
+ * available (with `waitUntil`), the response is returned to the client
+ * **immediately** with a pre-generated `X-Replay-Request-Id` header. The
+ * blob upload and metadata storage continue in the background via
+ * `context.waitUntil()`. This avoids adding latency to the client response.
+ *
+ * When `context.waitUntil` is not available (v1 handlers or missing context),
+ * the wrapper falls back to awaiting `finishRequest` before returning.
+ *
+ * For v2 handlers the request body is read from a clone internally — your
+ * handler still receives the original request with an unconsumed body.
+ *
+ * @example v1 handler (NetlifyEvent)
  * ```typescript
  * import { createRecordingRequestHandler, remoteCallbacks } from "@replayio-app-building/netlify-recorder";
  *
  * const handler = createRecordingRequestHandler(
  *   async (event) => {
- *     const result = await myBusinessLogic();
+ *     const result = await myBusinessLogic(event.body);
  *     return {
  *       statusCode: 200,
  *       headers: { "Content-Type": "application/json" },
@@ -196,8 +282,30 @@ interface CreateRecordingRequestHandlerOptions extends FinishRequestOptions {
  *
  * export { handler };
  * ```
+ *
+ * @example v2 handler (Web API Request)
+ * ```typescript
+ * import { createRecordingRequestHandler, remoteCallbacks } from "@replayio-app-building/netlify-recorder";
+ *
+ * export default createRecordingRequestHandler(
+ *   async (req) => {
+ *     // Body is still available — startRequest reads from a clone
+ *     const body = await (req as Request).json();
+ *     const result = await myBusinessLogic(body);
+ *     return {
+ *       statusCode: 200,
+ *       headers: { "Content-Type": "application/json" },
+ *       body: JSON.stringify(result),
+ *     };
+ *   },
+ *   {
+ *     callbacks: remoteCallbacks("https://netlify-recorder-bm4wmw.netlify.app"),
+ *     handlerPath: "netlify/functions/my-handler",
+ *   }
+ * );
+ * ```
  */
-declare function createRecordingRequestHandler(handler: (event: NetlifyEvent | Record<string, unknown>, context?: unknown) => Promise<HandlerResponse>, options: CreateRecordingRequestHandlerOptions): (event: NetlifyEvent | Record<string, unknown>, context?: unknown) => Promise<HandlerResponse>;
+declare function createRecordingRequestHandler(handler: (event: NetlifyEvent | NetlifyV2Request, context?: unknown) => Promise<HandlerResponse>, options: CreateRecordingRequestHandlerOptions): (event: NetlifyEvent | NetlifyV2Request, context?: unknown) => Promise<HandlerResponse>;
 
 /**
  * Creates `FinishRequestCallbacks` that send captured data to a remote
@@ -294,8 +402,6 @@ interface SpawnRecordingContainerOptions {
     branchName: string;
     /** Git repository URL for the app. */
     repositoryUrl: string;
-    /** Replay API key for uploading recordings. */
-    replayApiKey: string;
     /** Infrastructure credentials for Fly.io + Infisical. */
     infraConfig: ContainerInfraConfig;
     /** Optional webhook URL the container can POST log events to. */
@@ -315,4 +421,4 @@ interface SpawnRecordingContainerOptions {
  */
 declare function spawnRecordingContainer(options: SpawnRecordingContainerOptions): Promise<string>;
 
-export { type BlobData, type CapturedData, type ContainerInfraConfig, type CreateRecordingRequestHandlerOptions, type EnsureRecordingOptions, type EnvRead, type FinishRequestCallbacks, type FinishRequestOptions, type HandlerResponse$1 as HandlerResponse, type NetlifyEvent, type NetworkCall, type RecordingResult, type RequestContext, type RequestInfo, type SpawnRecordingContainerOptions, createRecordingRequestHandler, createRequestRecording, ensureRequestRecording, finishRequest, readInfraConfigFromEnv, redactBlobData, remoteCallbacks, spawnRecordingContainer, startRequest };
+export { type BlobData, type CapturedData, type ContainerInfraConfig, type CreateRecordingRequestHandlerOptions, type EnsureRecordingOptions, type EnvRead, type FinishRequestCallbacks, type FinishRequestOptions, type HandlerResponse$1 as HandlerResponse, type NetlifyEvent, type NetlifyV2Request, type NetworkCall, type RecordingResult, type RequestContext, type RequestInfo, type SpawnRecordingContainerOptions, createRecordingRequestHandler, createRequestRecording, ensureRequestRecording, finishRequest, readInfraConfigFromEnv, redactBlobData, remoteCallbacks, spawnRecordingContainer, startRequest };

package/dist/index.js

@@ -8,7 +8,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 // src/interceptors/network.ts
 function installNetworkInterceptor(mode, calls) {
   const originalFetch = globalThis.fetch;
-  let replayCallIndex = 0;
+  const consumed = /* @__PURE__ */ new Set();
   if (mode === "capture") {
     const captureFetch = async (input, init) => {
       const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
@@ -40,16 +40,35 @@ function installNetworkInterceptor(mode, calls) {
     };
     globalThis.fetch = captureFetch;
   } else {
-    const replayFetch = async () => {
-      const idx = replayCallIndex++;
-      const call = calls[idx];
-      if (!call) {
+    const replayFetch = async (input, init) => {
+      const url = typeof input === "string" ? input : input instanceof URL ? input.href : typeof input === "object" && input !== null && "url" in input ? input.url : String(input);
+      const requestBody = typeof init?.body === "string" ? init.body : void 0;
+      let matchIdx = -1;
+      for (let i = 0; i < calls.length; i++) {
+        if (consumed.has(i)) continue;
+        const c = calls[i];
+        if (c && c.url === url && c.requestBody === requestBody) {
+          matchIdx = i;
+          break;
+        }
+      }
+      if (matchIdx === -1) {
+        for (let i = 0; i < calls.length; i++) {
+          if (!consumed.has(i)) {
+            matchIdx = i;
+            break;
+          }
+        }
+      }
+      const call = calls[matchIdx];
+      if (matchIdx === -1 || !call) {
         throw new Error(
           `No more recorded network calls to replay (exhausted ${calls.length} calls)`
         );
       }
+      consumed.add(matchIdx);
       console.log(
-        `  [network-replay] Consumed call ${idx + 1}/${calls.length}: ${call.method} ${call.url} => ${call.responseStatus}`
+        `  [network-replay] Consumed call ${consumed.size}/${calls.length}: ${call.method} ${call.url} => ${call.responseStatus}`
       );
       const body = call.responseBody ?? "";
       const status = call.responseStatus;
@@ -88,10 +107,17 @@ function installNetworkInterceptor(mode, calls) {
       globalThis.fetch = originalFetch;
     },
     consumedCount() {
-      return replayCallIndex;
+      return consumed.size;
     },
     totalCount() {
       return calls.length;
+    },
+    unconsumedIndices() {
+      const indices = [];
+      for (let i = 0; i < calls.length; i++) {
+        if (!consumed.has(i)) indices.push(i);
+      }
+      return indices;
     }
   };
 }
@@ -367,7 +393,10 @@ function redactBlobData(blobData) {
 }
 
 // src/finishRequest.ts
+var SLOW_THRESHOLD_MS = 2e3;
+var SLOW_STEP_THRESHOLD_MS = 1e3;
 async function finishRequest(requestContext, callbacks, response, options) {
+  const finishStart = Date.now();
   requestContext.cleanup();
   if (globalThis.__REPLAY_RECORDING_MODE__ === true) {
     return response;
@@ -387,6 +416,7 @@ async function finishRequest(requestContext, callbacks, response, options) {
   const commitSha = rawCommitSha;
   const branchName = rawBranchName;
   const repositoryUrl = rawRepositoryUrl;
+  const handlerPath = options?.handlerPath ?? "unknown";
   if (requestContext._v2BodyPromise && !requestContext.requestInfo.body) {
     try {
       const bodyText = await requestContext._v2BodyPromise;
@@ -409,14 +439,35 @@ async function finishRequest(requestContext, callbacks, response, options) {
   };
   const blobData = redactBlobData(rawBlobData);
   const blobContent = JSON.stringify(blobData);
+  const uploadStart = Date.now();
   const blobUrl = await callbacks.uploadBlob(blobContent);
+  const uploadDuration = Date.now() - uploadStart;
+  if (uploadDuration > SLOW_STEP_THRESHOLD_MS) {
+    console.warn(
+      `netlify-recorder: uploadBlob took ${uploadDuration}ms (handler: ${handlerPath})`
+    );
+  }
+  const storeStart = Date.now();
   const storedRequestId = await callbacks.storeRequestData({
     blobUrl,
     commitSha,
     branchName,
     repositoryUrl,
-    handlerPath: options?.handlerPath ?? "unknown"
+    handlerPath,
+    requestId: options?.requestId
   });
+  const storeDuration = Date.now() - storeStart;
+  if (storeDuration > SLOW_STEP_THRESHOLD_MS) {
+    console.warn(
+      `netlify-recorder: storeRequestData took ${storeDuration}ms (handler: ${handlerPath})`
+    );
+  }
+  const totalDuration = Date.now() - finishStart;
+  if (totalDuration > SLOW_THRESHOLD_MS) {
+    console.warn(
+      `netlify-recorder: finishRequest took ${totalDuration}ms total (upload: ${uploadDuration}ms, store: ${storeDuration}ms, handler: ${handlerPath})`
+    );
+  }
   return {
     ...response,
     headers: {
@@ -427,16 +478,43 @@ async function finishRequest(requestContext, callbacks, response, options) {
 }
 
 // src/createRecordingRequestHandler.ts
+import crypto from "crypto";
 function createRecordingRequestHandler(handler, options) {
   return async (event, context) => {
     const reqContext = startRequest(event);
+    let response;
     try {
-      const response = await handler(event, context);
-      return await finishRequest(reqContext, options.callbacks, response, options);
+      response = await handler(event, context);
     } catch (err) {
       reqContext.cleanup();
       throw err;
     }
+    reqContext.cleanup();
+    const requestId = crypto.randomUUID();
+    const responseWithHeader = {
+      ...response,
+      headers: {
+        ...response.headers,
+        "X-Replay-Request-Id": requestId
+      }
+    };
+    const finishOpts = { ...options, requestId };
+    const ctx = context;
+    if (ctx && typeof ctx.waitUntil === "function") {
+      ctx.waitUntil(
+        finishRequest(reqContext, options.callbacks, response, finishOpts).catch(
+          (err) => {
+            console.error(
+              `netlify-recorder: background finishRequest failed (handler: ${options.handlerPath ?? "unknown"})`,
+              err
+            );
+          }
+        )
+      );
+      return responseWithHeader;
+    }
+    await finishRequest(reqContext, options.callbacks, response, finishOpts);
+    return responseWithHeader;
   };
 }
 
@@ -467,7 +545,8 @@ function remoteCallbacks(serviceUrl) {
             handlerPath: metadata.handlerPath,
             commitSha: metadata.commitSha,
             branchName: metadata.branchName,
-            repositoryUrl: metadata.repositoryUrl
+            repositoryUrl: metadata.repositoryUrl,
+            requestId: metadata.requestId
           })
         }
       );
@@ -491,7 +570,6 @@ async function spawnRecordingContainer(options) {
     commitSha,
     branchName,
     repositoryUrl,
-    replayApiKey,
     infraConfig,
     logWebhookUrl,
     onLog
@@ -581,7 +659,7 @@ async function spawnRecordingContainer(options) {
     `DB operations that were not in the original blob. Do NOT try to fix these.`,
     ``,
     `=== Step 6: Upload the recording ===`,
-    `RECORD_REPLAY_API_KEY=${replayApiKey} npx replayio upload --all 2>&1`,
+    `exec-secrets RECORD_REPLAY_API_KEY -- npx replayio upload --all 2>&1`,
     ``,
     `Find the recording ID (UUID) in the upload output and print:`,
     `  recording: <recording-id>`,
@@ -647,7 +725,7 @@ async function spawnRecordingContainer(options) {
 
 // src/ensureRequestRecording.ts
 async function ensureRequestRecording(requestId, options) {
-  const { repositoryUrl, replayApiKey, infraConfig, webhookUrl, lookupRequest, updateStatus, onLog } = options;
+  const { repositoryUrl, infraConfig, webhookUrl, lookupRequest, updateStatus, onLog } = options;
   const emit = async (level, message) => {
     if (onLog) {
       try {
@@ -672,7 +750,6 @@ async function ensureRequestRecording(requestId, options) {
       commitSha: requestData.commitSha,
       branchName: requestData.branchName,
       repositoryUrl,
-      replayApiKey,
       infraConfig,
       logWebhookUrl: webhookUrl,
       onLog
@@ -855,6 +932,12 @@ async function createRequestRecording(blobUrlOrData, handlerPath, requestInfo) {
         this.headers = new H(init?.headers);
         this.ok = this.status >= 200 && this.status < 300;
       }
+      static json(data, init) {
+        const body = JSON.stringify(data);
+        const headers = init?.headers ?? {};
+        headers["content-type"] = "application/json";
+        return new ResponseShim(body, { ...init, headers });
+      }
       async text() {
         return this._body ?? "";
       }
@@ -978,17 +1061,18 @@ async function createRequestRecording(blobUrlOrData, handlerPath, requestInfo) {
       }
     }
   } finally {
-    const consumed = networkHandle.consumedCount();
+    const consumedCount = networkHandle.consumedCount();
     const total = networkHandle.totalCount();
-    if (consumed < total) {
+    if (consumedCount < total) {
       result.unconsumedNetworkCalls = true;
+      const unconsumed = networkHandle.unconsumedIndices();
       const details = [
-        `Consumed ${consumed} of ${total} calls. ${total - consumed} call(s) were never replayed.`
+        `Consumed ${consumedCount} of ${total} calls. ${unconsumed.length} call(s) were never replayed.`
       ];
       console.error(
-        `ERROR: Not all recorded network calls were consumed during replay. Consumed ${consumed} of ${total} calls. ${total - consumed} call(s) were never replayed.`
+        `ERROR: Not all recorded network calls were consumed during replay. Consumed ${consumedCount} of ${total} calls. ${unconsumed.length} call(s) were never replayed.`
       );
-      for (let i = consumed; i < total; i++) {
+      for (const i of unconsumed) {
         const call = blobData.capturedData.networkCalls[i];
         if (call) {
           details.push(`Unconsumed: ${call.method} ${call.url} => ${call.responseStatus}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@replayio-app-building/netlify-recorder",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "Capture and replay Netlify function executions as Replay recordings",
   "type": "module",
   "exports": {