@yolk-sdk/conformance 0.1.0-canary.122 → 0.1.0-canary.124

package/README.md

@@ -14,9 +14,11 @@ Canary APIs are unstable. Keep all `@yolk-sdk/*` packages on the same version.
 ## Install
 
 ```bash
-pnpm add -D @yolk-sdk/conformance@canary effect@4.0.5
+pnpm add -D @yolk-sdk/conformance@canary effect@4.1.2
 ```
 
+Use the SDK's matching Effect version (`4.1.2`) in host code.
+
 ## Subpaths
 
 There is no root export. Import an explicit subpath:

package/dist/case.d.mts

@@ -1,7 +1,5 @@
 import { Effect } from "effect";
 import * as Schema from "effect/Schema";
-
-//#region src/case.d.ts
 /**
  * What a case does to the account it runs against:
  *
@@ -12,41 +10,48 @@ import * as Schema from "effect/Schema";
  * - `write-irreversible`: a write that cannot be undone (for example sending
  *   an email). Never automated against a live account.
  */
-declare const ConformanceSafety: Schema.Literals<readonly ["read", "write-reversible", "write-irreversible"]>;
-type ConformanceSafety = typeof ConformanceSafety.Type;
+export declare const ConformanceSafety: Schema.Literals<readonly ["read", "write-reversible", "write-irreversible"]>;
+export type ConformanceSafety = typeof ConformanceSafety.Type;
 /**
  * Dotted lower-case case id: two or more segments of `a-z`, `0-9`, and inner
  * hyphens, for example `vendor.stream.plain-text`.
  */
-declare const ConformanceCaseId: Schema.String;
+export declare const ConformanceCaseId: Schema.String;
 /** When and where a person last watched the claim hold against the real service. */
-declare const ConformanceObservation: Schema.Struct<{
-  /** Synthetic account label, for example `synthetic`; never a real account name. */readonly account: Schema.NonEmptyString; /** Calendar date of the observation (`YYYY-MM-DD`, UTC). */
+export declare const ConformanceObservation: Schema.Struct<{
+  /** Synthetic account label, for example `synthetic`; never a real account name. */
+  readonly account: Schema.NonEmptyString;
+  /** Calendar date of the observation (`YYYY-MM-DD`, UTC). */
   readonly date: Schema.String;
 }>;
-type ConformanceObservation = typeof ConformanceObservation.Type;
+export type ConformanceObservation = typeof ConformanceObservation.Type;
 /**
  * One wire claim. `run` succeeds when the claim holds and fails (with a
  * `ConformanceMismatch`, its own error, or a port's error) when it does not.
  */
-type ConformanceCase<E = never, R = never> = {
-  /** Dotted lower-case id (see `ConformanceCaseId`). */readonly id: string;
+export type ConformanceCase<E = never, R = never> = {
+  /** Dotted lower-case id (see `ConformanceCaseId`). */
+  readonly id: string;
   readonly title?: string;
-  readonly safety: ConformanceSafety; /** What the service's documentation claims. */
-  readonly docs: string; /** What the wire actually does (the claim this case proves). */
-  readonly wire: string; /** Last live observation. Absent means the claim is unverified against the real service. */
-  readonly observed?: ConformanceObservation; /** Ids of the fixtures (`WireFixture`s or `PortFixture`s) that back replay of this case. */
+  readonly safety: ConformanceSafety;
+  /** What the service's documentation claims. */
+  readonly docs: string;
+  /** What the wire actually does (the claim this case proves). */
+  readonly wire: string;
+  /** Last live observation. Absent means the claim is unverified against the real service. */
+  readonly observed?: ConformanceObservation;
+  /** Ids of the fixtures (`WireFixture`s or `PortFixture`s) that back replay of this case. */
   readonly fixtures: ReadonlyArray<string>;
   readonly run: Effect.Effect<void, E, R>;
 };
-declare const ConformanceCaseInvalid_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] }>) => import("effect/Cause").YieldableError & {
+declare const ConformanceCaseInvalid_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]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "ConformanceCaseInvalid";
 } & Readonly<A>;
 /**
  * Thrown by `defineConformanceCase` for an invalid definition. A programmer
  * error, surfaced when the defining module loads (like `makeTool`).
  */
-declare class ConformanceCaseInvalid extends ConformanceCaseInvalid_base<{
+export declare class ConformanceCaseInvalid extends ConformanceCaseInvalid_base<{
   readonly caseId: string;
   readonly reason: string;
 }> {
@@ -59,31 +64,30 @@ declare class ConformanceCaseInvalid extends ConformanceCaseInvalid_base<{
  * module-level constants, so a bad one fails fast when the module loads
  * instead of surfacing mid-run.
  */
-declare const defineConformanceCase: <E = never, R = never>(spec: ConformanceCase<E, R>) => ConformanceCase<E, R>;
-declare const ConformanceMismatch_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] }>) => import("effect/Cause").YieldableError & {
+export declare const defineConformanceCase: <E = never, R = never>(spec: ConformanceCase<E, R>) => ConformanceCase<E, R>;
+declare const ConformanceMismatch_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]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "ConformanceMismatch";
 } & Readonly<A>;
 /**
  * A wire claim did not hold. Model-free: `expected` / `actual` are optional
  * JSON values chosen by the case author; keep them small and synthetic.
  */
-declare class ConformanceMismatch extends ConformanceMismatch_base<{
+export declare class ConformanceMismatch extends ConformanceMismatch_base<{
   readonly message: string;
   readonly expected?: Schema.Json;
   readonly actual?: Schema.Json;
 }> {}
-type ConformanceMismatchDetails = {
+export type ConformanceMismatchDetails = {
   readonly expected?: Schema.Json;
   readonly actual?: Schema.Json;
 };
 /** Succeed when `condition` holds; otherwise fail with a `ConformanceMismatch`. */
-declare const expectConformance: (condition: boolean, message: string, details?: ConformanceMismatchDetails) => Effect.Effect<void, ConformanceMismatch>;
+export declare const expectConformance: (condition: boolean, message: string, details?: ConformanceMismatchDetails) => Effect.Effect<void, ConformanceMismatch>;
 /**
  * Succeed when `actual` and `expected` are structurally equal JSON values
  * (effect `Equal.equals`: same primitives, same array order, same object keys
  * and values); otherwise fail with a `ConformanceMismatch` carrying both.
  */
-declare const expectEqual: (actual: Schema.Json, expected: Schema.Json, message: string) => Effect.Effect<void, ConformanceMismatch>;
-//#endregion
-export { ConformanceCase, ConformanceCaseId, ConformanceCaseInvalid, ConformanceMismatch, ConformanceMismatchDetails, ConformanceObservation, ConformanceSafety, defineConformanceCase, expectConformance, expectEqual };
+export declare const expectEqual: (actual: Schema.Json, expected: Schema.Json, message: string) => Effect.Effect<void, ConformanceMismatch>;
+export {};
 //# sourceMappingURL=case.d.mts.map

package/dist/case.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"case.d.mts","names":[],"sources":["../src/case.ts"],"mappings":";;;;AA0B6D;AAM7D;;;;AAEC;AAKD;;;;AAb6D,cAFhD,iBAAA,EAAiB,MAAA,CAAA,QAAA;AAAA,KAElB,iBAAA,UAA2B,iBAAA,CAAkB,IAAI;;;;;cAMhD,iBAAA,EAAiB,MAAA,CAAA,MAE7B;;cAKY,sBAAA,EAAsB,MAAA,CAAA,MAAA;;;;KAOvB,sBAAA,UAAgC,sBAAA,CAAuB,IAAI;;;;AAAA;KAM3D,eAAA;EAAe,+DAEhB,EAAA;EAAA,SACA,KAAA;EAAA,SACA,MAAA,EAAQ,iBAAA,EAQE;EAAA,SANV,IAAA,UAO4B;EAAA,SAL5B,IAAA,UAKkB;EAAA,SAHlB,QAAA,GAAW,sBAAA,EAVM;EAAA,SAYjB,QAAA,EAAU,aAAA;EAAA,SACV,GAAA,EAAK,MAAA,CAAO,MAAA,OAAa,CAAA,EAAG,CAAA;AAAA;AAAA,cACtC,2BAAA;;;;;;;cAkBY,sBAAA,SAA+B,2BAAA;EAAA,SACjC,MAAA;EAAA,SACA,MAAA;AAAA;EAAA,IAEI,OAAA,CAAA;AAAA;;AAvByB;AACvC;;;;;cAkCY,qBAAA,yBACX,IAAA,EAAM,eAAA,CAAgB,CAAA,EAAG,CAAA,MACxB,eAAA,CAAgB,CAAA,EAAG,CAAA;AAAA,cAYrB,wBAAA;;;;;;;cAMY,mBAAA,SAA4B,wBAAA;EAAA,SAC9B,OAAA;EAAA,SACA,QAAA,GAAW,MAAA,CAAO,IAAA;EAAA,SAClB,MAAA,GAAS,MAAA,CAAO,IAAA;AAAA;AAAA,KAGf,0BAAA;EAAA,SACD,QAAA,GAAW,MAAA,CAAO,IAAA;EAAA,SAClB,MAAA,GAAS,MAAA,CAAO,IAAI;AAAA;;cAOlB,iBAAA,GACX,SAAA,WACA,OAAA,UACA,OAAA,GAAU,0BAAA,KACT,MAAA,CAAO,MAAA,OAAa,mBAAA;;;;;AAvDvB;cA+Da,WAAA,GACX,MAAA,EAAQ,MAAA,CAAO,IAAA,EACf,QAAA,EAAU,MAAA,CAAO,IAAA,EACjB,OAAA,aACC,MAAA,CAAO,MAAA,OAAa,mBAAA"}
+{"version":3,"file":"case.d.mts","names":[],"sources":["../src/case.ts"],"mappings":";;;;;;;;;;;;qBAwBa,mBAAiB,OAAA;YAElB,2BAA2B,kBAAkB;;;;;qBAM5C,mBAAiB,OAAA;;qBAOjB,wBAAsB,OAAA;;;;;;YAOvB,gCAAgC,uBAAuB;;;;;YAMvD,gBAAgB,WAAW;;WAE5B;WACA;WACA,QAAQ;;WAER;;WAEA;;WAEA,WAAW;;WAEX,UAAU;WACV,KAAK,OAAO,aAAa,GAAG;;;;;;;;;qBAmB1B,+BAA+B;WACjC;WACA;;MAEI;;;;;;;;;qBAYF,wBAAyB,WAAW,WAAS,MAClD,gBAAgB,GAAG,OACxB,gBAAgB,GAAG;;;;;;;;qBAkBT,4BAA4B;WAC9B;WACA,WAAW,OAAO;WAClB,SAAS,OAAO;;YAGf;WACD,WAAW,OAAO;WAClB,SAAS,OAAO;;;qBAOd,oBAAiB,oBACV,iBACH,UACL,+BACT,OAAO,aAAa;;;;;;qBAQV,cAAW,QACd,OAAO,MAAI,UACT,OAAO,MAAI,oBAEpB,OAAO,aAAa"}

package/dist/case.mjs

@@ -1,6 +1,6 @@
 import { Data, Effect, Equal, Result } from "effect";
 import * as Schema from "effect/Schema";
-//#region src/case.ts
+// src/case.ts
 /**
 * Conformance cases: small, named, pure Effect programs that each prove one
 * claim about how an outside service really behaves on the wire.
@@ -95,7 +95,6 @@ const expectEqual = (actual, expected, message) => expectConformance(Equal.equal
 	expected,
 	actual
 });
-//#endregion
 export { ConformanceCaseId, ConformanceCaseInvalid, ConformanceMismatch, ConformanceObservation, ConformanceSafety, defineConformanceCase, expectConformance, expectEqual };
 
 //# sourceMappingURL=case.mjs.map

package/dist/case.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"case.mjs","names":[],"sources":["../src/case.ts"],"sourcesContent":["/**\n * Conformance cases: small, named, pure Effect programs that each prove one\n * claim about how an outside service really behaves on the wire.\n *\n * A case only states what it needs (its `R`); the same case runs unchanged\n * against replayed fixtures, an in-process emulator, a local emulator\n * process, or a real practice account. Only the layers a host provides\n * change. See `@yolk-sdk/conformance/runner` for the safety policy.\n *\n * @experimental\n */\nimport { Data, Effect, Equal, Result } from 'effect'\nimport * as Schema from 'effect/Schema'\n\n/**\n * What a case does to the account it runs against:\n *\n * - `read`: only reads.\n * - `write-reversible`: writes but leaves the account as it found it (it\n *   creates its own records and cleans them up, or the write is rejected and\n *   changes nothing).\n * - `write-irreversible`: a write that cannot be undone (for example sending\n *   an email). Never automated against a live account.\n */\nexport const ConformanceSafety = Schema.Literals(['read', 'write-reversible', 'write-irreversible'])\n\nexport type ConformanceSafety = typeof ConformanceSafety.Type\n\n/**\n * Dotted lower-case case id: two or more segments of `a-z`, `0-9`, and inner\n * hyphens, for example `vendor.stream.plain-text`.\n */\nexport const ConformanceCaseId = Schema.String.check(\n  Schema.isPattern(/^[a-z0-9]+(?:-[a-z0-9]+)*(?:\\.[a-z0-9]+(?:-[a-z0-9]+)*)+$/u)\n)\n\nconst CalendarDate = Schema.String.check(Schema.isPattern(/^\\d{4}-\\d{2}-\\d{2}$/u))\n\n/** When and where a person last watched the claim hold against the real service. */\nexport const ConformanceObservation = Schema.Struct({\n  /** Synthetic account label, for example `synthetic`; never a real account name. */\n  account: Schema.NonEmptyString,\n  /** Calendar date of the observation (`YYYY-MM-DD`, UTC). */\n  date: CalendarDate\n})\n\nexport type ConformanceObservation = typeof ConformanceObservation.Type\n\n/**\n * One wire claim. `run` succeeds when the claim holds and fails (with a\n * `ConformanceMismatch`, its own error, or a port's error) when it does not.\n */\nexport type ConformanceCase<E = never, R = never> = {\n  /** Dotted lower-case id (see `ConformanceCaseId`). */\n  readonly id: string\n  readonly title?: string\n  readonly safety: ConformanceSafety\n  /** What the service's documentation claims. */\n  readonly docs: string\n  /** What the wire actually does (the claim this case proves). */\n  readonly wire: string\n  /** Last live observation. Absent means the claim is unverified against the real service. */\n  readonly observed?: ConformanceObservation\n  /** Ids of the fixtures (`WireFixture`s or `PortFixture`s) that back replay of this case. */\n  readonly fixtures: ReadonlyArray<string>\n  readonly run: Effect.Effect<void, E, R>\n}\n\nconst ConformanceCaseMetadata = Schema.Struct({\n  id: ConformanceCaseId,\n  title: Schema.optionalKey(Schema.NonEmptyString),\n  safety: ConformanceSafety,\n  docs: Schema.NonEmptyString,\n  wire: Schema.NonEmptyString,\n  observed: Schema.optionalKey(ConformanceObservation),\n  fixtures: Schema.Array(Schema.NonEmptyString)\n})\n\nconst validateMetadata = Schema.decodeUnknownResult(ConformanceCaseMetadata)\n\n/**\n * Thrown by `defineConformanceCase` for an invalid definition. A programmer\n * error, surfaced when the defining module loads (like `makeTool`).\n */\nexport class ConformanceCaseInvalid extends Data.TaggedError('ConformanceCaseInvalid')<{\n  readonly caseId: string\n  readonly reason: string\n}> {\n  override get message(): string {\n    return `Invalid conformance case ${JSON.stringify(this.caseId)}: ${this.reason}`\n  }\n}\n\n/**\n * Define a conformance case. The metadata (id format, safety, non-empty\n * `docs`/`wire`, observation date, fixture ids) is validated here and an\n * invalid definition throws `ConformanceCaseInvalid`: definitions are\n * module-level constants, so a bad one fails fast when the module loads\n * instead of surfacing mid-run.\n */\nexport const defineConformanceCase = <E = never, R = never>(\n  spec: ConformanceCase<E, R>\n): ConformanceCase<E, R> => {\n  const { run: _run, ...metadata } = spec\n  const result = validateMetadata(metadata)\n\n  if (Result.isFailure(result)) {\n    throw new ConformanceCaseInvalid({\n      caseId: spec.id,\n      reason: new Schema.SchemaError(result.failure.issue).message\n    })\n  }\n\n  return spec\n}\n\n/**\n * A wire claim did not hold. Model-free: `expected` / `actual` are optional\n * JSON values chosen by the case author; keep them small and synthetic.\n */\nexport class ConformanceMismatch extends Data.TaggedError('ConformanceMismatch')<{\n  readonly message: string\n  readonly expected?: Schema.Json\n  readonly actual?: Schema.Json\n}> {}\n\nexport type ConformanceMismatchDetails = {\n  readonly expected?: Schema.Json\n  readonly actual?: Schema.Json\n}\n\nconst mismatch = (message: string, details: ConformanceMismatchDetails = {}) =>\n  new ConformanceMismatch({ message, ...details })\n\n/** Succeed when `condition` holds; otherwise fail with a `ConformanceMismatch`. */\nexport const expectConformance = (\n  condition: boolean,\n  message: string,\n  details?: ConformanceMismatchDetails\n): Effect.Effect<void, ConformanceMismatch> =>\n  condition ? Effect.void : Effect.fail(mismatch(message, details))\n\n/**\n * Succeed when `actual` and `expected` are structurally equal JSON values\n * (effect `Equal.equals`: same primitives, same array order, same object keys\n * and values); otherwise fail with a `ConformanceMismatch` carrying both.\n */\nexport const expectEqual = (\n  actual: Schema.Json,\n  expected: Schema.Json,\n  message: string\n): Effect.Effect<void, ConformanceMismatch> =>\n  expectConformance(Equal.equals(actual, expected), message, { expected, actual })\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAwBA,MAAa,oBAAoB,OAAO,SAAS;CAAC;CAAQ;CAAoB;AAAoB,CAAC;;;;;AAQnG,MAAa,oBAAoB,OAAO,OAAO,MAC7C,OAAO,UAAU,4DAA4D,CAC/E;AAEA,MAAM,eAAe,OAAO,OAAO,MAAM,OAAO,UAAU,sBAAsB,CAAC;;AAGjF,MAAa,yBAAyB,OAAO,OAAO;;CAElD,SAAS,OAAO;;CAEhB,MAAM;AACR,CAAC;AAwBD,MAAM,0BAA0B,OAAO,OAAO;CAC5C,IAAI;CACJ,OAAO,OAAO,YAAY,OAAO,cAAc;CAC/C,QAAQ;CACR,MAAM,OAAO;CACb,MAAM,OAAO;CACb,UAAU,OAAO,YAAY,sBAAsB;CACnD,UAAU,OAAO,MAAM,OAAO,cAAc;AAC9C,CAAC;AAED,MAAM,mBAAmB,OAAO,oBAAoB,uBAAuB;;;;;AAM3E,IAAa,yBAAb,cAA4C,KAAK,YAAY,wBAAwB,EAGlF;CACD,IAAa,UAAkB;EAC7B,OAAO,4BAA4B,KAAK,UAAU,KAAK,MAAM,EAAE,IAAI,KAAK;CAC1E;AACF;;;;;;;;AASA,MAAa,yBACX,SAC0B;CAC1B,MAAM,EAAE,KAAK,MAAM,GAAG,aAAa;CACnC,MAAM,SAAS,iBAAiB,QAAQ;CAExC,IAAI,OAAO,UAAU,MAAM,GACzB,MAAM,IAAI,uBAAuB;EAC/B,QAAQ,KAAK;EACb,QAAQ,IAAI,OAAO,YAAY,OAAO,QAAQ,KAAK,EAAE;CACvD,CAAC;CAGH,OAAO;AACT;;;;;AAMA,IAAa,sBAAb,cAAyC,KAAK,YAAY,qBAAqB,EAI5E,CAAC;AAOJ,MAAM,YAAY,SAAiB,UAAsC,CAAC,MACxE,IAAI,oBAAoB;CAAE;CAAS,GAAG;AAAQ,CAAC;;AAGjD,MAAa,qBACX,WACA,SACA,YAEA,YAAY,OAAO,OAAO,OAAO,KAAK,SAAS,SAAS,OAAO,CAAC;;;;;;AAOlE,MAAa,eACX,QACA,UACA,YAEA,kBAAkB,MAAM,OAAO,QAAQ,QAAQ,GAAG,SAAS;CAAE;CAAU;AAAO,CAAC"}
+{"version":3,"file":"case.mjs","names":[],"sources":["../src/case.ts"],"sourcesContent":["/**\n * Conformance cases: small, named, pure Effect programs that each prove one\n * claim about how an outside service really behaves on the wire.\n *\n * A case only states what it needs (its `R`); the same case runs unchanged\n * against replayed fixtures, an in-process emulator, a local emulator\n * process, or a real practice account. Only the layers a host provides\n * change. See `@yolk-sdk/conformance/runner` for the safety policy.\n *\n * @experimental\n */\nimport { Data, Effect, Equal, Result } from 'effect'\nimport * as Schema from 'effect/Schema'\n\n/**\n * What a case does to the account it runs against:\n *\n * - `read`: only reads.\n * - `write-reversible`: writes but leaves the account as it found it (it\n *   creates its own records and cleans them up, or the write is rejected and\n *   changes nothing).\n * - `write-irreversible`: a write that cannot be undone (for example sending\n *   an email). Never automated against a live account.\n */\nexport const ConformanceSafety = Schema.Literals(['read', 'write-reversible', 'write-irreversible'])\n\nexport type ConformanceSafety = typeof ConformanceSafety.Type\n\n/**\n * Dotted lower-case case id: two or more segments of `a-z`, `0-9`, and inner\n * hyphens, for example `vendor.stream.plain-text`.\n */\nexport const ConformanceCaseId = Schema.String.check(\n  Schema.isPattern(/^[a-z0-9]+(?:-[a-z0-9]+)*(?:\\.[a-z0-9]+(?:-[a-z0-9]+)*)+$/u)\n)\n\nconst CalendarDate = Schema.String.check(Schema.isPattern(/^\\d{4}-\\d{2}-\\d{2}$/u))\n\n/** When and where a person last watched the claim hold against the real service. */\nexport const ConformanceObservation = Schema.Struct({\n  /** Synthetic account label, for example `synthetic`; never a real account name. */\n  account: Schema.NonEmptyString,\n  /** Calendar date of the observation (`YYYY-MM-DD`, UTC). */\n  date: CalendarDate\n})\n\nexport type ConformanceObservation = typeof ConformanceObservation.Type\n\n/**\n * One wire claim. `run` succeeds when the claim holds and fails (with a\n * `ConformanceMismatch`, its own error, or a port's error) when it does not.\n */\nexport type ConformanceCase<E = never, R = never> = {\n  /** Dotted lower-case id (see `ConformanceCaseId`). */\n  readonly id: string\n  readonly title?: string\n  readonly safety: ConformanceSafety\n  /** What the service's documentation claims. */\n  readonly docs: string\n  /** What the wire actually does (the claim this case proves). */\n  readonly wire: string\n  /** Last live observation. Absent means the claim is unverified against the real service. */\n  readonly observed?: ConformanceObservation\n  /** Ids of the fixtures (`WireFixture`s or `PortFixture`s) that back replay of this case. */\n  readonly fixtures: ReadonlyArray<string>\n  readonly run: Effect.Effect<void, E, R>\n}\n\nconst ConformanceCaseMetadata = Schema.Struct({\n  id: ConformanceCaseId,\n  title: Schema.optionalKey(Schema.NonEmptyString),\n  safety: ConformanceSafety,\n  docs: Schema.NonEmptyString,\n  wire: Schema.NonEmptyString,\n  observed: Schema.optionalKey(ConformanceObservation),\n  fixtures: Schema.Array(Schema.NonEmptyString)\n})\n\nconst validateMetadata = Schema.decodeUnknownResult(ConformanceCaseMetadata)\n\n/**\n * Thrown by `defineConformanceCase` for an invalid definition. A programmer\n * error, surfaced when the defining module loads (like `makeTool`).\n */\nexport class ConformanceCaseInvalid extends Data.TaggedError('ConformanceCaseInvalid')<{\n  readonly caseId: string\n  readonly reason: string\n}> {\n  override get message(): string {\n    return `Invalid conformance case ${JSON.stringify(this.caseId)}: ${this.reason}`\n  }\n}\n\n/**\n * Define a conformance case. The metadata (id format, safety, non-empty\n * `docs`/`wire`, observation date, fixture ids) is validated here and an\n * invalid definition throws `ConformanceCaseInvalid`: definitions are\n * module-level constants, so a bad one fails fast when the module loads\n * instead of surfacing mid-run.\n */\nexport const defineConformanceCase = <E = never, R = never>(\n  spec: ConformanceCase<E, R>\n): ConformanceCase<E, R> => {\n  const { run: _run, ...metadata } = spec\n  const result = validateMetadata(metadata)\n\n  if (Result.isFailure(result)) {\n    throw new ConformanceCaseInvalid({\n      caseId: spec.id,\n      reason: new Schema.SchemaError(result.failure.issue).message\n    })\n  }\n\n  return spec\n}\n\n/**\n * A wire claim did not hold. Model-free: `expected` / `actual` are optional\n * JSON values chosen by the case author; keep them small and synthetic.\n */\nexport class ConformanceMismatch extends Data.TaggedError('ConformanceMismatch')<{\n  readonly message: string\n  readonly expected?: Schema.Json\n  readonly actual?: Schema.Json\n}> {}\n\nexport type ConformanceMismatchDetails = {\n  readonly expected?: Schema.Json\n  readonly actual?: Schema.Json\n}\n\nconst mismatch = (message: string, details: ConformanceMismatchDetails = {}) =>\n  new ConformanceMismatch({ message, ...details })\n\n/** Succeed when `condition` holds; otherwise fail with a `ConformanceMismatch`. */\nexport const expectConformance = (\n  condition: boolean,\n  message: string,\n  details?: ConformanceMismatchDetails\n): Effect.Effect<void, ConformanceMismatch> =>\n  condition ? Effect.void : Effect.fail(mismatch(message, details))\n\n/**\n * Succeed when `actual` and `expected` are structurally equal JSON values\n * (effect `Equal.equals`: same primitives, same array order, same object keys\n * and values); otherwise fail with a `ConformanceMismatch` carrying both.\n */\nexport const expectEqual = (\n  actual: Schema.Json,\n  expected: Schema.Json,\n  message: string\n): Effect.Effect<void, ConformanceMismatch> =>\n  expectConformance(Equal.equals(actual, expected), message, { expected, actual })\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAwBA,MAAa,oBAAoB,OAAO,SAAS;CAAC;CAAQ;CAAoB;AAAoB,CAAC;;;;;AAQnG,MAAa,oBAAoB,OAAO,OAAO,MAC7C,OAAO,UAAU,4DAA4D,CAC/E;AAEA,MAAM,eAAe,OAAO,OAAO,MAAM,OAAO,UAAU,sBAAsB,CAAC;;AAGjF,MAAa,yBAAyB,OAAO,OAAO;;CAElD,SAAS,OAAO;;CAEhB,MAAM;AACR,CAAC;AAwBD,MAAM,0BAA0B,OAAO,OAAO;CAC5C,IAAI;CACJ,OAAO,OAAO,YAAY,OAAO,cAAc;CAC/C,QAAQ;CACR,MAAM,OAAO;CACb,MAAM,OAAO;CACb,UAAU,OAAO,YAAY,sBAAsB;CACnD,UAAU,OAAO,MAAM,OAAO,cAAc;AAC9C,CAAC;AAED,MAAM,mBAAmB,OAAO,oBAAoB,uBAAuB;;;;;AAM3E,IAAa,yBAAb,cAA4C,KAAK,YAAY,wBAAwB,CAAC,CAGnF;CACD,IAAa,UAAkB;EAC7B,OAAO,4BAA4B,KAAK,UAAU,KAAK,MAAM,EAAE,IAAI,KAAK;CAC1E;AACF;;;;;;;;AASA,MAAa,yBACX,SAC0B;CAC1B,MAAM,EAAE,KAAK,MAAM,GAAG,aAAa;CACnC,MAAM,SAAS,iBAAiB,QAAQ;CAExC,IAAI,OAAO,UAAU,MAAM,GACzB,MAAM,IAAI,uBAAuB;EAC/B,QAAQ,KAAK;EACb,QAAQ,IAAI,OAAO,YAAY,OAAO,QAAQ,KAAK,CAAC,CAAC;CACvD,CAAC;CAGH,OAAO;AACT;;;;;AAMA,IAAa,sBAAb,cAAyC,KAAK,YAAY,qBAAqB,CAAC,CAI7E,CAAC;AAOJ,MAAM,YAAY,SAAiB,UAAsC,CAAC,MACxE,IAAI,oBAAoB;CAAE;CAAS,GAAG;AAAQ,CAAC;;AAGjD,MAAa,qBACX,WACA,SACA,YAEA,YAAY,OAAO,OAAO,OAAO,KAAK,SAAS,SAAS,OAAO,CAAC;;;;;;AAOlE,MAAa,eACX,QACA,UACA,YAEA,kBAAkB,MAAM,OAAO,QAAQ,QAAQ,GAAG,SAAS;CAAE;CAAU;AAAO,CAAC"}

package/dist/fixture.d.mts

@@ -1,49 +1,49 @@
 import { syntheticPortCredentialParams } from "./wire-internal.mjs";
 import * as Schema from "effect/Schema";
-
-//#region src/fixture.d.ts
 /** `verified` = recorded from a live service; `unverified` = synthetic placeholder. */
-declare const WireFixtureEvidence: Schema.Literals<readonly ["verified", "unverified"]>;
-type WireFixtureEvidence = typeof WireFixtureEvidence.Type;
+export declare const WireFixtureEvidence: Schema.Literals<readonly ["verified", "unverified"]>;
+export type WireFixtureEvidence = typeof WireFixtureEvidence.Type;
 /** Lowercase header name to value. Request headers are allowlisted and never credentials. */
-declare const WireHeaders: Schema.$Record<Schema.String, Schema.String>;
-type WireHeaders = typeof WireHeaders.Type;
-declare const WireRequest: Schema.Struct<{
-  readonly method: Schema.NonEmptyString; /** Absolute URL including any query string. */
+export declare const WireHeaders: Schema.$Record<Schema.String, Schema.String>;
+export type WireHeaders = typeof WireHeaders.Type;
+export declare const WireRequest: Schema.Struct<{
+  readonly method: Schema.NonEmptyString;
+  /** Absolute URL including any query string. */
   readonly url: Schema.NonEmptyString;
-  readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>; /** Parsed JSON request body, or the raw text when it is not JSON (for example a form body). */
+  readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+  /** Parsed JSON request body, or the raw text when it is not JSON (for example a form body). */
   readonly body: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
 }>;
-type WireRequest = typeof WireRequest.Type;
+export type WireRequest = typeof WireRequest.Type;
 /**
  * One recorded network chunk. A chunk that is valid UTF-8 on its own is stored
  * as readable text (empty chunks as `""`); any other chunk is stored as
  * `{ base64 }` holding its exact bytes. Replay emits exactly these bytes.
  */
-declare const WireChunk: Schema.Union<readonly [Schema.String, Schema.Struct<{
+export declare const WireChunk: Schema.Union<readonly [Schema.String, Schema.Struct<{
   readonly base64: Schema.String;
 }>]>;
-type WireChunk = typeof WireChunk.Type;
+export type WireChunk = typeof WireChunk.Type;
 /** A response whose whole body is valid UTF-8, stored as one string. */
-declare const WireTextBodyResponse: Schema.Struct<{
+export declare const WireTextBodyResponse: Schema.Struct<{
   readonly status: Schema.Int;
   readonly headers: Schema.$Record<Schema.String, Schema.String>;
   readonly body: Schema.String;
   readonly bodyBase64: Schema.optionalKey<Schema.Never>;
   readonly chunks: Schema.optionalKey<Schema.Never>;
 }>;
-type WireTextBodyResponse = typeof WireTextBodyResponse.Type;
+export type WireTextBodyResponse = typeof WireTextBodyResponse.Type;
 /** A response whose whole body is not valid UTF-8 (for example a PDF), stored as base64 bytes. */
-declare const WireBase64BodyResponse: Schema.Struct<{
+export declare const WireBase64BodyResponse: Schema.Struct<{
   readonly status: Schema.Int;
   readonly headers: Schema.$Record<Schema.String, Schema.String>;
   readonly bodyBase64: Schema.String;
   readonly body: Schema.optionalKey<Schema.Never>;
   readonly chunks: Schema.optionalKey<Schema.Never>;
 }>;
-type WireBase64BodyResponse = typeof WireBase64BodyResponse.Type;
+export type WireBase64BodyResponse = typeof WireBase64BodyResponse.Type;
 /** A response recorded as one whole body: exactly one of `body` or `bodyBase64`. */
-declare const WireBodyResponse: Schema.Union<readonly [Schema.Struct<{
+export declare const WireBodyResponse: Schema.Union<readonly [Schema.Struct<{
   readonly status: Schema.Int;
   readonly headers: Schema.$Record<Schema.String, Schema.String>;
   readonly body: Schema.String;
@@ -56,13 +56,13 @@ declare const WireBodyResponse: Schema.Union<readonly [Schema.Struct<{
   readonly body: Schema.optionalKey<Schema.Never>;
   readonly chunks: Schema.optionalKey<Schema.Never>;
 }>]>;
-type WireBodyResponse = typeof WireBodyResponse.Type;
+export type WireBodyResponse = typeof WireBodyResponse.Type;
 /**
  * A streamed response (for example `text/event-stream`). Each entry is one
  * network chunk (see `WireChunk`); chunk boundaries and bytes are preserved on
  * replay.
  */
-declare const WireStreamResponse: Schema.Struct<{
+export declare const WireStreamResponse: Schema.Struct<{
   readonly status: Schema.Int;
   readonly headers: Schema.$Record<Schema.String, Schema.String>;
   readonly chunks: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
@@ -71,8 +71,8 @@ declare const WireStreamResponse: Schema.Struct<{
   readonly body: Schema.optionalKey<Schema.Never>;
   readonly bodyBase64: Schema.optionalKey<Schema.Never>;
 }>;
-type WireStreamResponse = typeof WireStreamResponse.Type;
-declare const WireResponse: Schema.Union<readonly [Schema.Struct<{
+export type WireStreamResponse = typeof WireStreamResponse.Type;
+export declare const WireResponse: Schema.Union<readonly [Schema.Struct<{
   readonly status: Schema.Int;
   readonly headers: Schema.$Record<Schema.String, Schema.String>;
   readonly body: Schema.String;
@@ -93,12 +93,14 @@ declare const WireResponse: Schema.Union<readonly [Schema.Struct<{
   readonly body: Schema.optionalKey<Schema.Never>;
   readonly bodyBase64: Schema.optionalKey<Schema.Never>;
 }>]>;
-type WireResponse = typeof WireResponse.Type;
-declare const WireExchange: Schema.Struct<{
+export type WireResponse = typeof WireResponse.Type;
+export declare const WireExchange: Schema.Struct<{
   readonly request: Schema.Struct<{
-    readonly method: Schema.NonEmptyString; /** Absolute URL including any query string. */
+    readonly method: Schema.NonEmptyString;
+    /** Absolute URL including any query string. */
     readonly url: Schema.NonEmptyString;
-    readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>; /** Parsed JSON request body, or the raw text when it is not JSON (for example a form body). */
+    readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+    /** Parsed JSON request body, or the raw text when it is not JSON (for example a form body). */
     readonly body: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
   }>;
   readonly response: Schema.Union<readonly [Schema.Struct<{
@@ -123,21 +125,25 @@ declare const WireExchange: Schema.Struct<{
     readonly bodyBase64: Schema.optionalKey<Schema.Never>;
   }>]>;
 }>;
-type WireExchange = typeof WireExchange.Type;
-declare const WireFixture: Schema.Struct<{
+export type WireExchange = typeof WireExchange.Type;
+export declare const WireFixture: Schema.Struct<{
   readonly id: Schema.NonEmptyString;
   readonly caseId: Schema.NonEmptyString;
-  readonly evidence: Schema.Literals<readonly ["verified", "unverified"]>; /** Calendar date of the recording (`YYYY-MM-DD`, UTC). */
-  readonly recordedAt: Schema.String; /** Synthetic account label, for example `synthetic`; never a real account name. */
+  readonly evidence: Schema.Literals<readonly ["verified", "unverified"]>;
+  /** Calendar date of the recording (`YYYY-MM-DD`, UTC). */
+  readonly recordedAt: Schema.String;
+  /** Synthetic account label, for example `synthetic`; never a real account name. */
   readonly account: Schema.NonEmptyString;
   readonly endpoint: Schema.NonEmptyString;
   readonly model: Schema.optionalKey<Schema.String>;
   readonly note: Schema.optionalKey<Schema.String>;
   readonly exchanges: Schema.NonEmptyArray<Schema.Struct<{
     readonly request: Schema.Struct<{
-      readonly method: Schema.NonEmptyString; /** Absolute URL including any query string. */
+      readonly method: Schema.NonEmptyString;
+      /** Absolute URL including any query string. */
       readonly url: Schema.NonEmptyString;
-      readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>; /** Parsed JSON request body, or the raw text when it is not JSON (for example a form body). */
+      readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+      /** Parsed JSON request body, or the raw text when it is not JSON (for example a form body). */
       readonly body: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
     }>;
     readonly response: Schema.Union<readonly [Schema.Struct<{
@@ -163,10 +169,17 @@ declare const WireFixture: Schema.Struct<{
     }>]>;
   }>>;
 }>;
-type WireFixture = typeof WireFixture.Type;
+export type WireFixture = typeof WireFixture.Type;
 /** Decode unknown input (for example a JSON file) into a `WireFixture`. */
-declare const decodeWireFixture: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<{
+export declare const decodeWireFixture: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<{
+  readonly id: string;
+  readonly caseId: string;
+  readonly evidence: "unverified" | "verified";
+  readonly recordedAt: string;
   readonly account: string;
+  readonly endpoint: string;
+  readonly model?: string | undefined;
+  readonly note?: string | undefined;
   readonly exchanges: readonly [{
     readonly request: {
       readonly method: string;
@@ -177,26 +190,26 @@ declare const decodeWireFixture: (input: unknown, options?: import("effect/Schem
       readonly body?: Schema.Json | undefined;
     };
     readonly response: {
+      readonly status: number;
       readonly headers: {
         readonly [x: string]: string;
       };
       readonly body: string;
-      readonly status: number;
       readonly bodyBase64?: undefined;
       readonly chunks?: undefined;
     } | {
+      readonly status: number;
       readonly headers: {
         readonly [x: string]: string;
       };
-      readonly status: number;
       readonly bodyBase64: string;
       readonly body?: undefined;
       readonly chunks?: undefined;
     } | {
+      readonly status: number;
       readonly headers: {
         readonly [x: string]: string;
       };
-      readonly status: number;
       readonly chunks: readonly (string | {
         readonly base64: string;
       })[];
@@ -213,26 +226,26 @@ declare const decodeWireFixture: (input: unknown, options?: import("effect/Schem
       readonly body?: Schema.Json | undefined;
     };
     readonly response: {
+      readonly status: number;
       readonly headers: {
         readonly [x: string]: string;
       };
       readonly body: string;
-      readonly status: number;
       readonly bodyBase64?: undefined;
       readonly chunks?: undefined;
     } | {
+      readonly status: number;
       readonly headers: {
         readonly [x: string]: string;
       };
-      readonly status: number;
       readonly bodyBase64: string;
       readonly body?: undefined;
       readonly chunks?: undefined;
     } | {
+      readonly status: number;
       readonly headers: {
         readonly [x: string]: string;
       };
-      readonly status: number;
       readonly chunks: readonly (string | {
         readonly base64: string;
       })[];
@@ -240,29 +253,22 @@ declare const decodeWireFixture: (input: unknown, options?: import("effect/Schem
       readonly bodyBase64?: undefined;
     };
   }[]];
-  readonly id: string;
-  readonly caseId: string;
-  readonly evidence: "verified" | "unverified";
-  readonly recordedAt: string;
-  readonly endpoint: string;
-  readonly model?: string | undefined;
-  readonly note?: string | undefined;
 }, Schema.SchemaError, never>;
-declare const isWireStreamResponse: (response: WireResponse) => response is WireStreamResponse;
-declare const isWireBase64BodyResponse: (response: WireResponse) => response is WireBase64BodyResponse;
+export declare const isWireStreamResponse: (response: WireResponse) => response is WireStreamResponse;
+export declare const isWireBase64BodyResponse: (response: WireResponse) => response is WireBase64BodyResponse;
 /**
  * Whole days between `recordedAt` (UTC midnight) and `now`. `NaN` when
  * `recordedAt` is not a `YYYY-MM-DD` date.
  */
-declare const fixtureAgeDays: (fixture: Pick<WireFixture, "recordedAt">, now: Date) => number;
+export declare const fixtureAgeDays: (fixture: Pick<WireFixture, 'recordedAt'>, now: Date) => number;
 /**
  * True when the fixture is older than `maxAgeDays` (default 30). Fixtures with
  * an unreadable `recordedAt` are treated as stale.
  */
-declare const isFixtureStale: (fixture: Pick<WireFixture, "recordedAt">, now: Date, maxAgeDays?: number) => boolean;
-type FixtureSecretIssueKind = 'credential_header' | 'bearer_token' | 'api_key' | 'credential_query_param' | 'credential_field';
+export declare const isFixtureStale: (fixture: Pick<WireFixture, 'recordedAt'>, now: Date, maxAgeDays?: number) => boolean;
+export type FixtureSecretIssueKind = 'credential_header' | 'bearer_token' | 'api_key' | 'credential_query_param' | 'credential_field';
 /** A secret-scan finding. `location` is a path into the fixture; the secret itself is never echoed. */
-type FixtureSecretIssue = {
+export type FixtureSecretIssue = {
   readonly kind: FixtureSecretIssueKind;
   readonly location: string;
 };
@@ -275,23 +281,21 @@ type FixtureSecretIssue = {
  * found). JSON bodies and SSE `data:` payloads get the credential-field scan.
  * Issues name locations only. Returns an empty array when clean.
  */
-declare const scanFixtureForSecrets: (fixture: WireFixture) => ReadonlyArray<FixtureSecretIssue>;
+export declare const scanFixtureForSecrets: (fixture: WireFixture) => ReadonlyArray<FixtureSecretIssue>;
 /**
  * A failure a port answered instead of a value. `expected` is the port's value-level failure (for
  * example a connector `ActionResult.failure`); `error` is the port's typed error channel. `code`
  * is a sanitized classification, never raw provider text.
  */
-declare const PortFailure: Schema.Struct<{
+export declare const PortFailure: Schema.Struct<{
   readonly kind: Schema.Literals<readonly ["expected", "error"]>;
   readonly code: Schema.NonEmptyString;
   readonly message: Schema.String;
   readonly status: Schema.optionalKey<Schema.Int>;
 }>;
-type PortFailure = typeof PortFailure.Type;
+export type PortFailure = typeof PortFailure.Type;
 /** A port call answered with a value (`response`, plain JSON). */
-declare const PortValueFixture: Schema.Struct<{
-  readonly response: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-  readonly failure: Schema.optionalKey<Schema.Never>;
+export declare const PortValueFixture: Schema.Struct<{
   readonly id: Schema.NonEmptyString;
   readonly port: Schema.NonEmptyString;
   readonly method: Schema.NonEmptyString;
@@ -301,17 +305,12 @@ declare const PortValueFixture: Schema.Struct<{
     readonly date: Schema.String;
   }>>;
   readonly note: Schema.optionalKey<Schema.String>;
+  readonly response: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+  readonly failure: Schema.optionalKey<Schema.Never>;
 }>;
-type PortValueFixture = typeof PortValueFixture.Type;
+export type PortValueFixture = typeof PortValueFixture.Type;
 /** A port call answered with a failure. */
-declare const PortFailureFixture: Schema.Struct<{
-  readonly failure: Schema.Struct<{
-    readonly kind: Schema.Literals<readonly ["expected", "error"]>;
-    readonly code: Schema.NonEmptyString;
-    readonly message: Schema.String;
-    readonly status: Schema.optionalKey<Schema.Int>;
-  }>;
-  readonly response: Schema.optionalKey<Schema.Never>;
+export declare const PortFailureFixture: Schema.Struct<{
   readonly id: Schema.NonEmptyString;
   readonly port: Schema.NonEmptyString;
   readonly method: Schema.NonEmptyString;
@@ -321,16 +320,21 @@ declare const PortFailureFixture: Schema.Struct<{
     readonly date: Schema.String;
   }>>;
   readonly note: Schema.optionalKey<Schema.String>;
+  readonly failure: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["expected", "error"]>;
+    readonly code: Schema.NonEmptyString;
+    readonly message: Schema.String;
+    readonly status: Schema.optionalKey<Schema.Int>;
+  }>;
+  readonly response: Schema.optionalKey<Schema.Never>;
 }>;
-type PortFailureFixture = typeof PortFailureFixture.Type;
+export type PortFailureFixture = typeof PortFailureFixture.Type;
 /**
  * One recorded call through a host-provided port: the port, the method, the credential-free JSON
  * request, and exactly one of `response` or `failure`. Plain JSON only, so one fixture backs
  * replay, an emulator, and parity checks alike.
  */
-declare const PortFixture: Schema.Union<readonly [Schema.Struct<{
-  readonly response: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-  readonly failure: Schema.optionalKey<Schema.Never>;
+export declare const PortFixture: Schema.Union<readonly [Schema.Struct<{
   readonly id: Schema.NonEmptyString;
   readonly port: Schema.NonEmptyString;
   readonly method: Schema.NonEmptyString;
@@ -340,14 +344,9 @@ declare const PortFixture: Schema.Union<readonly [Schema.Struct<{
     readonly date: Schema.String;
   }>>;
   readonly note: Schema.optionalKey<Schema.String>;
+  readonly response: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+  readonly failure: Schema.optionalKey<Schema.Never>;
 }>, Schema.Struct<{
-  readonly failure: Schema.Struct<{
-    readonly kind: Schema.Literals<readonly ["expected", "error"]>;
-    readonly code: Schema.NonEmptyString;
-    readonly message: Schema.String;
-    readonly status: Schema.optionalKey<Schema.Int>;
-  }>;
-  readonly response: Schema.optionalKey<Schema.Never>;
   readonly id: Schema.NonEmptyString;
   readonly port: Schema.NonEmptyString;
   readonly method: Schema.NonEmptyString;
@@ -357,45 +356,52 @@ declare const PortFixture: Schema.Union<readonly [Schema.Struct<{
     readonly date: Schema.String;
   }>>;
   readonly note: Schema.optionalKey<Schema.String>;
+  readonly failure: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["expected", "error"]>;
+    readonly code: Schema.NonEmptyString;
+    readonly message: Schema.String;
+    readonly status: Schema.optionalKey<Schema.Int>;
+  }>;
+  readonly response: Schema.optionalKey<Schema.Never>;
 }>]>;
-type PortFixture = typeof PortFixture.Type;
+export type PortFixture = typeof PortFixture.Type;
 /** Decode unknown input (for example a JSON file) into a `PortFixture`. */
-declare const decodePortFixture: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<{
-  readonly method: string;
-  readonly request: Schema.Json;
-  readonly response: Schema.Json;
+export declare const decodePortFixture: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<{
   readonly id: string;
   readonly port: string;
-  readonly note?: string | undefined;
-  readonly failure?: undefined;
+  readonly method: string;
+  readonly request: Schema.Json;
   readonly observed?: {
     readonly account: string;
     readonly date: string;
   } | undefined;
+  readonly note?: string | undefined;
+  readonly response: Schema.Json;
+  readonly failure?: undefined;
 } | {
+  readonly id: string;
+  readonly port: string;
   readonly method: string;
   readonly request: Schema.Json;
-  readonly id: string;
+  readonly observed?: {
+    readonly account: string;
+    readonly date: string;
+  } | undefined;
+  readonly note?: string | undefined;
   readonly failure: {
-    readonly kind: "expected" | "error";
+    readonly kind: "error" | "expected";
     readonly code: string;
     readonly message: string;
     readonly status?: number | undefined;
   };
-  readonly port: string;
-  readonly note?: string | undefined;
   readonly response?: undefined;
-  readonly observed?: {
-    readonly account: string;
-    readonly date: string;
-  } | undefined;
 }, Schema.SchemaError, never>;
 /** Any fixture a conformance case may cite: an HTTP `WireFixture` or a `PortFixture`. */
-type ConformanceFixture = WireFixture | PortFixture;
-declare const isPortFixture: (fixture: ConformanceFixture) => fixture is PortFixture;
-declare const isPortFailureFixture: (fixture: PortFixture) => fixture is PortFailureFixture;
+export type ConformanceFixture = WireFixture | PortFixture;
+export declare const isPortFixture: (fixture: ConformanceFixture) => fixture is PortFixture;
+export declare const isPortFailureFixture: (fixture: PortFixture) => fixture is PortFailureFixture;
 /** Evidence and (when known) date of a fixture. */
-type ConformanceFixtureEvidence = {
+export type ConformanceFixtureEvidence = {
   readonly evidence: WireFixtureEvidence;
   readonly date?: string;
 };
@@ -404,16 +410,16 @@ type ConformanceFixtureEvidence = {
  * `PortFixture` is `verified` as of `observed.date` when observed, else `unverified` without a
  * date.
  */
-declare const conformanceFixtureEvidence: (fixture: ConformanceFixture) => ConformanceFixtureEvidence;
+export declare const conformanceFixtureEvidence: (fixture: ConformanceFixture) => ConformanceFixtureEvidence;
 /** True for a port payload key that holds a credential (`credential`, `password`, `token`, ...). */
-declare const isPortCredentialKey: (key: string) => boolean;
+export declare const isPortCredentialKey: (key: string) => boolean;
 /**
  * A copy of a port payload without credential fields (see `isPortCredentialKey`: `credential(s)`
  * plus the credential field names, AWS-style `accessKeyId` / `secretAccessKey` / `sessionToken`
  * and their snake_case forms included), at any depth.
  * Port requests often carry the resolved credential; record and compare requests only after this.
  */
-declare const redactPortPayload: (value: Schema.Json) => Schema.Json;
+export declare const redactPortPayload: (value: Schema.Json) => Schema.Json;
 /**
  * Pure secret scan of a `PortFixture`: the same token patterns and credential JSON fields as
  * `scanFixtureForSecrets`, plus any non-null `credential` / `credentials` field (port requests must
@@ -426,7 +432,6 @@ declare const redactPortPayload: (value: Schema.Json) => Schema.Json;
  * found. Covers metadata, the request, the response, and the failure. Issues name locations only.
  * Returns an empty array when clean.
  */
-declare const scanPortFixtureForSecrets: (fixture: PortFixture) => ReadonlyArray<FixtureSecretIssue>;
-//#endregion
-export { ConformanceFixture, ConformanceFixtureEvidence, FixtureSecretIssue, FixtureSecretIssueKind, PortFailure, PortFailureFixture, PortFixture, PortValueFixture, WireBase64BodyResponse, WireBodyResponse, WireChunk, WireExchange, WireFixture, WireFixtureEvidence, WireHeaders, WireRequest, WireResponse, WireStreamResponse, WireTextBodyResponse, conformanceFixtureEvidence, decodePortFixture, decodeWireFixture, fixtureAgeDays, isFixtureStale, isPortCredentialKey, isPortFailureFixture, isPortFixture, isWireBase64BodyResponse, isWireStreamResponse, redactPortPayload, scanFixtureForSecrets, scanPortFixtureForSecrets, syntheticPortCredentialParams };
+export declare const scanPortFixtureForSecrets: (fixture: PortFixture) => ReadonlyArray<FixtureSecretIssue>;
+export { syntheticPortCredentialParams };
 //# sourceMappingURL=fixture.d.mts.map