Worker

declare const makeManager: Effect.Effect<WorkerManager, never, PlatformWorker>;

declare const makePool: <I, O, E>(
  options: WorkerPool.Options<I>,
) => Effect.Effect<WorkerPool<I, O, E>, WorkerError, WorkerManager | Spawner | Scope.Scope>;

declare const makePoolLayer: <Tag, I, O, E>(
  tag: Context.Tag<Tag, WorkerPool<I, O, E>>,
  options: WorkerPool.Options<I>,
) => Layer.Layer<Tag, WorkerError, WorkerManager | Spawner>;

declare const makePoolSerialized: <I extends Schema.TaggedRequest.All>(
  options: SerializedWorkerPool.Options<I>,
) => Effect.Effect<SerializedWorkerPool<I>, WorkerError, WorkerManager | Spawner | Scope.Scope>;

declare const makeSerialized: <I extends Schema.TaggedRequest.All>(
  options: SerializedWorker.Options<I>,
) => Effect.Effect<SerializedWorker<I>, WorkerError, WorkerManager | Spawner | Scope.Scope>;

declare const layerManager: Layer.Layer<WorkerManager, never, PlatformWorker>;

declare const layerSpawner: <W = unknown>(
  spawner: SpawnerFn<W>,
) => Layer.Layer<Spawner, never, never>;

declare const makePoolSerializedLayer: <Tag, I extends Schema.TaggedRequest.All>(
  tag: Context.Tag<Tag, SerializedWorkerPool<I>>,
  options: SerializedWorkerPool.Options<I>,
) => Layer.Layer<Tag, WorkerError, WorkerManager | Spawner>;

interface BackingWorker<I, O> {
  readonly run: <A, E, R>(handler: (_: Message<O>) => Effect<A, E, R>) => Effect<never, WorkerError | E, R>;
  readonly send: (message: I, transfers?: readonly Array<unknown>) => Effect<void, WorkerError>;
}

interface PlatformWorker {
  readonly [PlatformWorkerTypeId]: typeof PlatformWorkerTypeId;
  readonly spawn: <I, O>(id: number) => Effect<BackingWorker<I, O>, WorkerError, Spawner>;
}

interface SerializedWorker<I extends Schema.TaggedRequest.All> {
  readonly execute: <Req extends All>(
    message: Req,
  ) => Req extends WithResult<A, _I, E, _EI, R> ? Stream<A, any, R> : never;
  readonly executeEffect: <Req extends All>(
    message: Req,
  ) => Req extends WithResult<A, _I, E, _EI, R> ? Effect<A, any, R> : never;
  readonly id: number;
}

interface SerializedWorkerPool<I extends Schema.TaggedRequest.All> {
  readonly backing: Pool<SerializedWorker<I>, WorkerError>;
  readonly broadcast: <Req extends All>(
    message: Req,
  ) => Req extends WithResult<_A, _I, E, _EI, R> ? Effect<void, any, R> : never;
  readonly execute: <Req extends All>(
    message: Req,
  ) => Req extends WithResult<A, _I, E, _EI, R> ? Stream<A, any, R> : never;
  readonly executeEffect: <Req extends All>(
    message: Req,
  ) => Req extends WithResult<A, _I, E, _EI, R> ? Effect<A, any, R> : never;
}

interface Spawner {
  readonly _: typeof _;
}

interface SpawnerFn<W = unknown> {
  (id: number): W;
}

interface Worker<I, O, E = never> {
  readonly execute: (message: I) => Stream<O, WorkerError | E>;
  readonly executeEffect: (message: I) => Effect<O, WorkerError | E>;
  readonly id: number;
}

interface WorkerManager {
  readonly [WorkerManagerTypeId]: typeof WorkerManagerTypeId;
  readonly spawn: <I, O, E>(
    options: Options<I>,
  ) => Effect<Worker<I, O, E>, WorkerError, Scope | Spawner>;
}

interface WorkerPool<I, O, E = never> {
  readonly backing: Pool<Worker<I, O, E>, WorkerError>;
  readonly broadcast: (message: I) => Effect<void, WorkerError | E>;
  readonly execute: (message: I) => Stream<O, WorkerError | E>;
  readonly executeEffect: (message: I) => Effect<O, WorkerError | E>;
}

declare const makePlatform: <W>() => <
  P extends {
    readonly postMessage: (message: any, transfers?: any) => void;
  },
>(options: {
  readonly listen: (options: {
    readonly deferred: Deferred.Deferred<never, WorkerError>;
    readonly emit: (data: any) => void;
    readonly port: P;
    readonly scope: Scope.Scope;
  }) => Effect.Effect<void>;
  readonly setup: (options: {
    readonly scope: Scope.Scope;
    readonly worker: W;
  }) => Effect.Effect<P, WorkerError>;
}) => PlatformWorker;

declare const PlatformWorker: Tag<PlatformWorker, PlatformWorker>;

declare const Spawner: Tag<Spawner, SpawnerFn<unknown>>;

declare const WorkerManager: Tag<WorkerManager, WorkerManager>;

declare const PlatformWorkerTypeId: unique symbol;

type PlatformWorkerTypeId = typeof PlatformWorkerTypeId;

declare const WorkerManagerTypeId: unique symbol;

type WorkerManagerTypeId = typeof WorkerManagerTypeId;