@planet-matrix/mobius-model 0.9.0 → 0.10.1

package/tests/unit/basic/promise.spec.ts

@@ -2,9 +2,10 @@
 import { expect, test, vi } from "vitest"
 
 import {
-  isPromiseFailResult,
+  promiseIsFailResult,
   promiseCatch,
-  promiseConstructFailResult,
+  promiseCreateFailResult,
+  promiseDeferred,
   promiseFilterFailResults,
   promiseFilterSuccessResults,
   promiseFinally,
@@ -17,16 +18,16 @@ import {
 } from "#Source/basic/index.ts"
 
 test("promiseThen chains and transforms resolved values", async () => {
-  const example1 = await promiseThen((value: number) => value * 2, Promise.resolve(3))
-  const example2 = await promiseThen((value: string) => `${value}!`, Promise.resolve("ok"))
+  const example1 = await promiseThen(Promise.resolve(3), (value: number) => value * 2)
+  const example2 = await promiseThen(Promise.resolve("ok"), (value: string) => `${value}!`)
 
   expect(example1).toBe(6)
   expect(example2).toBe("ok!")
 })
 
 test("promiseCatch handles rejected and resolved promises", async () => {
-  const example1 = await promiseCatch(() => "fallback", Promise.reject(new Error("x")))
-  const example2 = await promiseCatch(() => 0, Promise.resolve(3))
+  const example1 = await promiseCatch(Promise.reject(new Error("x")), () => "fallback")
+  const example2 = await promiseCatch(Promise.resolve(3), () => 0)
 
   expect(example1).toBe("fallback")
   expect(example2).toBe(3)
@@ -35,32 +36,49 @@ test("promiseCatch handles rejected and resolved promises", async () => {
 test("promiseFinally runs finalizer and preserves resolution", async () => {
   let cleaned = false
 
-  const example1 = await promiseFinally(() => {
+  const example1 = await promiseFinally(Promise.resolve(10), () => {
     cleaned = true
-  }, Promise.resolve(10))
+  })
 
   expect(example1).toBe(10)
   expect(cleaned).toBe(true)
 })
 
-test("promiseConstructFailResult creates standardized failure objects", () => {
+test("promiseDeferred exposes external resolve and reject for the created promise", async () => {
+  const resolvedDeferred = promiseDeferred<number>()
+
+  resolvedDeferred.resolve(42)
+
+  await expect(resolvedDeferred.promise).resolves.toBe(42)
+  expect(typeof resolvedDeferred.resolve).toBe("function")
+  expect(typeof resolvedDeferred.reject).toBe("function")
+
+  const rejectedDeferred = promiseDeferred<number>()
+  const reason = new Error("deferred failure")
+
+  rejectedDeferred.reject(reason)
+
+  await expect(rejectedDeferred.promise).rejects.toBe(reason)
+})
+
+test("promiseCreateFailResult creates standardized failure objects", () => {
   const reason = new Error("x")
-  const failResult = promiseConstructFailResult(reason)
+  const failResult = promiseCreateFailResult(reason)
 
-  expect(isPromiseFailResult(failResult)).toBe(true)
+  expect(promiseIsFailResult(failResult)).toBe(true)
   expect(failResult.reason).toBe(reason)
 })
 
-test("isPromiseFailResult identifies standardized failure objects", () => {
-  const failResult = promiseConstructFailResult(new Error("x"))
+test("promiseIsFailResult identifies standardized failure objects", () => {
+  const failResult = promiseCreateFailResult(new Error("x"))
 
-  expect(isPromiseFailResult(failResult)).toBe(true)
-  expect(isPromiseFailResult({ reason: "x" })).toBe(false)
-  expect(isPromiseFailResult(null)).toBe(false)
+  expect(promiseIsFailResult(failResult)).toBe(true)
+  expect(promiseIsFailResult({ reason: "x" })).toBe(false)
+  expect(promiseIsFailResult(null)).toBe(false)
 })
 
 test("promiseFilterSuccessResults keeps only successful values", () => {
-  const failResult = promiseConstructFailResult(new Error("x"))
+  const failResult = promiseCreateFailResult(new Error("x"))
 
   const filtered = promiseFilterSuccessResults([1, failResult, 2])
 
@@ -83,93 +101,119 @@ test("promiseFilterFailResults keeps failure values with original indices", asyn
   expect(filtered).toHaveLength(2)
   expect(filtered[0]?.index).toBe(1)
   expect(filtered[1]?.index).toBe(2)
-  expect(isPromiseFailResult(filtered[0])).toBe(true)
-  expect(isPromiseFailResult(filtered[1])).toBe(true)
+  expect(promiseIsFailResult(filtered[0])).toBe(true)
+  expect(promiseIsFailResult(filtered[1])).toBe(true)
 })
 
 test("promiseQueue executes makers in sequence and keeps failed results", async () => {
   const results = await promiseQueue<number>([
     async (): Promise<number> => 1,
     async ({ previousResult, index }): Promise<number> => {
-      return isPromiseFailResult(previousResult) ? -1 : previousResult + index + 1
+      return promiseIsFailResult(previousResult) ? -1 : previousResult + index + 1
     },
     async ({ previousResult }): Promise<number> => {
-      if (isPromiseFailResult(previousResult)) {
+      if (promiseIsFailResult(previousResult)) {
         return -1
       }
       throw new Error(String(previousResult))
     },
     async ({ previousResult }): Promise<number> => {
-      return isPromiseFailResult(previousResult) ? -1 : previousResult + 1
+      return promiseIsFailResult(previousResult) ? -1 : previousResult + 1
     },
   ])
 
   expect(results[0]).toBe(1)
   expect(results[1]).toBe(3)
-  expect(isPromiseFailResult(results[2])).toBe(true)
+  expect(promiseIsFailResult(results[2])).toBe(true)
   expect(results[3]).toBe(-1)
 })
 
 test("promiseRetryWhile retries while predicate is true", async () => {
-  let attempts = 0
+  let successAttempts = 0
 
   const success = await promiseRetryWhile(
     (value) => value < 3,
     async () => {
-      attempts = attempts + 1
-      return attempts
+      successAttempts = successAttempts + 1
+      return successAttempts
     },
-    { maxTryTimes: 5 },
+    { maxTryIndex: 5 },
   )
 
-  attempts = 0
+  let failedAttempts = 0
   const failed = await promiseRetryWhile(
     () => true,
     async () => {
-      attempts = attempts + 1
+      failedAttempts = failedAttempts + 1
       throw new Error("x")
     },
-    { maxTryTimes: 2 },
+    { maxTryIndex: 2 },
   )
 
-  await expect(promiseRetryWhile(async () => false, async () => 1, { maxTryTimes: 0 })).rejects.toThrow(
-    "`maxTryTimes` must be greater than 0.",
+  let singleAttemptCount = 0
+  const singleAttempt = await promiseRetryWhile(
+    () => true,
+    async () => {
+      singleAttemptCount = singleAttemptCount + 1
+      return singleAttemptCount
+    },
+    { maxTryIndex: 0 },
+  )
+
+  await expect(promiseRetryWhile(async () => false, async () => 1, { maxTryIndex: -1 })).rejects.toThrow(
+    "`maxTryIndex` must be greater than or equal to 0.",
   )
 
   expect(success).toBe(3)
-  expect(attempts).toBe(2)
-  expect(isPromiseFailResult(failed)).toBe(true)
+  expect(successAttempts).toBe(3)
+  expect(promiseIsFailResult(failed)).toBe(true)
+  expect(failedAttempts).toBe(3)
+  expect(singleAttempt).toBe(1)
+  expect(singleAttemptCount).toBe(1)
 })
 
 test("promiseRetryUntil retries until predicate becomes true", async () => {
-  let attempts = 0
+  let successAttempts = 0
 
   const success = await promiseRetryUntil(
-    (value, time) => value >= 2 && time >= 2,
+    (value, index) => value >= 2 && index >= 1,
     async () => {
-      attempts = attempts + 1
-      return attempts
+      successAttempts = successAttempts + 1
+      return successAttempts
     },
-    { maxTryTimes: 5 },
+    { maxTryIndex: 5 },
   )
 
-  attempts = 0
+  let failedAttempts = 0
   const failed = await promiseRetryUntil(
     () => false,
     async () => {
-      attempts = attempts + 1
+      failedAttempts = failedAttempts + 1
       throw new Error("x")
     },
-    { maxTryTimes: 2 },
+    { maxTryIndex: 2 },
   )
 
-  await expect(promiseRetryUntil(async () => true, async () => 1, { maxTryTimes: 0 })).rejects.toThrow(
-    "`maxTryTimes` must be greater than 0.",
+  let singleAttemptCount = 0
+  const singleAttempt = await promiseRetryUntil(
+    () => false,
+    async () => {
+      singleAttemptCount = singleAttemptCount + 1
+      return singleAttemptCount
+    },
+    { maxTryIndex: 0 },
+  )
+
+  await expect(promiseRetryUntil(async () => true, async () => 1, { maxTryIndex: -1 })).rejects.toThrow(
+    "`maxTryIndex` must be greater than or equal to 0.",
   )
 
   expect(success).toBe(2)
-  expect(attempts).toBe(2)
-  expect(isPromiseFailResult(failed)).toBe(true)
+  expect(successAttempts).toBe(2)
+  expect(promiseIsFailResult(failed)).toBe(true)
+  expect(failedAttempts).toBe(3)
+  expect(singleAttempt).toBe(1)
+  expect(singleAttemptCount).toBe(1)
 })
 
 test("promiseInterval runs by interval and returns a stopper", async () => {
@@ -188,7 +232,7 @@ test("promiseInterval runs by interval and returns a stopper", async () => {
     stop()
     vi.advanceTimersByTime(50)
 
-    expect(calls).toEqual([1, 2, 3])
+    expect(calls).toEqual([0, 1, 2])
     expect(typeof stop).toBe("function")
   }
   finally {
@@ -196,6 +240,31 @@ test("promiseInterval runs by interval and returns a stopper", async () => {
   }
 })
 
+test("promiseInterval logs rejected runs instead of leaving them unhandled", async () => {
+  vi.useFakeTimers()
+
+  const errorSpy = vi.spyOn(console, "error").mockImplementation(() => undefined)
+
+  try {
+    promiseInterval(10, async () => {
+      throw new Error("interval failure")
+    })
+
+    vi.advanceTimersByTime(10)
+    await Promise.resolve()
+    await Promise.resolve()
+
+    expect(errorSpy).toHaveBeenCalledTimes(1)
+    expect(errorSpy.mock.calls[0]?.[0]).toBe("[promiseInterval] unexpected error occurred:")
+    expect(errorSpy.mock.calls[0]?.[1]).toBeInstanceOf(Error)
+  }
+  finally {
+    vi.clearAllTimers()
+    errorSpy.mockRestore()
+    vi.useRealTimers()
+  }
+})
+
 test("promiseForever loops continuously and reports rejections", async () => {
   vi.useFakeTimers()
 
@@ -210,20 +279,59 @@ test("promiseForever loops continuously and reports rejections", async () => {
       return value
     })
 
-    promiseForever(promiseMaker, { breakTime: 5, onRejected })
+    const result = promiseForever(promiseMaker, { breakTime: 5, onRejected })
     await Promise.resolve()
     await Promise.resolve()
 
     expect(promiseMaker).toHaveBeenCalledTimes(1)
     expect(onRejected).toHaveBeenCalledTimes(1)
-    expect(onRejected.mock.calls[0]?.[0]).toBe(1)
-    expect(isPromiseFailResult(onRejected.mock.calls[0]?.[1])).toBe(true)
+    expect(onRejected.mock.calls[0]?.[0]).toBe(0)
+    expect(promiseIsFailResult(onRejected.mock.calls[0]?.[1])).toBe(true)
+    expect(result.index).toBe(0)
+    expect(result.isStopped).toBe(false)
 
     vi.advanceTimersByTime(16)
     await Promise.resolve()
     await Promise.resolve()
 
     expect(promiseMaker.mock.calls.length).toBeGreaterThanOrEqual(2)
+
+    result.stop()
+    expect(result.isStopped).toBe(true)
+  }
+  finally {
+    vi.clearAllTimers()
+    vi.useRealTimers()
+  }
+})
+
+test("promiseForever stop prevents scheduling the next run when current run has not settled", async () => {
+  vi.useFakeTimers()
+
+  try {
+    const resolvers: Array<(value: number) => void> = []
+    const promiseMaker = vi.fn(async () => {
+      return await new Promise<number>((resolve) => {
+        resolvers.push(resolve)
+      })
+    })
+
+    const result = promiseForever(promiseMaker, { breakTime: 5 })
+
+    expect(promiseMaker).toHaveBeenCalledTimes(1)
+
+    result.stop()
+    expect(result.isStopped).toBe(true)
+
+    resolvers[0]?.(1)
+    await Promise.resolve()
+    await Promise.resolve()
+
+    vi.advanceTimersByTime(20)
+    await Promise.resolve()
+    await Promise.resolve()
+
+    expect(promiseMaker).toHaveBeenCalledTimes(1)
   }
   finally {
     vi.clearAllTimers()

package/tests/unit/credential/api-key.spec.ts

@@ -8,7 +8,6 @@ test("generateApiKey creates a stable sk-prefixed key shape", () => {
       return buffer
     }
 
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
     const target = buffer as Uint8Array
     target.forEach((_, index) => {
       target[index] = index

package/tests/unit/credential/password.spec.ts

@@ -8,7 +8,6 @@ test("Password.generateSalt returns a hexadecimal salt string of the requested b
       return buffer
     }
 
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
     const target = buffer as Uint8Array
     target.fill(0xAB)
     return buffer

package/tests/unit/exception/error/error.spec.ts

@@ -0,0 +1,83 @@
+import { expect, test, vi } from "vitest"
+
+import {
+  createTaggedError,
+  isTaggedError,
+} from "#Source/exception/index.ts"
+
+test("createTaggedError creates tagged errors with inferred message, cause and serialization", () => {
+  const dateNowSpy = vi.spyOn(Date, "now").mockReturnValue(123)
+
+  try {
+    const ExampleError = createTaggedError("Example")<{
+      message: string
+      cause: Error
+      extra: number
+    }>()
+    const MessageOnlyError = createTaggedError("MessageOnly")<string>()
+    const cause = new Error("root")
+
+    cause.stack = "Error: root\n    at cause"
+
+    const example1 = new ExampleError({
+      message: "boom",
+      cause,
+      extra: 1,
+    })
+    const example2 = new MessageOnlyError("plain-message")
+    const example3 = ExampleError.is(example1)
+    const example4 = ExampleError.is(
+      new (createTaggedError("Example")<{ message: string }>())({
+        message: "compatible",
+      }),
+    )
+    const example5 = example1.toJSON()
+
+    expect(example1).toBeInstanceOf(Error)
+    expect(example1.name).toBe("Example")
+    expect(example1.tag).toBe("Example")
+    expect(example1.data.extra).toBe(1)
+    expect(example1.message).toBe("boom")
+    expect(example1.cause).toBe(cause)
+    expect(example1.stack).toContain("Caused by: Error: root")
+    expect(example2.message).toBe("plain-message")
+    expect(example3).toBe(true)
+    expect(example4).toBe(true)
+    expect(example5).toMatchObject({
+      version: "1",
+      tag: "Example",
+      data: {
+        message: "boom",
+        cause,
+        extra: 1,
+      },
+      name: "Example",
+      message: "boom",
+      cause: {
+        name: "Error",
+        message: "root",
+        stack: "Error: root\n    at cause",
+      },
+      timestamp: 123,
+    })
+  } finally {
+    dateNowSpy.mockRestore()
+  }
+})
+
+test("isTaggedError distinguishes tagged errors from plain values", () => {
+  const ExampleError = createTaggedError("Example")<{ message: string }>()
+
+  const example1 = new ExampleError({ message: "boom" })
+  const example2 = new Error("boom")
+  const example3 = {
+    tag: "Example",
+    data: { message: "boom" },
+    toJSON: () => ({ message: "boom" }),
+  }
+
+  expect(isTaggedError(example1)).toBe(true)
+  expect(isTaggedError(example2)).toBe(false)
+  expect(isTaggedError(example3)).toBe(false)
+  expect(isTaggedError(null)).toBe(false)
+})

package/tests/unit/exception/error/match.spec.ts

@@ -0,0 +1,81 @@
+import { expect, test } from "vitest"
+
+import {
+  createTaggedError,
+  matchTaggedError,
+  matchTaggedErrorPartial,
+} from "#Source/exception/index.ts"
+
+class NetworkError extends createTaggedError("Network")<{
+  message: string
+  status: number
+}>() {
+  //
+}
+
+class ValidationError extends createTaggedError("Validation")<{
+  message: string
+  field: string
+}>() {
+  //
+}
+
+type ExampleTaggedError =
+  | NetworkError
+  | ValidationError
+
+test("matchTaggedError dispatches by tag and throws when a handler is missing", () => {
+  const example1 = new NetworkError({
+    message: "bad gateway",
+    status: 502,
+  }) as ExampleTaggedError
+  const example2 = new ValidationError({
+    message: "invalid email",
+    field: "email",
+  }) as ExampleTaggedError
+  const example3 = matchTaggedError(example1, {
+    Network: (error) => `${error.tag}:${error.data.status}`,
+    Validation: (error) => `${error.tag}:${error.data.field}`,
+  })
+  const example4 = matchTaggedError(example2, {
+    Network: (error) => `${error.tag}:${error.data.status}`,
+    Validation: (error) => `${error.tag}:${error.data.field}`,
+  })
+
+  expect(example3).toBe("Network:502")
+  expect(example4).toBe("Validation:email")
+  expect(() => {
+    // @ts-expect-error Testing runtime error when handler is missing
+    return matchTaggedError(example2, {
+      Network: (error) => error.data.status,
+    })
+  }).toThrow("No handler for tag: Validation")
+})
+
+test("matchTaggedErrorPartial uses a fallback for unhandled tags", () => {
+  const example1 = new NetworkError({
+    message: "bad gateway",
+    status: 502,
+  }) as ExampleTaggedError
+  const example2 = new ValidationError({
+    message: "invalid email",
+    field: "email",
+  }) as ExampleTaggedError
+  const example3 = matchTaggedErrorPartial(
+    example1,
+    {
+      Network: (error) => `${error.tag}:${error.data.status}`,
+    },
+    (error) => `${error.tag}:${error.message}`,
+  )
+  const example4 = matchTaggedErrorPartial(
+    example2,
+    {
+      Network: (error) => `${error.tag}:${error.data.status}`,
+    },
+    (error) => `${error.tag}:${error.data.field}`,
+  )
+
+  expect(example3).toBe("Network:502")
+  expect(example4).toBe("Validation:email")
+})

package/tests/unit/http/api-adapter/node-http.spec.ts

@@ -26,7 +26,6 @@ test("ApiHostNodeHttp exposes usable URLs and forwards request data to ApiCoreNo
   })
 
   const startResult = await apiHost.start()
-  // oxlint-disable-next-line typescript/no-unsafe-type-assertion
   const address = apiHost.safeGetServer().address() as AddressInfo
 
   expect(startResult.urlList).toContain(`http://127.0.0.1:${address.port}`)
@@ -61,7 +60,6 @@ test("ApiCoreNodeHttp returns a stable error response when the handler throws",
   })
 
   await apiHost.start()
-  // oxlint-disable-next-line typescript/no-unsafe-type-assertion
   const address = apiHost.safeGetServer().address() as AddressInfo
 
   const response = await fetch(`http://127.0.0.1:${address.port}/error`, {
@@ -89,7 +87,6 @@ test("ApiCoreNodeHttp treats an empty request body as an empty object", async ()
   })
 
   await apiHost.start()
-  // oxlint-disable-next-line typescript/no-unsafe-type-assertion
   const address = apiHost.safeGetServer().address() as AddressInfo
 
   const response = await fetch(`http://127.0.0.1:${address.port}/empty`, {
@@ -144,7 +141,6 @@ test("ApiCoreNodeHttp exposes normalized headers and parses multipart form data"
   })
 
   await apiHost.start()
-  // oxlint-disable-next-line typescript/no-unsafe-type-assertion
   const address = apiHost.safeGetServer().address() as AddressInfo
 
   const formData = new FormData()

package/tests/unit/identifier/uuid.spec.ts

@@ -66,7 +66,6 @@ test("generateUuidV7 returns UUIDv7 format and is monotonic within the same mill
       return buffer
     }
 
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
     const target = buffer as Uint8Array
     target.fill(0)
     return buffer

package/tests/unit/request/request/base.spec.ts

@@ -184,7 +184,6 @@ test("BaseRequest.request emits lifecycle callbacks and events for success and e
     }
   }
   const request = new TestRequest({
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
     fetchFactory: getFetch as unknown as FetchFactory,
     modifyRequestOptions,
     generatePatchOutput: ({ errorKind, error }) => {
@@ -315,7 +314,6 @@ test("BaseRequest.request converts network failures into patch outputs", async (
     return new TestRejectingFetch(new TypeError("fetch failed"))
   }
   const request = new TestRequest({
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
     fetchFactory: getFetch as unknown as FetchFactory,
     generatePatchOutput: ({ errorKind, error }) => {
       return {
@@ -357,7 +355,6 @@ test("BaseRequest.request stringifies non-Error failures into unknown patch outp
     return new TestRejectingFetch("boom")
   }
   const request = new TestRequest({
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
     fetchFactory: getFetch as unknown as FetchFactory,
     generatePatchOutput: ({ errorKind, error }) => {
       return {

package/tests/unit/request/request/general.spec.ts

@@ -123,7 +123,6 @@ test("GeneralRequest.request keeps success outputs and generates unknown patch o
     return new TestGeneralRejectingFetch()
   }
   const request = new GeneralRequest<ExampleGeneralResource>({
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
     fetchFactory: fetchFactory as unknown as FetchFactory,
   })
 

package/tests/unit/result/controller.spec.ts

@@ -0,0 +1,82 @@
+import { expect, test } from "vitest"
+
+import type { Either } from "#Source/result/index.ts"
+import { Controller, controllerFromEitherType, Left, Right } from "#Source/result/index.ts"
+
+test("Controller.isLeft currently overflows through recursive static dispatch", () => {
+  expect(() => Controller.isLeft(new Left<string, number>("stop"))).toThrow(RangeError)
+})
+
+test("Controller.isRight currently overflows through recursive static dispatch", () => {
+  expect(() => Controller.isRight(new Right<string, number>(2))).toThrow(RangeError)
+})
+
+test("Controller.value exposes the same pending promise until the controller resolves", async () => {
+  const controller = new Controller<string, number>()
+  const firstValue = controller.value
+  const secondValue = controller.value
+
+  expect(secondValue).toBe(firstValue)
+
+  const returned = await controller.returnRight(2)
+  const settled = await firstValue
+
+  expect(settled).toBe(returned)
+  expect(settled.isRight()).toBe(true)
+  expect(settled.getRight()).toBe(2)
+})
+
+test("Controller.returnRight resolves the controller with a Right value", async () => {
+  const controller = new Controller<string, number>()
+
+  const returned = await controller.returnRight(2)
+  const settled = await controller.value
+
+  expect(returned).toBeInstanceOf(Right)
+  expect(returned).toBe(settled)
+  expect(returned.isRight()).toBe(true)
+  expect(returned.getRight()).toBe(2)
+})
+
+test("Controller.returnLeft resolves the controller with a Left value", async () => {
+  const controller = new Controller<string, number>()
+
+  const returned = await controller.returnLeft("stop")
+  const settled = await controller.value
+
+  expect(returned).toBeInstanceOf(Left)
+  expect(returned).toBe(settled)
+  expect(returned.isLeft()).toBe(true)
+  expect(returned.getLeft()).toBe("stop")
+})
+
+test("Controller.throw resolves the controller with a Left value and rejects with the same Left", async () => {
+  const controller = new Controller<string, number>()
+  let caught: unknown
+
+  try {
+    await controller.throw("stop")
+  } catch (error) {
+    caught = error
+  }
+
+  const settled = await controller.value
+
+  expect(caught).toBeInstanceOf(Left)
+  expect(caught).toBe(settled)
+  expect(settled.isLeft()).toBe(true)
+  expect(settled.getLeft()).toBe("stop")
+})
+
+test("controllerFromEitherType creates a controller that matches the Either shape", async () => {
+  const controller = controllerFromEitherType<Either<string, number>>()
+  const typedController: Controller<string, number> = controller
+
+  const returned = await typedController.returnRight(3)
+  const settled = await controller.value
+
+  expect(controller).toBeInstanceOf(Controller)
+  expect(returned).toBe(settled)
+  expect(returned.isRight()).toBe(true)
+  expect(returned.getRight()).toBe(3)
+})