@yolk-sdk/conformance 0.1.0-canary.96

package/dist/record.mjs

@@ -0,0 +1,212 @@
+import { headerRecord, isCredentialHeaderName, isNullBodyStatus, mediaType, parseJsonText, recordBytes, requestBodyText } from "./wire-internal.mjs";
+import { decodeWireFixture, scanFixtureForSecrets } from "./fixture.mjs";
+import { Context, Data, Effect, Exit, Layer, Option, Ref, Stream } from "effect";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+//#region src/record.ts
+/**
+* Record live HTTP exchanges as wire fixtures.
+*
+* This module never constructs a network client: hosts supply the real
+* `HttpClient` (for example `FetchHttpClient.layer`) and this wrapper records
+* what flows through it without changing the bytes the caller receives.
+*
+* @experimental
+*/
+/** Default allowlisted request headers. Credential headers are always dropped. */
+const defaultRecordedRequestHeaders = ["content-type", "accept"];
+/**
+* Default allowlisted response headers. Entries ending in `*` are prefixes.
+* Credential headers (including `set-cookie`) are always dropped.
+*/
+const defaultRecordedResponseHeaders = [
+	"content-type",
+	"retry-after",
+	"retry-after-ms",
+	"x-ratelimit-*",
+	"ratelimit-*",
+	"anthropic-ratelimit-*"
+];
+/** Response media types recorded as `chunks` instead of a single `body`. */
+const defaultStreamMediaTypes = ["text/event-stream"];
+/** Raised by `drain` when a recorded request failed or its body was not read to the end. */
+var WireRecordingIncomplete = class extends Data.TaggedError("WireRecordingIncomplete") {
+	get message() {
+		return `Recording incomplete for ${this.requests.length} request(s): ${this.requests.join(", ")}`;
+	}
+};
+var WireRecorder = class WireRecorder extends Context.Service()("@yolk-sdk/conformance/WireRecorder") {
+	/**
+	* Wrap the `HttpClient` already in context and provide the recording client
+	* plus its `WireRecorder`. Provide the real client below this layer.
+	*/
+	static layer = (options = {}) => Layer.unwrap(Effect.gen(function* () {
+		const { client, recorder } = yield* makeRecordingHttpClient(yield* HttpClient.HttpClient, options);
+		return Layer.mergeAll(Layer.succeed(HttpClient.HttpClient, client), Layer.succeed(WireRecorder, recorder));
+	}));
+};
+const recordedChunk = (bytes) => {
+	const recorded = recordBytes(bytes);
+	return "text" in recorded ? recorded.text : { base64: recorded.base64 };
+};
+const recordedBody = (status, headers, bytes) => {
+	const recorded = recordBytes(bytes);
+	return "text" in recorded ? {
+		status,
+		headers,
+		body: recorded.text
+	} : {
+		status,
+		headers,
+		bodyBase64: recorded.base64
+	};
+};
+const headerAllowed = (allowlist, name) => !isCredentialHeaderName(name) && allowlist.some((entry) => {
+	const lower = entry.toLowerCase();
+	return lower.endsWith("*") ? name.startsWith(lower.slice(0, -1)) : name === lower;
+});
+const allowlistHeaders = (headers, allowlist) => {
+	const recorded = {};
+	for (const [name, value] of Object.entries(headerRecord(headers))) if (headerAllowed(allowlist, name)) recorded[name] = value;
+	return recorded;
+};
+const recordRequest = (request, allowlist) => Effect.gen(function* () {
+	const url = Option.match(HttpClientRequest.toUrl(request), {
+		onNone: () => request.url,
+		onSome: (resolved) => {
+			resolved.hash = "";
+			return resolved.toString();
+		}
+	});
+	const fields = {
+		method: request.method,
+		url
+	};
+	const headers = allowlistHeaders(request.headers, allowlist);
+	if (Object.keys(headers).length > 0) fields.headers = headers;
+	const text = requestBodyText(request);
+	if (text !== void 0 && text.length > 0) {
+		const json = yield* parseJsonText(text);
+		fields.body = Option.getOrElse(json, () => text);
+	}
+	return fields;
+});
+/**
+* Wrap a host-provided `HttpClient` so every exchange is recorded losslessly.
+* Streamed responses (see `streamMediaTypes`) are teed chunk by chunk with
+* network boundaries preserved: each chunk is stored as text when it is valid
+* UTF-8 on its own (empty chunks as `""`), otherwise as `{ base64 }` of its
+* exact bytes. Other responses are recorded as one `body` (valid UTF-8) or
+* `bodyBase64` (anything else). The caller receives the same status, headers,
+* and bytes. Body read failures still reach the caller as `HttpClientError`s
+* (the upstream error is kept as the cause), matching how `FetchHttpClient`
+* reports them.
+*/
+const makeRecordingHttpClient = (upstream, options = {}) => Effect.gen(function* () {
+	const requestAllowlist = options.requestHeaders ?? defaultRecordedRequestHeaders;
+	const responseAllowlist = options.responseHeaders ?? defaultRecordedResponseHeaders;
+	const streamMediaTypes = (options.streamMediaTypes ?? defaultStreamMediaTypes).map((type) => type.toLowerCase());
+	const state = yield* Ref.make({
+		nextId: 0,
+		entries: []
+	});
+	const reserve = (label) => Ref.modify(state, (current) => [current.nextId, {
+		nextId: current.nextId + 1,
+		entries: [...current.entries, {
+			id: current.nextId,
+			entry: {
+				status: "pending",
+				label
+			}
+		}]
+	}]);
+	const settle = (id, entry) => Ref.update(state, (current) => ({
+		...current,
+		entries: current.entries.map((item) => item.id === id && item.entry.status === "pending" ? {
+			id,
+			entry
+		} : item)
+	}));
+	return {
+		client: HttpClient.transform(upstream, (effect, request) => Effect.gen(function* () {
+			const wireRequest = yield* recordRequest(request, requestAllowlist);
+			const label = `${wireRequest.method} ${wireRequest.url.split("?", 1)[0]}`;
+			const id = yield* reserve(label);
+			const failed = settle(id, {
+				status: "failed",
+				label
+			});
+			const response = yield* effect.pipe(Effect.tapError(() => failed));
+			const headers = headerRecord(response.headers);
+			const recordedHeaders = allowlistHeaders(headers, responseAllowlist);
+			const init = {
+				status: response.status,
+				headers
+			};
+			const complete = (wireResponse) => settle(id, {
+				status: "complete",
+				label,
+				exchange: {
+					request: wireRequest,
+					response: wireResponse
+				}
+			});
+			const type = mediaType(headers["content-type"]);
+			if (type !== void 0 && streamMediaTypes.includes(type)) {
+				const chunks = [];
+				const teed = response.stream.pipe(Stream.tap((bytes) => Effect.sync(() => chunks.push(recordedChunk(bytes)))), Stream.onExit((exit) => Exit.isFailure(exit) ? failed : complete({
+					status: response.status,
+					headers: recordedHeaders,
+					chunks
+				})));
+				const readable = Stream.toReadableStream(teed, { strategy: { highWaterMark: 0 } });
+				return HttpClientResponse.fromWeb(request, new Response(readable, init));
+			}
+			const bytes = yield* response.arrayBuffer.pipe(Effect.tapError(() => failed));
+			yield* complete(recordedBody(response.status, recordedHeaders, new Uint8Array(bytes)));
+			return HttpClientResponse.fromWeb(request, new Response(isNullBodyStatus(response.status) ? null : bytes, init));
+		})),
+		recorder: { drain: Ref.modify(state, (current) => [current.entries, {
+			nextId: current.nextId,
+			entries: []
+		}]).pipe(Effect.flatMap((drained) => {
+			const exchanges = [];
+			const incomplete = [];
+			for (const { entry } of drained) if (entry.status === "complete") exchanges.push(entry.exchange);
+			else incomplete.push(entry.label);
+			return incomplete.length > 0 ? Effect.fail(new WireRecordingIncomplete({ requests: incomplete })) : Effect.succeed(exchanges);
+		})) }
+	};
+});
+/** A fixture failed schema validation (for example an empty exchange list or bad date). */
+var WireFixtureInvalid = class extends Data.TaggedError("WireFixtureInvalid") {
+	get message() {
+		return `Wire fixture ${this.fixtureId} is invalid`;
+	}
+};
+/** The secret scan found credentials or credential-like values in a fixture. */
+var WireFixtureSecretsFound = class extends Data.TaggedError("WireFixtureSecretsFound") {
+	get message() {
+		return `Wire fixture ${this.fixtureId} contains ${this.issues.length} secret-scan issue(s)`;
+	}
+};
+/**
+* Validate a fixture and run `scanFixtureForSecrets`. Fails with
+* `WireFixtureInvalid` or `WireFixtureSecretsFound`; never returns a fixture
+* with scan issues.
+*/
+const makeWireFixture = (input) => Effect.gen(function* () {
+	const fixture = yield* decodeWireFixture(input).pipe(Effect.mapError((cause) => new WireFixtureInvalid({
+		fixtureId: input.id,
+		cause
+	})));
+	const issues = scanFixtureForSecrets(fixture);
+	if (issues.length > 0) return yield* Effect.fail(new WireFixtureSecretsFound({
+		fixtureId: fixture.id,
+		issues
+	}));
+	return fixture;
+});
+//#endregion
+export { WireFixtureInvalid, WireFixtureSecretsFound, WireRecorder, WireRecordingIncomplete, defaultRecordedRequestHeaders, defaultRecordedResponseHeaders, defaultStreamMediaTypes, makeRecordingHttpClient, makeWireFixture };
+
+//# sourceMappingURL=record.mjs.map

package/dist/record.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"record.mjs","names":[],"sources":["../src/record.ts"],"sourcesContent":["/**\n * Record live HTTP exchanges as wire fixtures.\n *\n * This module never constructs a network client: hosts supply the real\n * `HttpClient` (for example `FetchHttpClient.layer`) and this wrapper records\n * what flows through it without changing the bytes the caller receives.\n *\n * @experimental\n */\nimport { Context, Data, Effect, Exit, Layer, Option, Ref, Stream } from 'effect'\nimport {\n  HttpClient,\n  HttpClientRequest,\n  HttpClientResponse,\n  type HttpClientError\n} from 'effect/unstable/http'\nimport {\n  decodeWireFixture,\n  scanFixtureForSecrets,\n  type FixtureSecretIssue,\n  type WireBodyResponse,\n  type WireChunk,\n  type WireExchange,\n  type WireFixture,\n  type WireHeaders,\n  type WireRequest,\n  type WireResponse\n} from './fixture.ts'\nimport {\n  headerRecord,\n  isCredentialHeaderName,\n  isNullBodyStatus,\n  mediaType,\n  parseJsonText,\n  recordBytes,\n  requestBodyText\n} from './wire-internal.ts'\n\n/** Default allowlisted request headers. Credential headers are always dropped. */\nexport const defaultRecordedRequestHeaders: ReadonlyArray<string> = ['content-type', 'accept']\n\n/**\n * Default allowlisted response headers. Entries ending in `*` are prefixes.\n * Credential headers (including `set-cookie`) are always dropped.\n */\nexport const defaultRecordedResponseHeaders: ReadonlyArray<string> = [\n  'content-type',\n  'retry-after',\n  'retry-after-ms',\n  'x-ratelimit-*',\n  'ratelimit-*',\n  'anthropic-ratelimit-*'\n]\n\n/** Response media types recorded as `chunks` instead of a single `body`. */\nexport const defaultStreamMediaTypes: ReadonlyArray<string> = ['text/event-stream']\n\nexport type WireRecorderOptions = {\n  readonly requestHeaders?: ReadonlyArray<string>\n  readonly responseHeaders?: ReadonlyArray<string>\n  readonly streamMediaTypes?: ReadonlyArray<string>\n}\n\n/** Raised by `drain` when a recorded request failed or its body was not read to the end. */\nexport class WireRecordingIncomplete extends Data.TaggedError('WireRecordingIncomplete')<{\n  /** `METHOD url` (query string removed) of each incomplete exchange. */\n  readonly requests: ReadonlyArray<string>\n}> {\n  override get message(): string {\n    return `Recording incomplete for ${this.requests.length} request(s): ${this.requests.join(', ')}`\n  }\n}\n\nexport type WireRecorderApi = {\n  /**\n   * Take every recorded exchange, in request order, and clear the recorder.\n   * Fails with `WireRecordingIncomplete` (and discards the drained entries)\n   * when any request failed or its body was not fully read.\n   *\n   * A request still pending at drain time is reported in that drain's\n   * `WireRecordingIncomplete` and is then dropped: if its body finishes later,\n   * the result is ignored and never appears in, or overwrites an entry of, a\n   * later drain.\n   */\n  readonly drain: Effect.Effect<ReadonlyArray<WireExchange>, WireRecordingIncomplete>\n}\n\nexport class WireRecorder extends Context.Service<WireRecorder, WireRecorderApi>()(\n  '@yolk-sdk/conformance/WireRecorder'\n) {\n  /**\n   * Wrap the `HttpClient` already in context and provide the recording client\n   * plus its `WireRecorder`. Provide the real client below this layer.\n   */\n  static layer = (\n    options: WireRecorderOptions = {}\n  ): Layer.Layer<HttpClient.HttpClient | WireRecorder, never, HttpClient.HttpClient> =>\n    Layer.unwrap(\n      Effect.gen(function* () {\n        const upstream = yield* HttpClient.HttpClient\n        const { client, recorder } = yield* makeRecordingHttpClient(upstream, options)\n\n        return Layer.mergeAll(\n          Layer.succeed(HttpClient.HttpClient, client),\n          Layer.succeed(WireRecorder, recorder)\n        )\n      })\n    )\n}\n\ntype RecordingEntry =\n  | { readonly status: 'pending'; readonly label: string }\n  | { readonly status: 'failed'; readonly label: string }\n  | { readonly status: 'complete'; readonly label: string; readonly exchange: WireExchange }\n\n// `id` is a monotonic reservation id that is never reused, so a finalizer from\n// a request reserved before a `drain` cannot settle an entry reserved after it.\ntype RecordingState = {\n  readonly nextId: number\n  readonly entries: ReadonlyArray<{ readonly id: number; readonly entry: RecordingEntry }>\n}\n\nconst recordedChunk = (bytes: Uint8Array): WireChunk => {\n  const recorded = recordBytes(bytes)\n\n  return 'text' in recorded ? recorded.text : { base64: recorded.base64 }\n}\n\nconst recordedBody = (\n  status: number,\n  headers: WireHeaders,\n  bytes: Uint8Array\n): WireBodyResponse => {\n  const recorded = recordBytes(bytes)\n\n  return 'text' in recorded\n    ? { status, headers, body: recorded.text }\n    : { status, headers, bodyBase64: recorded.base64 }\n}\n\nconst headerAllowed = (allowlist: ReadonlyArray<string>, name: string): boolean =>\n  !isCredentialHeaderName(name) &&\n  allowlist.some(entry => {\n    const lower = entry.toLowerCase()\n\n    return lower.endsWith('*') ? name.startsWith(lower.slice(0, -1)) : name === lower\n  })\n\nconst allowlistHeaders = (\n  headers: Readonly<Record<string, string | undefined>>,\n  allowlist: ReadonlyArray<string>\n): WireHeaders => {\n  const recorded: Record<string, string> = {}\n\n  for (const [name, value] of Object.entries(headerRecord(headers))) {\n    if (headerAllowed(allowlist, name)) {\n      recorded[name] = value\n    }\n  }\n\n  return recorded\n}\n\ntype WireRequestFields = {\n  method: string\n  url: string\n  headers?: WireHeaders\n  body?: WireRequest['body']\n}\n\nconst recordRequest = (\n  request: HttpClientRequest.HttpClientRequest,\n  allowlist: ReadonlyArray<string>\n): Effect.Effect<WireRequest> =>\n  Effect.gen(function* () {\n    const url = Option.match(HttpClientRequest.toUrl(request), {\n      onNone: () => request.url,\n      onSome: resolved => {\n        resolved.hash = ''\n\n        return resolved.toString()\n      }\n    })\n\n    const fields: WireRequestFields = { method: request.method, url }\n    const headers = allowlistHeaders(request.headers, allowlist)\n\n    if (Object.keys(headers).length > 0) {\n      fields.headers = headers\n    }\n\n    const text = requestBodyText(request)\n\n    if (text !== undefined && text.length > 0) {\n      const json = yield* parseJsonText(text)\n\n      fields.body = Option.getOrElse(json, () => text)\n    }\n\n    return fields\n  })\n\n/**\n * Wrap a host-provided `HttpClient` so every exchange is recorded losslessly.\n * Streamed responses (see `streamMediaTypes`) are teed chunk by chunk with\n * network boundaries preserved: each chunk is stored as text when it is valid\n * UTF-8 on its own (empty chunks as `\"\"`), otherwise as `{ base64 }` of its\n * exact bytes. Other responses are recorded as one `body` (valid UTF-8) or\n * `bodyBase64` (anything else). The caller receives the same status, headers,\n * and bytes. Body read failures still reach the caller as `HttpClientError`s\n * (the upstream error is kept as the cause), matching how `FetchHttpClient`\n * reports them.\n */\nexport const makeRecordingHttpClient = (\n  upstream: HttpClient.HttpClient,\n  options: WireRecorderOptions = {}\n): Effect.Effect<{ readonly client: HttpClient.HttpClient; readonly recorder: WireRecorderApi }> =>\n  Effect.gen(function* () {\n    const requestAllowlist = options.requestHeaders ?? defaultRecordedRequestHeaders\n    const responseAllowlist = options.responseHeaders ?? defaultRecordedResponseHeaders\n\n    const streamMediaTypes = (options.streamMediaTypes ?? defaultStreamMediaTypes).map(type =>\n      type.toLowerCase()\n    )\n\n    const state = yield* Ref.make<RecordingState>({ nextId: 0, entries: [] })\n\n    const reserve = (label: string) =>\n      Ref.modify(state, (current): [number, RecordingState] => [\n        current.nextId,\n        {\n          nextId: current.nextId + 1,\n          entries: [...current.entries, { id: current.nextId, entry: { status: 'pending', label } }]\n        }\n      ])\n\n    // Settles only a still-pending entry with this id; an entry already drained\n    // (or settled) is left untouched.\n    const settle = (id: number, entry: RecordingEntry) =>\n      Ref.update(state, current => ({\n        ...current,\n        entries: current.entries.map(item =>\n          item.id === id && item.entry.status === 'pending' ? { id, entry } : item\n        )\n      }))\n\n    const client = HttpClient.transform(\n      upstream,\n      (\n        effect: Effect.Effect<\n          HttpClientResponse.HttpClientResponse,\n          HttpClientError.HttpClientError\n        >,\n        request\n      ) =>\n        Effect.gen(function* () {\n          const wireRequest = yield* recordRequest(request, requestAllowlist)\n          // Query strings may carry credentials: labels keep origin and path only.\n          const label = `${wireRequest.method} ${wireRequest.url.split('?', 1)[0]}`\n          const id = yield* reserve(label)\n          const failed = settle(id, { status: 'failed', label })\n          const response = yield* effect.pipe(Effect.tapError(() => failed))\n          const headers = headerRecord(response.headers)\n          const recordedHeaders = allowlistHeaders(headers, responseAllowlist)\n          const init = { status: response.status, headers }\n\n          const complete = (wireResponse: WireResponse) =>\n            settle(id, {\n              status: 'complete',\n              label,\n              exchange: { request: wireRequest, response: wireResponse }\n            })\n\n          const type = mediaType(headers['content-type'])\n\n          if (type !== undefined && streamMediaTypes.includes(type)) {\n            const chunks: Array<WireChunk> = []\n\n            // Each network chunk is recorded standalone (no decoder carry-over),\n            // so replay can reproduce the original bytes and boundaries.\n            const teed = response.stream.pipe(\n              Stream.tap(bytes => Effect.sync(() => chunks.push(recordedChunk(bytes)))),\n              Stream.onExit(exit =>\n                Exit.isFailure(exit)\n                  ? failed\n                  : complete({ status: response.status, headers: recordedHeaders, chunks })\n              )\n            )\n\n            const readable = Stream.toReadableStream(teed, { strategy: { highWaterMark: 0 } })\n\n            return HttpClientResponse.fromWeb(request, new Response(readable, init))\n          }\n\n          const bytes = yield* response.arrayBuffer.pipe(Effect.tapError(() => failed))\n\n          yield* complete(recordedBody(response.status, recordedHeaders, new Uint8Array(bytes)))\n\n          return HttpClientResponse.fromWeb(\n            request,\n            new Response(isNullBodyStatus(response.status) ? null : bytes, init)\n          )\n        })\n    )\n\n    const recorder: WireRecorderApi = {\n      drain: Ref.modify(state, (current): [RecordingState['entries'], RecordingState] => [\n        current.entries,\n        { nextId: current.nextId, entries: [] }\n      ]).pipe(\n        Effect.flatMap(drained => {\n          const exchanges: Array<WireExchange> = []\n          const incomplete: Array<string> = []\n\n          for (const { entry } of drained) {\n            if (entry.status === 'complete') {\n              exchanges.push(entry.exchange)\n            } else {\n              incomplete.push(entry.label)\n            }\n          }\n\n          return incomplete.length > 0\n            ? Effect.fail(new WireRecordingIncomplete({ requests: incomplete }))\n            : Effect.succeed(exchanges)\n        })\n      )\n    }\n\n    return { client, recorder }\n  })\n\n/** A fixture failed schema validation (for example an empty exchange list or bad date). */\nexport class WireFixtureInvalid extends Data.TaggedError('WireFixtureInvalid')<{\n  readonly fixtureId: string\n  readonly cause: unknown\n}> {\n  override get message(): string {\n    return `Wire fixture ${this.fixtureId} is invalid`\n  }\n}\n\n/** The secret scan found credentials or credential-like values in a fixture. */\nexport class WireFixtureSecretsFound extends Data.TaggedError('WireFixtureSecretsFound')<{\n  readonly fixtureId: string\n  readonly issues: ReadonlyArray<FixtureSecretIssue>\n}> {\n  override get message(): string {\n    return `Wire fixture ${this.fixtureId} contains ${this.issues.length} secret-scan issue(s)`\n  }\n}\n\nexport type WireFixtureInput = Omit<WireFixture, 'exchanges'> & {\n  readonly exchanges: ReadonlyArray<WireExchange>\n}\n\n/**\n * Validate a fixture and run `scanFixtureForSecrets`. Fails with\n * `WireFixtureInvalid` or `WireFixtureSecretsFound`; never returns a fixture\n * with scan issues.\n */\nexport const makeWireFixture = (\n  input: WireFixtureInput\n): Effect.Effect<WireFixture, WireFixtureInvalid | WireFixtureSecretsFound> =>\n  Effect.gen(function* () {\n    const fixture = yield* decodeWireFixture(input).pipe(\n      Effect.mapError(cause => new WireFixtureInvalid({ fixtureId: input.id, cause }))\n    )\n\n    const issues = scanFixtureForSecrets(fixture)\n\n    if (issues.length > 0) {\n      return yield* Effect.fail(new WireFixtureSecretsFound({ fixtureId: fixture.id, issues }))\n    }\n\n    return fixture\n  })\n"],"mappings":"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"}

package/dist/replay.d.mts

@@ -0,0 +1,316 @@
+import { WireFixture, WireHeaders } from "./fixture.mjs";
+import { Cause, Context, Data, Effect, Layer } from "effect";
+import * as Schema from "effect/Schema";
+import { HttpClient } from "effect/unstable/http";
+
+//#region src/replay.d.ts
+/**
+ * Optional fault filter. `method` compares case-insensitively. `url` matches
+ * the normalized request URL exactly, or as a prefix when it ends with `*`.
+ * An omitted field matches every request.
+ */
+type WireFaultMatch = {
+  readonly method?: string;
+  readonly url?: string;
+};
+/**
+ * Wire faults injected by the replay client. `attempt` is 1-based and counted
+ * per method + normalized URL.
+ *
+ * - `StatusOnAttempt`: respond with this status instead of consuming a recorded
+ *   exchange, so the next attempt still gets the recording. It fires only when
+ *   an unconsumed recorded exchange exists for the method + normalized URL;
+ *   unknown or exhausted requests still fail closed as `unmatched`.
+ * - `FailAfterChunks`: emit the first `chunks` recorded chunks, then fail the
+ *   body stream the way a dropped connection does under `FetchHttpClient`.
+ * - `TruncateAfterChunks`: emit the first `chunks` recorded chunks, then end
+ *   the body cleanly.
+ * - `HoldAfterChunks`: emit the first `chunks` recorded chunks, run `release`,
+ *   then emit the rest.
+ *
+ * `attempt` omitted means every matching attempt. A chunk fault that cannot
+ * take effect fails the request with a typed `HttpClientError` (and a ledger
+ * `invalid` outcome) instead of silently doing nothing: any chunk fault matched
+ * against a whole-body response, `TruncateAfterChunks`/`HoldAfterChunks` with
+ * `chunks` >= the recorded chunk count, or `FailAfterChunks` with `chunks` >
+ * the recorded chunk count. That error's reason is a `TransportError`, so
+ * transient-retry policies may retry past it: assert the ledger has no
+ * `invalid` outcome when testing through a retrying client.
+ */
+type WireFault = Data.TaggedEnum<{
+  StatusOnAttempt: {
+    readonly match?: WireFaultMatch;
+    readonly attempt: number;
+    readonly status: number;
+    readonly headers?: WireHeaders;
+    readonly body?: string;
+  };
+  FailAfterChunks: {
+    readonly match?: WireFaultMatch;
+    readonly attempt?: number;
+    readonly chunks: number;
+  };
+  TruncateAfterChunks: {
+    readonly match?: WireFaultMatch;
+    readonly attempt?: number;
+    readonly chunks: number;
+  };
+  HoldAfterChunks: {
+    readonly match?: WireFaultMatch;
+    readonly attempt?: number;
+    readonly chunks: number;
+    readonly release: Effect.Effect<void>;
+  };
+}>;
+declare const WireFault: {
+  readonly StatusOnAttempt: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "StatusOnAttempt";
+    readonly match?: WireFaultMatch | undefined;
+    readonly attempt: number;
+    readonly status: number;
+    readonly headers?: WireHeaders | undefined;
+    readonly body?: string | undefined;
+  }, "_tag">;
+  readonly FailAfterChunks: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "FailAfterChunks";
+    readonly match?: WireFaultMatch | undefined;
+    readonly attempt?: number | undefined;
+    readonly chunks: number;
+  }, "_tag">;
+  readonly TruncateAfterChunks: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "TruncateAfterChunks";
+    readonly match?: WireFaultMatch | undefined;
+    readonly attempt?: number | undefined;
+    readonly chunks: number;
+  }, "_tag">;
+  readonly HoldAfterChunks: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "HoldAfterChunks";
+    readonly match?: WireFaultMatch | undefined;
+    readonly attempt?: number | undefined;
+    readonly chunks: number;
+    readonly release: Effect.Effect<void>;
+  }, "_tag">;
+  readonly $is: <Tag extends "StatusOnAttempt" | "FailAfterChunks" | "TruncateAfterChunks" | "HoldAfterChunks">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "StatusOnAttempt";
+    readonly match?: WireFaultMatch | undefined;
+    readonly attempt: number;
+    readonly status: number;
+    readonly headers?: WireHeaders | undefined;
+    readonly body?: string | undefined;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "FailAfterChunks";
+    readonly match?: WireFaultMatch | undefined;
+    readonly attempt?: number | undefined;
+    readonly chunks: number;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "TruncateAfterChunks";
+    readonly match?: WireFaultMatch | undefined;
+    readonly attempt?: number | undefined;
+    readonly chunks: number;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "HoldAfterChunks";
+    readonly match?: WireFaultMatch | undefined;
+    readonly attempt?: number | undefined;
+    readonly chunks: number;
+    readonly release: Effect.Effect<void>;
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends {
+      readonly StatusOnAttempt: (args: {
+        readonly _tag: "StatusOnAttempt";
+        readonly match?: WireFaultMatch | undefined;
+        readonly attempt: number;
+        readonly status: number;
+        readonly headers?: WireHeaders | undefined;
+        readonly body?: string | undefined;
+      }) => any;
+      readonly FailAfterChunks: (args: {
+        readonly _tag: "FailAfterChunks";
+        readonly match?: WireFaultMatch | undefined;
+        readonly attempt?: number | undefined;
+        readonly chunks: number;
+      }) => any;
+      readonly TruncateAfterChunks: (args: {
+        readonly _tag: "TruncateAfterChunks";
+        readonly match?: WireFaultMatch | undefined;
+        readonly attempt?: number | undefined;
+        readonly chunks: number;
+      }) => any;
+      readonly HoldAfterChunks: (args: {
+        readonly _tag: "HoldAfterChunks";
+        readonly match?: WireFaultMatch | undefined;
+        readonly attempt?: number | undefined;
+        readonly chunks: number;
+        readonly release: Effect.Effect<void>;
+      }) => any;
+    }>(cases: Cases): (value: {
+      readonly _tag: "StatusOnAttempt";
+      readonly match?: WireFaultMatch | undefined;
+      readonly attempt: number;
+      readonly status: number;
+      readonly headers?: WireHeaders | undefined;
+      readonly body?: string | undefined;
+    } | {
+      readonly _tag: "FailAfterChunks";
+      readonly match?: WireFaultMatch | undefined;
+      readonly attempt?: number | undefined;
+      readonly chunks: number;
+    } | {
+      readonly _tag: "TruncateAfterChunks";
+      readonly match?: WireFaultMatch | undefined;
+      readonly attempt?: number | undefined;
+      readonly chunks: number;
+    } | {
+      readonly _tag: "HoldAfterChunks";
+      readonly match?: WireFaultMatch | undefined;
+      readonly attempt?: number | undefined;
+      readonly chunks: number;
+      readonly release: Effect.Effect<void>;
+    }) => import("effect/Unify").Unify<ReturnType<Cases["StatusOnAttempt" | "FailAfterChunks" | "TruncateAfterChunks" | "HoldAfterChunks"]>>;
+    <Cases extends {
+      readonly StatusOnAttempt: (args: {
+        readonly _tag: "StatusOnAttempt";
+        readonly match?: WireFaultMatch | undefined;
+        readonly attempt: number;
+        readonly status: number;
+        readonly headers?: WireHeaders | undefined;
+        readonly body?: string | undefined;
+      }) => any;
+      readonly FailAfterChunks: (args: {
+        readonly _tag: "FailAfterChunks";
+        readonly match?: WireFaultMatch | undefined;
+        readonly attempt?: number | undefined;
+        readonly chunks: number;
+      }) => any;
+      readonly TruncateAfterChunks: (args: {
+        readonly _tag: "TruncateAfterChunks";
+        readonly match?: WireFaultMatch | undefined;
+        readonly attempt?: number | undefined;
+        readonly chunks: number;
+      }) => any;
+      readonly HoldAfterChunks: (args: {
+        readonly _tag: "HoldAfterChunks";
+        readonly match?: WireFaultMatch | undefined;
+        readonly attempt?: number | undefined;
+        readonly chunks: number;
+        readonly release: Effect.Effect<void>;
+      }) => any;
+    }>(value: {
+      readonly _tag: "StatusOnAttempt";
+      readonly match?: WireFaultMatch | undefined;
+      readonly attempt: number;
+      readonly status: number;
+      readonly headers?: WireHeaders | undefined;
+      readonly body?: string | undefined;
+    } | {
+      readonly _tag: "FailAfterChunks";
+      readonly match?: WireFaultMatch | undefined;
+      readonly attempt?: number | undefined;
+      readonly chunks: number;
+    } | {
+      readonly _tag: "TruncateAfterChunks";
+      readonly match?: WireFaultMatch | undefined;
+      readonly attempt?: number | undefined;
+      readonly chunks: number;
+    } | {
+      readonly _tag: "HoldAfterChunks";
+      readonly match?: WireFaultMatch | undefined;
+      readonly attempt?: number | undefined;
+      readonly chunks: number;
+      readonly release: Effect.Effect<void>;
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["StatusOnAttempt" | "FailAfterChunks" | "TruncateAfterChunks" | "HoldAfterChunks"]>>;
+  };
+};
+type WireFaultTag = WireFault['_tag'];
+declare const WireTransportFault_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => Cause.YieldableError & {
+  readonly _tag: "WireTransportFault";
+} & Readonly<A>;
+/** Cause attached to a body stream failed by `FailAfterChunks`. */
+declare class WireTransportFault extends WireTransportFault_base<{
+  readonly afterChunks: number;
+}> {
+  get message(): string;
+}
+/**
+ * How a replayed request was answered: a recorded exchange, a response
+ * injected by a `StatusOnAttempt` fault, nothing (fail closed), or a matched
+ * exchange that could not be replayed (`invalid`: a chunk fault that cannot
+ * take effect, or undecodable base64). `invalid` requests fail with a typed
+ * `HttpClientError` and do not consume the exchange.
+ */
+type ReplayLedgerMatch = {
+  readonly outcome: 'matched';
+  readonly fixtureId: string;
+  readonly exchangeIndex: number;
+} | {
+  readonly outcome: 'injected';
+} | {
+  readonly outcome: 'unmatched';
+} | {
+  readonly outcome: 'invalid';
+  readonly fixtureId: string;
+  readonly exchangeIndex: number; /** Why the recording could not be replayed; never contains request or response data. */
+  readonly reason: string;
+};
+type ReplayLedgerEntry = {
+  readonly method: string; /** Normalized absolute URL. */
+  readonly url: string; /** Request headers with credential headers replaced by `<redacted>`. */
+  readonly headers: Readonly<Record<string, string>>;
+  readonly bodyText?: string; /** Parsed request body when `bodyText` is valid JSON. */
+  readonly bodyJson?: Schema.Json; /** 1-based attempt number for this method + URL. */
+  readonly attempt: number;
+  readonly match: ReplayLedgerMatch; /** Tag of the fault that shaped this response, if any (never set for a fault that did not apply). */
+  readonly fault?: WireFaultTag;
+};
+type ReplayExchangeRef = {
+  readonly fixtureId: string;
+  readonly exchangeIndex: number;
+};
+type ReplayLedgerApi = {
+  /** Every request seen by the replay client, in arrival order. */readonly entries: Effect.Effect<ReadonlyArray<ReplayLedgerEntry>>; /** Recorded exchanges not consumed yet, in fixture order. */
+  readonly remaining: Effect.Effect<ReadonlyArray<ReplayExchangeRef>>;
+};
+declare const ReplayLedger_base: Context.ServiceClass<ReplayLedger, "@yolk-sdk/conformance/ReplayLedger", ReplayLedgerApi>;
+declare class ReplayLedger extends ReplayLedger_base {}
+type ReplayHttpClientOptions = {
+  readonly faults?: ReadonlyArray<WireFault>;
+};
+declare const WireReplayInvalid_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => Cause.YieldableError & {
+  readonly _tag: "WireReplayInvalid";
+} & Readonly<A>;
+/**
+ * Cause attached to the `HttpClientError` (reason `TransportError`) of a request
+ * whose recording could not be replayed. Retrying clients may retry past it;
+ * check the ledger for an `invalid` outcome.
+ */
+declare class WireReplayInvalid extends WireReplayInvalid_base<{
+  readonly reason: string;
+}> {
+  get message(): string;
+}
+/**
+ * Build a replay `HttpClient` and its ledger over the given fixtures. Each
+ * call has independent consumption, attempt, and ledger state.
+ */
+declare const makeReplayHttpClient: (fixtures: ReadonlyArray<WireFixture>, options?: ReplayHttpClientOptions) => Effect.Effect<{
+  readonly client: HttpClient.HttpClient;
+  readonly ledger: ReplayLedgerApi;
+}>;
+declare const ReplayHttpClient: {
+  /**
+   * Layer providing a replay `HttpClient` and its `ReplayLedger`. Each layer
+   * build gets fresh consumption and ledger state.
+   */
+  readonly layer: (fixtures: ReadonlyArray<WireFixture>, options?: ReplayHttpClientOptions) => Layer.Layer<HttpClient.HttpClient | ReplayLedger>;
+};
+//#endregion
+export { ReplayExchangeRef, ReplayHttpClient, ReplayHttpClientOptions, ReplayLedger, ReplayLedgerApi, ReplayLedgerEntry, ReplayLedgerMatch, WireFault, WireFaultMatch, WireFaultTag, WireReplayInvalid, WireTransportFault, makeReplayHttpClient };
+//# sourceMappingURL=replay.d.mts.map

package/dist/replay.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay.d.mts","names":[],"sources":["../src/replay.ts"],"mappings":"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"}