effect-start 0.25.0 → 0.26.0

package/dist/Start.js

@@ -1,79 +0,0 @@
-import * as Context from "effect/Context"
-import * as Deferred from "effect/Deferred"
-import * as Effect from "effect/Effect"
-import * as Function from "effect/Function"
-import * as Layer from "effect/Layer"
-import * as BunRuntime from "./bun/BunRuntime.js"
-import * as BunServer from "./bun/BunServer.js"
-import * as NodeFileSystem from "./node/NodeFileSystem.js"
-import * as BunChildProcessSpawner from "./bun/BunChildProcessSpawner.js"
-import * as StartApp from "./StartApp.js"
-
-export function layer(
-  ...layers
-) {
-  return Layer.mergeAll(...layers)
-}
-
-/**
- * Bundles layers together, wiring their dependencies automatically.
- *
- * Equivalent to chaining `Layer.provide` calls, but more concise.
- *
- * **Ordering: dependents first, dependencies last.**
- *
- * @example
- * ```ts
- * // UserRepo needs Database, Database needs Logger
- * const AppLayer = Start.pack(
- *   UserRepoLive,   // needs Database, Logger
- *   DatabaseLive,   // needs Logger
- *   LoggerLive,     // no deps
- * )
- * // Result: Layer<UserRepo | Database | Logger, never, never>
- * ```
- *
- * @since 1.0.0
- * @category constructors
- */
-export function pack(
-  ...layers
-) {
-  const layerArray = layers
-  const result = layerArray.reduce(
-    (acc, layer) => Layer.provideMerge(acc, layer),
-    Layer.succeedContext(Context.empty()),
-  )
-
-  return result
-}
-
-export const Live = Layer.mergeAll(
-  NodeFileSystem.layer,
-  BunChildProcessSpawner.layer,
-  Layer.effect(
-    StartApp.StartApp,
-    Deferred.make().pipe(Effect.map((server) => ({ server }))),
-  ),
-)
-
-export function serve(
-  load,
-) {
-  const appLayer = Function.pipe(
-    Effect.tryPromise(load),
-    Effect.map((v) => v.default),
-    Effect.orDie,
-    Layer.unwrapEffect,
-  )
-
-  const appLayerResolved = Function.pipe(appLayer, Layer.provideMerge(Live))
-
-  const composed = Function.pipe(
-    BunServer.layerStart(),
-    BunServer.withLogAddress,
-    Layer.provide(appLayerResolved),
-  )
-
-  return Function.pipe(composed, Layer.launch, BunRuntime.runMain)
-}

package/dist/StartApp.js

@@ -1,3 +0,0 @@
-import * as Context from "effect/Context"
-
-export class StartApp extends Context.Tag("effect-start/StartApp")() {}

package/dist/StreamExtra.js

@@ -1,135 +0,0 @@
-import * as Cause from "effect/Cause"
-import * as Effect from "effect/Effect"
-import * as Fiber from "effect/Fiber"
-import * as Function from "effect/Function"
-import * as Predicate from "effect/Predicate"
-import * as Runtime from "effect/Runtime"
-import * as Stream from "effect/Stream"
-
-export const isStream = (u) =>
-  Predicate.hasProperty(u, Stream.StreamTypeId)
-
-/**
- * Patched version of original Stream.toReadableStreamRuntime (v3.14.4) to
- * fix an issue in Bun when native stream controller stops working when request
- * is terminated by the client:
- *
- *  TypeError: Value of "this" must be of type ReadableStreamDefaultController
- *
- * See related issues:
- * https://github.com/Effect-TS/effect/issues/4538
- * https://github.com/oven-sh/bun/issues/17837
- */
-export const toReadableStreamRuntimePatched = Function.dual(
-  (args) => Predicate.hasProperty(args[0], Stream.StreamTypeId) || Effect.isEffect(args[0]),
-  (
-    self,
-    runtime,
-    options,
-  ) => {
-    const runFork = Runtime.runFork(runtime)
-    let currentResolve = undefined
-    let fiber = undefined
-    const latch = Effect.unsafeMakeLatch(false)
-
-    return new ReadableStream(
-      {
-        start(controller) {
-          fiber = runFork(
-            Stream.runForEachChunk(self, (chunk) =>
-              latch.whenOpen(
-                Effect.sync(() => {
-                  latch.unsafeClose()
-                  try {
-                    for (const item of chunk) {
-                      controller.enqueue(item)
-                    }
-                  } catch (e) {
-                    if (
-                      (e).message ===
-                      `Value of "this" must be of type ReadableStreamDefaultController`
-                    ) {
-                      // Do nothing when this happens in Bun.
-                    } else {
-                      throw e
-                    }
-                  }
-                  currentResolve()
-                  currentResolve = undefined
-                }),
-              ),
-            ),
-          )
-          // --- CHANGES HERE ---
-          // In original code, we had fiber.addObserver here that called
-          // error() or close() on controller. This patched version removes it.
-        },
-        pull() {
-          return new Promise((resolve) => {
-            currentResolve = resolve
-            Effect.runSync(latch.open)
-          })
-        },
-        cancel() {
-          if (!fiber) return
-          return Effect.runPromise(Effect.asVoid(Fiber.interrupt(fiber)))
-        },
-      },
-      options?.strategy,
-    )
-  },
-)
-
-export const toReadableStreamRuntimePatched2 = Function.dual(
-  (args) => Predicate.hasProperty(args[0], Stream.StreamTypeId) || Effect.isEffect(args[0]),
-  (
-    self,
-    runtime,
-    options,
-  ) => {
-    const runSync = Runtime.runSync(runtime)
-    const runFork = Runtime.runFork(runtime)
-    let currentResolve = undefined
-    let fiber = undefined
-    const latch = Effect.unsafeMakeLatch(false)
-
-    return new ReadableStream(
-      {
-        start(controller) {
-          fiber = runFork(
-            Stream.runForEachChunk(self, (chunk) =>
-              latch.whenOpen(
-                Effect.sync(() => {
-                  latch.unsafeClose()
-                  for (const item of chunk) {
-                    controller.enqueue(item)
-                  }
-                  currentResolve()
-                  currentResolve = undefined
-                }),
-              ),
-            ),
-          )
-          fiber.addObserver((exit) => {
-            if (exit._tag === "Failure") {
-              controller.error(Cause.squash(exit.cause))
-            } else {
-              controller.close()
-            }
-          })
-        },
-        pull() {
-          return new Promise((resolve) => {
-            currentResolve = resolve
-            Effect.runSync(latch.open)
-          })
-        },
-        cancel() {
-          if (!fiber) return
-          return Effect.runPromise(Effect.asVoid(Fiber.interrupt(fiber)))
-        },
-      },
-      options?.strategy,
-    )
-  },
-)

package/dist/System.js

@@ -1,38 +0,0 @@
-import * as Effect from "effect/Effect"
-
-import * as ChildProcess from "./ChildProcess.js"
-import * as PlatformError from "./PlatformError.js"
-
-export const cwd = Effect.sync(() => process.cwd())
-
-export const which = (name) =>
-  Effect.flatMap(
-    Effect.try({
-      try: () => Bun.which(name),
-      catch: (err) =>
-        new PlatformError.SystemError({
-          reason: "Unknown",
-          module: "System",
-          method: "which",
-          description: err instanceof Error ? err.message : `Failed to look up "${name}"`,
-          cause: err,
-        }),
-    }),
-    (path) =>
-      path === null
-        ? Effect.fail(
-            new PlatformError.SystemError({
-              reason: "NotFound",
-              module: "System",
-              method: "which",
-              description: `Executable not found: "${name}"`,
-            }),
-          )
-        : Effect.succeed(path),
-  )
-
-export const spawn = (
-  command,
-  args,
-  options,
-) => ChildProcess.spawn(ChildProcess.make(command, args, options))

package/dist/TuplePathPattern.js

@@ -1,74 +0,0 @@
-
-export function format(tuple) {
-  return ("/" +
-    tuple
-      .map((el) => {
-        if (typeof el === "string") return el
-        if (Array.isArray(el[0])) return "[[" + el[0][0] + "]]"
-        const [name, suffix, prefix] = el
-        return (prefix ?? "") + "[" + name + "]" + (suffix ?? "")
-      })
-      .join("/"))
-}
-
-export function toColon(tuple) {
-  return (
-    "/" +
-    tuple
-      .map((el) => {
-        if (typeof el === "string") return el
-        if (Array.isArray(el[0])) return "*"
-        const [name, suffix, prefix] = el
-        return (prefix ?? "") + ":" + name + (suffix ?? "")
-      })
-      .join("/")
-  )
-}
-
-export const toHono = toColon
-
-export function toExpress(tuple) {
-  return (
-    "/" +
-    tuple
-      .map((el) => {
-        if (typeof el === "string") return el
-        if (Array.isArray(el[0])) return "*" + el[0][0]
-        const [name, suffix, prefix] = el
-        return (prefix ?? "") + ":" + name + (suffix ?? "")
-      })
-      .join("/")
-  )
-}
-
-export const toEffect = toColon
-
-export function toURLPattern(tuple) {
-  return (
-    "/" +
-    tuple
-      .map((el) => {
-        if (typeof el === "string") return el
-        if (Array.isArray(el[0])) return ":" + el[0][0] + "+"
-        const [name, suffix, prefix] = el
-        return (prefix ?? "") + ":" + name + (suffix ?? "")
-      })
-      .join("/")
-  )
-}
-
-export function toRemix(tuple) {
-  return (
-    "/" +
-    tuple
-      .map((el) => {
-        if (typeof el === "string") return el
-        if (Array.isArray(el[0])) return "$"
-        const [name, suffix, prefix] = el
-        return (prefix ?? "") + "$" + name + (suffix ?? "")
-      })
-      .join("/")
-  )
-}
-
-export const toBun = toColon

package/dist/Unique.js

@@ -1,226 +0,0 @@
-export const ALPHABET_BASE32_CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ"
-export const ALPHABET_BASE32_RFC4648 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"
-export const ALPHABET_BASE64_URL =
-  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
-export const ALPHABET_HEX = "0123456789abcdef"
-
-/**
- * Generate a random string for ids, session tokens, and API keys.
- * It uses human-friendly crockford base32 encoding (5 bit of entropy per char)
- *
- * Minimal recommended length:
- * - public ids: 16 chars (~80 bits)
- * - API keys: 32 chars (~160 bits)
- * - session tokens: 32-40 chars (~160-200 bits)
- */
-export function token(length = 32) {
-  if (length <= 0) return ""
-
-  const buf = new Uint8Array(length)
-  crypto.getRandomValues(buf)
-
-  let result = ""
-  for (let i = 0; i < buf.length; i++) {
-    result += ALPHABET_BASE32_CROCKFORD[buf[i] & 31]
-  }
-
-  return result
-}
-
-export function bytes(length) {
-  const buf = new Uint8Array(length)
-  crypto.getRandomValues(buf)
-  return buf
-}
-
-export const UUID_NIL = "00000000-0000-0000-0000-000000000000"
-
-export function uuid4() {
-  return formatUuid(uuid4bytes())
-}
-
-export function uuid7(time = Date.now()) {
-  return formatUuid(uuid7Bytes(time))
-}
-
-function uuid4bytes() {
-  const buf = bytes(16)
-  buf[6] = (buf[6] & 0x0f) | 0x40 // version 4
-  buf[8] = (buf[8] & 0x3f) | 0x80 // variant
-
-  return buf
-}
-
-/**
- * Decode a 48-bit Unix timestamp (ms) from UUID7 or ULID.
- *
- * @example
- * const bytes = Unique.uuid7Bytes()
- * const timestamp = Unique.toTimestamp(bytes)
- *
- * @example
- * const bytes = Unique.ulidBytes()
- * const timestamp = Unique.toTimestamp(bytes)
- */
-export function toTimestamp(bytes) {
-  if (bytes.length < 6) return 0
-
-  return (
-    bytes[0] * 0x10000000000 +
-    bytes[1] * 0x100000000 +
-    bytes[2] * 0x1000000 +
-    bytes[3] * 0x10000 +
-    bytes[4] * 0x100 +
-    bytes[5]
-  )
-}
-
-export function uuid7Bytes(time = Date.now()) {
-  const buf = new Uint8Array(16)
-  const timestamp = BigInt(toSafeTime(time))
-
-  // 48-bit timestamp (6 bytes)
-  buf[0] = Number((timestamp >> 40n) & 0xffn)
-  buf[1] = Number((timestamp >> 32n) & 0xffn)
-  buf[2] = Number((timestamp >> 24n) & 0xffn)
-  buf[3] = Number((timestamp >> 16n) & 0xffn)
-  buf[4] = Number((timestamp >> 8n) & 0xffn)
-  buf[5] = Number(timestamp & 0xffn)
-
-  // 12-bit random A (1.5 bytes)
-  crypto.getRandomValues(buf.subarray(6, 8))
-  buf[6] = (buf[6] & 0x0f) | 0x70 // version 7
-
-  // 2-bit variant + 62-bit random B (8 bytes)
-  crypto.getRandomValues(buf.subarray(8, 16))
-  buf[8] = (buf[8] & 0x3f) | 0x80 // variant
-
-  return buf
-}
-
-/**
- * Convert UUID bytes to canonical (RFC9562) representation.
- *
- * @example
- * Unique.formatUuid(new Uint8Array(16))
- */
-export function formatUuid(bytes) {
-  if (bytes.length === 0) return ""
-
-  let result = ""
-
-  for (let i = 0; i < bytes.length; i++) {
-    const byte = bytes[i]
-    result += ALPHABET_HEX[(byte >> 4) & 0x0f]
-    result += ALPHABET_HEX[byte & 0x0f]
-
-    if (i === 3 || i === 5 || i === 7 || i === 9) result += "-"
-  }
-
-  return result
-}
-
-export function ulid(time = Date.now()) {
-  const bytes = ulidBytes(time)
-  return formatUlid(bytes)
-}
-
-export function ulidBytes(time = Date.now()) {
-  const buf = new Uint8Array(16)
-  const timestamp = BigInt(toSafeTime(time))
-
-  buf[0] = Number((timestamp >> 40n) & 0xffn)
-  buf[1] = Number((timestamp >> 32n) & 0xffn)
-  buf[2] = Number((timestamp >> 24n) & 0xffn)
-  buf[3] = Number((timestamp >> 16n) & 0xffn)
-  buf[4] = Number((timestamp >> 8n) & 0xffn)
-  buf[5] = Number(timestamp & 0xffn)
-
-  crypto.getRandomValues(buf.subarray(6, 16))
-
-  return buf
-}
-
-function formatUlid(bytes) {
-  if (bytes.length !== 16) return ""
-
-  const timestamp = toTimestamp(bytes)
-  const timePart = encodeUlidTime(timestamp)
-  const randomPart = toBase32(bytes.subarray(6, 16))
-
-  return `${timePart}${randomPart}`
-}
-
-function encodeUlidTime(time) {
-  let value = BigInt(time)
-  const result = Array.from({ length: 10 })
-
-  for (let i = 9; i >= 0; i--) {
-    result[i] = ALPHABET_BASE32_CROCKFORD[Number(value & 31n)]
-    value >>= 5n
-  }
-
-  return result.join("")
-}
-
-function toSafeTime(time) {
-  if (!Number.isFinite(time)) return 0
-
-  return Math.max(0, Math.trunc(time))
-}
-
-/**
- * Generate a nanoid-style random string.
- *
- * FUN_FACT: Original nanoid implementation uses base64url alphabet
- * with non-standard custom order where charater form common words found
- * in source code (like use, random, strict) to make gzip/brotli more efficient.
- * It's qt lil opt from the times where web developers
- * were competing to have the smallest possible bundle size.
- */
-export function nanoid(size = 21, alphabet = ALPHABET_BASE64_URL) {
-  if (size <= 0 || alphabet.length === 0) return ""
-
-  const length = alphabet.length
-  const mask = (2 << Math.floor(Math.log2(length - 1))) - 1
-  const step = Math.ceil((1.6 * mask * size) / length)
-
-  let id = ""
-  while (id.length < size) {
-    const bytes = new Uint8Array(step)
-    crypto.getRandomValues(bytes)
-
-    for (let i = 0; i < step && id.length < size; i++) {
-      const index = bytes[i] & mask
-      if (index < length) id += alphabet[index]
-    }
-  }
-  return id
-}
-
-function toBase32(bytes, alphabet = ALPHABET_BASE32_CROCKFORD) {
-  if (bytes.length === 0) return ""
-
-  let result = ""
-  let buffer = 0
-  let bits = 0
-
-  for (const byte of bytes) {
-    buffer = (buffer << 8) | byte
-    bits += 8
-
-    while (bits >= 5) {
-      bits -= 5
-      const index = (buffer >> bits) & 31
-      result += alphabet[index]
-      buffer &= (1 << bits) - 1
-    }
-  }
-
-  if (bits > 0) {
-    const index = (buffer << (5 - bits)) & 31
-    result += alphabet[index]
-  }
-
-  return result
-}

package/dist/Values.js

@@ -1,52 +0,0 @@
-
-
-export function isPlainObject(value) {
-  if (value === null || typeof value !== "object") {
-    return false
-  }
-
-  // Check for built-in types and web APIs
-  if (
-    ArrayBuffer.isView(value) ||
-    value instanceof ArrayBuffer ||
-    value instanceof Blob ||
-    value instanceof FormData ||
-    value instanceof URLSearchParams ||
-    value instanceof ReadableStream ||
-    value instanceof Date ||
-    value instanceof Map ||
-    value instanceof Set ||
-    value instanceof RegExp ||
-    value instanceof Error ||
-    value instanceof Promise ||
-    Array.isArray(value)
-  ) {
-    return false
-  }
-
-  // Check if it's a plain object (Object.prototype or null prototype)
-  const proto = Object.getPrototypeOf(value)
-  return proto === null || proto === Object.prototype
-}
-
-/**
- * Type helper that returns `true` if type T has any method properties,
- * otherwise returns `never`.
- *
- * Used internally by IsPlainObject to distinguish plain objects from
- * class instances or objects with methods.
- */
-
-export const firstValue = (record) => {
-  for (const key in record) {
-    return record[key]
-  }
-  return undefined
-}
-
-export const concatBytes = (a, b) => {
-  const result = new Uint8Array(a.byteLength + b.byteLength)
-  result.set(a)
-  result.set(b, a.byteLength)
-  return result
-}