WorkerRunner

declare const CloseLatch: any

interface CloseLatch {
  readonly _: typeof _;
}

declare const layerCloseLatch: Layer.Layer<CloseLatch>

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>

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

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

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>) => Layer.Layer<never, WorkerError, R | PlatformRunner>

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

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

interface PlatformRunner {
  readonly [PlatformRunnerTypeId]: typeof PlatformRunnerTypeId;
  readonly start: <I, O>(closeLatch: any) => Effect<BackingRunner<I, O>, WorkerError>;
}

declare const PlatformRunner: Tag<PlatformRunner, PlatformRunner>

declare const PlatformRunnerTypeId: unique symbol

type PlatformRunnerTypeId = typeof PlatformRunnerTypeId