@useairfoil/effect-vcr 0.4.2 → 0.4.4

package/README.md

@@ -103,6 +103,8 @@ type VcrConfig = {
     readonly responseHeaders?: ReadonlyArray<string>;
     readonly requestBodyKeys?: ReadonlyArray<string>;
     readonly responseBodyKeys?: ReadonlyArray<string>;
+    readonly requestBodyReplacements?: Readonly<Record<string, string | number | boolean | null>>;
+    readonly responseBodyReplacements?: Readonly<Record<string, string | number | boolean | null>>;
   };
   readonly matchIgnore?: {
     readonly requestHeaders?: ReadonlyArray<string>;
@@ -124,9 +126,11 @@ type VcrConfig = {
   - `replay`: only serve from cassette; missing entries fail
   - `auto`: replay if the cassette exists, otherwise record; when `CI=true`, missing cassettes fail instead of recording
 - `redact`
-  - remove sensitive headers or JSON body keys before writing to disk
+  - remove sensitive headers or JSON and URL-encoded body keys before writing to disk
+  - replace body values with safe placeholders when the field must remain available during replay
+  - request fields redacted here are also ignored when building cassette keys
 - `matchIgnore`
-  - ignore request headers or JSON body keys when computing the request lookup key
+  - ignore request headers or JSON and URL-encoded body keys when computing the request lookup key
 - `match`
   - custom request matcher for advanced lookup behavior
 
@@ -156,11 +160,14 @@ Typical usage:
 const vcrLayer = VcrHttpClient.layer({
   vcrName: "shopify-products",
   mode: "auto",
-  matchIgnore: {
-    requestHeaders: ["x-shopify-access-token", "authorization"],
-  },
   redact: {
     requestHeaders: ["x-shopify-access-token", "authorization"],
+    requestBodyReplacements: {
+      client_secret: "client-secret-placeholder",
+    },
+    responseBodyReplacements: {
+      access_token: "access-token-placeholder",
+    },
   },
 });
 ```
@@ -168,6 +175,9 @@ const vcrLayer = VcrHttpClient.layer({
 Use `matchIgnore` when a request field should not affect cassette identity.
 
 Use `redact` when a field should never be written to disk.
+Replacement values are useful for fields such as access tokens that a replayed
+response must still contain. If body redaction changes the encoded length, the VCR
+also removes and ignores the stale `content-length` header.
 
 ## Runtime configuration
 

package/dist/{cassette-store-CnXX5OLB.js → cassette-store-BF9e0rz3.js}

@@ -1,5 +1,6 @@
 import { t as __export } from "./chunk-Bp6m_JJh.js";
-import { Context, Data, DateTime, Effect } from "effect";
+import { t as CassetteFileSchema } from "./types-DMuz_JGd.js";
+import { Context, Data, DateTime, Effect, Schema } from "effect";
 
 //#region src/cassette-store.ts
 var cassette_store_exports = /* @__PURE__ */ __export({
@@ -43,18 +44,15 @@ const toStoreError = (operation, path, cause, message) => new CassetteStoreError
 	message
 });
 /**
-* Parses cassette JSON and maps invalid JSON to a store error.
+* Parses cassette JSON and maps invalid JSON or an invalid cassette shape 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);
-}));
+}).pipe(Effect.flatMap((parsed) => Schema.decodeUnknownEffect(CassetteFileSchema)(parsed).pipe(Effect.mapError((error) => toStoreError("load", path, error, "Invalid cassette file format")))));
 /** Creates a `CassetteStore` implementation that uses the given `impl` object. */
 const make = (impl) => CassetteStore.of({ ...impl });
 
 //#endregion
 export { createEmptyCassetteFile as a, toStoreError as c, createEmptyCassette as i, CassetteStoreError as n, make as o, cassette_store_exports as r, parseCassette as s, CassetteStore as t };
-//# sourceMappingURL=cassette-store-CnXX5OLB.js.map
+//# sourceMappingURL=cassette-store-BF9e0rz3.js.map

package/dist/cassette-store-BF9e0rz3.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cassette-store-BF9e0rz3.js","names":[],"sources":["../src/cassette-store.ts"],"sourcesContent":["import { Context, Data, DateTime, Effect, Schema } from \"effect\";\n\nimport { CassetteFileSchema, type Cassette, type CassetteFile } from \"./types\";\n\nexport type CassetteStoreOperation = \"exists\" | \"load\" | \"save\" | \"loadOrInit\" | \"resolveRoot\";\n\n/**\n * Storage contract for VCR cassettes.\n *\n */\nexport interface CassetteStoreService {\n  /** Returns true if a cassette with the given name exists. */\n  readonly exists: (name: string) => Effect.Effect<boolean, CassetteStoreError>;\n\n  /** Loads a cassette by name, returning a `CassetteFile` if found. */\n  readonly load: (name: string) => Effect.Effect<CassetteFile, CassetteStoreError>;\n\n  /** Saves a cassette by name, overwriting any existing cassette with the same name. */\n  readonly save: (name: string, content: CassetteFile) => Effect.Effect<void, CassetteStoreError>;\n\n  /** Loads a cassette by name, initializing a new empty cassette if not found. */\n  readonly loadOrInit: (name: string) => Effect.Effect<CassetteFile, CassetteStoreError>;\n}\n\n/**\n * Effect service tag for the cassette store.\n */\nexport class CassetteStore extends Context.Service<CassetteStore, CassetteStoreService>()(\n  \"@useairfoil/effect-vcr/CassetteStore\",\n) {}\n\n/**\n * Creates a new empty cassette with a timestamp and format version.\n */\nexport const createEmptyCassette = Effect.fnUntraced(function* (): Effect.fn.Return<Cassette> {\n  const now = yield* DateTime.now;\n  return {\n    meta: {\n      createdAt: DateTime.formatIso(now),\n      version: \"1\",\n    },\n    entries: {},\n  };\n});\n\nexport const createEmptyCassetteFile = (): Effect.Effect<CassetteFile> =>\n  Effect.map(createEmptyCassette(), (cassette) => ({\n    exports: { default: cassette },\n  }));\n\n/**\n * Structured error for cassette persistence operations.\n *\n * `operation` indicates which store function failed.\n * `path` is the file or directory path that was targeted.\n */\nexport class CassetteStoreError extends Data.TaggedError(\"CassetteStoreError\")<{\n  readonly operation: CassetteStoreOperation;\n  readonly path: string;\n  readonly message?: string;\n  readonly cause?: unknown;\n}> {}\n\nexport const toStoreError = (\n  operation: CassetteStoreOperation,\n  path: string,\n  cause?: unknown,\n  message?: string,\n) =>\n  new CassetteStoreError({\n    operation,\n    path,\n    cause,\n    message,\n  });\n\n/**\n * Parses cassette JSON and maps invalid JSON or an invalid cassette shape to a store error.\n */\nexport const parseCassette = (\n  content: string,\n  path: string,\n): Effect.Effect<CassetteFile, CassetteStoreError> =>\n  Effect.try({\n    try: () => JSON.parse(content) as unknown,\n    catch: (error) => toStoreError(\"load\", path, error, \"Invalid JSON\"),\n  }).pipe(\n    Effect.flatMap((parsed) =>\n      Schema.decodeUnknownEffect(CassetteFileSchema)(parsed).pipe(\n        Effect.mapError((error) =>\n          toStoreError(\"load\", path, error, \"Invalid cassette file format\"),\n        ),\n      ),\n    ),\n  );\n\n/** Creates a `CassetteStore` implementation that uses the given `impl` object. */\nexport const make = (impl: CassetteStoreService): CassetteStoreService =>\n  CassetteStore.of({ ...impl });\n"],"mappings":";;;;;;;;;;;;;;;;;AA2BA,IAAa,gBAAb,cAAmC,QAAQ,SAA8C,CACvF,uCACD,CAAC;;;;AAKF,MAAa,sBAAsB,OAAO,WAAW,aAAyC;CAC5F,MAAM,MAAM,OAAO,SAAS;AAC5B,QAAO;EACL,MAAM;GACJ,WAAW,SAAS,UAAU,IAAI;GAClC,SAAS;GACV;EACD,SAAS,EAAE;EACZ;EACD;AAEF,MAAa,gCACX,OAAO,IAAI,qBAAqB,GAAG,cAAc,EAC/C,SAAS,EAAE,SAAS,UAAU,EAC/B,EAAE;;;;;;;AAQL,IAAa,qBAAb,cAAwC,KAAK,YAAY,qBAAqB,CAK3E;AAEH,MAAa,gBACX,WACA,MACA,OACA,YAEA,IAAI,mBAAmB;CACrB;CACA;CACA;CACA;CACD,CAAC;;;;AAKJ,MAAa,iBACX,SACA,SAEA,OAAO,IAAI;CACT,WAAW,KAAK,MAAM,QAAQ;CAC9B,QAAQ,UAAU,aAAa,QAAQ,MAAM,OAAO,eAAe;CACpE,CAAC,CAAC,KACD,OAAO,SAAS,WACd,OAAO,oBAAoB,mBAAmB,CAAC,OAAO,CAAC,KACrD,OAAO,UAAU,UACf,aAAa,QAAQ,MAAM,OAAO,+BAA+B,CAClE,CACF,CACF,CACF;;AAGH,MAAa,QAAQ,SACnB,cAAc,GAAG,EAAE,GAAG,MAAM,CAAC"}

package/dist/{cassette-store-BunkvLoV.d.ts → cassette-store-BMtcjh5h.d.ts}

@@ -1,4 +1,4 @@
-import { n as CassetteFile, t as Cassette } from "./types-DWwkMzxG.js";
+import { n as CassetteFile } from "./types-XZehMu_v.js";
 import { Context, Effect } from "effect";
 import * as effect_Types0 from "effect/Types";
 import * as effect_Cause0 from "effect/Cause";
@@ -30,7 +30,31 @@ declare class CassetteStore extends CassetteStore_base {}
 /**
  * Creates a new empty cassette with a timestamp and format version.
  */
-declare const createEmptyCassette: () => Effect.Effect<Cassette, never, never>;
+declare const createEmptyCassette: () => Effect.Effect<{
+  readonly meta: {
+    readonly createdAt: string;
+    readonly version: string;
+  };
+  readonly entries: {
+    readonly [x: string]: {
+      readonly request: {
+        readonly method: string;
+        readonly url: string;
+        readonly headers?: {
+          readonly [x: string]: string;
+        } | undefined;
+        readonly body?: string | undefined;
+      };
+      readonly response: {
+        readonly body: string;
+        readonly status: number;
+        readonly headers?: {
+          readonly [x: string]: string;
+        } | undefined;
+      };
+    };
+  };
+}, never, never>;
 declare const createEmptyCassetteFile: () => Effect.Effect<CassetteFile>;
 declare const CassetteStoreError_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: "CassetteStoreError";
@@ -49,11 +73,11 @@ declare class CassetteStoreError extends CassetteStoreError_base<{
 }> {}
 declare const toStoreError: (operation: CassetteStoreOperation, path: string, cause?: unknown, message?: string) => CassetteStoreError;
 /**
- * Parses cassette JSON and maps invalid JSON to a store error.
+ * Parses cassette JSON and maps invalid JSON or an invalid cassette shape to a store error.
  */
-declare const parseCassette: (content: string, path: string) => Effect.Effect<CassetteFile, CassetteStoreError, never>;
+declare const parseCassette: (content: string, path: string) => Effect.Effect<CassetteFile, CassetteStoreError>;
 /** Creates a `CassetteStore` implementation that uses the given `impl` object. */
 declare const make: (impl: CassetteStoreService) => CassetteStoreService;
 //#endregion
 export { cassette_store_d_exports as a, make as c, CassetteStoreService as i, parseCassette as l, CassetteStoreError as n, createEmptyCassette as o, CassetteStoreOperation as r, createEmptyCassetteFile as s, CassetteStore as t, toStoreError as u };
-//# sourceMappingURL=cassette-store-BunkvLoV.d.ts.map
+//# sourceMappingURL=cassette-store-BMtcjh5h.d.ts.map

package/dist/cassette-store.d.ts

@@ -1,3 +1,3 @@
-import "./types-DWwkMzxG.js";
-import { c as make, i as CassetteStoreService, l as parseCassette, n as CassetteStoreError, o as createEmptyCassette, r as CassetteStoreOperation, s as createEmptyCassetteFile, t as CassetteStore, u as toStoreError } from "./cassette-store-BunkvLoV.js";
+import "./types-XZehMu_v.js";
+import { c as make, i as CassetteStoreService, l as parseCassette, n as CassetteStoreError, o as createEmptyCassette, r as CassetteStoreOperation, s as createEmptyCassetteFile, t as CassetteStore, u as toStoreError } from "./cassette-store-BMtcjh5h.js";
 export { CassetteStore, CassetteStoreError, CassetteStoreOperation, CassetteStoreService, createEmptyCassette, createEmptyCassetteFile, make, parseCassette, toStoreError };

package/dist/cassette-store.js

@@ -1,3 +1,4 @@
-import { a as createEmptyCassetteFile, c as toStoreError, i as createEmptyCassette, n as CassetteStoreError, o as make, s as parseCassette, t as CassetteStore } from "./cassette-store-CnXX5OLB.js";
+import "./types-DMuz_JGd.js";
+import { a as createEmptyCassetteFile, c as toStoreError, i as createEmptyCassette, n as CassetteStoreError, o as make, s as parseCassette, t as CassetteStore } from "./cassette-store-BF9e0rz3.js";
 
 export { CassetteStore, CassetteStoreError, createEmptyCassette, createEmptyCassetteFile, make, parseCassette, toStoreError };

package/dist/{file-system-cassette-store-LXpwwrw3.d.ts → file-system-cassette-store-ClYAuH7U.d.ts}

@@ -1,4 +1,4 @@
-import { n as CassetteStoreError, t as CassetteStore } from "./cassette-store-BunkvLoV.js";
+import { n as CassetteStoreError, t as CassetteStore } from "./cassette-store-BMtcjh5h.js";
 import { FileSystem, Layer, Path } from "effect";
 
 //#region src/file-system-cassette-store.d.ts
@@ -13,7 +13,7 @@ type FileSystemCassetteStoreConfig = {
  *
  * Requires a platform FileSystem layer (Node/Bun) to be provided by the user.
  */
-declare const layer: (config?: FileSystemCassetteStoreConfig) => Layer.Layer<CassetteStore, CassetteStoreError, Path.Path | FileSystem.FileSystem>;
+declare const layer: (config?: FileSystemCassetteStoreConfig) => Layer.Layer<CassetteStore, CassetteStoreError, FileSystem.FileSystem | Path.Path>;
 //#endregion
 export { file_system_cassette_store_d_exports as n, layer as r, FileSystemCassetteStoreConfig as t };
-//# sourceMappingURL=file-system-cassette-store-LXpwwrw3.d.ts.map
+//# sourceMappingURL=file-system-cassette-store-ClYAuH7U.d.ts.map

package/dist/{file-system-cassette-store-zWkrhhlO.js → file-system-cassette-store-CyOsu3z5.js}

@@ -1,6 +1,6 @@
 import { t as __export } from "./chunk-Bp6m_JJh.js";
-import { a as createEmptyCassetteFile, c as toStoreError, o as make, s as parseCassette, t as CassetteStore } from "./cassette-store-CnXX5OLB.js";
-import { t as getVitestState } from "./vitest-state-BOynp4Va.js";
+import { a as createEmptyCassetteFile, c as toStoreError, o as make, s as parseCassette, t as CassetteStore } from "./cassette-store-BF9e0rz3.js";
+import { t as getVitestState } from "./vitest-state-CiW5dzXZ.js";
 import { Effect, FileSystem, Layer, Path } from "effect";
 
 //#region src/file-system-cassette-store.ts
@@ -39,4 +39,4 @@ const layer = (config = {}) => Layer.effect(CassetteStore)(Effect.gen(function*
 
 //#endregion
 export { layer as n, file_system_cassette_store_exports as t };
-//# sourceMappingURL=file-system-cassette-store-zWkrhhlO.js.map
+//# sourceMappingURL=file-system-cassette-store-CyOsu3z5.js.map

package/dist/{file-system-cassette-store-zWkrhhlO.js.map → file-system-cassette-store-CyOsu3z5.js.map}

@@ -1 +1 @@
-{"version":3,"file":"file-system-cassette-store-zWkrhhlO.js","names":["CassetteStore.CassetteStore","rootDir: string","CassetteStore.toStoreError","CassetteStore.parseCassette","CassetteStore.createEmptyCassetteFile","CassetteStore.make"],"sources":["../src/file-system-cassette-store.ts"],"sourcesContent":["import { Effect, Layer, FileSystem, Path } from \"effect\";\n\nimport type { CassetteFile } from \"./types\";\n\nimport * as CassetteStore from \"./cassette-store\";\nimport { getVitestState } from \"./vitest-state\";\n\nexport type FileSystemCassetteStoreConfig = {\n  readonly cassetteDir?: string;\n};\n\n/**\n * FileSystem-backed cassette store.\n *\n * Requires a platform FileSystem layer (Node/Bun) to be provided by the user.\n */\nexport const layer = (config: FileSystemCassetteStoreConfig = {}) =>\n  Layer.effect(CassetteStore.CassetteStore)(\n    Effect.gen(function* () {\n      const fs = yield* FileSystem.FileSystem;\n      const path = yield* Path.Path;\n\n      let rootDir: string;\n      if (config.cassetteDir) {\n        rootDir = config.cassetteDir;\n      } else {\n        const { testPath } = getVitestState();\n        if (!testPath) {\n          return yield* Effect.fail(\n            CassetteStore.toStoreError(\n              \"resolveRoot\",\n              \"__cassettes__\",\n              undefined,\n              \"VCR cassette directory could not be inferred. Provide cassetteDir when not running in Vitest.\",\n            ),\n          );\n        }\n        const testFolder = path.dirname(testPath);\n        rootDir = path.join(testFolder, \"__cassettes__\");\n      }\n\n      const fullPath = (name: string) => path.join(rootDir, name);\n\n      const load = (name: string) =>\n        fs.readFileString(fullPath(name)).pipe(\n          Effect.mapError((error) => CassetteStore.toStoreError(\"load\", name, error)),\n          Effect.flatMap((content) => CassetteStore.parseCassette(content, name)),\n        );\n\n      const save = (name: string, cassette: CassetteFile) => {\n        const filePath = fullPath(name);\n        const dir = path.dirname(filePath);\n        const ensureDir =\n          dir === \"\"\n            ? Effect.void\n            : fs\n                .makeDirectory(dir, { recursive: true })\n                .pipe(Effect.mapError((error) => CassetteStore.toStoreError(\"save\", dir, error)));\n        return ensureDir.pipe(\n          Effect.andThen(\n            fs\n              .writeFileString(filePath, JSON.stringify(cassette, null, 2))\n              .pipe(Effect.mapError((error) => CassetteStore.toStoreError(\"save\", name, error))),\n          ),\n        );\n      };\n\n      const loadOrInit = (name: string) =>\n        fs.exists(fullPath(name)).pipe(\n          Effect.mapError((error) => CassetteStore.toStoreError(\"loadOrInit\", name, error)),\n          Effect.flatMap((exists) =>\n            exists\n              ? load(name)\n              : CassetteStore.createEmptyCassetteFile().pipe(\n                  Effect.tap((cassette) => save(name, cassette)),\n                ),\n          ),\n        );\n\n      return CassetteStore.make({\n        exists: (name: string) =>\n          fs\n            .exists(fullPath(name))\n            .pipe(Effect.mapError((error) => CassetteStore.toStoreError(\"exists\", name, error))),\n        load,\n        save,\n        loadOrInit,\n      });\n    }),\n  );\n"],"mappings":";;;;;;;;;;;;AAgBA,MAAa,SAAS,SAAwC,EAAE,KAC9D,MAAM,OAAOA,cAA4B,CACvC,OAAO,IAAI,aAAa;CACtB,MAAM,KAAK,OAAO,WAAW;CAC7B,MAAM,OAAO,OAAO,KAAK;CAEzB,IAAIC;AACJ,KAAI,OAAO,YACT,WAAU,OAAO;MACZ;EACL,MAAM,EAAE,aAAa,gBAAgB;AACrC,MAAI,CAAC,SACH,QAAO,OAAO,OAAO,KACnBC,aACE,eACA,iBACA,QACA,gGACD,CACF;EAEH,MAAM,aAAa,KAAK,QAAQ,SAAS;AACzC,YAAU,KAAK,KAAK,YAAY,gBAAgB;;CAGlD,MAAM,YAAY,SAAiB,KAAK,KAAK,SAAS,KAAK;CAE3D,MAAM,QAAQ,SACZ,GAAG,eAAe,SAAS,KAAK,CAAC,CAAC,KAChC,OAAO,UAAU,UAAUA,aAA2B,QAAQ,MAAM,MAAM,CAAC,EAC3E,OAAO,SAAS,YAAYC,cAA4B,SAAS,KAAK,CAAC,CACxE;CAEH,MAAM,QAAQ,MAAc,aAA2B;EACrD,MAAM,WAAW,SAAS,KAAK;EAC/B,MAAM,MAAM,KAAK,QAAQ,SAAS;AAOlC,UALE,QAAQ,KACJ,OAAO,OACP,GACG,cAAc,KAAK,EAAE,WAAW,MAAM,CAAC,CACvC,KAAK,OAAO,UAAU,UAAUD,aAA2B,QAAQ,KAAK,MAAM,CAAC,CAAC,EACxE,KACf,OAAO,QACL,GACG,gBAAgB,UAAU,KAAK,UAAU,UAAU,MAAM,EAAE,CAAC,CAC5D,KAAK,OAAO,UAAU,UAAUA,aAA2B,QAAQ,MAAM,MAAM,CAAC,CAAC,CACrF,CACF;;CAGH,MAAM,cAAc,SAClB,GAAG,OAAO,SAAS,KAAK,CAAC,CAAC,KACxB,OAAO,UAAU,UAAUA,aAA2B,cAAc,MAAM,MAAM,CAAC,EACjF,OAAO,SAAS,WACd,SACI,KAAK,KAAK,GACVE,yBAAuC,CAAC,KACtC,OAAO,KAAK,aAAa,KAAK,MAAM,SAAS,CAAC,CAC/C,CACN,CACF;AAEH,QAAOC,KAAmB;EACxB,SAAS,SACP,GACG,OAAO,SAAS,KAAK,CAAC,CACtB,KAAK,OAAO,UAAU,UAAUH,aAA2B,UAAU,MAAM,MAAM,CAAC,CAAC;EACxF;EACA;EACA;EACD,CAAC;EACF,CACH"}
+{"version":3,"file":"file-system-cassette-store-CyOsu3z5.js","names":["CassetteStore.CassetteStore","rootDir: string","CassetteStore.toStoreError","CassetteStore.parseCassette","CassetteStore.createEmptyCassetteFile","CassetteStore.make"],"sources":["../src/file-system-cassette-store.ts"],"sourcesContent":["import { Effect, Layer, FileSystem, Path } from \"effect\";\n\nimport type { CassetteFile } from \"./types\";\n\nimport * as CassetteStore from \"./cassette-store\";\nimport { getVitestState } from \"./vitest-state\";\n\nexport type FileSystemCassetteStoreConfig = {\n  readonly cassetteDir?: string;\n};\n\n/**\n * FileSystem-backed cassette store.\n *\n * Requires a platform FileSystem layer (Node/Bun) to be provided by the user.\n */\nexport const layer = (config: FileSystemCassetteStoreConfig = {}) =>\n  Layer.effect(CassetteStore.CassetteStore)(\n    Effect.gen(function* () {\n      const fs = yield* FileSystem.FileSystem;\n      const path = yield* Path.Path;\n\n      let rootDir: string;\n      if (config.cassetteDir) {\n        rootDir = config.cassetteDir;\n      } else {\n        const { testPath } = getVitestState();\n        if (!testPath) {\n          return yield* Effect.fail(\n            CassetteStore.toStoreError(\n              \"resolveRoot\",\n              \"__cassettes__\",\n              undefined,\n              \"VCR cassette directory could not be inferred. Provide cassetteDir when not running in Vitest.\",\n            ),\n          );\n        }\n        const testFolder = path.dirname(testPath);\n        rootDir = path.join(testFolder, \"__cassettes__\");\n      }\n\n      const fullPath = (name: string) => path.join(rootDir, name);\n\n      const load = (name: string) =>\n        fs.readFileString(fullPath(name)).pipe(\n          Effect.mapError((error) => CassetteStore.toStoreError(\"load\", name, error)),\n          Effect.flatMap((content) => CassetteStore.parseCassette(content, name)),\n        );\n\n      const save = (name: string, cassette: CassetteFile) => {\n        const filePath = fullPath(name);\n        const dir = path.dirname(filePath);\n        const ensureDir =\n          dir === \"\"\n            ? Effect.void\n            : fs\n                .makeDirectory(dir, { recursive: true })\n                .pipe(Effect.mapError((error) => CassetteStore.toStoreError(\"save\", dir, error)));\n        return ensureDir.pipe(\n          Effect.andThen(\n            fs\n              .writeFileString(filePath, JSON.stringify(cassette, null, 2))\n              .pipe(Effect.mapError((error) => CassetteStore.toStoreError(\"save\", name, error))),\n          ),\n        );\n      };\n\n      const loadOrInit = (name: string) =>\n        fs.exists(fullPath(name)).pipe(\n          Effect.mapError((error) => CassetteStore.toStoreError(\"loadOrInit\", name, error)),\n          Effect.flatMap((exists) =>\n            exists\n              ? load(name)\n              : CassetteStore.createEmptyCassetteFile().pipe(\n                  Effect.tap((cassette) => save(name, cassette)),\n                ),\n          ),\n        );\n\n      return CassetteStore.make({\n        exists: (name: string) =>\n          fs\n            .exists(fullPath(name))\n            .pipe(Effect.mapError((error) => CassetteStore.toStoreError(\"exists\", name, error))),\n        load,\n        save,\n        loadOrInit,\n      });\n    }),\n  );\n"],"mappings":";;;;;;;;;;;;AAgBA,MAAa,SAAS,SAAwC,EAAE,KAC9D,MAAM,OAAOA,cAA4B,CACvC,OAAO,IAAI,aAAa;CACtB,MAAM,KAAK,OAAO,WAAW;CAC7B,MAAM,OAAO,OAAO,KAAK;CAEzB,IAAIC;AACJ,KAAI,OAAO,YACT,WAAU,OAAO;MACZ;EACL,MAAM,EAAE,aAAa,gBAAgB;AACrC,MAAI,CAAC,SACH,QAAO,OAAO,OAAO,KACnBC,aACE,eACA,iBACA,QACA,gGACD,CACF;EAEH,MAAM,aAAa,KAAK,QAAQ,SAAS;AACzC,YAAU,KAAK,KAAK,YAAY,gBAAgB;;CAGlD,MAAM,YAAY,SAAiB,KAAK,KAAK,SAAS,KAAK;CAE3D,MAAM,QAAQ,SACZ,GAAG,eAAe,SAAS,KAAK,CAAC,CAAC,KAChC,OAAO,UAAU,UAAUA,aAA2B,QAAQ,MAAM,MAAM,CAAC,EAC3E,OAAO,SAAS,YAAYC,cAA4B,SAAS,KAAK,CAAC,CACxE;CAEH,MAAM,QAAQ,MAAc,aAA2B;EACrD,MAAM,WAAW,SAAS,KAAK;EAC/B,MAAM,MAAM,KAAK,QAAQ,SAAS;AAOlC,UALE,QAAQ,KACJ,OAAO,OACP,GACG,cAAc,KAAK,EAAE,WAAW,MAAM,CAAC,CACvC,KAAK,OAAO,UAAU,UAAUD,aAA2B,QAAQ,KAAK,MAAM,CAAC,CAAC,EACxE,KACf,OAAO,QACL,GACG,gBAAgB,UAAU,KAAK,UAAU,UAAU,MAAM,EAAE,CAAC,CAC5D,KAAK,OAAO,UAAU,UAAUA,aAA2B,QAAQ,MAAM,MAAM,CAAC,CAAC,CACrF,CACF;;CAGH,MAAM,cAAc,SAClB,GAAG,OAAO,SAAS,KAAK,CAAC,CAAC,KACxB,OAAO,UAAU,UAAUA,aAA2B,cAAc,MAAM,MAAM,CAAC,EACjF,OAAO,SAAS,WACd,SACI,KAAK,KAAK,GACVE,yBAAuC,CAAC,KACtC,OAAO,KAAK,aAAa,KAAK,MAAM,SAAS,CAAC,CAC/C,CACN,CACF;AAEH,QAAOC,KAAmB;EACxB,SAAS,SACP,GACG,OAAO,SAAS,KAAK,CAAC,CACtB,KAAK,OAAO,UAAU,UAAUH,aAA2B,UAAU,MAAM,MAAM,CAAC,CAAC;EACxF;EACA;EACA;EACD,CAAC;EACF,CACH"}

package/dist/file-system-cassette-store.d.ts

@@ -1,4 +1,4 @@
-import "./types-DWwkMzxG.js";
-import "./cassette-store-BunkvLoV.js";
-import { r as layer, t as FileSystemCassetteStoreConfig } from "./file-system-cassette-store-LXpwwrw3.js";
+import "./types-XZehMu_v.js";
+import "./cassette-store-BMtcjh5h.js";
+import { r as layer, t as FileSystemCassetteStoreConfig } from "./file-system-cassette-store-ClYAuH7U.js";
 export { FileSystemCassetteStoreConfig, layer };

package/dist/file-system-cassette-store.js

@@ -1,5 +1,6 @@
-import "./cassette-store-CnXX5OLB.js";
-import "./vitest-state-BOynp4Va.js";
-import { n as layer } from "./file-system-cassette-store-zWkrhhlO.js";
+import "./types-DMuz_JGd.js";
+import "./cassette-store-BF9e0rz3.js";
+import "./vitest-state-CiW5dzXZ.js";
+import { n as layer } from "./file-system-cassette-store-CyOsu3z5.js";
 
 export { layer };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-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 };
+import { a as VcrConfig, c as VcrMode, d as VcrRequestSchema, f as VcrResponse, i as CassetteSchema, l as VcrRedactedValue, n as CassetteFile, o as VcrEntry, p as VcrResponseSchema, r as CassetteFileSchema, s as VcrEntrySchema, t as Cassette, u as VcrRequest } from "./types-XZehMu_v.js";
+import { a as cassette_store_d_exports } from "./cassette-store-BMtcjh5h.js";
+import { n as file_system_cassette_store_d_exports } from "./file-system-cassette-store-ClYAuH7U.js";
+import { r as vcr_http_client_d_exports } from "./vcr-http-client-BveeoOoW.js";
+export { Cassette, CassetteFile, CassetteFileSchema, CassetteSchema, cassette_store_d_exports as CassetteStore, file_system_cassette_store_d_exports as FileSystemCassetteStore, VcrConfig, VcrEntry, VcrEntrySchema, vcr_http_client_d_exports as VcrHttpClient, VcrMode, VcrRedactedValue, VcrRequest, VcrRequestSchema, VcrResponse, VcrResponseSchema };

package/dist/index.js

@@ -1,7 +1,7 @@
-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";
+import { a as VcrResponseSchema, i as VcrRequestSchema, n as CassetteSchema, r as VcrEntrySchema, t as CassetteFileSchema } from "./types-DMuz_JGd.js";
+import { r as cassette_store_exports } from "./cassette-store-BF9e0rz3.js";
+import "./vitest-state-CiW5dzXZ.js";
+import { t as file_system_cassette_store_exports } from "./file-system-cassette-store-CyOsu3z5.js";
+import { r as vcr_http_client_exports } from "./vcr-http-client-Ba0WYPV9.js";
 
-export { cassette_store_exports as CassetteStore, file_system_cassette_store_exports as FileSystemCassetteStore, vcr_http_client_exports as VcrHttpClient };
+export { CassetteFileSchema, CassetteSchema, cassette_store_exports as CassetteStore, file_system_cassette_store_exports as FileSystemCassetteStore, VcrEntrySchema, vcr_http_client_exports as VcrHttpClient, VcrRequestSchema, VcrResponseSchema };

package/dist/types-DMuz_JGd.js

@@ -0,0 +1,45 @@
+import { Schema } from "effect";
+
+//#region src/types.ts
+/**
+* Serialized request shape stored in a cassette.
+*/
+const VcrRequestSchema = Schema.Struct({
+	method: Schema.String,
+	url: Schema.String,
+	headers: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+	body: Schema.optional(Schema.String)
+});
+/**
+* Serialized response shape stored in a cassette.
+*/
+const VcrResponseSchema = Schema.Struct({
+	status: Schema.Number,
+	body: Schema.String,
+	headers: Schema.optional(Schema.Record(Schema.String, Schema.String))
+});
+/**
+* A single request/response pair keyed in the cassette.
+*/
+const VcrEntrySchema = Schema.Struct({
+	request: VcrRequestSchema,
+	response: VcrResponseSchema
+});
+/**
+* Cassette file format.
+*/
+const CassetteSchema = Schema.Struct({
+	meta: Schema.Struct({
+		createdAt: Schema.String,
+		version: Schema.String
+	}),
+	entries: Schema.Record(Schema.String, VcrEntrySchema)
+});
+/**
+* Cassette file format with multiple exports.
+*/
+const CassetteFileSchema = Schema.Struct({ exports: Schema.Record(Schema.String, CassetteSchema) });
+
+//#endregion
+export { VcrResponseSchema as a, VcrRequestSchema as i, CassetteSchema as n, VcrEntrySchema as r, CassetteFileSchema as t };
+//# sourceMappingURL=types-DMuz_JGd.js.map

package/dist/types-DMuz_JGd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-DMuz_JGd.js","names":[],"sources":["../src/types.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\n/**\n * VCR operating mode.\n * - record: always call the live client and persist.\n * - replay: serve only from cassette, fail if missing.\n * - auto: replay if cassette exists, otherwise record (fail in CI).\n */\nexport type VcrMode = \"record\" | \"replay\" | \"auto\";\n\n/**\n * Safe scalar value written in place of a sensitive body field.\n */\nexport type VcrRedactedValue = string | number | boolean | null;\n\n/**\n * Serialized request shape stored in a cassette.\n */\nexport const VcrRequestSchema = Schema.Struct({\n  method: Schema.String,\n  url: Schema.String,\n  headers: Schema.optional(Schema.Record(Schema.String, Schema.String)),\n  body: Schema.optional(Schema.String),\n});\nexport type VcrRequest = Schema.Schema.Type<typeof VcrRequestSchema>;\n\n/**\n * Serialized response shape stored in a cassette.\n */\nexport const VcrResponseSchema = Schema.Struct({\n  status: Schema.Number,\n  body: Schema.String,\n  headers: Schema.optional(Schema.Record(Schema.String, Schema.String)),\n});\nexport type VcrResponse = Schema.Schema.Type<typeof VcrResponseSchema>;\n\n/**\n * A single request/response pair keyed in the cassette.\n */\nexport const VcrEntrySchema = Schema.Struct({\n  request: VcrRequestSchema,\n  response: VcrResponseSchema,\n});\nexport type VcrEntry = Schema.Schema.Type<typeof VcrEntrySchema>;\n\n/**\n * Cassette file format.\n */\nexport const CassetteSchema = Schema.Struct({\n  meta: Schema.Struct({\n    createdAt: Schema.String,\n    version: Schema.String,\n  }),\n  entries: Schema.Record(Schema.String, VcrEntrySchema),\n});\nexport type Cassette = Schema.Schema.Type<typeof CassetteSchema>;\n\n/**\n * Cassette file format with multiple exports.\n */\nexport const CassetteFileSchema = Schema.Struct({\n  exports: Schema.Record(Schema.String, CassetteSchema),\n});\nexport type CassetteFile = Schema.Schema.Type<typeof CassetteFileSchema>;\n\n/**\n * VCR configuration.\n */\nexport type VcrConfig = {\n  readonly vcrName?: string;\n  /**\n   * Cassette file name or basename.\n   *\n   * `users` resolves to `users.cassette`.\n   * `users.cassette` is preserved as-is.\n   */\n  readonly cassetteName?: string;\n  readonly mode?: VcrMode;\n  /**\n   * Remove or replace sensitive data before writing to disk.\n   */\n  readonly redact?: {\n    readonly requestHeaders?: ReadonlyArray<string>;\n    readonly responseHeaders?: ReadonlyArray<string>;\n    readonly requestBodyKeys?: ReadonlyArray<string>;\n    readonly responseBodyKeys?: ReadonlyArray<string>;\n    readonly requestBodyReplacements?: Readonly<Record<string, VcrRedactedValue>>;\n    readonly responseBodyReplacements?: Readonly<Record<string, VcrRedactedValue>>;\n  };\n  /**\n   * Ignore fields when computing the request key for replay matching.\n   */\n  readonly matchIgnore?: {\n    readonly requestHeaders?: ReadonlyArray<string>;\n    readonly requestBodyKeys?: ReadonlyArray<string>;\n  };\n  /**\n   * Custom matcher to override key-based lookup.\n   */\n  readonly match?: (request: VcrRequest, entry: VcrEntry) => boolean;\n};\n"],"mappings":";;;;;;AAkBA,MAAa,mBAAmB,OAAO,OAAO;CAC5C,QAAQ,OAAO;CACf,KAAK,OAAO;CACZ,SAAS,OAAO,SAAS,OAAO,OAAO,OAAO,QAAQ,OAAO,OAAO,CAAC;CACrE,MAAM,OAAO,SAAS,OAAO,OAAO;CACrC,CAAC;;;;AAMF,MAAa,oBAAoB,OAAO,OAAO;CAC7C,QAAQ,OAAO;CACf,MAAM,OAAO;CACb,SAAS,OAAO,SAAS,OAAO,OAAO,OAAO,QAAQ,OAAO,OAAO,CAAC;CACtE,CAAC;;;;AAMF,MAAa,iBAAiB,OAAO,OAAO;CAC1C,SAAS;CACT,UAAU;CACX,CAAC;;;;AAMF,MAAa,iBAAiB,OAAO,OAAO;CAC1C,MAAM,OAAO,OAAO;EAClB,WAAW,OAAO;EAClB,SAAS,OAAO;EACjB,CAAC;CACF,SAAS,OAAO,OAAO,OAAO,QAAQ,eAAe;CACtD,CAAC;;;;AAMF,MAAa,qBAAqB,OAAO,OAAO,EAC9C,SAAS,OAAO,OAAO,OAAO,QAAQ,eAAe,EACtD,CAAC"}

package/dist/types-XZehMu_v.d.ts

@@ -0,0 +1,138 @@
+import { Schema } from "effect";
+
+//#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";
+/**
+ * Safe scalar value written in place of a sensitive body field.
+ */
+type VcrRedactedValue = string | number | boolean | null;
+/**
+ * Serialized request shape stored in a cassette.
+ */
+declare const VcrRequestSchema: Schema.Struct<{
+  readonly method: Schema.String;
+  readonly url: Schema.String;
+  readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+  readonly body: Schema.optional<Schema.String>;
+}>;
+type VcrRequest = Schema.Schema.Type<typeof VcrRequestSchema>;
+/**
+ * Serialized response shape stored in a cassette.
+ */
+declare const VcrResponseSchema: Schema.Struct<{
+  readonly status: Schema.Number;
+  readonly body: Schema.String;
+  readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+}>;
+type VcrResponse = Schema.Schema.Type<typeof VcrResponseSchema>;
+/**
+ * A single request/response pair keyed in the cassette.
+ */
+declare const VcrEntrySchema: Schema.Struct<{
+  readonly request: Schema.Struct<{
+    readonly method: Schema.String;
+    readonly url: Schema.String;
+    readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    readonly body: Schema.optional<Schema.String>;
+  }>;
+  readonly response: Schema.Struct<{
+    readonly status: Schema.Number;
+    readonly body: Schema.String;
+    readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+  }>;
+}>;
+type VcrEntry = Schema.Schema.Type<typeof VcrEntrySchema>;
+/**
+ * Cassette file format.
+ */
+declare const CassetteSchema: Schema.Struct<{
+  readonly meta: Schema.Struct<{
+    readonly createdAt: Schema.String;
+    readonly version: Schema.String;
+  }>;
+  readonly entries: Schema.$Record<Schema.String, Schema.Struct<{
+    readonly request: Schema.Struct<{
+      readonly method: Schema.String;
+      readonly url: Schema.String;
+      readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+      readonly body: Schema.optional<Schema.String>;
+    }>;
+    readonly response: Schema.Struct<{
+      readonly status: Schema.Number;
+      readonly body: Schema.String;
+      readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    }>;
+  }>>;
+}>;
+type Cassette = Schema.Schema.Type<typeof CassetteSchema>;
+/**
+ * Cassette file format with multiple exports.
+ */
+declare const CassetteFileSchema: Schema.Struct<{
+  readonly exports: Schema.$Record<Schema.String, Schema.Struct<{
+    readonly meta: Schema.Struct<{
+      readonly createdAt: Schema.String;
+      readonly version: Schema.String;
+    }>;
+    readonly entries: Schema.$Record<Schema.String, Schema.Struct<{
+      readonly request: Schema.Struct<{
+        readonly method: Schema.String;
+        readonly url: Schema.String;
+        readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+        readonly body: Schema.optional<Schema.String>;
+      }>;
+      readonly response: Schema.Struct<{
+        readonly status: Schema.Number;
+        readonly body: Schema.String;
+        readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+      }>;
+    }>>;
+  }>>;
+}>;
+type CassetteFile = Schema.Schema.Type<typeof CassetteFileSchema>;
+/**
+ * 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 or replace sensitive data before writing to disk.
+   */
+  readonly redact?: {
+    readonly requestHeaders?: ReadonlyArray<string>;
+    readonly responseHeaders?: ReadonlyArray<string>;
+    readonly requestBodyKeys?: ReadonlyArray<string>;
+    readonly responseBodyKeys?: ReadonlyArray<string>;
+    readonly requestBodyReplacements?: Readonly<Record<string, VcrRedactedValue>>;
+    readonly responseBodyReplacements?: Readonly<Record<string, VcrRedactedValue>>;
+  };
+  /**
+   * 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 { VcrConfig as a, VcrMode as c, VcrRequestSchema as d, VcrResponse as f, CassetteSchema as i, VcrRedactedValue as l, CassetteFile as n, VcrEntry as o, VcrResponseSchema as p, CassetteFileSchema as r, VcrEntrySchema as s, Cassette as t, VcrRequest as u };
+//# sourceMappingURL=types-XZehMu_v.d.ts.map

package/dist/types.d.ts

@@ -1,2 +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 };
+import { a as VcrConfig, c as VcrMode, d as VcrRequestSchema, f as VcrResponse, i as CassetteSchema, l as VcrRedactedValue, n as CassetteFile, o as VcrEntry, p as VcrResponseSchema, r as CassetteFileSchema, s as VcrEntrySchema, t as Cassette, u as VcrRequest } from "./types-XZehMu_v.js";
+export { Cassette, CassetteFile, CassetteFileSchema, CassetteSchema, VcrConfig, VcrEntry, VcrEntrySchema, VcrMode, VcrRedactedValue, VcrRequest, VcrRequestSchema, VcrResponse, VcrResponseSchema };

package/dist/types.js

@@ -1,3 +1,3 @@
-import "./types-BsuPrIpu.js";
+import { a as VcrResponseSchema, i as VcrRequestSchema, n as CassetteSchema, r as VcrEntrySchema, t as CassetteFileSchema } from "./types-DMuz_JGd.js";
 
-export {  };
+export { CassetteFileSchema, CassetteSchema, VcrEntrySchema, VcrRequestSchema, VcrResponseSchema };