effect-start 0.25.0 → 0.26.0

package/dist/Http.js

@@ -1,107 +0,0 @@
-import * as Values from "./Values.js"
-
-export function fetch(
-  handler,
-  init,
-) {
-  const url = "path" in init ? `http://localhost${init.path}` : init.url
-
-  const isPlain = Values.isPlainObject(init.body)
-
-  const headers = new Headers(init.headers)
-  if (isPlain && !headers.has("Content-Type")) {
-    headers.set("Content-Type", "application/json")
-  }
-
-  const body = isPlain ? JSON.stringify(init.body) : init.body
-
-  const request = new Request(url, {
-    ...init,
-    headers,
-    body: body,
-  })
-  return Promise.resolve(handler(request))
-}
-
-export function createAbortableRequest(
-  init,
-) {
-  const url = "path" in init ? `http://localhost${init.path}` : init.url
-  const controller = new AbortController()
-  const request = new Request(url, { ...init, signal: controller.signal })
-  return { request, abort: () => controller.abort() }
-}
-
-export function mapHeaders(headers) {
-  const result = {}
-  headers.forEach((value, key) => {
-    result[key.toLowerCase()] = value
-  })
-  return result
-}
-
-export function parseCookies(cookieHeader) {
-  if (!cookieHeader) return {}
-  const result = {}
-  for (const part of cookieHeader.split(";")) {
-    const idx = part.indexOf("=")
-    if (idx === -1) {
-      // Cookie without value (e.g., "name" or just whitespace)
-      const key = part.trim()
-      if (key) {
-        result[key] = undefined
-      }
-    } else {
-      const key = part.slice(0, idx).trim()
-      const value = part.slice(idx + 1).trim()
-      if (key) {
-        result[key] = value
-      }
-    }
-  }
-  return result
-}
-
-export function mapUrlSearchParams(
-  params,
-) {
-  const result = {}
-  for (const key of new Set(params.keys())) {
-    const values = params.getAll(key)
-    result[key] = values.length === 1 ? values[0] : values
-  }
-  return result
-}
-
-export async function parseFormData(
-  request,
-) {
-  const formData = await request.formData()
-  const result = {}
-
-  for (const key of new Set(formData.keys())) {
-    const values = formData.getAll(key)
-    const first = values[0]
-
-    if (typeof first === "string") {
-      result[key] = values.length === 1 ? first : (values)
-    } else {
-      const files = []
-      for (const value of values) {
-        if (typeof value !== "string") {
-          const content = new Uint8Array(await value.arrayBuffer())
-          files.push({
-            _tag: "File",
-            key,
-            name: value.name,
-            contentType: value.type || "application/octet-stream",
-            content,
-          })
-        }
-      }
-      result[key] = files
-    }
-  }
-
-  return result
-}

package/dist/PathPattern.js

@@ -1,451 +0,0 @@
-
-
-function isValidSegment(segment) {
-  if (segment.startsWith(":")) {
-    const rest = segment.slice(1)
-    if (rest.endsWith("*") || rest.endsWith("+") || rest.endsWith("?")) {
-      const name = rest.slice(0, -1)
-      return name !== "" && /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)
-    }
-    return rest !== "" && /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(rest)
-  }
-  return /^[\p{L}\p{N}._~-]+$/u.test(segment)
-}
-
-export function validate(path) {
-  const segments = path.split("/").filter(Boolean)
-  for (const segment of segments) {
-    if (!isValidSegment(segment)) {
-      return {
-        ok: false,
-        error: `Invalid segment "${segment}" in "${path}"`,
-      }
-    }
-  }
-  return { ok: true, segments }
-}
-
-export function match(pattern, path) {
-  const patternSegments = pattern.split("/").filter(Boolean)
-  const pathSegments = path.split("/").filter(Boolean)
-  const params = {}
-  let patternIndex = 0
-  let pathIndex = 0
-
-  while (patternIndex < patternSegments.length) {
-    const seg = patternSegments[patternIndex]
-
-    if (seg.startsWith(":")) {
-      const rest = seg.slice(1)
-
-      if (rest.endsWith("+")) {
-        const name = rest.slice(0, -1)
-        const remaining = pathSegments.slice(pathIndex)
-        if (remaining.length === 0) {
-          return null
-        }
-        params[name] = remaining.join("/")
-        return params
-      }
-
-      if (rest.endsWith("*")) {
-        const name = rest.slice(0, -1)
-        const remaining = pathSegments.slice(pathIndex)
-        if (remaining.length > 0) {
-          params[name] = remaining.join("/")
-        }
-        return params
-      }
-
-      if (rest.endsWith("?")) {
-        const name = rest.slice(0, -1)
-        if (pathIndex < pathSegments.length) {
-          params[name] = pathSegments[pathIndex]
-          pathIndex++
-        }
-        patternIndex++
-        continue
-      }
-
-      if (pathIndex >= pathSegments.length) {
-        return null
-      }
-
-      params[rest] = pathSegments[pathIndex]
-      pathIndex++
-      patternIndex++
-      continue
-    }
-
-    if (pathIndex >= pathSegments.length) {
-      return null
-    }
-
-    if (seg !== pathSegments[pathIndex]) {
-      return null
-    }
-
-    pathIndex++
-    patternIndex++
-  }
-
-  if (pathIndex !== pathSegments.length) {
-    return null
-  }
-
-  return params
-}
-
-export function toRegex(path) {
-  const result = path
-    .replace(/\/+(\/|$)/g, "$1")
-    .replace(/\./g, "\\.")
-    .replace(/(\/?):(\w+)\+/g, "($1(?<$2>*))")
-    .replace(/(\/?):(\w+)\*/g, "(?:\\/(?<$2>.*))?")
-    .replace(/(\/?):(\w+)/g, "($1(?<$2>[^$1/]+?))")
-    .replace(/(\/?)\*/g, "($1.*)?")
-
-  return new RegExp(`^${result}/*$`)
-}
-
-function getModifier(seg) {
-  const last = seg[seg.length - 1]
-  if (last === "?" || last === "*" || last === "+") return last
-  return ""
-}
-
-function getParamName(seg) {
-  const modifier = getModifier(seg)
-  return modifier ? seg.slice(1, -1) : seg.slice(1)
-}
-
-/**
- * Converts to Express path pattern.
- *
- * @see https://expressjs.com/en/guide/routing.html
- *
- * - `:param` → `:param`
- * - `:param?` → `{/:param}`
- * - `:param+` → `/*param`
- * - `:param*` → `/`, `/*param`
- */
-export function toExpress(path) {
-  const segments = path.split("/").filter(Boolean)
-  const optionalWildcardIndex = segments.findIndex((s) => s.startsWith(":") && s.endsWith("*"))
-
-  if (optionalWildcardIndex !== -1) {
-    const before = segments.slice(0, optionalWildcardIndex)
-    const rest = segments[optionalWildcardIndex]
-    const name = getParamName(rest)
-    const beforeJoined = before
-      .map((s) => (s.startsWith(":") ? `:${getParamName(s)}` : s))
-      .join("/")
-    const basePath = beforeJoined ? "/" + beforeJoined : "/"
-    const withWildcard = basePath === "/" ? `/*${name}` : basePath + `/*${name}`
-    return [basePath, withWildcard]
-  }
-
-  let result = ""
-  for (const seg of segments) {
-    if (!seg.startsWith(":")) {
-      result += "/" + seg
-    } else {
-      const name = getParamName(seg)
-      const modifier = getModifier(seg)
-      switch (modifier) {
-        case "":
-          result += `/:${name}`
-          break
-        case "?":
-          result += `{/:${name}}`
-          break
-        case "+":
-          result += `/*${name}`
-          break
-        case "*":
-          result += `/*${name}`
-          break
-      }
-    }
-  }
-  return [result || "/"]
-}
-
-/**
- * Converts to URLPattern path pattern.
- *
- * @see https://developer.mozilla.org/en-US/docs/Web/API/URL_Pattern_API
- *
- * - `:param` → `:param`
- * - `:param?` → `:param?`
- * - `:param+` → `:param+`
- * - `:param*` → `:param*`
- */
-export function toURLPattern(path) {
-  const segments = path.split("/").filter(Boolean)
-  const joined = segments
-    .map((seg) => {
-      if (!seg.startsWith(":")) return seg
-      const name = getParamName(seg)
-      const modifier = getModifier(seg)
-      return `:${name}${modifier}`
-    })
-    .join("/")
-  return [joined ? "/" + joined : "/"]
-}
-
-/**
- * Converts to React Router path pattern.
- *
- * @see https://reactrouter.com/start/framework/routing
- *
- * - `:param` → `:param`
- * - `:param?` → `:param?`
- * - `:param+` → `*` (splat, required)
- * - `:param*` → `/`, `/*` (splat, optional - two routes)
- */
-export function toReactRouter(path) {
-  const segments = path.split("/").filter(Boolean)
-  const optionalWildcardIndex = segments.findIndex((s) => s.startsWith(":") && s.endsWith("*"))
-
-  if (optionalWildcardIndex !== -1) {
-    const before = segments.slice(0, optionalWildcardIndex)
-    const beforeJoined = before
-      .map((s) => {
-        if (!s.startsWith(":")) return s
-        const name = getParamName(s)
-        const modifier = getModifier(s)
-        return modifier === "?" ? `:${name}?` : `:${name}`
-      })
-      .join("/")
-    const basePath = beforeJoined ? "/" + beforeJoined : "/"
-    const withWildcard = basePath === "/" ? "/*" : basePath + "/*"
-    return [basePath, withWildcard]
-  }
-
-  const joined = segments
-    .map((s) => {
-      if (!s.startsWith(":")) return s
-      const name = getParamName(s)
-      const modifier = getModifier(s)
-      switch (modifier) {
-        case "":
-          return `:${name}`
-        case "?":
-          return `:${name}?`
-        case "+":
-        case "*":
-          return "*"
-      }
-    })
-    .join("/")
-  return [joined ? "/" + joined : "/"]
-}
-
-/**
- * Alias for toReactRouter.
- *
- * @see https://reactrouter.com/start/framework/routing
- */
-export const toRemix = toReactRouter
-
-/**
- * Converts to Remix file-based route naming convention.
- *
- * Returns a file path segment (without extension) for Remix's
- * flat file routing convention.
- *
- * @see https://remix.run/docs/file-conventions/routes
- *
- * - `:param` → `$param`
- * - `:param?` → `($param)`
- * - `:param+` → `$` (splat)
- * - `:param*` → `($)` (optional splat) - Note: not officially supported
- */
-export function toRemixFile(path) {
-  const segments = path.split("/").filter(Boolean)
-
-  const mapped = segments.map((seg) => {
-    if (!seg.startsWith(":")) return seg
-    const name = getParamName(seg)
-    const modifier = getModifier(seg)
-    switch (modifier) {
-      case "":
-        return `$${name}`
-      case "?":
-        return `($${name})`
-      case "+":
-        return "$"
-      case "*":
-        return "($)"
-    }
-  })
-
-  return mapped.join(".")
-}
-
-/**
- * Converts to TanStack Router path/file pattern.
- *
- * TanStack uses the same `$param` syntax for both route paths and file names.
- * Returns a dot-separated file name (without extension).
- *
- * @see https://tanstack.com/router/v1/docs/framework/react/guide/path-params
- * @see https://tanstack.com/router/v1/docs/framework/react/routing/file-naming-conventions
- *
- * - `:param` → `$param`
- * - `:param?` → `{-$param}` (optional segment)
- * - `:param+` → `$` (splat)
- * - `:param*` → `$` (splat, optional not supported - treated as required)
- */
-export function toTanStack(path) {
-  const segments = path.split("/").filter(Boolean)
-
-  const mapped = segments.map((seg) => {
-    if (!seg.startsWith(":")) return seg
-    const name = getParamName(seg)
-    const modifier = getModifier(seg)
-    switch (modifier) {
-      case "":
-        return `$${name}`
-      case "?":
-        return `{-$${name}}`
-      case "+":
-        return "$"
-      case "*":
-        return "$"
-    }
-  })
-
-  return mapped.join(".")
-}
-
-/**
- * Converts to Hono path pattern.
- *
- * Hono uses unnamed wildcards - they are NOT accessible via c.req.param().
- * Use c.req.path to access the matched path for wildcard routes.
- *
- * @see https://hono.dev/docs/api/routing
- *
- * - `:param` → `:param`
- * - `:param?` → `:param?`
- * - `:param+` → `*` (unnamed, required)
- * - `:param*` → `/`, `/*` (unnamed, optional - two routes)
- */
-export function toHono(path) {
-  const segments = path.split("/").filter(Boolean)
-  const optionalWildcardIndex = segments.findIndex((s) => s.startsWith(":") && s.endsWith("*"))
-
-  if (optionalWildcardIndex !== -1) {
-    const before = segments.slice(0, optionalWildcardIndex)
-    const beforeJoined = before
-      .map((s) => {
-        if (!s.startsWith(":")) return s
-        const name = getParamName(s)
-        const modifier = getModifier(s)
-        return modifier === "?" ? `:${name}?` : `:${name}`
-      })
-      .join("/")
-    const basePath = beforeJoined ? "/" + beforeJoined : "/"
-    const withWildcard = basePath === "/" ? "/*" : basePath + "/*"
-    return [basePath, withWildcard]
-  }
-
-  const joined = segments
-    .map((s) => {
-      if (!s.startsWith(":")) return s
-      const name = getParamName(s)
-      const modifier = getModifier(s)
-      switch (modifier) {
-        case "":
-          return `:${name}`
-        case "?":
-          return `:${name}?`
-        case "+":
-        case "*":
-          return "*"
-      }
-    })
-    .join("/")
-  return [joined ? "/" + joined : "/"]
-}
-
-/**
- * Converts to Effect HttpRouter / find-my-way path pattern.
- *
- * Effect uses colon-style params with unnamed wildcards.
- *
- * @see https://effect.website/docs/platform/http-router
- *
- * - `:param` → `:param`
- * - `:param?` → `:param?`
- * - `:param+` → `*` (unnamed)
- * - `:param*` → `/`, `/*` (two routes)
- */
-export function toEffect(path) {
-  return toHono(path)
-}
-
-/**
- * Converts to Bun.serve path pattern.
- *
- * Since Bun doesn't support optional params (`:param?`), optional segments
- * are expanded into multiple routes.
- *
- * @see https://bun.sh/docs/api/http#routing
- *
- * - `:param` → `:param`
- * - `:param?` → `/`, `/:param` (two routes)
- * - `:param+` → `/*`
- * - `:param*` → `/`, `/*` (two routes)
- */
-export function toBun(path) {
-  const segments = path.split("/").filter(Boolean)
-
-  const optionalIndex = segments.findIndex(
-    (s) => s.startsWith(":") && (s.endsWith("?") || s.endsWith("*")),
-  )
-
-  if (optionalIndex === -1) {
-    const joined = segments
-      .map((s) => {
-        if (!s.startsWith(":")) return s
-        const modifier = getModifier(s)
-        const name = getParamName(s)
-        return modifier === "+" || modifier === "*" ? "*" : `:${name}`
-      })
-      .join("/")
-    return [joined ? `/${joined}` : "/"]
-  }
-
-  const before = segments.slice(0, optionalIndex)
-  const optional = segments[optionalIndex]
-  const after = segments.slice(optionalIndex + 1)
-
-  const formatSegment = (s) => {
-    if (!s.startsWith(":")) return s
-    const modifier = getModifier(s)
-    const name = getParamName(s)
-    switch (modifier) {
-      case "":
-      case "?":
-        return `:${name}`
-      case "+":
-      case "*":
-        return "*"
-    }
-  }
-
-  const beforePath = before.map(formatSegment).join("/")
-  const basePath = beforePath ? `/${beforePath}` : "/"
-
-  const optionalModifier = getModifier(optional)
-  const optionalName = getParamName(optional)
-  const requiredOptional = optionalModifier === "*" ? `:${optionalName}+` : `:${optionalName}`
-
-  const withOptionalSegments = [...before, requiredOptional, ...after]
-  const withOptionalPath = `/${withOptionalSegments.map(formatSegment).join("/")}`
-
-  return [...toBun(basePath), ...toBun(withOptionalPath)]
-}

package/dist/PlatformError.js

@@ -1,40 +0,0 @@
-/*
- * Adapted from @effect/platform
- */
-import * as Data from "effect/Data"
-import * as Predicate from "effect/Predicate"
-
-export const TypeId = Symbol.for("@effect/platform/Error/PlatformError")
-
-export const isPlatformError = (u) => Predicate.hasProperty(u, TypeId)
-
-export const TypeIdError = (
-  typeId,
-  tag,
-) => {
-  class Base extends Data.Error {
-    _tag = tag
-  }
-  ;(Base.prototype)[typeId] = typeId
-  ;(Base.prototype).name = tag
-  return Base
-}
-
-export class BadArgument extends Data.TaggedError("BadArgument") {
-  [TypeId] = TypeId
-
-  get message() {
-    return `${this.module}.${this.method}${this.description ? `: ${this.description}` : ""}`
-  }
-}
-
-export class SystemError extends Data.TaggedError("SystemError") {
-  [TypeId] = TypeId
-
-  get message() {
-    return `${this.reason}: ${this.module}.${this.method}${
-      this.pathOrDescriptor !== undefined ? ` (${this.pathOrDescriptor})` : ""
-    }${this.description ? `: ${this.description}` : ""}`
-  }
-}
-

package/dist/PlatformRuntime.js

@@ -1,71 +0,0 @@
-import * as Cause from "effect/Cause"
-import * as Effect from "effect/Effect"
-import * as Exit from "effect/Exit"
-import * as FiberRef from "effect/FiberRef"
-import * as FiberRefs from "effect/FiberRefs"
-import * as Function from "effect/Function"
-import * as HashSet from "effect/HashSet"
-import * as Logger from "effect/Logger"
-
-export const defaultTeardown = (
-  exit,
-  onExit,
-) => {
-  onExit(Exit.isFailure(exit) && !Cause.isInterruptedOnly(exit.cause) ? 1 : 0)
-}
-
-const addPrettyLogger = (refs, fiberId) => {
-  const loggers = FiberRefs.getOrDefault(refs, FiberRef.currentLoggers)
-  if (!HashSet.has(loggers, Logger.defaultLogger)) {
-    return refs
-  }
-  return FiberRefs.updateAs(refs, {
-    fiberId,
-    fiberRef: FiberRef.currentLoggers,
-    value: loggers.pipe(
-      HashSet.remove(Logger.defaultLogger),
-      HashSet.add(Logger.prettyLoggerDefault),
-    ),
-  })
-}
-
-export const makeRunMain = (
-  f,
-) =>
-  Function.dual(
-    (args) => Effect.isEffect(args[0]),
-    (
-      effect,
-      options,
-    ) => {
-      const fiber =
-        options?.disableErrorReporting === true
-          ? Effect.runFork(effect, {
-              updateRefs: options?.disablePrettyLogger === true ? undefined : addPrettyLogger,
-            })
-          : Effect.runFork(
-              Effect.tapErrorCause(effect, (cause) => {
-                if (Cause.isInterruptedOnly(cause)) {
-                  return Effect.void
-                }
-                return Effect.logError(cause)
-              }),
-              {
-                updateRefs: options?.disablePrettyLogger === true ? undefined : addPrettyLogger,
-              },
-            )
-      const teardown = options?.teardown ?? defaultTeardown
-      return f({ fiber, teardown })
-    },
-  )
-
-/**
- * Are we running within an agent harness, like Claude Code?
- */
-export function isAgentHarness() {
-  return (
-    typeof process !== "undefined" &&
-    !process.stdout.isTTY &&
-    (process.env.CLAUDECODE || process.env.CURSOR_AGENT)
-  )
-}