@tranquilload/core 0.1.0

package/src/progress/getprogress.test.ts

@@ -0,0 +1,102 @@
+import { describe, expect, it } from "@effect/vitest"
+import { Effect, Option } from "effect"
+import { uploadMultipart, type Progress } from "../multipart/index.js"
+
+// Helper: create a ReadableStream from repeated chunks with a delay
+const slowStream = (chunkCount: number, chunkSize: number): ReadableStream<Uint8Array> =>
+  new ReadableStream({
+    async start(controller) {
+      for (let i = 0; i < chunkCount; i++) {
+        controller.enqueue(new Uint8Array(chunkSize).fill(i))
+        await new Promise((r) => setTimeout(r, 5))
+      }
+      controller.close()
+    },
+  })
+
+describe("getProgress()", () => {
+  it.effect("getProgress() returns increasing bytesUploaded during an in-progress upload", () =>
+    Effect.gen(function* () {
+      let snapshotDuringUpload: Progress | null = null
+
+      const { result, getProgress } = uploadMultipart({
+        stream: slowStream(3, 10), // 3 parts × 10 bytes = 30 bytes total
+        chunkSize: 10,
+        uploadPart: async (partNumber, _chunk) => {
+          // Poll getProgress mid-upload (while part 2 is uploading — part 1 already completed)
+          if (partNumber === 2) {
+            snapshotDuringUpload = await getProgress()
+          }
+          return `etag-${partNumber}`
+        },
+        completeUpload: () => {},
+      })
+
+      yield* Effect.promise(() => result)
+
+      // snapshot taken while part 2 is uploading → part 1 completed → bytesUploaded ≥ 10
+      expect(snapshotDuringUpload).not.toBeNull()
+      expect((snapshotDuringUpload as unknown as Progress).bytesUploaded).toBeGreaterThanOrEqual(10)
+
+      // After completion, full 30 bytes accounted
+      const finalProgress = yield* Effect.promise(() => getProgress())
+      expect(finalProgress.bytesUploaded).toBe(30)
+    })
+  )
+
+  it.effect("calling getProgress() multiple times does not affect the upload", () =>
+    Effect.gen(function* () {
+      const { result, getProgress } = uploadMultipart({
+        stream: new ReadableStream({
+          start(c) {
+            c.enqueue(new Uint8Array(20).fill(1))
+            c.close()
+          },
+        }),
+        chunkSize: 10,
+        uploadPart: () => "etag",
+        completeUpload: () => {},
+      })
+
+      yield* Effect.promise(() => result)
+
+      const p1 = yield* Effect.promise(() => getProgress())
+      const p2 = yield* Effect.promise(() => getProgress())
+      const p3 = yield* Effect.promise(() => getProgress())
+
+      expect(p1.bytesUploaded).toBe(20)
+      expect(p2.bytesUploaded).toBe(20)
+      expect(p3.bytesUploaded).toBe(20)
+      expect(p1.totalBytes).toEqual(Option.none())
+    })
+  )
+
+  it.effect("getProgress.effect reads from Ref without launching the upload", () =>
+    Effect.gen(function* () {
+      const { result, getProgress } = uploadMultipart({
+        stream: new ReadableStream({
+          start(c) {
+            c.enqueue(new Uint8Array(15).fill(1))
+            c.close()
+          },
+        }),
+        chunkSize: 15,
+        uploadPart: () => "etag",
+        completeUpload: () => {},
+        totalBytes: 15,
+      })
+
+      // Call getProgress.effect BEFORE awaiting result — proves it doesn't launch the upload
+      const before = yield* getProgress.effect
+      expect(before.bytesUploaded).toBe(0)
+      expect(before.totalBytes).toEqual(Option.some(15))
+
+      yield* Effect.promise(() => result)
+
+      // After completion, Ref reflects final state
+      const after = yield* getProgress.effect
+      expect(after.bytesUploaded).toBe(15)
+      expect(after.totalBytes).toEqual(Option.some(15))
+    })
+  )
+})

package/src/progress/index.ts

@@ -0,0 +1,10 @@
+export type {
+  UploadEvent,
+  UploadInitiated,
+  PartCompleted,
+  ProgressTick,
+  UploadCompleted,
+  CircuitOpen,
+} from "./upload-event.js"
+
+export type { Progress } from "../multipart/index.js"

package/src/progress/upload-event.test.ts

@@ -0,0 +1,102 @@
+import { it, describe, expect } from "@effect/vitest"
+import { Effect, Match, Option } from "effect"
+import type { UploadEvent, ProgressTick } from "./upload-event.js"
+import { uploadMultipart } from "../multipart/index.js"
+
+describe("UploadEvent type system", () => {
+  it("exhaustive switch on _tag compiles and handles all variants", () => {
+    const handle = (event: UploadEvent): string => {
+      switch (event._tag) {
+        case "UploadInitiated":
+          return "initiated"
+        case "PartCompleted":
+          return "part"
+        case "ProgressTick":
+          return "progress"
+        case "UploadCompleted":
+          return "done"
+        case "CircuitOpen":
+          return "circuit"
+      }
+    }
+    const event: UploadEvent = {
+      _tag: "ProgressTick",
+      bytesUploaded: 500,
+      totalBytes: Option.none(),
+      timestamp: 0,
+    }
+    expect(handle(event)).toBe("progress")
+  })
+
+  it.effect("Match.tag handles all variants exhaustively", () =>
+    Effect.gen(function* () {
+      const event: UploadEvent = {
+        _tag: "PartCompleted",
+        partNumber: 1,
+        etag: "abc",
+        bytesUploaded: 100,
+        timestamp: 0,
+      }
+      const result = Match.type<UploadEvent>().pipe(
+        Match.tag("UploadInitiated", (e) => `initiated:${e.uploadId}`),
+        Match.tag("PartCompleted", (e) => `part:${e.partNumber}`),
+        Match.tag("ProgressTick", (e) => `progress:${e.bytesUploaded}`),
+        Match.tag("UploadCompleted", (e) => `done:${e.totalParts}`),
+        Match.tag("CircuitOpen", (e) => `circuit:${e.failedParts}`),
+        Match.exhaustive
+      )(event)
+      expect(result).toBe("part:1")
+    })
+  )
+
+  it("all variants have _tag and timestamp fields", () => {
+    const variants: UploadEvent[] = [
+      { _tag: "UploadInitiated", uploadId: "id", timestamp: 0 },
+      { _tag: "PartCompleted", partNumber: 1, etag: "e", bytesUploaded: 10, timestamp: 1 },
+      { _tag: "ProgressTick", bytesUploaded: 10, totalBytes: Option.some(100), timestamp: 2 },
+      { _tag: "UploadCompleted", uploadId: "id", totalParts: 1, timestamp: 3 },
+      { _tag: "CircuitOpen", failedParts: 3, timestamp: 4 },
+    ]
+    for (const v of variants) {
+      expect(typeof v._tag).toBe("string")
+      expect(typeof v.timestamp).toBe("number")
+    }
+  })
+
+  it.effect("uploadMultipart emits ProgressTick after each PartCompleted", () =>
+    Effect.gen(function* () {
+      const allEvents: UploadEvent[] = []
+      const { result, events } = uploadMultipart({
+        stream: new ReadableStream({
+          start(c) {
+            c.enqueue(new Uint8Array([1, 2, 3]))
+            c.enqueue(new Uint8Array([4, 5, 6]))
+            c.close()
+          },
+        }),
+        chunkSize: 3,
+        uploadPart: (_partNumber, _chunk) => "etag",
+        completeUpload: () => {},
+      })
+
+      const consumeEvents = async () => {
+        const reader = events.getReader()
+        while (true) {
+          const { done, value } = await reader.read()
+          if (done) break
+          allEvents.push(value)
+        }
+      }
+
+      yield* Effect.promise(() => Promise.all([result, consumeEvents()]))
+      const progressTicks = allEvents.filter((e) => e._tag === "ProgressTick")
+      expect(progressTicks).toHaveLength(2)
+      const tick1 = progressTicks[0] as ProgressTick
+      const tick2 = progressTicks[1] as ProgressTick
+      expect(tick1.bytesUploaded).toBe(3)
+      expect(tick1.totalBytes).toStrictEqual(Option.none())
+      expect(tick2.bytesUploaded).toBe(6)
+      expect(tick2.totalBytes).toStrictEqual(Option.none())
+    })
+  )
+})

package/src/progress/upload-event.ts

@@ -0,0 +1,37 @@
+import { Option } from "effect"
+
+export interface UploadInitiated {
+  readonly _tag: "UploadInitiated"
+  readonly uploadId: string
+  readonly timestamp: number
+}
+
+export interface UploadCompleted {
+  readonly _tag: "UploadCompleted"
+  readonly uploadId: string
+  readonly totalParts: number
+  readonly timestamp: number
+}
+
+export interface PartCompleted {
+  readonly _tag: "PartCompleted"
+  readonly partNumber: number
+  readonly etag: string
+  readonly bytesUploaded: number
+  readonly timestamp: number
+}
+
+export interface CircuitOpen {
+  readonly _tag: "CircuitOpen"
+  readonly failedParts: number
+  readonly timestamp: number
+}
+
+export interface ProgressTick {
+  readonly _tag: "ProgressTick"
+  readonly bytesUploaded: number
+  readonly totalBytes: Option.Option<number>
+  readonly timestamp: number
+}
+
+export type UploadEvent = UploadInitiated | UploadCompleted | PartCompleted | ProgressTick | CircuitOpen

package/src/scaffold.test.ts

@@ -0,0 +1,5 @@
+import { it } from 'vitest'
+
+it('scaffold', () => {
+  // Placeholder test — replaced when business logic is implemented
+})

package/src/services/compression-service.test.ts

@@ -0,0 +1,68 @@
+import { it, describe, expect } from "@effect/vitest"
+import { Cause, Effect, Layer } from "effect"
+import {
+  CompressionService,
+  CompressionServiceLive,
+  CompressionUnavailableError,
+} from "./compression-service.js"
+
+describe("CompressionService", () => {
+  it.effect("CompressionServiceLive fails with typed CompressionUnavailableError when CompressionStream is absent", () =>
+    Effect.gen(function* () {
+      const AbsentLayer: Layer.Layer<CompressionService, CompressionUnavailableError> =
+        Layer.effect(CompressionService, Effect.fail(new CompressionUnavailableError()))
+
+      const result = yield* Effect.exit(
+        Effect.provide(
+          Effect.flatMap(CompressionService, (s) => Effect.succeed(s)),
+          AbsentLayer
+        )
+      )
+
+      expect(result._tag).toBe("Failure")
+      if (result._tag === "Failure") {
+        const failure = Cause.failureOption(result.cause)
+        expect(failure._tag).toBe("Some")
+        if (failure._tag === "Some") {
+          expect(failure.value).toBeInstanceOf(CompressionUnavailableError)
+          expect(failure.value._tag).toBe("CompressionUnavailableError")
+          expect(failure.value.message).toBe("globalThis.CompressionStream is not available in this environment")
+        }
+      }
+    })
+  )
+
+  it.effect("CompressionUnavailableError has correct _tag and message", () =>
+    Effect.gen(function* () {
+      const err = new CompressionUnavailableError()
+      expect(err._tag).toBe("CompressionUnavailableError")
+      expect(err.name).toBe("CompressionUnavailableError")
+      expect(err.message).toBe("globalThis.CompressionStream is not available in this environment")
+    })
+  )
+
+  it.effect("custom CompressionService Layer is used when provided", () =>
+    Effect.gen(function* () {
+      const mockStream = new ReadableStream<Uint8Array>()
+      let calledWith: ReadableStream<Uint8Array> | null = null
+
+      const TestLayer: Layer.Layer<CompressionService> = Layer.succeed(CompressionService, {
+        compress: (stream: ReadableStream<Uint8Array>, _algorithm: CompressionFormat): ReadableStream<Uint8Array> => {
+          calledWith = stream
+          return mockStream
+        },
+      })
+
+      const inputStream = new ReadableStream<Uint8Array>()
+      const result = yield* Effect.provide(
+        Effect.flatMap(CompressionService, (svc) =>
+          Effect.sync(() => svc.compress(inputStream, "deflate-raw"))
+        ),
+        TestLayer
+      )
+
+      expect(result).toBe(mockStream)
+      expect(calledWith).toBe(inputStream)
+    })
+  )
+})

package/src/services/compression-service.ts

@@ -0,0 +1,31 @@
+import { Context, Effect, Layer } from "effect"
+
+export class CompressionUnavailableError extends Error {
+  readonly _tag = "CompressionUnavailableError" as const
+  constructor() {
+    super("globalThis.CompressionStream is not available in this environment")
+    this.name = "CompressionUnavailableError"
+  }
+}
+
+export class CompressionService extends Context.Tag("@tranquilload/CompressionService")<
+  CompressionService,
+  { readonly compress: (stream: ReadableStream<Uint8Array>, algorithm: CompressionFormat) => ReadableStream<Uint8Array> }
+>() {}
+
+export const CompressionServiceLive: Layer.Layer<CompressionService, CompressionUnavailableError> =
+  Layer.effect(
+    CompressionService,
+    Effect.gen(function* () {
+      const cs = (globalThis as { CompressionStream?: unknown }).CompressionStream
+      if (typeof cs === "undefined") {
+        return yield* Effect.fail(new CompressionUnavailableError())
+      }
+      return {
+        compress: (stream, algorithm) =>
+          stream.pipeThrough(
+            new CompressionStream(algorithm) as unknown as TransformStream<Uint8Array, Uint8Array>
+          ),
+      }
+    })
+  )

package/src/services/index.ts

@@ -0,0 +1,11 @@
+export {
+  CompressionUnavailableError,
+  CompressionService,
+  CompressionServiceLive,
+} from "./compression-service.js"
+
+export {
+  type LogLevel,
+  LoggerService,
+  LoggerServiceLive,
+} from "./logger-service.js"

package/src/services/logger-service-integration.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, it } from "@effect/vitest"
+import { Effect, Layer, Stream } from "effect"
+import { LoggerService, type LogLevel } from "./logger-service.js"
+import { uploadOnce } from "../oneshot/index.js"
+import { uploadMultipart } from "../multipart/index.js"
+import { uploadOnceEffect } from "../oneshot/upload.js"
+import { uploadMultipartEffect } from "../multipart/upload-stream.js"
+
+// Helpers
+const tinyStream = (bytes: number): ReadableStream<Uint8Array> =>
+  new ReadableStream({
+    start(c) {
+      c.enqueue(new Uint8Array(bytes).fill(1))
+      c.close()
+    },
+  })
+
+type LogEntry = { level: LogLevel; message: string; data?: unknown }
+
+const makeTestLayer = (received: LogEntry[]): Layer.Layer<LoggerService> =>
+  Layer.succeed(LoggerService, {
+    log: (level, message, data?) => {
+      received.push({ level, message, data })
+    },
+  })
+
+describe("LoggerService integration", () => {
+  it.effect("uploadOnce.effect with custom LoggerService captures internal log entries", () =>
+    Effect.gen(function* () {
+      const received: LogEntry[] = []
+
+      yield* Stream.runDrain(
+        uploadOnceEffect({
+          stream: tinyStream(10),
+          upload: () => {},
+        }).pipe(Stream.provideLayer(makeTestLayer(received)))
+      )
+
+      // Expect "One-shot upload starting" and "One-shot upload completed"
+      expect(received).toHaveLength(2)
+      expect(received.some(e => e.message === "One-shot upload starting")).toBe(true)
+      expect(received.some(e => e.message === "One-shot upload completed")).toBe(true)
+      expect(received.every(e => e.level === "info")).toBe(true)
+    })
+  )
+
+  it.effect("uploadMultipart.effect with custom LoggerService captures part completion and final log", () =>
+    Effect.gen(function* () {
+      const received: LogEntry[] = []
+
+      yield* Stream.runDrain(
+        uploadMultipartEffect({
+          stream: tinyStream(20),
+          chunkSize: 10,
+          uploadPart: (_partNumber, _chunk) => "etag",
+          completeUpload: () => {},
+        }).pipe(Stream.provideLayer(makeTestLayer(received)))
+      )
+
+      // 2 parts → 2 "Part N completed" + 1 "Multipart upload completed"
+      const partLogs = received.filter(e => e.message.startsWith("Part ") && e.message.endsWith("completed"))
+      expect(partLogs.length).toBe(2)
+      expect(received.some(e => e.message === "Multipart upload completed")).toBe(true)
+    })
+  )
+
+  it.effect("Promise API (uploadOnce) auto-provides LoggerServiceLive — user log fn is never called", () =>
+    Effect.gen(function* () {
+      const received: LogEntry[] = []
+
+      // uploadOnce uses LoggerServiceLive (no-op) — custom logger receives nothing
+      const { result } = uploadOnce({
+        stream: tinyStream(10),
+        upload: () => {},
+      })
+      yield* Effect.promise(() => result)
+
+      // The custom logger was never invoked — Promise API is fully wired
+      expect(received).toHaveLength(0)
+    })
+  )
+
+  it.effect("Promise API (uploadMultipart) auto-provides LoggerServiceLive — user log fn is never called", () =>
+    Effect.gen(function* () {
+      const received: LogEntry[] = []
+
+      const { result } = uploadMultipart({
+        stream: tinyStream(20),
+        chunkSize: 10,
+        uploadPart: () => "etag",
+        completeUpload: () => {},
+      })
+      yield* Effect.promise(() => result)
+
+      expect(received).toHaveLength(0)
+    })
+  )
+})

package/src/services/logger-service.test.ts

@@ -0,0 +1,40 @@
+import { it, describe, expect } from "@effect/vitest"
+import { Effect, Layer } from "effect"
+import { LoggerService, LoggerServiceLive, type LogLevel } from "./logger-service.js"
+
+describe("LoggerService", () => {
+  it.effect("LoggerServiceLive is a no-op (produces zero output)", () =>
+    Effect.gen(function* () {
+      const logger = yield* LoggerService
+      expect(() => logger.log("info", "test message", { key: "value" })).not.toThrow()
+      expect(() => logger.log("debug", "debug msg")).not.toThrow()
+      expect(() => logger.log("warn", "warn msg")).not.toThrow()
+      expect(() => logger.log("error", "error msg")).not.toThrow()
+    }).pipe(Effect.provide(LoggerServiceLive))
+  )
+
+  it.effect("custom LoggerService Layer receives structured log entries", () =>
+    Effect.gen(function* () {
+      const received: Array<{ level: LogLevel; message: string; data?: unknown }> = []
+
+      const TestLayer: Layer.Layer<LoggerService> = Layer.succeed(LoggerService, {
+        log: (level: LogLevel, message: string, data?: unknown): void => {
+          received.push({ level, message, data })
+        },
+      })
+
+      yield* Effect.provide(
+        Effect.gen(function* () {
+          const logger = yield* LoggerService
+          logger.log("info", "part completed", { partNumber: 1 })
+          logger.log("warn", "retry attempt", { attempt: 2 })
+        }),
+        TestLayer
+      )
+
+      expect(received).toHaveLength(2)
+      expect(received[0]).toEqual({ level: "info", message: "part completed", data: { partNumber: 1 } })
+      expect(received[1]).toEqual({ level: "warn", message: "retry attempt", data: { attempt: 2 } })
+    })
+  )
+})

package/src/services/logger-service.ts

@@ -0,0 +1,17 @@
+import { Context, Layer } from "effect"
+
+export type LogLevel = "debug" | "info" | "warn" | "error"
+
+export class LoggerService extends Context.Tag("@tranquilload/LoggerService")<
+  LoggerService,
+  { readonly log: (level: LogLevel, message: string, data?: unknown) => void }
+>() {}
+
+export const LoggerServiceLive: Layer.Layer<LoggerService> = Layer.succeed(
+  LoggerService,
+  {
+    log: (_level: LogLevel, _message: string, _data?: unknown): void => {
+      // intentional no-op
+    },
+  }
+)

package/src/utils/abort-interop.test.ts

@@ -0,0 +1,65 @@
+import { Effect, Exit, Fiber } from "effect"
+import { it, describe, expect } from "@effect/vitest"
+import { fromAbortSignal } from "./abort-interop.js"
+import { AbortError } from "../errors/upload-error.js"
+
+describe("fromAbortSignal", () => {
+  it.effect("no signal: never settles on its own (race wins with other branch)", () =>
+    Effect.gen(function* () {
+      // fromAbortSignal with no signal never resolves; race with a succeeding Effect
+      const result = yield* Effect.race(Effect.succeed("winner"), fromAbortSignal())
+      expect(result).toBe("winner")
+    })
+  )
+
+  it.effect("signal already aborted: fails immediately with AbortError", () =>
+    Effect.gen(function* () {
+      const controller = new AbortController()
+      controller.abort()
+      const exit = yield* Effect.exit(fromAbortSignal(controller.signal))
+      expect(Exit.isFailure(exit)).toBe(true)
+      if (Exit.isFailure(exit)) {
+        const cause = exit.cause
+        // The error should be an AbortError
+        expect(cause._tag).toBe("Fail")
+        if (cause._tag === "Fail") {
+          expect(cause.error).toBeInstanceOf(AbortError)
+          expect((cause.error as AbortError)._tag).toBe("AbortError")
+        }
+      }
+    })
+  )
+
+  it.effect("controller.abort() after fromAbortSignal: fails with AbortError", () =>
+    Effect.gen(function* () {
+      const controller = new AbortController()
+      const fiber = yield* Effect.fork(fromAbortSignal(controller.signal))
+      yield* Effect.sync(() => controller.abort())
+      const exit = yield* Fiber.await(fiber)
+      expect(Exit.isFailure(exit)).toBe(true)
+      if (Exit.isFailure(exit)) {
+        const cause = exit.cause
+        expect(cause._tag).toBe("Fail")
+        if (cause._tag === "Fail") {
+          expect(cause.error).toBeInstanceOf(AbortError)
+        }
+      }
+    })
+  )
+
+  it.effect("AbortError shape: _tag, instanceof Error, message", () =>
+    Effect.gen(function* () {
+      const controller = new AbortController()
+      controller.abort()
+      const exit = yield* Effect.exit(fromAbortSignal(controller.signal))
+      if (Exit.isFailure(exit) && exit.cause._tag === "Fail") {
+        const error = exit.cause.error as AbortError
+        expect(error._tag).toBe("AbortError")
+        expect(error).toBeInstanceOf(Error)
+        expect(error.message).toBe("Upload aborted")
+      } else {
+        expect.fail("Expected a Fail exit")
+      }
+    })
+  )
+})

package/src/utils/abort-interop.ts

@@ -0,0 +1,14 @@
+import { Effect } from "effect"
+import { AbortError } from "../errors/upload-error.js"
+
+export const fromAbortSignal = (signal?: AbortSignal): Effect.Effect<never, AbortError> =>
+  Effect.async<never, AbortError>((resume) => {
+    if (!signal) return
+    if (signal.aborted) {
+      resume(Effect.fail(new AbortError()))
+      return
+    }
+    const handler = (): void => resume(Effect.fail(new AbortError()))
+    signal.addEventListener("abort", handler, { once: true })
+    return Effect.sync(() => signal.removeEventListener("abort", handler))
+  })

package/src/utils/normalize-callback.test.ts

@@ -0,0 +1,46 @@
+import { Effect, Exit } from "effect"
+import { it, describe, expect } from "@effect/vitest"
+import { normalizeCallback } from "./normalize-callback.js"
+
+describe("normalizeCallback", () => {
+  it.effect("plain value: succeeds with the value", () =>
+    Effect.gen(function* () {
+      const result = yield* normalizeCallback(() => 42)
+      expect(result).toBe(42)
+    })
+  )
+
+  it.effect("Promise: succeeds with resolved value", () =>
+    Effect.gen(function* () {
+      const result = yield* normalizeCallback(() => Promise.resolve("hello"))
+      expect(result).toBe("hello")
+    })
+  )
+
+  it.effect("Effect: passes through unchanged", () =>
+    Effect.gen(function* () {
+      const result = yield* normalizeCallback(() => Effect.succeed(true))
+      expect(result).toBe(true)
+    })
+  )
+
+  it.effect("throwing function: fails in error channel (not unhandled)", () =>
+    Effect.gen(function* () {
+      const exit = yield* Effect.exit(
+        normalizeCallback(() => {
+          throw new Error("boom")
+        })
+      )
+      expect(Exit.isFailure(exit)).toBe(true)
+    })
+  )
+
+  it.effect("Promise rejection: fails in error channel", () =>
+    Effect.gen(function* () {
+      const exit = yield* Effect.exit(
+        normalizeCallback(() => Promise.reject(new Error("async fail")))
+      )
+      expect(Exit.isFailure(exit)).toBe(true)
+    })
+  )
+})

package/src/utils/normalize-callback.ts

@@ -0,0 +1,18 @@
+import { Effect } from "effect"
+
+export const normalizeCallback = <A, E = never>(
+  fn: () => A | Promise<A> | Effect.Effect<A, E>
+): Effect.Effect<A, E | unknown> =>
+  Effect.suspend((): Effect.Effect<A, E | unknown> => {
+    let result: A | Promise<A> | Effect.Effect<A, E>
+    try {
+      result = fn()
+    } catch (e) {
+      return Effect.fail(e)
+    }
+    if (Effect.isEffect(result)) return result
+    if (result instanceof Promise) {
+      return Effect.tryPromise({ try: () => result as Promise<A>, catch: (e) => e })
+    }
+    return Effect.succeed(result)
+  })