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