export declare const make: <I, R, E, O>(
  process: (request: I) => Stream.Stream<R, E, O> | Effect.Effect<R, E, O>,
  options?: Runner.Options<I, E, O> | undefined
) => Effect.Effect<PlatformRunner | R | Scope.Scope, WorkerError, void>

export declare const makeSerialized: <
  I,
  A extends Schema.TaggedRequest.Any,
  const Handlers extends SerializedRunner.Handlers<A>
>(
  schema: Schema.Schema<I, A>,
  handlers: Handlers
) => Effect.Effect<PlatformRunner | Scope.Scope | SerializedRunner.HandlersContext<Handlers>, WorkerError, void>

export declare const layer: <I, R, E, O>(
  process: (request: I) => Stream.Stream<R, E, O> | Effect.Effect<R, E, O>,
  options?: Runner.Options<I, E, O> | undefined
) => Layer.Layer<PlatformRunner | R, WorkerError, never>

export declare const layerSerialized: <
  I,
  A extends Schema.TaggedRequest.Any,
  const Handlers extends SerializedRunner.Handlers<A>
>(
  schema: Schema.Schema<I, A>,
  handlers: Handlers
) => Layer.Layer<PlatformRunner | SerializedRunner.HandlersContext<Handlers>, WorkerError, never>

export interface BackingRunner<I, O> {
  readonly queue: Queue.Dequeue<I>
  readonly send: (message: O, transfers?: ReadonlyArray<unknown>) => Effect.Effect<never, never, void>
}

export type Message<I> = readonly [request: 0, I] | readonly [close: 1]

export interface PlatformRunner {
  readonly [PlatformRunnerTypeId]: PlatformRunnerTypeId
  readonly start: <I, O>() => Effect.Effect<Scope.Scope, WorkerError, BackingRunner<I, O>>
}

export interface Options<I, E, O> {
  readonly decode?: (message: unknown) => Effect.Effect<never, WorkerError, I>
  readonly encodeOutput?: (request: I, message: O) => Effect.Effect<never, WorkerError, unknown>
  readonly encodeError?: (request: I, error: E) => Effect.Effect<never, WorkerError, unknown>
  readonly transfers?: (message: O | E) => ReadonlyArray<unknown>
}

export type Handlers<A extends Schema.TaggedRequest.Any> = {
  readonly [K in A["_tag"]]: Extract<A, { readonly _tag: K }> extends Serializable.SerializableWithResult<
    infer _IS,
    infer S,
    infer _IE,
    infer E,
    infer _IO,
    infer O
  >
    ? (
        _: S
      ) => Stream.Stream<any, E, O> | Effect.Effect<any, E, O> | Layer.Layer<any, E, any> | Layer.Layer<any, E, never>
    : never
}

export type HandlersContext<Handlers extends Record<string, (...args: ReadonlyArray<any>) => any>> =
  | Exclude<
      {
        [K in keyof Handlers]: ReturnType<Handlers[K]> extends Stream.Stream<infer R, infer _E, infer _A> ? R : never
      }[keyof Handlers],
      {
        [K in keyof Handlers]: ReturnType<Handlers[K]> extends Layer.Layer<infer _R, infer _E, infer A> ? A : never
      }[keyof Handlers]
    >
  | {
      [K in keyof Handlers]: ReturnType<Handlers[K]> extends Layer.Layer<infer R, infer _E, infer _A> ? R : never
    }[keyof Handlers]

export declare const PlatformRunner: Context.Tag<PlatformRunner, PlatformRunner>

export declare const PlatformRunnerTypeId: typeof PlatformRunnerTypeId

export type PlatformRunnerTypeId = typeof PlatformRunnerTypeId