effect-start 0.20.1 → 0.22.0

package/src/Http.ts

@@ -1,38 +1,21 @@
 import * as Values from "./Values.ts"
 
-export type Method =
-  | "GET"
-  | "POST"
-  | "PUT"
-  | "DELETE"
-  | "PATCH"
-  | "HEAD"
-  | "OPTIONS"
-
-type Respondable =
-  | Response
-  | Promise<Response>
+export type Method = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS"
+
+type Respondable = Response | Promise<Response>
 
 export type WebHandler = (request: Request) => Respondable
 
-export type WebMiddleware = (
-  request: Request,
-  next: WebHandler,
-) => Respondable
+export type WebMiddleware = (request: Request, next: WebHandler) => Respondable
 
 export function fetch(
   handler: WebHandler,
-  init:
-    & Omit<RequestInit, "body">
-    & (
-      | { url: string }
-      | { path: `/${string}` }
-    )
-    & { body?: RequestInit["body"] | Record<string, unknown> },
+  init: Omit<RequestInit, "body"> &
+    ({ url: string } | { path: `/${string}` }) & {
+      body?: RequestInit["body"] | Record<string, unknown>
+    },
 ): Promise<Response> {
-  const url = "path" in init
-    ? `http://localhost${init.path}`
-    : init.url
+  const url = "path" in init ? `http://localhost${init.path}` : init.url
 
   const isPlain = Values.isPlainObject(init.body)
 
@@ -52,24 +35,15 @@ export function fetch(
 }
 
 export function createAbortableRequest(
-  init:
-    & Omit<RequestInit, "signal">
-    & (
-      | { url: string }
-      | { path: `/${string}` }
-    ),
+  init: Omit<RequestInit, "signal"> & ({ url: string } | { path: `/${string}` }),
 ): { request: Request; abort: () => void } {
-  const url = "path" in init
-    ? `http://localhost${init.path}`
-    : init.url
+  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: Headers,
-): Record<string, string | undefined> {
+export function mapHeaders(headers: Headers): Record<string, string | undefined> {
   const result: Record<string, string | undefined> = {}
   headers.forEach((value, key) => {
     result[key.toLowerCase()] = value
@@ -77,9 +51,7 @@ export function mapHeaders(
   return result
 }
 
-export function parseCookies(
-  cookieHeader: string | null,
-): Record<string, string | undefined> {
+export function parseCookies(cookieHeader: string | null): Record<string, string | undefined> {
   if (!cookieHeader) return {}
   const result: Record<string, string | undefined> = {}
   for (const part of cookieHeader.split(";")) {
@@ -130,23 +102,18 @@ export type MultipartPart = FilePart | FieldPart
 
 export async function parseFormData(
   request: Request,
-): Promise<
-  Record<string, ReadonlyArray<FilePart> | ReadonlyArray<string> | string>
-> {
+): Promise<Record<string, ReadonlyArray<FilePart> | ReadonlyArray<string> | string>> {
   const formData = await request.formData()
-  const result: Record<
-    string,
-    ReadonlyArray<FilePart> | ReadonlyArray<string> | string
-  > = {}
+  const result: Record<string, ReadonlyArray<FilePart> | ReadonlyArray<string> | string> = {}
 
   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 as string[])
+      result[key] = values.length === 1 ? first : (values as Array<string>)
     } else {
-      const files: FilePart[] = []
+      const files: Array<FilePart> = []
       for (const value of values) {
         if (typeof value !== "string") {
           const content = new Uint8Array(await value.arrayBuffer())

package/src/PathPattern.ts

@@ -2,24 +2,29 @@ export type PathPattern = `/${string}`
 
 export type Segments<Path extends string> = Path extends `/${infer Rest}`
   ? Segments<Rest>
-  : Path extends `${infer Head}/${infer Tail}` ? [Head, ...Segments<Tail>]
-  : Path extends "" ? []
-  : [Path]
-
-export type Params<T extends string> = string extends T ? Record<string, string>
+  : Path extends `${infer Head}/${infer Tail}`
+    ? [Head, ...Segments<Tail>]
+    : Path extends ""
+      ? []
+      : [Path]
+
+export type Params<T extends string> = string extends T
+  ? Record<string, string>
   : T extends `${infer _Start}:${infer Param}?/${infer Rest}`
     ? { [K in Param]?: string } & Params<`/${Rest}`>
-  : T extends `${infer _Start}:${infer Param}/${infer Rest}`
-    ? { [K in Param]: string } & Params<`/${Rest}`>
-  : T extends `${infer _Start}:${infer Param}+` ? { [K in Param]: string }
-  : T extends `${infer _Start}:${infer Param}*` ? { [K in Param]?: string }
-  : T extends `${infer _Start}:${infer Param}?` ? { [K in Param]?: string }
-  : T extends `${infer _Start}:${infer Param}` ? { [K in Param]: string }
-  : {}
-
-export type ValidateResult =
-  | { ok: true; segments: string[] }
-  | { ok: false; error: string }
+    : T extends `${infer _Start}:${infer Param}/${infer Rest}`
+      ? { [K in Param]: string } & Params<`/${Rest}`>
+      : T extends `${infer _Start}:${infer Param}+`
+        ? { [K in Param]: string }
+        : T extends `${infer _Start}:${infer Param}*`
+          ? { [K in Param]?: string }
+          : T extends `${infer _Start}:${infer Param}?`
+            ? { [K in Param]?: string }
+            : T extends `${infer _Start}:${infer Param}`
+              ? { [K in Param]: string }
+              : {}
+
+export type ValidateResult = { ok: true; segments: Array<string> } | { ok: false; error: string }
 
 function isValidSegment(segment: string): boolean {
   if (segment.startsWith(":")) {
@@ -46,10 +51,7 @@ export function validate(path: string): ValidateResult {
   return { ok: true, segments }
 }
 
-export function match(
-  pattern: string,
-  path: string,
-): Record<string, string> | null {
+export function match(pattern: string, path: string): Record<string, string> | null {
   const patternSegments = pattern.split("/").filter(Boolean)
   const pathSegments = path.split("/").filter(Boolean)
   const params: Record<string, string> = {}
@@ -153,11 +155,9 @@ function getParamName(seg: string): string {
  * - `:param+` → `/*param`
  * - `:param*` → `/`, `/*param`
  */
-export function toExpress(path: string): string[] {
+export function toExpress(path: string): Array<string> {
   const segments = path.split("/").filter(Boolean)
-  const optionalWildcardIndex = segments.findIndex(
-    (s) => s.startsWith(":") && s.endsWith("*"),
-  )
+  const optionalWildcardIndex = segments.findIndex((s) => s.startsWith(":") && s.endsWith("*"))
 
   if (optionalWildcardIndex !== -1) {
     const before = segments.slice(0, optionalWildcardIndex)
@@ -207,7 +207,7 @@ export function toExpress(path: string): string[] {
  * - `:param+` → `:param+`
  * - `:param*` → `:param*`
  */
-export function toURLPattern(path: string): string[] {
+export function toURLPattern(path: string): Array<string> {
   const segments = path.split("/").filter(Boolean)
   const joined = segments
     .map((seg) => {
@@ -230,11 +230,9 @@ export function toURLPattern(path: string): string[] {
  * - `:param+` → `*` (splat, required)
  * - `:param*` → `/`, `/*` (splat, optional - two routes)
  */
-export function toReactRouter(path: string): string[] {
+export function toReactRouter(path: string): Array<string> {
   const segments = path.split("/").filter(Boolean)
-  const optionalWildcardIndex = segments.findIndex(
-    (s) => s.startsWith(":") && s.endsWith("*"),
-  )
+  const optionalWildcardIndex = segments.findIndex((s) => s.startsWith(":") && s.endsWith("*"))
 
   if (optionalWildcardIndex !== -1) {
     const before = segments.slice(0, optionalWildcardIndex)
@@ -361,11 +359,9 @@ export function toTanStack(path: string): string {
  * - `:param+` → `*` (unnamed, required)
  * - `:param*` → `/`, `/*` (unnamed, optional - two routes)
  */
-export function toHono(path: string): string[] {
+export function toHono(path: string): Array<string> {
   const segments = path.split("/").filter(Boolean)
-  const optionalWildcardIndex = segments.findIndex(
-    (s) => s.startsWith(":") && s.endsWith("*"),
-  )
+  const optionalWildcardIndex = segments.findIndex((s) => s.startsWith(":") && s.endsWith("*"))
 
   if (optionalWildcardIndex !== -1) {
     const before = segments.slice(0, optionalWildcardIndex)
@@ -413,7 +409,7 @@ export function toHono(path: string): string[] {
  * - `:param+` → `*` (unnamed)
  * - `:param*` → `/`, `/*` (two routes)
  */
-export function toEffect(path: string): string[] {
+export function toEffect(path: string): Array<string> {
   return toHono(path)
 }
 
@@ -430,7 +426,7 @@ export function toEffect(path: string): string[] {
  * - `:param+` → `/*`
  * - `:param*` → `/`, `/*` (two routes)
  */
-export function toBun(path: string): PathPattern[] {
+export function toBun(path: string): Array<PathPattern> {
   const segments = path.split("/").filter(Boolean)
 
   const optionalIndex = segments.findIndex(
@@ -472,14 +468,10 @@ export function toBun(path: string): PathPattern[] {
 
   const optionalModifier = getModifier(optional)
   const optionalName = getParamName(optional)
-  const requiredOptional = optionalModifier === "*"
-    ? `:${optionalName}+`
-    : `:${optionalName}`
+  const requiredOptional = optionalModifier === "*" ? `:${optionalName}+` : `:${optionalName}`
 
   const withOptionalSegments = [...before, requiredOptional, ...after]
-  const withOptionalPath: PathPattern = `/${
-    withOptionalSegments.map(formatSegment).join("/")
-  }`
+  const withOptionalPath: PathPattern = `/${withOptionalSegments.map(formatSegment).join("/")}`
 
   return [...toBun(basePath), ...toBun(withOptionalPath)]
 }

package/src/PlatformError.ts

@@ -7,29 +7,18 @@ import * as Predicate from "effect/Predicate"
 import * as Schema from "effect/Schema"
 import type * as Types from "effect/Types"
 
-import { TypeId as TypeId_ } from "@effect/platform/Error"
-
-export const TypeId: typeof TypeId_ = TypeId_
+export const TypeId: unique symbol = Symbol.for("@effect/platform/Error/PlatformError")
 
 export type TypeId = typeof TypeId
 
-export const isPlatformError = (u: unknown): u is PlatformError =>
-  Predicate.hasProperty(u, TypeId)
+export const isPlatformError = (u: unknown): u is PlatformError => Predicate.hasProperty(u, TypeId)
 
-export const TypeIdError = <
-  const TypeId extends symbol,
-  const Tag extends string,
->(
+export const TypeIdError = <const TypeId extends symbol, const Tag extends string>(
   typeId: TypeId,
   tag: Tag,
-): new<A extends Record<string, any>>(
+): (new <A extends Record<string, any>>(
   args: Types.Simplify<A>,
-) =>
-  & Cause.YieldableError
-  & Record<TypeId, TypeId>
-  & { readonly _tag: Tag }
-  & Readonly<A> =>
-{
+) => Cause.YieldableError & Record<TypeId, TypeId> & { readonly _tag: Tag } & Readonly<A>) => {
   class Base extends Data.Error<{}> {
     readonly _tag = tag
   }
@@ -48,23 +37,18 @@ export const Module = Schema.Literal(
   "Terminal",
 )
 
-export class BadArgument
-  extends Schema.TaggedError<BadArgument>("@effect/platform/Error/BadArgument")(
-    "BadArgument",
-    {
-      module: Module,
-      method: Schema.String,
-      description: Schema.optional(Schema.String),
-      cause: Schema.optional(Schema.Defect),
-    },
-  )
-{
+export class BadArgument extends Schema.TaggedError<BadArgument>(
+  "@effect/platform/Error/BadArgument",
+)("BadArgument", {
+  module: Module,
+  method: Schema.String,
+  description: Schema.optional(Schema.String),
+  cause: Schema.optional(Schema.Defect),
+}) {
   readonly [TypeId]: typeof TypeId = TypeId
 
   get message(): string {
-    return `${this.module}.${this.method}${
-      this.description ? `: ${this.description}` : ""
-    }`
+    return `${this.module}.${this.method}${this.description ? `: ${this.description}` : ""}`
   }
 }
 
@@ -84,22 +68,17 @@ export const SystemErrorReason = Schema.Literal(
 
 export type SystemErrorReason = typeof SystemErrorReason.Type
 
-export class SystemError
-  extends Schema.TaggedError<SystemError>("@effect/platform/Error/SystemError")(
-    "SystemError",
-    {
-      reason: SystemErrorReason,
-      module: Module,
-      method: Schema.String,
-      description: Schema.optional(Schema.String),
-      syscall: Schema.optional(Schema.String),
-      pathOrDescriptor: Schema.optional(
-        Schema.Union(Schema.String, Schema.Number),
-      ),
-      cause: Schema.optional(Schema.Defect),
-    },
-  )
-{
+export class SystemError extends Schema.TaggedError<SystemError>(
+  "@effect/platform/Error/SystemError",
+)("SystemError", {
+  reason: SystemErrorReason,
+  module: Module,
+  method: Schema.String,
+  description: Schema.optional(Schema.String),
+  syscall: Schema.optional(Schema.String),
+  pathOrDescriptor: Schema.optional(Schema.Union(Schema.String, Schema.Number)),
+  cause: Schema.optional(Schema.Defect),
+}) {
   readonly [TypeId]: typeof TypeId = TypeId
 
   get message(): string {
@@ -111,7 +90,7 @@ export class SystemError
 
 export type PlatformError = BadArgument | SystemError
 
-export const PlatformError: Schema.Union<[
-  typeof BadArgument,
-  typeof SystemError,
-]> = Schema.Union(BadArgument, SystemError)
+export const PlatformError: Schema.Union<[typeof BadArgument, typeof SystemError]> = Schema.Union(
+  BadArgument,
+  SystemError,
+)

package/src/PlatformRuntime.ts

@@ -21,13 +21,11 @@ export const defaultTeardown: Teardown = <E, A>(
 }
 
 export interface RunMain {
-  (
-    options?: {
-      readonly disableErrorReporting?: boolean | undefined
-      readonly disablePrettyLogger?: boolean | undefined
-      readonly teardown?: Teardown | undefined
-    },
-  ): <E, A>(effect: Effect.Effect<A, E>) => void
+  (options?: {
+    readonly disableErrorReporting?: boolean | undefined
+    readonly disablePrettyLogger?: boolean | undefined
+    readonly teardown?: Teardown | undefined
+  }): <E, A>(effect: Effect.Effect<A, E>) => void
   <E, A>(
     effect: Effect.Effect<A, E>,
     options?: {
@@ -38,10 +36,7 @@ export interface RunMain {
   ): void
 }
 
-const addPrettyLogger = (
-  refs: FiberRefs.FiberRefs,
-  fiberId: FiberId.Runtime,
-) => {
+const addPrettyLogger = (refs: FiberRefs.FiberRefs, fiberId: FiberId.Runtime) => {
   const loggers = FiberRefs.getOrDefault(refs, FiberRef.currentLoggers)
   if (!HashSet.has(loggers, Logger.defaultLogger)) {
     return refs
@@ -57,39 +52,37 @@ const addPrettyLogger = (
 }
 
 export const makeRunMain = (
-  f: <E, A>(
-    options: {
-      readonly fiber: Fiber.RuntimeFiber<A, E>
-      readonly teardown: Teardown
-    },
-  ) => void,
+  f: <E, A>(options: {
+    readonly fiber: Fiber.RuntimeFiber<A, E>
+    readonly teardown: Teardown
+  }) => void,
 ): RunMain =>
   Function.dual(
     (args) => Effect.isEffect(args[0]),
-    (effect: Effect.Effect<any, any>, options?: {
-      readonly disableErrorReporting?: boolean | undefined
-      readonly disablePrettyLogger?: boolean | undefined
-      readonly teardown?: Teardown | undefined
-    }) => {
-      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,
-          },
-        )
+    (
+      effect: Effect.Effect<any, any>,
+      options?: {
+        readonly disableErrorReporting?: boolean | undefined
+        readonly disablePrettyLogger?: boolean | undefined
+        readonly teardown?: Teardown | undefined
+      },
+    ) => {
+      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 })
     },
@@ -99,10 +92,9 @@ export const makeRunMain = (
  * 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
-    )
+  return (
+    typeof process !== "undefined" &&
+    !process.stdout.isTTY &&
+    (process.env.CLAUDECODE || process.env.CURSOR_AGENT)
+  )
 }