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;