@useairfoil/effect-vcr 0.4.0 → 0.4.2

package/dist/index.d.ts

@@ -1,150 +1,5 @@
-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
+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";
+import { a as cassette_store_d_exports } from "./cassette-store-BunkvLoV.js";
+import { n as file_system_cassette_store_d_exports } from "./file-system-cassette-store-LXpwwrw3.js";
+import { r as vcr_http_client_d_exports } from "./vcr-http-client-aedmnq0C.js";
+export { Cassette, CassetteFile, cassette_store_d_exports as CassetteStore, file_system_cassette_store_d_exports as FileSystemCassetteStore, VcrConfig, VcrEntry, vcr_http_client_d_exports as VcrHttpClient, VcrMode, VcrRequest, VcrResponse };

package/dist/index.js

@@ -1,451 +1,7 @@
-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";
+import { r as cassette_store_exports } from "./cassette-store-CnXX5OLB.js";
+import "./vitest-state-BOynp4Va.js";
+import { t as file_system_cassette_store_exports } from "./file-system-cassette-store-zWkrhhlO.js";
+import { r as vcr_http_client_exports } from "./vcr-http-client-BaMxQun5.js";
+import "./types-BsuPrIpu.js";
 
-//#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
+export { cassette_store_exports as CassetteStore, file_system_cassette_store_exports as FileSystemCassetteStore, vcr_http_client_exports as VcrHttpClient };

package/dist/types-BsuPrIpu.js

@@ -0,0 +1 @@
+export {  };

package/dist/types-DWwkMzxG.d.ts

@@ -0,0 +1,85 @@
+//#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 VcrConfig = {
+  readonly vcrName?: string;
+  /**
+   * Cassette file name or basename.
+   *
+   * `users` resolves to `users.cassette`.
+   * `users.cassette` is preserved as-is.
+   */
+  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;
+};
+//#endregion
+export { VcrMode as a, VcrEntry as i, CassetteFile as n, VcrRequest as o, VcrConfig as r, VcrResponse as s, Cassette as t };
+//# sourceMappingURL=types-DWwkMzxG.d.ts.map