@useairfoil/effect-vcr 0.4.0 → 0.4.1

package/dist/types.d.ts

@@ -0,0 +1,2 @@
+import { a as VcrMode, i as VcrEntry, n as CassetteFile, o as VcrRequest, r as VcrConfig, s as VcrResponse, t as Cassette } from "./types-DWwkMzxG.js";
+export { Cassette, CassetteFile, VcrConfig, VcrEntry, VcrMode, VcrRequest, VcrResponse };

package/dist/types.js

@@ -0,0 +1,3 @@
+import "./types-BsuPrIpu.js";
+
+export {  };

package/dist/vcr-http-client-BaMxQun5.js

@@ -0,0 +1,351 @@
+import { t as __export } from "./chunk-Bp6m_JJh.js";
+import { i as createEmptyCassette, t as CassetteStore } from "./cassette-store-CnXX5OLB.js";
+import { t as getVitestState } from "./vitest-state-BOynp4Va.js";
+import { Config, Data, Effect, Option, Path } from "effect";
+import { HttpClient, HttpClientError, HttpClientResponse } from "effect/unstable/http";
+import stableStringify from "json-stable-stringify";
+
+//#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
+	});
+	return stableStringify({
+		method: sanitized.method.toUpperCase(),
+		url: sanitized.url,
+		headers: sanitized.headers ?? {},
+		body: sanitized.body ?? ""
+	}) ?? JSON.stringify({
+		method: sanitized.method.toUpperCase(),
+		url: sanitized.url,
+		headers: sanitized.headers ?? {},
+		body: sanitized.body ?? ""
+	});
+});
+/**
+* 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({
+	VcrHttpClientError: () => VcrHttpClientError,
+	layer: () => layer
+});
+/**
+* Decoder for Uint8Array request bodies when building cassette keys.
+*/
+const decoder = new TextDecoder();
+var VcrHttpClientError = class extends Data.TaggedError("VcrHttpClientError") {};
+const toCassetteFileName = (name) => name.endsWith(".cassette") ? name : `${name}.cassette`;
+/**
+* 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 = Effect.fnUntraced(function* (config) {
+	const path = yield* Path.Path;
+	if (config.cassetteName) return {
+		name: toCassetteFileName(config.cassetteName),
+		exportKey: "default"
+	};
+	const { testPath, currentTestName } = getVitestState();
+	if (!testPath || !currentTestName) return yield* Effect.fail(new VcrHttpClientError({ message: "VCR cassette path could not be inferred. Provide cassetteName when not running in Vitest." }));
+	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]));
+};
+const replayResponse = (request, entry) => {
+	const web = new Response(entry.response.body, {
+		status: entry.response.status,
+		headers: entry.response.headers
+	});
+	return HttpClientResponse.fromWeb(request, web);
+};
+/**
+* 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}`
+	}) }));
+	return Effect.succeed(replayResponse(request, entry));
+}))));
+/**
+* Record a live response into the cassette and return the original response.
+*/
+const record = Effect.fnUntraced(function* (store, request, vcrRequest, effect, config, name, exportKey) {
+	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 = Effect.fnUntraced(function* (config = {}) {
+	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.fnUntraced(function* (effect, request) {
+		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) return replayResponse(request, entry);
+		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 { layer as n, vcr_http_client_exports as r, VcrHttpClientError as t };
+//# sourceMappingURL=vcr-http-client-BaMxQun5.js.map

package/dist/vcr-http-client-BaMxQun5.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vcr-http-client-BaMxQun5.js","names":["record: Record<string, string>","record","filtered: Record<string, string>","next: Record<string, unknown>","record: Record<string, string>","record","next: Cassette"],"sources":["../src/sanitize.ts","../src/vcr-http-client.ts"],"sourcesContent":["import { Effect, Option } from \"effect\";\nimport stableStringify from \"json-stable-stringify\";\n\nimport type { VcrRequest, VcrResponse } from \"./types\";\n\n/**\n * Normalize header names to match HttpClient's lowercase behavior.\n */\nconst normalizeHeaderKey = (key: string) => key.toLowerCase();\n\n/**\n * Canonicalize headers: lowercase keys and stable ordering.\n */\nconst toHeaderRecord = (headers?: Record<string, string>) => {\n  if (!headers) return undefined;\n  const entries = Object.entries(headers).map(\n    ([key, value]) => [normalizeHeaderKey(key), value] as const,\n  );\n  entries.sort(([a], [b]) => a.localeCompare(b));\n  const record: Record<string, string> = {};\n  for (const [key, value] of entries) {\n    record[key] = value;\n  }\n  return record;\n};\n\n/**\n * Remove specified header names (case-insensitive).\n */\nconst omitHeaderKeys = (\n  headers: Record<string, string> | undefined,\n  ignore: ReadonlyArray<string> | undefined,\n): Option.Option<Record<string, string>> => {\n  if (!headers) return Option.none();\n  if (!ignore || ignore.length === 0) return Option.some(headers);\n  const ignoreSet = new Set(ignore.map(normalizeHeaderKey));\n  const filtered: Record<string, string> = {};\n  for (const [key, value] of Object.entries(headers)) {\n    if (!ignoreSet.has(normalizeHeaderKey(key))) {\n      filtered[key] = value;\n    }\n  }\n  return Option.some(filtered);\n};\n\n/**\n * Best-effort JSON parse; returns undefined for non-JSON bodies.\n */\nconst tryParseJson = Option.liftThrowable((input: string) => JSON.parse(input));\n\n/**\n * Recursively drop keys from JSON objects to build stable request keys.\n */\nconst stripKeys = (value: unknown, ignore: Set<string>): unknown => {\n  if (Array.isArray(value)) {\n    return value.map((item) => stripKeys(item, ignore));\n  }\n  if (value && typeof value === \"object\") {\n    const record = value as Record<string, unknown>;\n    const next: Record<string, unknown> = {};\n    for (const [key, entry] of Object.entries(record)) {\n      if (!ignore.has(key)) {\n        next[key] = stripKeys(entry, ignore);\n      }\n    }\n    return next;\n  }\n  return value;\n};\n\n/**\n * Remove JSON keys from a string body when possible.\n */\nconst omitBodyKeys = (\n  body: string | undefined,\n  ignore: ReadonlyArray<string> | undefined,\n): Option.Option<string> => {\n  if (!body) return Option.none();\n  return Option.some(\n    tryParseJson(body).pipe(\n      Option.match({\n        onNone: () => body,\n        onSome: (parsed) => {\n          if (!ignore || ignore.length === 0) {\n            return stableStringify(parsed) ?? body;\n          }\n          const ignoreSet = new Set(ignore);\n          return stableStringify(stripKeys(parsed, ignoreSet)) ?? body;\n        },\n      }),\n    ),\n  );\n};\n\n/**\n * Normalize request for matching: header canonicalization + JSON body filtering.\n */\nexport const sanitizeRequest = (\n  request: VcrRequest,\n  options: {\n    readonly ignoreHeaders?: ReadonlyArray<string>;\n    readonly ignoreBodyKeys?: ReadonlyArray<string>;\n  },\n): VcrRequest => {\n  const filteredHeaders = omitHeaderKeys(request.headers, options.ignoreHeaders);\n  return {\n    ...request,\n    headers: toHeaderRecord(Option.getOrUndefined(filteredHeaders)),\n    body: Option.getOrUndefined(omitBodyKeys(request.body, options.ignoreBodyKeys)),\n  };\n};\n\n/**\n * Compute the stable request key used for cassette lookups.\n */\nexport const buildRequestKey = (\n  request: VcrRequest,\n  options: {\n    readonly ignoreHeaders?: ReadonlyArray<string>;\n    readonly ignoreBodyKeys?: ReadonlyArray<string>;\n  },\n): Effect.Effect<string> =>\n  Effect.sync(() => {\n    const sanitized = sanitizeRequest(request, {\n      ignoreHeaders: options.ignoreHeaders,\n      ignoreBodyKeys: options.ignoreBodyKeys,\n    });\n    return (\n      stableStringify({\n        method: sanitized.method.toUpperCase(),\n        url: sanitized.url,\n        headers: sanitized.headers ?? {},\n        body: sanitized.body ?? \"\",\n      }) ??\n      JSON.stringify({\n        method: sanitized.method.toUpperCase(),\n        url: sanitized.url,\n        headers: sanitized.headers ?? {},\n        body: sanitized.body ?? \"\",\n      })\n    );\n  });\n\n/**\n * Remove sensitive request data before persisting to a cassette.\n */\nexport const redactRequest = (\n  request: VcrRequest,\n  options: {\n    readonly redactHeaders?: ReadonlyArray<string>;\n    readonly redactBodyKeys?: ReadonlyArray<string>;\n  },\n): VcrRequest => ({\n  ...request,\n  headers: Option.getOrUndefined(omitHeaderKeys(request.headers, options.redactHeaders)),\n  body: Option.getOrUndefined(omitBodyKeys(request.body, options.redactBodyKeys)),\n});\n\n/**\n * Remove sensitive response data before persisting to a cassette.\n */\nexport const redactResponse = (\n  response: VcrResponse,\n  options: {\n    readonly redactHeaders?: ReadonlyArray<string>;\n    readonly redactBodyKeys?: ReadonlyArray<string>;\n  },\n): VcrResponse => ({\n  ...response,\n  headers: Option.getOrUndefined(omitHeaderKeys(response.headers, options.redactHeaders)),\n  body: Option.getOrElse(omitBodyKeys(response.body, options.redactBodyKeys), () => response.body),\n});\n","import { Config, Data, Effect, Option, Path } from \"effect\";\nimport {\n  HttpClient,\n  HttpClientError,\n  type HttpClientRequest,\n  HttpClientResponse,\n} from \"effect/unstable/http\";\n\nimport type { Cassette, CassetteFile, VcrConfig, VcrEntry, VcrRequest, VcrResponse } from \"./types\";\n\nimport { CassetteStore, type CassetteStoreService, createEmptyCassette } from \"./cassette-store\";\nimport { buildRequestKey, redactRequest, redactResponse } from \"./sanitize\";\nimport { getVitestState } from \"./vitest-state\";\n\n/**\n * Decoder for Uint8Array request bodies when building cassette keys.\n */\nconst decoder = new TextDecoder();\n\nexport class VcrHttpClientError extends Data.TaggedError(\"VcrHttpClientError\")<{\n  readonly message: string;\n  readonly cause?: unknown;\n}> {}\n\nconst toCassetteFileName = (name: string): string =>\n  name.endsWith(\".cassette\") ? name : `${name}.cassette`;\n\n/**\n * Resolve the cassette file name and export key.\n *\n * If explicit cassetteName are provided, use them and default to\n * the \"default\" export. Otherwise infer from Vitest state:\n * - <file-name>.cassette file name\n * - export key = current test name (describe > test)\n */\nconst resolveCassetteLocation = Effect.fnUntraced(function* (config: VcrConfig) {\n  const path = yield* Path.Path;\n  if (config.cassetteName) {\n    return {\n      name: toCassetteFileName(config.cassetteName),\n      exportKey: \"default\",\n    };\n  }\n\n  const { testPath, currentTestName } = getVitestState();\n  if (!testPath || !currentTestName) {\n    return yield* Effect.fail(\n      new VcrHttpClientError({\n        message:\n          \"VCR cassette path could not be inferred. Provide cassetteName when not running in Vitest.\",\n      }),\n    );\n  }\n\n  const fileName = path.basename(testPath, \".ts\");\n  const cassetteName = `${fileName}.cassette`;\n\n  return {\n    name: cassetteName,\n    exportKey: currentTestName,\n  };\n});\n\n/**\n * Apply defaults for common VCR behavior while preserving explicit overrides.\n */\nconst normalizeConfig = (config: VcrConfig): VcrConfig => ({\n  vcrName: config.vcrName,\n  cassetteName: config.cassetteName,\n  mode: config.mode ?? \"auto\",\n  matchIgnore: {\n    requestHeaders: [\"authorization\"],\n    ...config.matchIgnore,\n  },\n  redact: {\n    requestHeaders: [\"authorization\"],\n    ...config.redact,\n  },\n  match: config.match,\n});\n\nconst AckDisableVcrConfig = Config.option(Config.string(\"ACK_DISABLE_VCR\")).pipe(\n  Config.map((value) =>\n    Option.match(value, {\n      onNone: () => new Set<string>(),\n      onSome: (raw) =>\n        raw === \"*\"\n          ? \"*\"\n          : new Set(\n              raw\n                .split(\",\")\n                .map((segment) => segment.trim().toLowerCase())\n                .filter((segment) => segment.length > 0),\n            ),\n    }),\n  ),\n);\n\nconst shouldDisableVcr = (name: string | undefined, disabled: \"*\" | Set<string>): boolean => {\n  if (disabled === \"*\") return true;\n  if (!name) return false;\n  const normalized = name.trim().toLowerCase();\n  return disabled.has(normalized);\n};\n\n/**\n * Convert store or replay failures into HttpClient transport errors.\n */\nconst toRequestError = (\n  request: HttpClientRequest.HttpClientRequest,\n  cause: unknown,\n  description?: string,\n) =>\n  new HttpClientError.HttpClientError({\n    reason: new HttpClientError.TransportError({\n      request,\n      cause,\n      description,\n    }),\n  });\n\n/**\n * Convert header map to a plain record for JSON persistence.\n */\nconst recordFromHeaders = (headers: Record<string, string>) => {\n  const record: Record<string, string> = {};\n  for (const [key, value] of Object.entries(headers)) {\n    record[key] = value;\n  }\n  return record;\n};\n\n/**\n * Serialize an Effect HttpClientRequest into a cassette request shape.\n *\n * Note: some body variants (Stream, FormData) are not safely serializable\n * without consuming the body, so we store placeholders to avoid breaking\n * live requests.\n */\nconst toVcrRequest = (request: HttpClientRequest.HttpClientRequest): VcrRequest => {\n  const headers = recordFromHeaders(request.headers as Record<string, string>);\n  const body = (() => {\n    switch (request.body._tag) {\n      case \"Empty\":\n        return \"\";\n      case \"Uint8Array\":\n        return decoder.decode(request.body.body);\n      case \"Raw\": {\n        const raw = request.body.body as unknown;\n        if (typeof raw === \"string\") return raw;\n        if (raw instanceof Uint8Array) return decoder.decode(raw);\n        try {\n          return JSON.stringify(raw);\n        } catch {\n          return \"[raw]\";\n        }\n      }\n      case \"FormData\":\n        return \"[form-data]\";\n      case \"Stream\":\n        return \"[stream]\";\n    }\n  })();\n\n  return {\n    method: request.method,\n    url: request.url,\n    headers,\n    body,\n  };\n};\n\n/**\n * Serialize an Effect HttpClientResponse into a cassette response shape.\n */\nconst toVcrResponse = (\n  response: HttpClientResponse.HttpClientResponse,\n  body: string,\n): VcrResponse => ({\n  status: response.status,\n  body,\n  headers: recordFromHeaders(response.headers as Record<string, string>),\n});\n\n/**\n * Load a cassette and map store errors into HttpClient errors.\n */\nconst readCassetteFile = (\n  store: CassetteStoreService,\n  name: string,\n  request: HttpClientRequest.HttpClientRequest,\n) => store.load(name).pipe(Effect.mapError((error) => toRequestError(request, error)));\n\n/**\n * Load a cassette or initialize a new one if missing.\n */\nconst loadOrInitCassetteFile = (\n  store: CassetteStoreService,\n  name: string,\n  request: HttpClientRequest.HttpClientRequest,\n) => store.loadOrInit(name).pipe(Effect.mapError((error) => toRequestError(request, error)));\n\n/**\n * Persist the updated cassette.\n */\nconst saveCassetteFile = (\n  store: CassetteStoreService,\n  name: string,\n  cassette: CassetteFile,\n  request: HttpClientRequest.HttpClientRequest,\n) => store.save(name, cassette).pipe(Effect.mapError((error) => toRequestError(request, error)));\n\n/**\n * Load a named cassette export from the file, or return a fresh empty cassette.\n */\nconst readCassetteExport = (\n  store: CassetteStoreService,\n  name: string,\n  exportKey: string,\n  request: HttpClientRequest.HttpClientRequest,\n) =>\n  readCassetteFile(store, name, request).pipe(\n    Effect.flatMap((file) => {\n      const found = file.exports[exportKey];\n      if (found) return Effect.succeed(found);\n      return createEmptyCassette();\n    }),\n  );\n\n/**\n * Locate a cassette entry by custom matcher or stable request key.\n */\nconst findEntry = (\n  request: VcrRequest,\n  cassette: Cassette,\n  config: VcrConfig,\n): Effect.Effect<VcrEntry | undefined> => {\n  if (config.match) {\n    return Effect.succeed(\n      Object.values(cassette.entries).find((entry) => config.match?.(request, entry)),\n    );\n  }\n  return buildRequestKey(request, {\n    ignoreHeaders: config.matchIgnore?.requestHeaders,\n    ignoreBodyKeys: config.matchIgnore?.requestBodyKeys,\n  }).pipe(Effect.map((key) => cassette.entries[key]));\n};\n\nconst replayResponse = (\n  request: HttpClientRequest.HttpClientRequest,\n  entry: VcrEntry,\n): HttpClientResponse.HttpClientResponse => {\n  const web = new Response(entry.response.body, {\n    status: entry.response.status,\n    headers: entry.response.headers,\n  });\n  return HttpClientResponse.fromWeb(request, web);\n};\n\n/**\n * Replay a response from cassette data using HttpClientResponse.fromWeb.\n */\nconst replay = (\n  store: CassetteStoreService,\n  request: HttpClientRequest.HttpClientRequest,\n  vcrRequest: VcrRequest,\n  config: VcrConfig,\n  name: string,\n  exportKey: string,\n) =>\n  readCassetteExport(store, name, exportKey, request).pipe(\n    Effect.flatMap((cassette) =>\n      findEntry(vcrRequest, cassette, config).pipe(\n        Effect.flatMap((entry) => {\n          if (!entry) {\n            return Effect.fail(\n              new HttpClientError.HttpClientError({\n                reason: new HttpClientError.TransportError({\n                  request,\n                  description: `VCR replay missing entry for ${request.method} ${request.url}`,\n                }),\n              }),\n            );\n          }\n\n          return Effect.succeed(replayResponse(request, entry));\n        }),\n      ),\n    ),\n  );\n\n/**\n * Record a live response into the cassette and return the original response.\n */\nconst record = Effect.fnUntraced(function* (\n  store: CassetteStoreService,\n  request: HttpClientRequest.HttpClientRequest,\n  vcrRequest: VcrRequest,\n  effect: Effect.Effect<HttpClientResponse.HttpClientResponse, HttpClientError.HttpClientError>,\n  config: VcrConfig,\n  name: string,\n  exportKey: string,\n): Effect.fn.Return<HttpClientResponse.HttpClientResponse, HttpClientError.HttpClientError> {\n  const response = yield* effect;\n  const body = yield* response.text;\n  const vcrResponse = toVcrResponse(response, body);\n\n  const sanitizedRequest = config.redact\n    ? redactRequest(vcrRequest, {\n        redactHeaders: config.redact.requestHeaders,\n        redactBodyKeys: config.redact.requestBodyKeys,\n      })\n    : vcrRequest;\n  const sanitizedResponse = config.redact\n    ? redactResponse(vcrResponse, {\n        redactHeaders: config.redact.responseHeaders,\n        redactBodyKeys: config.redact.responseBodyKeys,\n      })\n    : vcrResponse;\n\n  const file = yield* loadOrInitCassetteFile(store, name, request);\n  const cassette = file.exports[exportKey] ?? (yield* createEmptyCassette());\n  const key = yield* buildRequestKey(vcrRequest, {\n    ignoreHeaders: config.matchIgnore?.requestHeaders,\n    ignoreBodyKeys: config.matchIgnore?.requestBodyKeys,\n  });\n  const next: Cassette = {\n    ...cassette,\n    entries: {\n      ...cassette.entries,\n      [key]: {\n        request: sanitizedRequest,\n        response: sanitizedResponse,\n      },\n    },\n  };\n  const nextFile: CassetteFile = {\n    ...file,\n    exports: {\n      ...file.exports,\n      [exportKey]: next,\n    },\n  };\n  yield* saveCassetteFile(store, name, nextFile, request);\n  return response;\n});\n\n/**\n * Build a VCR-aware HttpClient that replays or records per config.\n */\nconst makeVcrHttpClient = Effect.fnUntraced(function* (config: VcrConfig = {}) {\n  const live = yield* HttpClient.HttpClient;\n  const normalized = normalizeConfig(config);\n\n  const isCi = yield* Config.boolean(\"CI\").pipe(Config.withDefault(false));\n\n  const disabledVcrs = yield* AckDisableVcrConfig;\n  if (shouldDisableVcr(normalized.vcrName, disabledVcrs)) {\n    return live;\n  }\n\n  const store = yield* CassetteStore;\n\n  const { name, exportKey } = yield* resolveCassetteLocation(normalized);\n\n  return live.pipe(\n    HttpClient.transform(\n      Effect.fnUntraced(function* (effect, request) {\n        const vcrRequest = toVcrRequest(request);\n        if (normalized.mode === \"replay\") {\n          return yield* replay(store, request, vcrRequest, normalized, name, exportKey);\n        }\n\n        if (normalized.mode === \"record\") {\n          return yield* record(store, request, vcrRequest, effect, normalized, name, exportKey);\n        }\n\n        const available = yield* store\n          .exists(name)\n          .pipe(Effect.mapError((error) => toRequestError(request, error)));\n\n        if (!available) {\n          if (isCi) {\n            return yield* Effect.fail(\n              new HttpClientError.HttpClientError({\n                reason: new HttpClientError.TransportError({\n                  request,\n                  description: \"VCR cassette missing in CI for auto mode\",\n                }),\n              }),\n            );\n          }\n\n          return yield* record(store, request, vcrRequest, effect, normalized, name, exportKey);\n        }\n\n        const cassette = yield* readCassetteExport(store, name, exportKey, request);\n        const entry = yield* findEntry(vcrRequest, cassette, normalized);\n\n        if (entry) {\n          return replayResponse(request, entry);\n        }\n\n        return yield* record(store, request, vcrRequest, effect, normalized, name, exportKey);\n      }),\n    ),\n  );\n});\n\n/**\n * Layer that provides a VCR-wrapped HttpClient.\n */\nexport const layer = (config: VcrConfig = {}) =>\n  HttpClient.layerMergedContext(makeVcrHttpClient(config));\n"],"mappings":"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"}

package/dist/vcr-http-client-Mwb8ZMsc.d.ts

@@ -0,0 +1,26 @@
+import { r as VcrConfig } from "./types-DWwkMzxG.js";
+import { t as CassetteStore } from "./cassette-store-BunkvLoV.js";
+import { Config, Path } from "effect";
+import { HttpClient } from "effect/unstable/http";
+import * as effect_Types0 from "effect/Types";
+import * as effect_Cause0 from "effect/Cause";
+import * as effect_Layer0 from "effect/Layer";
+
+//#region src/vcr-http-client.d.ts
+declare namespace vcr_http_client_d_exports {
+  export { VcrHttpClientError, layer };
+}
+declare const VcrHttpClientError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => effect_Cause0.YieldableError & {
+  readonly _tag: "VcrHttpClientError";
+} & Readonly<A>;
+declare class VcrHttpClientError extends VcrHttpClientError_base<{
+  readonly message: string;
+  readonly cause?: unknown;
+}> {}
+/**
+ * Layer that provides a VCR-wrapped HttpClient.
+ */
+declare const layer: (config?: VcrConfig) => effect_Layer0.Layer<HttpClient.HttpClient, VcrHttpClientError | Config.ConfigError, CassetteStore | Path.Path | HttpClient.HttpClient>;
+//#endregion
+export { layer as n, vcr_http_client_d_exports as r, VcrHttpClientError as t };
+//# sourceMappingURL=vcr-http-client-Mwb8ZMsc.d.ts.map

package/dist/vcr-http-client.d.ts

@@ -0,0 +1,4 @@
+import "./types-DWwkMzxG.js";
+import "./cassette-store-BunkvLoV.js";
+import { n as layer, t as VcrHttpClientError } from "./vcr-http-client-Mwb8ZMsc.js";
+export { VcrHttpClientError, layer };

package/dist/vcr-http-client.js

@@ -0,0 +1,5 @@
+import "./cassette-store-CnXX5OLB.js";
+import "./vitest-state-BOynp4Va.js";
+import { n as layer, t as VcrHttpClientError } from "./vcr-http-client-BaMxQun5.js";
+
+export { VcrHttpClientError, layer };

package/dist/vitest-state-BOynp4Va.js

@@ -0,0 +1,14 @@
+//#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
+export { getVitestState as t };
+//# sourceMappingURL=vitest-state-BOynp4Va.js.map

package/dist/vitest-state-BOynp4Va.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitest-state-BOynp4Va.js","names":[],"sources":["../src/vitest-state.ts"],"sourcesContent":["export type VitestState = {\n  readonly testPath?: string;\n  readonly currentTestName?: string;\n};\n\nexport const getVitestState = (): VitestState => {\n  const expectGlobal =\n    // biome-ignore lint/suspicious/noExplicitAny: --\n    (globalThis as { expect?: { getState?: () => any } }).expect;\n  const symbolExpect =\n    // biome-ignore lint/suspicious/noExplicitAny: --\n    (globalThis as { [key: symbol]: { getState?: () => any } })[Symbol.for(\"expect-global\")];\n  const state = expectGlobal?.getState?.() ?? symbolExpect?.getState?.();\n  return {\n    testPath: state?.testPath as string | undefined,\n    currentTestName: state?.currentTestName as string | undefined,\n  };\n};\n"],"mappings":";AAKA,MAAa,uBAAoC;CAC/C,MAAM,eAEH,WAAqD;CACxD,MAAM,eAEH,WAA2D,OAAO,IAAI,gBAAgB;CACzF,MAAM,QAAQ,cAAc,YAAY,IAAI,cAAc,YAAY;AACtE,QAAO;EACL,UAAU,OAAO;EACjB,iBAAiB,OAAO;EACzB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@useairfoil/effect-vcr",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "keywords": [
     "effect"
   ],
@@ -18,6 +18,26 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "default": "./dist/index.js"
+    },
+    "./cassette-store": {
+      "types": "./dist/cassette-store.d.ts",
+      "import": "./dist/cassette-store.js",
+      "default": "./dist/cassette-store.js"
+    },
+    "./file-system-cassette-store": {
+      "types": "./dist/file-system-cassette-store.d.ts",
+      "import": "./dist/file-system-cassette-store.js",
+      "default": "./dist/file-system-cassette-store.js"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/types.js",
+      "default": "./dist/types.js"
+    },
+    "./vcr-http-client": {
+      "types": "./dist/vcr-http-client.d.ts",
+      "import": "./dist/vcr-http-client.js",
+      "default": "./dist/vcr-http-client.js"
     }
   },
   "scripts": {
@@ -30,14 +50,14 @@
     "json-stable-stringify": "^1.3.0"
   },
   "devDependencies": {
-    "@effect/platform-node": "4.0.0-beta.54",
-    "@effect/vitest": "4.0.0-beta.54",
+    "@effect/platform-node": "4.0.0-beta.83",
+    "@effect/vitest": "4.0.0-beta.83",
     "@types/node": "^24.2.0",
     "tsdown": "^0.15.6",
     "vitest": "^3.2.4"
   },
   "peerDependencies": {
-    "effect": "4.0.0-beta.54"
+    "effect": "4.0.0-beta.83"
   },
   "peerDependenciesMeta": {
     "effect": {

package/src/cassette-store.ts

@@ -1,12 +1,14 @@
-import { Context, DateTime, Effect, Schema } from "effect";
+import { Context, Data, DateTime, Effect } from "effect";
 
 import type { Cassette, CassetteFile } from "./types";
 
+export type CassetteStoreOperation = "exists" | "load" | "save" | "loadOrInit" | "resolveRoot";
+
 /**
  * Storage contract for VCR cassettes.
  *
  */
-export interface CassetteStore {
+export interface CassetteStoreService {
   /** Returns true if a cassette with the given name exists. */
   readonly exists: (name: string) => Effect.Effect<boolean, CassetteStoreError>;
 
@@ -23,24 +25,23 @@ export interface CassetteStore {
 /**
  * Effect service tag for the cassette store.
  */
-export const CassetteStore: Context.Service<CassetteStore, CassetteStore> = Context.Service(
+export class CassetteStore extends Context.Service<CassetteStore, CassetteStoreService>()(
   "@useairfoil/effect-vcr/CassetteStore",
-);
+) {}
 
 /**
  * Creates a new empty cassette with a timestamp and format version.
  */
-export const createEmptyCassette = (): Effect.Effect<Cassette> =>
-  Effect.gen(function* () {
-    const now = yield* DateTime.now;
-    return {
-      meta: {
-        createdAt: DateTime.formatIso(now),
-        version: "1",
-      },
-      entries: {},
-    };
-  });
+export const createEmptyCassette = Effect.fnUntraced(function* (): Effect.fn.Return<Cassette> {
+  const now = yield* DateTime.now;
+  return {
+    meta: {
+      createdAt: DateTime.formatIso(now),
+      version: "1",
+    },
+    entries: {},
+  };
+});
 
 export const createEmptyCassetteFile = (): Effect.Effect<CassetteFile> =>
   Effect.map(createEmptyCassette(), (cassette) => ({
@@ -53,18 +54,15 @@ export const createEmptyCassetteFile = (): Effect.Effect<CassetteFile> =>
  * `operation` indicates which store function failed.
  * `path` is the file or directory path that was targeted.
  */
-export class CassetteStoreError extends Schema.TaggedErrorClass<CassetteStoreError>()(
-  "CassetteStoreError",
-  {
-    operation: Schema.String,
-    path: Schema.String,
-    message: Schema.optional(Schema.String),
-    cause: Schema.optional(Schema.Unknown),
-  },
-) {}
+export class CassetteStoreError extends Data.TaggedError("CassetteStoreError")<{
+  readonly operation: CassetteStoreOperation;
+  readonly path: string;
+  readonly message?: string;
+  readonly cause?: unknown;
+}> {}
 
 export const toStoreError = (
-  operation: "exists" | "load" | "save" | "loadOrInit",
+  operation: CassetteStoreOperation,
   path: string,
   cause?: unknown,
   message?: string,
@@ -93,7 +91,5 @@ export const parseCassette = (content: string, path: string) =>
   );
 
 /** Creates a `CassetteStore` implementation that uses the given `impl` object. */
-export const make = (impl: CassetteStore): CassetteStore =>
-  CassetteStore.of({
-    ...impl,
-  });
+export const make = (impl: CassetteStoreService): CassetteStoreService =>
+  CassetteStore.of({ ...impl });

package/src/file-system-cassette-store.ts

@@ -5,24 +5,35 @@ import type { CassetteFile } from "./types";
 import * as CassetteStore from "./cassette-store";
 import { getVitestState } from "./vitest-state";
 
+export type FileSystemCassetteStoreConfig = {
+  readonly cassetteDir?: string;
+};
+
 /**
  * FileSystem-backed cassette store.
  *
  * Requires a platform FileSystem layer (Node/Bun) to be provided by the user.
  */
-export const layer = ({ cassetteDir }: { cassetteDir?: string } = {}) =>
+export const layer = (config: FileSystemCassetteStoreConfig = {}) =>
   Layer.effect(CassetteStore.CassetteStore)(
     Effect.gen(function* () {
       const fs = yield* FileSystem.FileSystem;
       const path = yield* Path.Path;
 
       let rootDir: string;
-      if (cassetteDir) {
-        rootDir = cassetteDir;
+      if (config.cassetteDir) {
+        rootDir = config.cassetteDir;
       } else {
         const { testPath } = getVitestState();
         if (!testPath) {
-          return yield* Effect.fail(new Error("vcr must be used within a vitest test"));
+          return yield* Effect.fail(
+            CassetteStore.toStoreError(
+              "resolveRoot",
+              "__cassettes__",
+              undefined,
+              "VCR cassette directory could not be inferred. Provide cassetteDir when not running in Vitest.",
+            ),
+          );
         }
         const testFolder = path.dirname(testPath);
         rootDir = path.join(testFolder, "__cassettes__");

package/src/index.ts

@@ -1,4 +1,4 @@
 export * as CassetteStore from "./cassette-store";
 export * as FileSystemCassetteStore from "./file-system-cassette-store";
-
 export * as VcrHttpClient from "./vcr-http-client";
+export * from "./types";