@effect/platform 0.34.0 → 0.36.0

package/src/Http/Server.ts

@@ -3,11 +3,11 @@
  */
 import type * as Context from "effect/Context"
 import type * as Effect from "effect/Effect"
+import type * as Layer from "effect/Layer"
 import type * as Scope from "effect/Scope"
 import * as internal from "../internal/http/server.js"
 import type * as App from "./App.js"
 import type * as Middleware from "./Middleware.js"
-import type * as Error from "./ServerError.js"
 import type * as ServerRequest from "./ServerRequest.js"
 
 /**
@@ -31,16 +31,16 @@ export interface Server {
   readonly serve: {
     <R, E>(httpApp: App.Default<R, E>): Effect.Effect<
       Exclude<R, ServerRequest.ServerRequest> | Scope.Scope,
-      Error.ServeError,
-      never
+      never,
+      void
     >
     <R, E, App extends App.Default<any, any>>(
       httpApp: App.Default<R, E>,
       middleware: Middleware.Middleware.Applied<R, E, App>
     ): Effect.Effect<
       Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest> | Scope.Scope,
-      Error.ServeError,
-      never
+      never,
+      void
     >
   }
   readonly address: Address
@@ -94,7 +94,7 @@ export const make: (
     readonly serve: (
       httpApp: App.Default<never, unknown>,
       middleware?: Middleware.Middleware
-    ) => Effect.Effect<Scope.Scope, Error.ServeError, never>
+    ) => Effect.Effect<Scope.Scope, never, void>
     readonly address: Address
   }
 ) => Server = internal.make
@@ -104,31 +104,41 @@ export const make: (
  * @category accessors
  */
 export const serve: {
+  (): <R, E>(httpApp: App.Default<R, E>) => Layer.Layer<Server | Exclude<R, ServerRequest.ServerRequest>, never, never>
+  <R, E, App extends App.Default<any, any>>(
+    middleware: Middleware.Middleware.Applied<R, E, App>
+  ): (
+    httpApp: App.Default<R, E>
+  ) => Layer.Layer<Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest>, never, never>
+  <R, E>(httpApp: App.Default<R, E>): Layer.Layer<Server | Exclude<R, ServerRequest.ServerRequest>, never, never>
+  <R, E, App extends App.Default<any, any>>(
+    httpApp: App.Default<R, E>,
+    middleware: Middleware.Middleware.Applied<R, E, App>
+  ): Layer.Layer<Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest>, never, never>
+} = internal.serve
+
+/**
+ * @since 1.0.0
+ * @category accessors
+ */
+export const serveEffect: {
   (): <R, E>(
     httpApp: App.Default<R, E>
-  ) => Effect.Effect<
-    Server | Scope.Scope | Exclude<R, ServerRequest.ServerRequest>,
-    Error.ServeError,
-    never
-  >
+  ) => Effect.Effect<Scope.Scope | Server | Exclude<R, ServerRequest.ServerRequest>, never, void>
   <R, E, App extends App.Default<any, any>>(
     middleware: Middleware.Middleware.Applied<R, E, App>
   ): (
     httpApp: App.Default<R, E>
   ) => Effect.Effect<
-    Server | Scope.Scope | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest>,
-    Error.ServeError,
-    never
+    Scope.Scope | Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest>,
+    never,
+    void
   >
   <R, E>(
     httpApp: App.Default<R, E>
-  ): Effect.Effect<Server | Scope.Scope | Exclude<R, ServerRequest.ServerRequest>, Error.ServeError, never>
+  ): Effect.Effect<Scope.Scope | Server | Exclude<R, ServerRequest.ServerRequest>, never, void>
   <R, E, App extends App.Default<any, any>>(
     httpApp: App.Default<R, E>,
     middleware: Middleware.Middleware.Applied<R, E, App>
-  ): Effect.Effect<
-    Server | Scope.Scope | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest>,
-    Error.ServeError,
-    never
-  >
-} = internal.serve
+  ): Effect.Effect<Scope.Scope | Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest>, never, void>
+} = internal.serveEffect

package/src/Transferable.ts

@@ -0,0 +1,28 @@
+/**
+ * @since 1.0.0
+ */
+
+/**
+ * @since 1.0.0
+ * @category symbols
+ */
+export const symbol = Symbol.for("@effect/platform/Transferable")
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface Transferable {
+  readonly [symbol]: () => ReadonlyArray<globalThis.Transferable>
+}
+
+/**
+ * @since 1.0.0
+ * @category accessors
+ */
+export const get = (u: unknown): ReadonlyArray<globalThis.Transferable> => {
+  if (typeof u === "object" && u !== null && symbol in u) {
+    return (u as Transferable)[symbol]()
+  }
+  return []
+}

package/src/Worker.ts

@@ -1,6 +1,9 @@
 /**
  * @since 1.0.0
  */
+import type * as ParseResult from "@effect/schema/ParseResult"
+import type * as Schema from "@effect/schema/Schema"
+import type * as Serializable from "@effect/schema/Serializable"
 import type * as Context from "effect/Context"
 import type * as Duration from "effect/Duration"
 import type * as Effect from "effect/Effect"
@@ -210,3 +213,110 @@ export const makePoolLayer: <W>(
   tag: Context.Tag<Tag, WorkerPool<I, E, O>>,
   options: WorkerPool.Options<I, W>
 ) => Layer.Layer<never, never, Tag> = internal.makePoolLayer
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface SerializedWorker<I extends Schema.TaggedRequest.Any> {
+  readonly id: number
+  readonly join: Effect.Effect<never, WorkerError, never>
+  readonly execute: <Req extends I>(
+    message: Req
+  ) => Req extends Serializable.WithResult<infer _IE, infer E, infer _IA, infer A>
+    ? Stream.Stream<never, E | WorkerError | ParseResult.ParseError, A>
+    : never
+  readonly executeEffect: <Req extends I>(
+    message: Req
+  ) => Req extends Serializable.WithResult<infer _IE, infer E, infer _IA, infer A>
+    ? Effect.Effect<never, E | WorkerError | ParseResult.ParseError, A>
+    : never
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export declare namespace SerializedWorker {
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export interface Options<I, W = unknown> {
+    readonly spawn: (id: number) => W
+    readonly permits?: number
+    readonly queue?: WorkerQueue<I>
+  }
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface SerializedWorkerPool<I extends Schema.TaggedRequest.Any> {
+  readonly backing: Pool.Pool<WorkerError, SerializedWorker<I>>
+  readonly broadcast: <Req extends I>(
+    message: Req
+  ) => Req extends Serializable.WithResult<infer _IE, infer E, infer _IA, infer _A>
+    ? Effect.Effect<never, E | WorkerError | ParseResult.ParseError, void>
+    : never
+  readonly execute: <Req extends I>(
+    message: Req
+  ) => Req extends Serializable.WithResult<infer _IE, infer E, infer _IA, infer A>
+    ? Stream.Stream<never, E | WorkerError | ParseResult.ParseError, A>
+    : never
+  readonly executeEffect: <Req extends I>(
+    message: Req
+  ) => Req extends Serializable.WithResult<infer _IE, infer E, infer _IA, infer A>
+    ? Effect.Effect<never, E | WorkerError | ParseResult.ParseError, A>
+    : never
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export declare namespace SerializedWorkerPool {
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Options<I, W = unknown> =
+    & SerializedWorker.Options<I, W>
+    & ({
+      readonly onCreate?: (worker: Worker<I, unknown, unknown>) => Effect.Effect<never, WorkerError, void>
+      readonly size: number
+    } | {
+      readonly onCreate?: (worker: Worker<I, unknown, unknown>) => Effect.Effect<never, WorkerError, void>
+      readonly minSize: number
+      readonly maxSize: number
+      readonly timeToLive: Duration.DurationInput
+    })
+}
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const makeSerialized: <I extends Schema.TaggedRequest.Any, W = unknown>(
+  options: SerializedWorker.Options<I, W>
+) => Effect.Effect<WorkerManager | Scope.Scope, WorkerError, SerializedWorker<I>> = internal.makeSerialized
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const makePoolSerialized: <W>() => <I extends Schema.TaggedRequest.Any>(
+  options: SerializedWorkerPool.Options<I, W>
+) => Effect.Effect<WorkerManager | Scope.Scope, never, SerializedWorkerPool<I>> = internal.makePoolSerialized
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const makePoolSerializedLayer: <W>(
+  managerLayer: Layer.Layer<never, never, WorkerManager>
+) => <Tag, I extends Schema.TaggedRequest.Any>(
+  tag: Context.Tag<Tag, SerializedWorkerPool<I>>,
+  options: SerializedWorkerPool.Options<I, W>
+) => Layer.Layer<never, never, Tag> = internal.makePoolSerializedLayer

package/src/WorkerRunner.ts

@@ -1,6 +1,8 @@
 /**
  * @since 1.0.0
  */
+import type * as Schema from "@effect/schema/Schema"
+import type * as Serializable from "@effect/schema/Serializable"
 import type * as Context from "effect/Context"
 import type * as Effect from "effect/Effect"
 import type * as Fiber from "effect/Fiber"
@@ -82,3 +84,27 @@ export const make: <I, R, E, O>(
   process: (request: I) => Stream.Stream<R, E, O> | Effect.Effect<R, E, O>,
   options?: Runner.Options<O> | undefined
 ) => Effect.Effect<Scope.Scope | R | PlatformRunner, WorkerError, never> = internal.make
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const makeSerialized: <
+  I,
+  A extends Schema.TaggedRequest.Any,
+  Handlers extends {
+    readonly [K in A["_tag"]]: Extract<A, { readonly _tag: K }> extends
+      Serializable.SerializableWithResult<infer _IS, infer S, infer _IE, infer E, infer _IO, infer O>
+      ? (_: S) => Stream.Stream<any, E, O> | Effect.Effect<any, E, O> :
+      never
+  }
+>(
+  schema: Schema.Schema<I, A>,
+  handlers: Handlers
+) => Effect.Effect<
+  | PlatformRunner
+  | Scope.Scope
+  | (ReturnType<Handlers[keyof Handlers]> extends Stream.Stream<infer R, infer _E, infer _A> ? R : never),
+  WorkerError,
+  never
+> = internal.makeSerialized

package/src/internal/http/server.ts

@@ -1,11 +1,11 @@
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import { dual } from "effect/Function"
+import * as Layer from "effect/Layer"
 import type * as Scope from "effect/Scope"
 import type * as App from "../../Http/App.js"
 import type * as Middleware from "../../Http/Middleware.js"
 import type * as Server from "../../Http/Server.js"
-import type * as Error from "../../Http/ServerError.js"
 import type * as ServerRequest from "../../Http/ServerRequest.js"
 
 /** @internal */
@@ -27,40 +27,89 @@ export const make = (
     readonly serve: (
       httpApp: App.Default<never, unknown>,
       middleware?: Middleware.Middleware
-    ) => Effect.Effect<Scope.Scope, Error.ServeError, never>
+    ) => Effect.Effect<Scope.Scope, never, void>
     readonly address: Server.Address
   }
 ): Server.Server => Object.assign(Object.create(serverProto), options)
 
 /** @internal */
 export const serve = dual<
+  {
+    (): <R, E>(
+      httpApp: App.Default<R, E>
+    ) => Layer.Layer<
+      Server.Server | Exclude<R, ServerRequest.ServerRequest>,
+      never,
+      never
+    >
+    <R, E, App extends App.Default<any, any>>(middleware: Middleware.Middleware.Applied<R, E, App>): (
+      httpApp: App.Default<R, E>
+    ) => Layer.Layer<
+      Server.Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest>,
+      never,
+      never
+    >
+  },
+  {
+    <R, E>(
+      httpApp: App.Default<R, E>
+    ): Layer.Layer<Server.Server | Exclude<R, ServerRequest.ServerRequest>, never, never>
+    <R, E, App extends App.Default<any, any>>(
+      httpApp: App.Default<R, E>,
+      middleware: Middleware.Middleware.Applied<R, E, App>
+    ): Layer.Layer<
+      Server.Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest>,
+      never,
+      never
+    >
+  }
+>(
+  (args) => Effect.isEffect(args[0]),
+  <R, E, App extends App.Default<any, any>>(
+    httpApp: App.Default<R, E>,
+    middleware?: Middleware.Middleware.Applied<R, E, App>
+  ): Layer.Layer<
+    Server.Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest>,
+    never,
+    never
+  > =>
+    Layer.scopedDiscard(
+      Effect.flatMap(
+        serverTag,
+        (server) => server.serve(httpApp, middleware!)
+      )
+    ) as any
+)
+
+/** @internal */
+export const serveEffect = dual<
   {
     (): <R, E>(
       httpApp: App.Default<R, E>
     ) => Effect.Effect<
       Server.Server | Scope.Scope | Exclude<R, ServerRequest.ServerRequest>,
-      Error.ServeError,
-      never
+      never,
+      void
     >
     <R, E, App extends App.Default<any, any>>(middleware: Middleware.Middleware.Applied<R, E, App>): (
       httpApp: App.Default<R, E>
     ) => Effect.Effect<
       Server.Server | Scope.Scope | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest>,
-      Error.ServeError,
-      never
+      never,
+      void
     >
   },
   {
     <R, E>(
       httpApp: App.Default<R, E>
-    ): Effect.Effect<Server.Server | Scope.Scope | Exclude<R, ServerRequest.ServerRequest>, Error.ServeError, never>
+    ): Effect.Effect<Server.Server | Scope.Scope | Exclude<R, ServerRequest.ServerRequest>, never, void>
     <R, E, App extends App.Default<any, any>>(
       httpApp: App.Default<R, E>,
       middleware: Middleware.Middleware.Applied<R, E, App>
     ): Effect.Effect<
       Server.Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest> | Scope.Scope,
-      Error.ServeError,
-      never
+      never,
+      void
     >
   }
 >(
@@ -70,8 +119,8 @@ export const serve = dual<
     middleware: Middleware.Middleware.Applied<R, E, App>
   ): Effect.Effect<
     Server.Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest> | Scope.Scope,
-    Error.ServeError,
-    never
+    never,
+    void
   > =>
     Effect.flatMap(
       serverTag,

package/src/internal/worker.ts

@@ -1,3 +1,5 @@
+import * as Schema from "@effect/schema/Schema"
+import * as Serializable from "@effect/schema/Serializable"
 import * as Cause from "effect/Cause"
 import * as Channel from "effect/Channel"
 import * as Chunk from "effect/Chunk"
@@ -10,7 +12,9 @@ import { identity, pipe } from "effect/Function"
 import * as Layer from "effect/Layer"
 import * as Pool from "effect/Pool"
 import * as Queue from "effect/Queue"
+import type * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
+import * as Transferable from "../Transferable.js"
 import type * as Worker from "../Worker.js"
 import type { WorkerError } from "../WorkerError.js"
 
@@ -284,3 +288,110 @@ export const makePoolLayer = <W>(managerLayer: Layer.Layer<never, never, Worker.
   tag: Context.Tag<Tag, Worker.WorkerPool<I, E, O>>,
   options: Worker.WorkerPool.Options<I, W>
 ) => Layer.scoped(tag, makePool<W>()(options)).pipe(Layer.provide(managerLayer))
+
+/** @internal */
+export const makeSerialized = <
+  I extends Schema.TaggedRequest.Any,
+  W = unknown
+>(
+  options: Worker.SerializedWorker.Options<I, W>
+): Effect.Effect<Worker.WorkerManager | Scope.Scope, WorkerError, Worker.SerializedWorker<I>> =>
+  Effect.gen(function*(_) {
+    const manager = yield* _(WorkerManager)
+    const backing = yield* _(
+      manager.spawn({
+        ...options,
+        transfers(message) {
+          return Transferable.get(message)
+        }
+      })
+    )
+    const execute = <Req extends I>(message: Req) => {
+      const parseSuccess = Schema.decode(Serializable.successSchema(message as any))
+      const parseFailure = Schema.decode(Serializable.failureSchema(message as any))
+      return pipe(
+        Serializable.serialize(message),
+        Stream.flatMap((message) => backing.execute(message)),
+        Stream.catchAll((error) => Effect.flatMap(parseFailure(error), Effect.fail)),
+        Stream.mapEffect(parseSuccess)
+      )
+    }
+    const executeEffect = <Req extends I>(message: Req) => {
+      const parseSuccess = Schema.decode(Serializable.successSchema(message as any))
+      const parseFailure = Schema.decode(Serializable.failureSchema(message as any))
+      return pipe(
+        Serializable.serialize(message),
+        Effect.flatMap((message) => backing.executeEffect(message)),
+        Effect.matchEffect({
+          onFailure: (error) => Effect.flatMap(parseFailure(error), Effect.fail),
+          onSuccess: parseSuccess
+        })
+      )
+    }
+    return identity<Worker.SerializedWorker<I>>({
+      id: backing.id,
+      join: backing.join,
+      execute: execute as any,
+      executeEffect: executeEffect as any
+    })
+  })
+
+/** @internal */
+export const makePoolSerialized = <W>() =>
+<I extends Schema.TaggedRequest.Any>(
+  options: Worker.SerializedWorkerPool.Options<I, W>
+) =>
+  Effect.gen(function*(_) {
+    const manager = yield* _(WorkerManager)
+    const workers = new Set<Worker.SerializedWorker<I>>()
+    const acquire = pipe(
+      makeSerialized<I, W>(options),
+      Effect.tap((worker) => Effect.sync(() => workers.add(worker))),
+      Effect.tap((worker) => Effect.addFinalizer(() => Effect.sync(() => workers.delete(worker)))),
+      options.onCreate ? Effect.tap(options.onCreate) : identity,
+      Effect.provideService(WorkerManager, manager)
+    )
+    const backing = yield* _(
+      "timeToLive" in options ?
+        Pool.makeWithTTL({
+          acquire,
+          min: options.minSize,
+          max: options.maxSize,
+          timeToLive: options.timeToLive
+        }) :
+        Pool.make({
+          acquire,
+          size: options.size
+        })
+    )
+    const pool: Worker.SerializedWorkerPool<I> = {
+      backing,
+      broadcast: <Req extends I>(message: Req) =>
+        Effect.forEach(workers, (worker) => worker.executeEffect(message), {
+          concurrency: "unbounded",
+          discard: true
+        }) as any,
+      execute: <Req extends I>(message: Req) =>
+        Stream.unwrap(
+          Effect.map(
+            Effect.scoped(backing.get),
+            (worker) => worker.execute(message)
+          )
+        ) as any,
+      executeEffect: <Req extends I>(message: Req) =>
+        Effect.flatMap(
+          Effect.scoped(backing.get),
+          (worker) => worker.executeEffect(message)
+        ) as any
+    }
+
+    return pool
+  })
+
+/** @internal */
+export const makePoolSerializedLayer =
+  <W>(managerLayer: Layer.Layer<never, never, Worker.WorkerManager>) =>
+  <Tag, I extends Schema.TaggedRequest.Any>(
+    tag: Context.Tag<Tag, Worker.SerializedWorkerPool<I>>,
+    options: Worker.SerializedWorkerPool.Options<I, W>
+  ) => Layer.scoped(tag, makePoolSerialized<W>()(options)).pipe(Layer.provide(managerLayer))

package/src/internal/workerRunner.ts

@@ -1,11 +1,16 @@
+import * as Schema from "@effect/schema/Schema"
+import * as Serializable from "@effect/schema/Serializable"
 import * as Cause from "effect/Cause"
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as Either from "effect/Either"
 import * as Fiber from "effect/Fiber"
 import { pipe } from "effect/Function"
+import * as Predicate from "effect/Predicate"
 import * as Queue from "effect/Queue"
+import type * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
+import * as Transferable from "../Transferable.js"
 import type * as Worker from "../Worker.js"
 import type * as WorkerError from "../WorkerError.js"
 import type * as WorkerRunner from "../WorkerRunner.js"
@@ -90,3 +95,67 @@ export const make = <I, R, E, O>(
       ], { concurrency: "unbounded", discard: true }) as Effect.Effect<R, WorkerError.WorkerError, never>
     )
   })
+
+/** @internal */
+export const makeSerialized = <
+  I,
+  A extends Schema.TaggedRequest.Any,
+  const Handlers extends {
+    readonly [K in A["_tag"]]: Extract<A, { readonly _tag: K }> extends
+      Serializable.SerializableWithResult<infer _IS, infer S, infer _IE, infer E, infer _IO, infer O>
+      ? (_: S) => Stream.Stream<any, E, O> | Effect.Effect<any, E, O> :
+      never
+  }
+>(
+  schema: Schema.Schema<I, A>,
+  handlers: Handlers
+): Effect.Effect<
+  | WorkerRunner.PlatformRunner
+  | Scope.Scope
+  | (ReturnType<Handlers[keyof Handlers]> extends Stream.Stream<infer R, infer _E, infer _A> ? R : never),
+  WorkerError.WorkerError,
+  never
+> => {
+  const parseRequest = Schema.decode(schema)
+  const effectTags = new Set<string>()
+  return make((request: I) => {
+    if (Predicate.hasProperty(request, "_tag") && effectTags.has(request._tag as string)) {
+      return Effect.flatMap(parseRequest(request), (request: A) => {
+        const handler =
+          (handlers as unknown as Record<string, (req: unknown) => Effect.Effect<never, any, any>>)[request._tag]
+        if (!handler) {
+          return Effect.dieMessage(`No handler for ${request._tag}`)
+        }
+        const encodeSuccess = Schema.encode(Serializable.successSchema(request as any))
+        return pipe(
+          Effect.matchEffect(handler(request), {
+            onFailure: (error) => Effect.flatMap(Serializable.serializeFailure(request as any, error), Effect.fail),
+            onSuccess: encodeSuccess
+          })
+        )
+      })
+    }
+
+    return Stream.flatMap(parseRequest(request), (request: A) => {
+      const handler =
+        (handlers as unknown as Record<string, (req: unknown) => Stream.Stream<never, any, any>>)[request._tag]
+      if (!handler) {
+        return Stream.dieMessage(`No handler for ${request._tag}`)
+      }
+      const encodeSuccess = Schema.encode(Serializable.successSchema(request as any))
+      const stream = handler(request)
+      if (Effect.isEffect(stream)) {
+        effectTags.add(request._tag)
+      }
+      return pipe(
+        stream,
+        Stream.catchAll((error) => Effect.flatMap(Serializable.serializeFailure(request as any, error), Effect.fail)),
+        Stream.mapEffect(encodeSuccess)
+      )
+    })
+  }, {
+    transfers(message) {
+      return Transferable.get(message)
+    }
+  })
+}

package/dist/cjs/index.js

@@ -1,60 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.WorkerRunner = exports.WorkerError = exports.Worker = exports.Terminal = exports.Runtime = exports.Path = exports.KeyValueStore = exports.HttpServer = exports.HttpClient = exports.FileSystem = exports.Error = exports.Effectify = exports.CommandExecutor = exports.Command = void 0;
-var _Command = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./Command.js"));
-exports.Command = _Command;
-var _CommandExecutor = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./CommandExecutor.js"));
-exports.CommandExecutor = _CommandExecutor;
-var _Effectify = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./Effectify.js"));
-exports.Effectify = _Effectify;
-var _Error = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./Error.js"));
-exports.Error = _Error;
-var _FileSystem = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./FileSystem.js"));
-exports.FileSystem = _FileSystem;
-var _HttpClient = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./HttpClient.js"));
-exports.HttpClient = _HttpClient;
-var _HttpServer = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./HttpServer.js"));
-exports.HttpServer = _HttpServer;
-var _KeyValueStore = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./KeyValueStore.js"));
-exports.KeyValueStore = _KeyValueStore;
-var _Path = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./Path.js"));
-exports.Path = _Path;
-var _Runtime = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./Runtime.js"));
-exports.Runtime = _Runtime;
-var _Terminal = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./Terminal.js"));
-exports.Terminal = _Terminal;
-var _Worker = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./Worker.js"));
-exports.Worker = _Worker;
-var _WorkerError = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./WorkerError.js"));
-exports.WorkerError = _WorkerError;
-var _WorkerRunner = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./WorkerRunner.js"));
-exports.WorkerRunner = _WorkerRunner;
-function _getRequireWildcardCache(e) {
-  if ("function" != typeof WeakMap) return null;
-  var r = new WeakMap(),
-    t = new WeakMap();
-  return (_getRequireWildcardCache = function (e) {
-    return e ? t : r;
-  })(e);
-}
-function _interopRequireWildcard(e, r) {
-  if (!r && e && e.__esModule) return e;
-  if (null === e || "object" != typeof e && "function" != typeof e) return {
-    default: e
-  };
-  var t = _getRequireWildcardCache(r);
-  if (t && t.has(e)) return t.get(e);
-  var n = {
-      __proto__: null
-    },
-    a = Object.defineProperty && Object.getOwnPropertyDescriptor;
-  for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) {
-    var i = a ? Object.getOwnPropertyDescriptor(e, u) : null;
-    i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u];
-  }
-  return n.default = e, t && t.set(e, n), n;
-}
-//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":""}