@useairfoil/effect-vcr 0.0.1 → 0.3.0

package/README.md

@@ -0,0 +1,79 @@
+# @useairfoil/effect-vcr
+
+An HttpClient for Effect that records all HTTP interactions and stores them on tape, ready to be replayed for future test runs.
+
+The first time the following test is run, it sends the HTTP request to httpbin.org and stores the request/response pair to a cassette. All subsequent tests will replay the response from the cassette, making no HTTP requests.
+
+```ts
+// my-program.ts
+export const program = Effect.gen(function* () {
+  const client = yield* HttpClient.HttpClient;
+  const response = yield* client.get("https://httpbin.org");
+  return yield* response.text;
+});
+
+// my-program.test.ts
+import { VcrHttpClient, FileSystemCassetteStore } from "@useairfoil/effect-vcr";
+
+describe("my awesome program", () => {
+  it.effect("works", () =>
+    Effect.gen(function* () {
+      yield* program;
+    }),
+  ).pipe(
+    // Wrap the HttpClient with the VCR
+    Effect.provide(VcrHttpClient.layer()),
+    // Store cassettes on the file system
+    Effect.provide(FileSystemCassetteStore.layer()),
+    // HttpClient based on fetch
+    Effect.provide(FetchHttpClient.layer),
+    // Node is used to access the file system
+    Effect.provide(NodeServices.layer),
+  );
+});
+```
+
+The main use case for the VCR is to allow open source projects to run tests against a real API endpoint without exposing secrets to forks.
+
+- Project owners generate cassettes locally by interacting with the upstream API
+- External contributors run their tests using the cassettes
+- CI runs using cassettes
+- Optionally, CI runs against the upstream API periodically, to catch any schema drift
+
+## Usage
+
+Use the VCR by providing the VcrHttpClient and FileSystemCassetteStore layers to the Effect being tested.
+
+- VcrHttpClient: this HttpClient wraps another HttpClient, adding support for recording and replaying HTTP interactions.
+- FileSystemCassetteStore: stores cassettes on the file system.
+
+## Configuration and defaults
+
+### VcrHttpClient
+
+- `vcrName?: string`: the VCR name. Used to selectively disable VCRs during test runs (more on this in the runtime configuration section).
+- `cassetteName?: string`: the cassette name. If not set, defaults to the current vitest file name.
+- `mode: "record" | "replay" | "auto"`: controls the VCR behaviour. Defaults to `auto`.
+  - `record`: always call the live client and write a cassette.
+  - `replay`: only serve from cassette; missing entries fail.
+  - `auto`: replay if cassette exists, otherwise record. If `CI=true`, missing cassette fails.
+- `redact`: control which sensitive headers and JSON body keys to remove from requests and responses.
+  - `.requestHeaders?: string[]`: redact the specified request headers.
+  - `.responseHeaders?: string[]`: redact the specified response headers.
+  - `.requestBodyKeys?: string[]`: redact the specified request JSON keys.
+  - `.responseBodyKeys?: string[]`: redact the specified response JSON keys.
+- `matchIgnore`: control which fields are ignored when matching requests.
+  - `.requestHeaders?: string[]`: ignore the specified request headers.
+  - `.requestBodyKeys?: string[]`: ignore the specified request JSON keys.
+- `match: (request: VcrRequest, entry: VcrEntry) => boolean`: custom request to entry matcher.
+
+### FileSystemCassetteStore
+
+- `cassetteDir?: string`: change the location of the cassette. By default, the VCR stores cassettes in the `__cassettes__` folder next to the test.
+
+## Runtime configuration
+
+The VCR is controlled by the following environment variables:
+
+- `CI=true`: if set and the VCR mode is `auto`, tests with a missing cassette fail.
+- `ACK_DISABLE_VCR=<...>`: disable the VCR. If `'*'`, then all VCRs are disabled. To selectively disable VCRs, pass a comma separated list of VCRs to disable (based on their `vcrName` config). Use this to test against the upstream API. In this case, the cassettes are not updated.

package/dist/chunk-Bp6m_JJh.js

@@ -0,0 +1,13 @@
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __export = (all) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	return target;
+};
+
+//#endregion
+export { __export as t };

package/dist/index.d.ts

@@ -0,0 +1,150 @@
+import { Config, Context, Effect, FileSystem, Layer, Path, Schema } from "effect";
+import { HttpClient } from "effect/unstable/http";
+import * as effect_Cause0 from "effect/Cause";
+import * as effect_Layer0 from "effect/Layer";
+
+//#region src/types.d.ts
+/**
+ * VCR operating mode.
+ * - record: always call the live client and persist.
+ * - replay: serve only from cassette, fail if missing.
+ * - auto: replay if cassette exists, otherwise record (fail in CI).
+ */
+type VcrMode = "record" | "replay" | "auto";
+/**
+ * Serialized request shape stored in a cassette.
+ */
+type VcrRequest = {
+  readonly method: string;
+  readonly url: string;
+  readonly headers?: Record<string, string>;
+  readonly body?: string;
+};
+/**
+ * Serialized response shape stored in a cassette.
+ */
+type VcrResponse = {
+  readonly status: number;
+  readonly body: string;
+  readonly headers?: Record<string, string>;
+};
+/**
+ * A single request/response pair keyed in the cassette.
+ */
+type VcrEntry = {
+  readonly request: VcrRequest;
+  readonly response: VcrResponse;
+};
+/**
+ * Cassette file format.
+ */
+type Cassette = {
+  readonly meta: {
+    readonly createdAt: string;
+    readonly version: string;
+  };
+  readonly entries: Record<string, VcrEntry>;
+};
+/**
+ * Cassette file format with multiple exports.
+ */
+type CassetteFile = {
+  readonly exports: Record<string, Cassette>;
+};
+/**
+ * VCR configuration.
+ */
+type Configuration = {
+  readonly vcrName?: string;
+  readonly cassetteName?: string;
+  readonly mode?: VcrMode;
+  /**
+   * Remove sensitive data before writing to disk.
+   */
+  readonly redact?: {
+    readonly requestHeaders?: ReadonlyArray<string>;
+    readonly responseHeaders?: ReadonlyArray<string>;
+    readonly requestBodyKeys?: ReadonlyArray<string>;
+    readonly responseBodyKeys?: ReadonlyArray<string>;
+  };
+  /**
+   * Ignore fields when computing the request key for replay matching.
+   */
+  readonly matchIgnore?: {
+    readonly requestHeaders?: ReadonlyArray<string>;
+    readonly requestBodyKeys?: ReadonlyArray<string>;
+  };
+  /**
+   * Custom matcher to override key-based lookup.
+   */
+  readonly match?: (request: VcrRequest, entry: VcrEntry) => boolean;
+};
+declare namespace cassette_store_d_exports {
+  export { CassetteStore, CassetteStoreError, createEmptyCassette, createEmptyCassetteFile, make, parseCassette, toStoreError };
+}
+/**
+ * Storage contract for VCR cassettes.
+ *
+ */
+interface CassetteStore {
+  /** Returns true if a cassette with the given name exists. */
+  readonly exists: (name: string) => Effect.Effect<boolean, CassetteStoreError>;
+  /** Loads a cassette by name, returning a `CassetteFile` if found. */
+  readonly load: (name: string) => Effect.Effect<CassetteFile, CassetteStoreError>;
+  /** Saves a cassette by name, overwriting any existing cassette with the same name. */
+  readonly save: (name: string, content: CassetteFile) => Effect.Effect<void, CassetteStoreError>;
+  /** Loads a cassette by name, initializing a new empty cassette if not found. */
+  readonly loadOrInit: (name: string) => Effect.Effect<CassetteFile, CassetteStoreError>;
+}
+/**
+ * Effect service tag for the cassette store.
+ */
+declare const CassetteStore: Context.Service<CassetteStore, CassetteStore>;
+/**
+ * Creates a new empty cassette with a timestamp and format version.
+ */
+declare const createEmptyCassette: () => Effect.Effect<Cassette>;
+declare const createEmptyCassetteFile: () => Effect.Effect<CassetteFile>;
+declare const CassetteStoreError_base: Schema.Class<CassetteStoreError, Schema.TaggedStruct<"CassetteStoreError", {
+  readonly operation: Schema.String;
+  readonly path: Schema.String;
+  readonly message: Schema.optional<Schema.String>;
+  readonly cause: Schema.optional<Schema.Unknown>;
+}>, effect_Cause0.YieldableError>;
+/**
+ * Structured error for cassette persistence operations.
+ *
+ * `operation` indicates which store function failed.
+ * `path` is the file or directory path that was targeted.
+ */
+declare class CassetteStoreError extends CassetteStoreError_base {}
+declare const toStoreError: (operation: "exists" | "load" | "save" | "loadOrInit", path: string, cause?: unknown, message?: string) => CassetteStoreError;
+/**
+ * Parses cassette JSON and maps invalid JSON to a store error.
+ */
+declare const parseCassette: (content: string, path: string) => Effect.Effect<CassetteFile, CassetteStoreError, never>;
+/** Creates a `CassetteStore` implementation that uses the given `impl` object. */
+declare const make: (impl: CassetteStore) => CassetteStore;
+declare namespace file_system_cassette_store_d_exports {
+  export { layer$1 as layer };
+}
+/**
+ * FileSystem-backed cassette store.
+ *
+ * Requires a platform FileSystem layer (Node/Bun) to be provided by the user.
+ */
+declare const layer$1: ({
+  cassetteDir
+}?: {
+  cassetteDir?: string;
+}) => Layer.Layer<CassetteStore, Error, Path.Path | FileSystem.FileSystem>;
+declare namespace vcr_http_client_d_exports {
+  export { layer };
+}
+/**
+ * Layer that provides a VCR-wrapped HttpClient.
+ */
+declare const layer: (config?: Configuration) => effect_Layer0.Layer<HttpClient.HttpClient, Config.ConfigError, HttpClient.HttpClient | CassetteStore | Path.Path>;
+//#endregion
+export { cassette_store_d_exports as CassetteStore, file_system_cassette_store_d_exports as FileSystemCassetteStore, vcr_http_client_d_exports as VcrHttpClient };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,451 @@
+import { t as __export } from "./chunk-Bp6m_JJh.js";
+import { Config, Context, DateTime, Effect, FileSystem, Layer, Option, Path, Schema } from "effect";
+import { HttpClient, HttpClientError, HttpClientResponse } from "effect/unstable/http";
+import stableStringify from "json-stable-stringify";
+
+//#region src/cassette-store.ts
+var cassette_store_exports = /* @__PURE__ */ __export({
+	CassetteStore: () => CassetteStore,
+	CassetteStoreError: () => CassetteStoreError,
+	createEmptyCassette: () => createEmptyCassette,
+	createEmptyCassetteFile: () => createEmptyCassetteFile,
+	make: () => make,
+	parseCassette: () => parseCassette,
+	toStoreError: () => toStoreError
+});
+/**
+* Effect service tag for the cassette store.
+*/
+const CassetteStore = Context.Service("@useairfoil/effect-vcr/CassetteStore");
+/**
+* Creates a new empty cassette with a timestamp and format version.
+*/
+const createEmptyCassette = () => Effect.gen(function* () {
+	const now = yield* DateTime.now;
+	return {
+		meta: {
+			createdAt: DateTime.formatIso(now),
+			version: "1"
+		},
+		entries: {}
+	};
+});
+const createEmptyCassetteFile = () => Effect.map(createEmptyCassette(), (cassette) => ({ exports: { default: cassette } }));
+/**
+* Structured error for cassette persistence operations.
+*
+* `operation` indicates which store function failed.
+* `path` is the file or directory path that was targeted.
+*/
+var CassetteStoreError = class extends Schema.TaggedErrorClass()("CassetteStoreError", {
+	operation: Schema.String,
+	path: Schema.String,
+	message: Schema.optional(Schema.String),
+	cause: Schema.optional(Schema.Unknown)
+}) {};
+const toStoreError = (operation, path, cause, message) => new CassetteStoreError({
+	operation,
+	path,
+	cause,
+	message
+});
+/**
+* Parses cassette JSON and maps invalid JSON to a store error.
+*/
+const parseCassette = (content, path) => Effect.try({
+	try: () => JSON.parse(content),
+	catch: (error) => toStoreError("load", path, error, "Invalid JSON")
+}).pipe(Effect.flatMap((parsed) => {
+	if (!parsed || typeof parsed !== "object" || !("exports" in parsed)) return Effect.fail(toStoreError("load", path, void 0, "Invalid cassette file format"));
+	return Effect.succeed(parsed);
+}));
+/** Creates a `CassetteStore` implementation that uses the given `impl` object. */
+const make = (impl) => CassetteStore.of({ ...impl });
+
+//#endregion
+//#region src/vitest-state.ts
+const getVitestState = () => {
+	const expectGlobal = globalThis.expect;
+	const symbolExpect = globalThis[Symbol.for("expect-global")];
+	const state = expectGlobal?.getState?.() ?? symbolExpect?.getState?.();
+	return {
+		testPath: state?.testPath,
+		currentTestName: state?.currentTestName
+	};
+};
+
+//#endregion
+//#region src/file-system-cassette-store.ts
+var file_system_cassette_store_exports = /* @__PURE__ */ __export({ layer: () => layer$1 });
+/**
+* FileSystem-backed cassette store.
+*
+* Requires a platform FileSystem layer (Node/Bun) to be provided by the user.
+*/
+const layer$1 = ({ cassetteDir } = {}) => Layer.effect(CassetteStore)(Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	let rootDir;
+	if (cassetteDir) rootDir = cassetteDir;
+	else {
+		const { testPath } = getVitestState();
+		if (!testPath) return yield* Effect.fail(/* @__PURE__ */ new Error("vcr must be used within a vitest test"));
+		const testFolder = path.dirname(testPath);
+		rootDir = path.join(testFolder, "__cassettes__");
+	}
+	const fullPath = (name) => path.join(rootDir, name);
+	const load = (name) => fs.readFileString(fullPath(name)).pipe(Effect.mapError((error) => toStoreError("load", name, error)), Effect.flatMap((content) => parseCassette(content, name)));
+	const save = (name, cassette) => {
+		const filePath = fullPath(name);
+		const dir = path.dirname(filePath);
+		return (dir === "" ? Effect.void : fs.makeDirectory(dir, { recursive: true }).pipe(Effect.mapError((error) => toStoreError("save", dir, error)))).pipe(Effect.andThen(fs.writeFileString(filePath, JSON.stringify(cassette, null, 2)).pipe(Effect.mapError((error) => toStoreError("save", name, error)))));
+	};
+	const loadOrInit = (name) => fs.exists(fullPath(name)).pipe(Effect.mapError((error) => toStoreError("loadOrInit", name, error)), Effect.flatMap((exists) => exists ? load(name) : createEmptyCassetteFile().pipe(Effect.tap((cassette) => save(name, cassette)))));
+	return make({
+		exists: (name) => fs.exists(fullPath(name)).pipe(Effect.mapError((error) => toStoreError("exists", name, error))),
+		load,
+		save,
+		loadOrInit
+	});
+}));
+
+//#endregion
+//#region src/sanitize.ts
+/**
+* Normalize header names to match HttpClient's lowercase behavior.
+*/
+const normalizeHeaderKey = (key) => key.toLowerCase();
+/**
+* Canonicalize headers: lowercase keys and stable ordering.
+*/
+const toHeaderRecord = (headers) => {
+	if (!headers) return void 0;
+	const entries = Object.entries(headers).map(([key, value]) => [normalizeHeaderKey(key), value]);
+	entries.sort(([a], [b]) => a.localeCompare(b));
+	const record$1 = {};
+	for (const [key, value] of entries) record$1[key] = value;
+	return record$1;
+};
+/**
+* Remove specified header names (case-insensitive).
+*/
+const omitHeaderKeys = (headers, ignore) => {
+	if (!headers) return Option.none();
+	if (!ignore || ignore.length === 0) return Option.some(headers);
+	const ignoreSet = new Set(ignore.map(normalizeHeaderKey));
+	const filtered = {};
+	for (const [key, value] of Object.entries(headers)) if (!ignoreSet.has(normalizeHeaderKey(key))) filtered[key] = value;
+	return Option.some(filtered);
+};
+/**
+* Best-effort JSON parse; returns undefined for non-JSON bodies.
+*/
+const tryParseJson = Option.liftThrowable((input) => JSON.parse(input));
+/**
+* Recursively drop keys from JSON objects to build stable request keys.
+*/
+const stripKeys = (value, ignore) => {
+	if (Array.isArray(value)) return value.map((item) => stripKeys(item, ignore));
+	if (value && typeof value === "object") {
+		const record$1 = value;
+		const next = {};
+		for (const [key, entry] of Object.entries(record$1)) if (!ignore.has(key)) next[key] = stripKeys(entry, ignore);
+		return next;
+	}
+	return value;
+};
+/**
+* Remove JSON keys from a string body when possible.
+*/
+const omitBodyKeys = (body, ignore) => {
+	if (!body) return Option.none();
+	return Option.some(tryParseJson(body).pipe(Option.match({
+		onNone: () => body,
+		onSome: (parsed) => {
+			if (!ignore || ignore.length === 0) return stableStringify(parsed) ?? body;
+			return stableStringify(stripKeys(parsed, new Set(ignore))) ?? body;
+		}
+	})));
+};
+/**
+* Normalize request for matching: header canonicalization + JSON body filtering.
+*/
+const sanitizeRequest = (request, options) => {
+	const filteredHeaders = omitHeaderKeys(request.headers, options.ignoreHeaders);
+	return {
+		...request,
+		headers: toHeaderRecord(Option.getOrUndefined(filteredHeaders)),
+		body: Option.getOrUndefined(omitBodyKeys(request.body, options.ignoreBodyKeys))
+	};
+};
+/**
+* Compute the stable request key used for cassette lookups.
+*/
+const buildRequestKey = (request, options) => Effect.sync(() => {
+	const sanitized = sanitizeRequest(request, {
+		ignoreHeaders: options.ignoreHeaders,
+		ignoreBodyKeys: options.ignoreBodyKeys
+	});
+	const key = stableStringify({
+		method: sanitized.method.toUpperCase(),
+		url: sanitized.url,
+		headers: sanitized.headers ?? {},
+		body: sanitized.body ?? ""
+	});
+	if (!key) throw new Error("Failed to build VCR request key");
+	return key;
+});
+/**
+* Remove sensitive request data before persisting to a cassette.
+*/
+const redactRequest = (request, options) => ({
+	...request,
+	headers: Option.getOrUndefined(omitHeaderKeys(request.headers, options.redactHeaders)),
+	body: Option.getOrUndefined(omitBodyKeys(request.body, options.redactBodyKeys))
+});
+/**
+* Remove sensitive response data before persisting to a cassette.
+*/
+const redactResponse = (response, options) => ({
+	...response,
+	headers: Option.getOrUndefined(omitHeaderKeys(response.headers, options.redactHeaders)),
+	body: Option.getOrElse(omitBodyKeys(response.body, options.redactBodyKeys), () => response.body)
+});
+
+//#endregion
+//#region src/vcr-http-client.ts
+var vcr_http_client_exports = /* @__PURE__ */ __export({ layer: () => layer });
+/**
+* Decoder for Uint8Array request bodies when building cassette keys.
+*/
+const decoder = new TextDecoder();
+/**
+* Resolve the cassette file name and export key.
+*
+* If explicit cassetteName are provided, use them and default to
+* the "default" export. Otherwise infer from Vitest state:
+* - <file-name>.cassette file name
+* - export key = current test name (describe > test)
+*/
+const resolveCassetteLocation = (config) => Effect.gen(function* () {
+	const path = yield* Path.Path;
+	if (config.cassetteName) return {
+		name: `${config.cassetteName}.cassette`,
+		exportKey: "default"
+	};
+	const { testPath, currentTestName } = getVitestState();
+	if (!testPath || !currentTestName) throw new Error("VCR cassette path could not be inferred. Provide cassetteName.");
+	return {
+		name: `${path.basename(testPath, ".ts")}.cassette`,
+		exportKey: currentTestName
+	};
+});
+/**
+* Apply defaults for common VCR behavior while preserving explicit overrides.
+*/
+const normalizeConfig = (config) => ({
+	vcrName: config.vcrName,
+	cassetteName: config.cassetteName,
+	mode: config.mode ?? "auto",
+	matchIgnore: {
+		requestHeaders: ["authorization"],
+		...config.matchIgnore
+	},
+	redact: {
+		requestHeaders: ["authorization"],
+		...config.redact
+	},
+	match: config.match
+});
+const AckDisableVcrConfig = Config.option(Config.string("ACK_DISABLE_VCR")).pipe(Config.map((value) => Option.match(value, {
+	onNone: () => /* @__PURE__ */ new Set(),
+	onSome: (raw) => raw === "*" ? "*" : new Set(raw.split(",").map((segment) => segment.trim().toLowerCase()).filter((segment) => segment.length > 0))
+})));
+const shouldDisableVcr = (name, disabled) => {
+	if (disabled === "*") return true;
+	if (!name) return false;
+	const normalized = name.trim().toLowerCase();
+	return disabled.has(normalized);
+};
+/**
+* Convert store or replay failures into HttpClient transport errors.
+*/
+const toRequestError = (request, cause, description) => new HttpClientError.HttpClientError({ reason: new HttpClientError.TransportError({
+	request,
+	cause,
+	description
+}) });
+/**
+* Convert header map to a plain record for JSON persistence.
+*/
+const recordFromHeaders = (headers) => {
+	const record$1 = {};
+	for (const [key, value] of Object.entries(headers)) record$1[key] = value;
+	return record$1;
+};
+/**
+* Serialize an Effect HttpClientRequest into a cassette request shape.
+*
+* Note: some body variants (Stream, FormData) are not safely serializable
+* without consuming the body, so we store placeholders to avoid breaking
+* live requests.
+*/
+const toVcrRequest = (request) => {
+	const headers = recordFromHeaders(request.headers);
+	const body = (() => {
+		switch (request.body._tag) {
+			case "Empty": return "";
+			case "Uint8Array": return decoder.decode(request.body.body);
+			case "Raw": {
+				const raw = request.body.body;
+				if (typeof raw === "string") return raw;
+				if (raw instanceof Uint8Array) return decoder.decode(raw);
+				try {
+					return JSON.stringify(raw);
+				} catch {
+					return "[raw]";
+				}
+			}
+			case "FormData": return "[form-data]";
+			case "Stream": return "[stream]";
+		}
+	})();
+	return {
+		method: request.method,
+		url: request.url,
+		headers,
+		body
+	};
+};
+/**
+* Serialize an Effect HttpClientResponse into a cassette response shape.
+*/
+const toVcrResponse = (response, body) => ({
+	status: response.status,
+	body,
+	headers: recordFromHeaders(response.headers)
+});
+/**
+* Load a cassette and map store errors into HttpClient errors.
+*/
+const readCassetteFile = (store, name, request) => store.load(name).pipe(Effect.mapError((error) => toRequestError(request, error)));
+/**
+* Load a cassette or initialize a new one if missing.
+*/
+const loadOrInitCassetteFile = (store, name, request) => store.loadOrInit(name).pipe(Effect.mapError((error) => toRequestError(request, error)));
+/**
+* Persist the updated cassette.
+*/
+const saveCassetteFile = (store, name, cassette, request) => store.save(name, cassette).pipe(Effect.mapError((error) => toRequestError(request, error)));
+/**
+* Load a named cassette export from the file, or return a fresh empty cassette.
+*/
+const readCassetteExport = (store, name, exportKey, request) => readCassetteFile(store, name, request).pipe(Effect.flatMap((file) => {
+	const found = file.exports[exportKey];
+	if (found) return Effect.succeed(found);
+	return createEmptyCassette();
+}));
+/**
+* Locate a cassette entry by custom matcher or stable request key.
+*/
+const findEntry = (request, cassette, config) => {
+	if (config.match) return Effect.succeed(Object.values(cassette.entries).find((entry) => config.match?.(request, entry)));
+	return buildRequestKey(request, {
+		ignoreHeaders: config.matchIgnore?.requestHeaders,
+		ignoreBodyKeys: config.matchIgnore?.requestBodyKeys
+	}).pipe(Effect.map((key) => cassette.entries[key]));
+};
+/**
+* Replay a response from cassette data using HttpClientResponse.fromWeb.
+*/
+const replay = (store, request, vcrRequest, config, name, exportKey) => readCassetteExport(store, name, exportKey, request).pipe(Effect.flatMap((cassette) => findEntry(vcrRequest, cassette, config).pipe(Effect.flatMap((entry) => {
+	if (!entry) return Effect.fail(new HttpClientError.HttpClientError({ reason: new HttpClientError.TransportError({
+		request,
+		description: `VCR replay missing entry for ${request.method} ${request.url}`
+	}) }));
+	const web = new Response(entry.response.body, {
+		status: entry.response.status,
+		headers: entry.response.headers
+	});
+	return Effect.succeed(HttpClientResponse.fromWeb(request, web));
+}))));
+/**
+* Record a live response into the cassette and return the original response.
+*/
+const record = (store, request, vcrRequest, effect, config, name, exportKey) => Effect.gen(function* () {
+	const response = yield* effect;
+	const vcrResponse = toVcrResponse(response, yield* response.text);
+	const sanitizedRequest = config.redact ? redactRequest(vcrRequest, {
+		redactHeaders: config.redact.requestHeaders,
+		redactBodyKeys: config.redact.requestBodyKeys
+	}) : vcrRequest;
+	const sanitizedResponse = config.redact ? redactResponse(vcrResponse, {
+		redactHeaders: config.redact.responseHeaders,
+		redactBodyKeys: config.redact.responseBodyKeys
+	}) : vcrResponse;
+	const file = yield* loadOrInitCassetteFile(store, name, request);
+	const cassette = file.exports[exportKey] ?? (yield* createEmptyCassette());
+	const key = yield* buildRequestKey(vcrRequest, {
+		ignoreHeaders: config.matchIgnore?.requestHeaders,
+		ignoreBodyKeys: config.matchIgnore?.requestBodyKeys
+	});
+	const next = {
+		...cassette,
+		entries: {
+			...cassette.entries,
+			[key]: {
+				request: sanitizedRequest,
+				response: sanitizedResponse
+			}
+		}
+	};
+	yield* saveCassetteFile(store, name, {
+		...file,
+		exports: {
+			...file.exports,
+			[exportKey]: next
+		}
+	}, request);
+	return response;
+});
+/**
+* Build a VCR-aware HttpClient that replays or records per config.
+*/
+const makeVcrHttpClient = (config) => Effect.gen(function* () {
+	const live = yield* HttpClient.HttpClient;
+	const normalized = normalizeConfig(config);
+	const isCi = yield* Config.boolean("CI").pipe(Config.withDefault(false));
+	const disabledVcrs = yield* AckDisableVcrConfig;
+	if (shouldDisableVcr(normalized.vcrName, disabledVcrs)) return live;
+	const store = yield* CassetteStore;
+	const { name, exportKey } = yield* resolveCassetteLocation(normalized);
+	return live.pipe(HttpClient.transform((effect, request) => Effect.gen(function* () {
+		const vcrRequest = toVcrRequest(request);
+		if (normalized.mode === "replay") return yield* replay(store, request, vcrRequest, normalized, name, exportKey);
+		if (normalized.mode === "record") return yield* record(store, request, vcrRequest, effect, normalized, name, exportKey);
+		if (!(yield* store.exists(name).pipe(Effect.mapError((error) => toRequestError(request, error))))) {
+			if (isCi) return yield* Effect.fail(new HttpClientError.HttpClientError({ reason: new HttpClientError.TransportError({
+				request,
+				description: "VCR cassette missing in CI for auto mode"
+			}) }));
+			return yield* record(store, request, vcrRequest, effect, normalized, name, exportKey);
+		}
+		const entry = yield* findEntry(vcrRequest, yield* readCassetteExport(store, name, exportKey, request), normalized);
+		if (entry) {
+			const web = new Response(entry.response.body, {
+				status: entry.response.status,
+				headers: entry.response.headers
+			});
+			return HttpClientResponse.fromWeb(request, web);
+		}
+		return yield* record(store, request, vcrRequest, effect, normalized, name, exportKey);
+	})));
+});
+/**
+* Layer that provides a VCR-wrapped HttpClient.
+*/
+const layer = (config = {}) => HttpClient.layerMergedContext(makeVcrHttpClient(config));
+
+//#endregion
+export { cassette_store_exports as CassetteStore, file_system_cassette_store_exports as FileSystemCassetteStore, vcr_http_client_exports as VcrHttpClient };
+//# sourceMappingURL=index.js.map