effect-start 0.25.0 → 0.26.0

package/dist/bun/BunBundle.js

@@ -1,186 +0,0 @@
-import { Array, Effect, Iterable, Layer, pipe, Record } from "effect"
-import * as NPath from "node:path"
-import * as Bundle from "../bundler/Bundle.js"
-
-export const buildClient = (config) => {
-  if (typeof config === "string") {
-    config = {
-      entrypoints: [config],
-    }
-  }
-
-  const baseConfig = /** @type {const} */ {
-    sourcemap: "linked",
-    naming: {
-      entry: "[name]-[hash].[ext]",
-      chunk: "[name]-[hash].[ext]",
-      asset: "[name]-[hash].[ext]",
-    },
-    packages: "bundle",
-    publicPath: "/_bundle/",
-  }
-  const resolvedConfig = {
-    ...baseConfig,
-    target: /** @type {const} */ "browser",
-    ...config,
-  }
-
-  return build(resolvedConfig)
-}
-
-export const buildServer = (config) => {
-  if (typeof config === "string") {
-    config = {
-      entrypoints: [config],
-    }
-  }
-
-  const baseConfig = /** @type {const} */ {
-    sourcemap: "linked",
-    naming: {
-      entry: "[dir]/[name]-[hash].[ext]",
-      chunk: "[name]-[hash].[ext]",
-      asset: "[name]-[hash].[ext]",
-    },
-    packages: "bundle",
-  }
-  const resolvedConfig = {
-    ...baseConfig,
-    target: /** @type {const} */ "bun",
-    ...config,
-  }
-
-  return build(resolvedConfig)
-}
-
-/**
- * Given a config, build a bundle and returns every time when effect is executed.
- */
-export function build(
-  config,
-) {
-  return Effect.gen(function* () {
-    const output = yield* buildBun(config)
-    const manifest = generateManifestfromBunBundle(config, output)
-    const artifactsMap = Record.fromIterableBy(output.outputs, (v) => v.path.replace(/^\.\//, ""))
-
-    const resolve = (path) => {
-      return manifest.entrypoints[path] ?? null
-    }
-
-    const getArtifact = (path) => {
-      return artifactsMap[resolve(path)] ?? artifactsMap[path] ?? null
-    }
-
-    return {
-      ...manifest,
-      resolve,
-      getArtifact,
-    }
-  })
-}
-
-export function layer(tag, config) {
-  return Layer.effect(tag, build(config))
-}
-
-/**
- * Finds common path prefix across provided paths.
- */
-function getBaseDir(paths) {
-  if (paths.length === 0) return ""
-  if (paths.length === 1) return NPath.dirname(paths[0])
-
-  const segmentsList = paths.map((path) => NPath.dirname(path).split("/").filter(Boolean))
-
-  return (
-    segmentsList[0]
-      .filter((segment, i) => segmentsList.every((segs) => segs[i] === segment))
-      .reduce((path, seg) => `${path}/${seg}`, "") ?? ""
-  )
-}
-
-/**
- * Maps entrypoints to their respective build artifacts.
- * Entrypoint key is trimmed to remove common path prefix.
- */
-function joinBuildEntrypoints(options, output) {
-  const commonPathPrefix = getBaseDir(options.entrypoints) + "/"
-
-  return pipe(
-    Iterable.zip(
-      options.entrypoints,
-      pipe(
-        output.outputs,
-        // Filter out source maps to properly map artifacts to entrypoints.
-        Iterable.filter(
-          (v) => v.kind !== "sourcemap" && !(v.loader === "html" && v.path.endsWith(".js")),
-        ),
-      ),
-    ),
-    Iterable.map(([entrypoint, artifact]) => {
-      return /** @type {const} */ {
-        shortPath: entrypoint.replace(commonPathPrefix, ""),
-        fullPath: entrypoint,
-        artifact,
-      }
-    }),
-  )
-}
-
-/**
- * Generate manifest from a build.
- * Useful for SSR and providing source->artifact path mapping.
- */
-function generateManifestfromBunBundle(
-  options,
-  output,
-  imports,
-) {
-  const entrypointArtifacts = joinBuildEntrypoints(options, output)
-
-  return {
-    entrypoints: pipe(
-      entrypointArtifacts,
-      Iterable.map((v) => /** @type {const} */ [v.shortPath, v.artifact.path.replace(/^\.\//, "")]),
-      Record.fromEntries,
-    ),
-
-    artifacts: pipe(
-      output.outputs,
-      Iterable.map((v) => {
-        // strip './' prefix
-        const shortPath = v.path.replace(/^\.\//, "")
-
-        return {
-          path: shortPath,
-          type: v.type,
-          size: v.size,
-          hash: v.hash ?? undefined,
-          imports: imports?.get(v.path),
-        }
-      }),
-      Array.fromIterable,
-    ),
-  }
-}
-
-function buildBun(config) {
-  return Object.assign(
-    Effect.gen(function* () {
-      const buildOutput = yield* Effect.tryPromise({
-        try: () => Bun.build(config),
-        catch: (err) => {
-          const cause = err instanceof AggregateError ? (err.errors?.[0] ?? err) : err
-
-          return new Bundle.BundleError({
-            message: "Failed to Bun.build: " + cause,
-            cause: cause,
-          })
-        },
-      })
-
-      return buildOutput
-    }),
-  )
-}

package/dist/bun/BunChildProcessSpawner.js

@@ -1,142 +0,0 @@
-import * as Effect from "effect/Effect"
-import * as Layer from "effect/Layer"
-import * as Sink from "effect/Sink"
-import * as Stream from "effect/Stream"
-import * as ChildProcess from "../ChildProcess.js"
-import * as PlatformError from "../PlatformError.js"
-
-const toCmd = (command) => [
-  command.command,
-  ...command.args,
-]
-
-export const layer = Layer.succeed(
-  ChildProcess.ChildProcessSpawner,
-  {
-    spawn: (command) =>
-      Effect.gen(function* () {
-        const cmd = toCmd(command)
-
-        const proc = yield* Effect.try({
-          try: () =>
-            Bun.spawn(cmd, {
-              cwd: command.cwd,
-              env: command.env,
-              stdin: command.stdin ?? "ignore",
-              stdout: command.stdout ?? "pipe",
-              stderr: command.stderr ?? "pipe",
-              detached: command.detached,
-            }),
-          catch: (err) =>
-            new PlatformError.SystemError({
-              reason: "Unknown",
-              module: "ChildProcess",
-              method: "spawn",
-              description: err instanceof Error ? err.message : "Failed to spawn process",
-              cause: err,
-            }),
-        })
-
-        yield* Effect.addFinalizer(() =>
-          Effect.sync(() => {
-            if (!proc.killed) {
-              proc.kill()
-            }
-          }),
-        )
-
-        const handle = {
-          pid: proc.pid,
-
-          exitCode: Effect.tryPromise({
-            try: () => proc.exited,
-            catch: (err) =>
-              new PlatformError.SystemError({
-                reason: "Unknown",
-                module: "ChildProcess",
-                method: "exitCode",
-                description: "Process exited unexpectedly",
-                cause: err,
-              }),
-          }),
-
-          isRunning: Effect.try({
-            try: () => !proc.killed && proc.exitCode === null,
-            catch: (err) =>
-              new PlatformError.SystemError({
-                reason: "BadResource",
-                module: "ChildProcess",
-                method: "isRunning",
-                description: err instanceof Error ? err.message : "Failed to check process status",
-                cause: err,
-              }),
-          }),
-
-          kill: (options) =>
-            Effect.try({
-              try: () => {
-                proc.kill(options?.killSignal)
-              },
-              catch: (err) =>
-                new PlatformError.SystemError({
-                  reason: "BadResource",
-                  module: "ChildProcess",
-                  method: "kill",
-                  description: err instanceof Error ? err.message : "Failed to kill process",
-                  cause: err,
-                }),
-            }),
-
-          stdin: Sink.forEach((chunk) =>
-            Effect.try({
-              try: () => {
-                const sink = proc.stdin
-                sink.write(chunk)
-              },
-              catch: (err) =>
-                new PlatformError.SystemError({
-                  reason: "Unknown",
-                  module: "ChildProcess",
-                  method: "fromWritable(stdin)",
-                  description: "Failed to write to stdin",
-                  cause: err,
-                }),
-            }),
-          ).pipe(
-            Sink.ensuring(
-              Effect.promise(async () => {
-                const sink = proc.stdin
-                await sink.end()
-              }),
-            ),
-          ),
-
-          stdout: Stream.fromReadableStream(
-            () => proc.stdout,
-            (err) =>
-              new PlatformError.SystemError({
-                reason: "Unknown",
-                module: "ChildProcess",
-                method: "fromReadable(stdout)",
-                description: "Failed to read stdout stream",
-                cause: err,
-              }),
-          ),
-
-          stderr: Stream.fromReadableStream(
-            () => proc.stderr,
-            (err) =>
-              new PlatformError.SystemError({
-                reason: "Unknown",
-                module: "ChildProcess",
-                method: "fromReadable(stderr)",
-                description: "Failed to read stderr stream",
-                cause: err,
-              }),
-          ),
-        }
-
-        return handle
-      }),
-  },
-)

package/dist/bun/BunImportTrackerPlugin.js

@@ -1,91 +0,0 @@
-import * as NPath from "node:path"
-
-/**
- * Tracks all imported modules.
- * State can be accessed via 'virtual:import-tracker' module within a bundle
- * or through `state` property returned by this function.
- */
-export const make = (
-  opts = {},
-) => {
-  const foundImports = new Map()
-  const baseDir = opts.baseDir ?? process.cwd()
-
-  return {
-    name: "import tracker",
-    setup(build) {
-      const transpiler = new Bun.Transpiler({
-        loader: "tsx",
-      })
-
-      // Each module that goes through this onLoad callback
-      // will record its imports in `trackedImports`
-      build.onLoad(
-        {
-          filter: /\.(ts|js)x?$/,
-        },
-        async (args) => {
-          if (!opts.includeNodeModules && args.path.includes("/node_modules/")) {
-            return undefined
-          }
-
-          const contents = await Bun.file(args.path).arrayBuffer()
-          try {
-            const fileImport = transpiler.scanImports(contents)
-            const resolvedImports = fileImport.map((imp) => {
-              const absoluteImportPath = NPath.resolve(
-                NPath.dirname(args.path),
-                // 'file' is a default namespace, trim it
-                imp.path.replace(/^file:/, ""),
-              )
-
-              return {
-                ...imp,
-                // keep all module identifiers with namespace intact
-                path: /(\w+):/.test(imp.path)
-                  ? imp.path
-                  : NPath.relative(baseDir, absoluteImportPath),
-              }
-            })
-            foundImports.set(NPath.relative(baseDir, args.path), resolvedImports)
-          } catch (e) {}
-
-          return undefined
-        },
-      )
-
-      build.onResolve(
-        {
-          filter: /^virtual:import-tracker$/,
-        },
-        () => {
-          return {
-            namespace: "effect-start",
-            path: "virtual:import-tracker",
-          }
-        },
-      )
-
-      build.onLoad(
-        {
-          filter: /^virtual:import-tracker$/,
-          namespace: "effect-start",
-        },
-        async (args) => {
-          // Wait for all files to be loaded, ensuring
-          // that every file goes through the above `onLoad()` function
-          // and their imports tracked
-          await args.defer()
-
-          // Emit JSON containing the stats of each import
-          return {
-            contents: JSON.stringify(Object.fromEntries(foundImports.entries())),
-            loader: "json",
-          }
-        },
-      )
-    },
-
-    state: foundImports,
-  }
-}

package/dist/bun/BunRoute.js

@@ -1,157 +0,0 @@
-import * as Array from "effect/Array"
-import * as Data from "effect/Data"
-import * as Effect from "effect/Effect"
-import * as Option from "effect/Option"
-import * as Entity from "../Entity.js"
-import * as FilePathPattern from "../FilePathPattern.js"
-import * as Hyper from "../hyper/Hyper.js"
-import * as HyperHtml from "../hyper/HyperHtml.js"
-import * as Route from "../Route.js"
-import * as Unique from "../Unique.js"
-import * as BunServer from "./BunServer.js"
-
-const INTERNAL_FETCH_HEADER = "x-effect-start-internal-fetch"
-
-export class BunRouteError extends Data.TaggedError("BunRouteError") {}
-
-export function descriptors(
-  route,
-) {
-  const descriptor = Route.descriptor(route)
-  if (typeof descriptor.bunPrefix === "string" && typeof descriptor.bunLoad === "function") {
-    return descriptor
-  }
-  return undefined
-}
-
-export function htmlBundle(load) {
-  const bunPrefix = `/.BunRoute-${Unique.token(10)}`
-  const bunLoad = () =>
-    Promise.resolve(load()).then((mod) => ("default" in mod ? mod.default : mod))
-  const descriptors = { bunPrefix, bunLoad, format: /** @type {const} */ "html" }
-
-  return function (
-    self,
-  ) {
-    const handler = (context, next) =>
-      Effect.gen(function* () {
-        const originalRequest = context.request
-
-        if (originalRequest.headers.get(INTERNAL_FETCH_HEADER) === "true") {
-          const url = new URL(originalRequest.url)
-          return yield* Effect.fail(
-            new BunRouteError({
-              reason: "ProxyError",
-              pattern: url.pathname,
-              message:
-                "Request to internal Bun server was caught by BunRoute handler. This should not happen. Please report a bug.",
-            }),
-          )
-        }
-
-        const bunServer = yield* BunServer.BunServer
-        const url = new URL(originalRequest.url)
-
-        const internalPath = `${bunPrefix}${url.pathname}`
-        const internalUrl = new URL(internalPath, bunServer.server.url)
-
-        const headers = new Headers(originalRequest.headers)
-        headers.set(INTERNAL_FETCH_HEADER, "true")
-
-        const proxyRequest = new Request(internalUrl, {
-          method: originalRequest.method,
-          headers,
-        })
-
-        const response = yield* Effect.tryPromise({
-          try: () => fetch(proxyRequest),
-          catch: (error) =>
-            new BunRouteError({
-              reason: "ProxyError",
-              pattern: internalPath,
-              message: `Failed to fetch internal HTML bundle: ${String(error)}`,
-            }),
-        })
-
-        let html = yield* Effect.tryPromise({
-          try: () => response.text(),
-          catch: (error) =>
-            new BunRouteError({
-              reason: "ProxyError",
-              pattern: internalPath,
-              message: String(error),
-            }),
-        })
-
-        const childEntity = yield* Entity.resolve(next(context))
-        const children = childEntity?.body ?? childEntity
-
-        let childrenHtml = ""
-        if (children != null) {
-          if ((children) instanceof Response) {
-            childrenHtml = yield* Effect.promise(() => (children).text())
-          } else if (Hyper.isGenericJsxObject(children)) {
-            childrenHtml = HyperHtml.renderToString(children)
-          } else {
-            childrenHtml = String(children)
-          }
-        }
-
-        html = html.replace(/%children%/g, childrenHtml)
-
-        return Entity.make(html, {
-          status: response.status,
-          headers: {
-            "content-type": response.headers.get("content-type"),
-          },
-        })
-      })
-
-    const route = Route.make(handler, descriptors)
-
-    return Route.set([...Route.items(self), route], Route.descriptor(self))
-  }
-}
-
-/**
- * Validates that a route pattern can be implemented with Bun.serve routes.
- *
- * Supported patterns (native or via multiple routes):
- * - /exact        - Exact match
- * - /users/:id    - Full-segment named param
- * - /path/*       - Directory wildcard
- * - /[[404]]      - Catch-all / Rest
- *
- * Unsupported patterns (cannot be implemented in Bun):
- * - /pk_[id]   - Prefix before param
- * - /[id]_sfx  - Suffix after param
- * - /[id].json - Suffix with dot
- * - /[id]~test - Suffix with tilde
- * - /hello-*   - Inline prefix wildcard
- */
-
-export function validateBunPattern(pattern) {
-  const segs = FilePathPattern.segments(pattern)
-
-  const invalid = Array.findFirst(segs, (seg) => seg._tag === "InvalidSegment")
-
-  if (Option.isSome(invalid)) {
-    return Option.some(
-      new BunRouteError({
-        reason: "UnsupportedPattern",
-        pattern,
-        message: `Pattern "${pattern}" contains invalid segment.`,
-      }),
-    )
-  }
-
-  return Option.none()
-}
-
-export const isHtmlBundle = (handle) => {
-  return (
-    typeof handle === "object" &&
-    handle !== null &&
-    (handle.toString() === "[object HTMLBundle]" || typeof handle.index === "string")
-  )
-}

package/dist/bun/BunRuntime.js

@@ -1,41 +0,0 @@
-import * as GlobalValue from "effect/GlobalValue"
-import * as MutableRef from "effect/MutableRef"
-import * as PlatformRuntime from "../PlatformRuntime.js"
-
-const mainFiber = GlobalValue.globalValue(Symbol.for("effect-start/BunRuntime/existingFiber"), () =>
-  MutableRef.make(undefined),
-)
-
-export const runMain = PlatformRuntime.makeRunMain(({ fiber, teardown }) => {
-  const prevFiber = MutableRef.get(mainFiber)
-
-  MutableRef.set(mainFiber, fiber)
-
-  let receivedSignal = false
-
-  fiber.addObserver((exit) => {
-    if (!receivedSignal) {
-      process.removeListener("SIGINT", onSigint)
-      process.removeListener("SIGTERM", onSigint)
-    }
-    teardown(exit, (code) => {
-      if (receivedSignal || code !== 0) {
-        process.exit(code)
-      }
-    })
-  })
-
-  function onSigint() {
-    receivedSignal = true
-    process.removeListener("SIGINT", onSigint)
-    process.removeListener("SIGTERM", onSigint)
-    fiber.unsafeInterruptAsFork(fiber.id())
-  }
-
-  process.on("SIGINT", onSigint)
-  process.on("SIGTERM", onSigint)
-
-  if (prevFiber) {
-    prevFiber.unsafeInterruptAsFork(prevFiber.id())
-  }
-})