export declare const CloseLatch: Context.Reference<CloseLatch, Deferred.Deferred<void, WorkerError>>

export interface CloseLatch {
  readonly _: unique symbol
}

export declare const layerCloseLatch: Layer.Layer<CloseLatch>

export declare const launch: <A, E, R>(layer: Layer.Layer<A, E, R>) => Effect.Effect<void, E | WorkerError, R>

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

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

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

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

export interface BackingRunner<I, O> {
  readonly run: <A, E, R>(
    handler: (portId: number, message: I) => Effect.Effect<A, E, R>
  ) => Effect.Effect<void, never, Scope.Scope | R>
  readonly send: (portId: number, message: O, transfers?: ReadonlyArray<unknown>) => Effect.Effect<void>
}

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

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

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

export type Handlers<A extends Schema.TaggedRequest.All> = {
  readonly [K in A["_tag"]]: Extract<A, { readonly _tag: K }> extends Schema.SerializableWithResult<
    infer S,
    infer _SI,
    infer _SR,
    infer A,
    infer _AI,
    infer E,
    infer _EI,
    infer _RR
  >
    ? (
        _: S
      ) => Stream.Stream<A, E, any> | Effect.Effect<A, E, any> | Layer.Layer<any, E, any> | Layer.Layer<never, E, any>
    : never
}

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

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

export declare const PlatformRunnerTypeId: typeof PlatformRunnerTypeId

export type PlatformRunnerTypeId = typeof PlatformRunnerTypeId