export function acquireProxiedClient(opts: {
  readonly ctx: ConformanceRunContext;
  readonly proxy: ToxiproxyProxy;
  readonly name: string;
  readonly defaultTimeoutMs: number;
  readonly unavailable: (reason: string) => PropertyUnavailable;
}): Effect.Effect<
  { agent: TestAgent; client: AgentTestClient },
  PropertyUnavailable,
  Scope.Scope
>

export const ADVERSITY_CATEGORY = "adversity"

export function adversityViolation(
  name: string,
  reason: string,
): PropertyInvariantViolation

export function createOneOnOneConversation(
  owner: { agent: TestAgent; client: AgentTestClient },
  participant: { agent: TestAgent; client: AgentTestClient },
  propertyName: string,
): Effect.Effect<
  { conversationId: ConversationId },
  PropertyInvariantViolation
>

export function proxyName(prefix: string, seed: number): string

export function registerLatencyResilience(ctx: ConformanceRunContext): void

export function registerResetPeerRecovery(ctx: ConformanceRunContext): void

export function registerSlowCloseCleanup(ctx: ConformanceRunContext): void

export function registerTimeoutSurface(ctx: ConformanceRunContext): void

export interface ToxicBodyParams {
  readonly proxy: ToxiproxyProxy;
  readonly unavailable: (reason: string) => PropertyUnavailable;
  readonly attachToxic: Effect.Effect<void, PropertyUnavailable, Scope.Scope>;
}

Effect.scoped(gen(function* () {
  const client = yield* acquireProxiedClient(...)  // outer
  yield* Effect.scoped(gen(function* () {
    yield* attachToxic                             // inner
    yield* assertion(client)
  }))                                              // toxic removed
}))                                                // client close OK

export const TRANSPORT_PROPERTIES: ReadonlyArray<
  (ctx: ConformanceRunContext) => void
> = [
  registerLatencyResilience,
  registerResetPeerRecovery,
  registerTimeoutSurface,
  registerSlowCloseCleanup,
]

export function withToxicProxy(opts: {
  readonly ctx: ConformanceRunContext;
  readonly propertyName: string;
  readonly description: string;
  readonly proxyName: string;
  readonly profile: ToxicProfile;
  readonly body: (
    params: ToxicBodyParams,
  ) => Effect.Effect<void, ToxicPropertyError, Scope.Scope>;
}): void