effect-start 0.21.0 → 0.22.0

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"
 
-export const TypeId: unique symbol = Symbol.for(
-  "@effect/platform/Error/PlatformError",
-)
+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)
+  )
 }

package/src/Route.ts

@@ -6,7 +6,7 @@ import * as Predicate from "effect/Predicate"
 import * as Entity from "./Entity.ts"
 import * as RouteBody from "./RouteBody.ts"
 import * as RouteTree from "./RouteTree.ts"
-import * as Values from "./Values.ts"
+import type * as Values from "./Values.ts"
 
 export const RouteItems: unique symbol = Symbol()
 export const RouteDescriptor: unique symbol = Symbol()
@@ -26,49 +26,30 @@ export namespace RouteSet {
     D extends RouteDescriptor.Any = {},
     B = {},
     M extends Route.Tuple = [],
-  > =
-    & Data<D, B, M>
-    & {
-      [TypeId]: typeof TypeId
-    }
-    & Pipeable.Pipeable
-    & Iterable<M[number]>
+  > = Data<D, B, M> & {
+    [TypeId]: typeof TypeId
+  } & Pipeable.Pipeable &
+    Iterable<M[number]>
 
-  export type Data<
-    D extends RouteDescriptor.Any = {},
-    B = {},
-    M extends Route.Tuple = [],
-  > = {
+  export type Data<D extends RouteDescriptor.Any = {}, B = {}, M extends Route.Tuple = []> = {
     [RouteItems]: M
     [RouteDescriptor]: D
     [RouteBindings]: B
   }
 
-  export type Proto =
-    & Pipeable.Pipeable
-    & Iterable<Route.Route<any, any, any, any, any>>
-    & {
+  export type Proto = Pipeable.Pipeable &
+    Iterable<Route.Route<any, any, any, any, any>> & {
       [TypeId]: typeof TypeId
     }
 
   export type Any = RouteSet<{}, {}, Route.Tuple>
 
-  export type Infer<R> = R extends RouteSet<infer D, infer B, infer I>
-    ? RouteSet<D, B, I>
-    : R
-
-  export type Items<
-    T extends Data<any, any, any>,
-  > = T extends Data<
-    any,
-    any,
-    infer M
-  > ? M
-    : never
-
-  export type Descriptor<
-    T extends Data<any, any, any>,
-  > = T extends Data<infer D, any, any> ? D : never
+  export type Infer<R> = R extends RouteSet<infer D, infer B, infer I> ? RouteSet<D, B, I> : R
+
+  export type Items<T extends Data<any, any, any>> = T extends Data<any, any, infer M> ? M : never
+
+  export type Descriptor<T extends Data<any, any, any>> =
+    T extends Data<infer D, any, any> ? D : never
 }
 
 export namespace Route {
@@ -78,25 +59,15 @@ export namespace Route {
     A = any,
     E = never,
     R = never,
-  > extends
-    RouteSet.RouteSet<D, {}, [
-      Route<D, B, A, E, R>,
-    ]>
-  {
+  > extends RouteSet.RouteSet<D, {}, [Route<D, B, A, E, R>]> {
     readonly handler: Handler<B & D, A, E, R>
   }
 
-  export type With<D extends RouteDescriptor.Any> =
-    & Route<any, any, any, any, any>
-    & {
-      [RouteDescriptor]: D
-    }
+  export type With<D extends RouteDescriptor.Any> = Route<any, any, any, any, any> & {
+    [RouteDescriptor]: D
+  }
 
-  export type Tuple<
-    _D extends RouteDescriptor.Any = {},
-  > = [
-    ...Route<any, any, any, any, any>[],
-  ]
+  export type Tuple<_D extends RouteDescriptor.Any = {}> = [...Route<any, any, any, any, any>[]]
 
   export type Handler<B, A, E, R> = (
     context: B,
@@ -106,17 +77,13 @@ export namespace Route {
   /**
    * Extracts only the bindings (B) from routes, excluding descriptors.
    */
-  export type Bindings<
-    T extends RouteSet.Any,
-    M extends Tuple = RouteSet.Items<T>,
-  > = M extends [
+  export type Bindings<T extends RouteSet.Any, M extends Tuple = RouteSet.Items<T>> = M extends [
     infer Head,
     ...infer Tail extends Tuple,
-  ] ? (
-      Head extends Route<any, infer B, any, any, any>
-        ? ShallowMerge<B, Bindings<T, Tail>>
-        : Bindings<T, Tail>
-    )
+  ]
+    ? Head extends Route<any, infer B, any, any, any>
+      ? ShallowMerge<B, Bindings<T, Tail>>
+      : Bindings<T, Tail>
     : {}
 
   /**
@@ -125,32 +92,16 @@ export namespace Route {
    * taking precedence via ShallowMerge to avoid `never` from conflicting
    * literal types (e.g. `{ method: "*" } & { method: "GET" }`).
    */
-  export type Context<T extends RouteSet.Any> =
-    & Omit<
-      RouteSet.Descriptor<T>,
-      keyof ExtractContext<RouteSet.Items<T>>
-    >
-    & ExtractContext<RouteSet.Items<T>>
-
-  type ExtractContext<
-    M extends Tuple,
-  > = M extends [
-    infer Head,
-    ...infer Tail extends Tuple,
-  ] ? (
-      Head extends Route<
-        infer D,
-        infer B,
-        any,
-        any,
-        any
-      > ? ShallowMerge<
-          & Omit<D, keyof B>
-          & B,
-          ExtractContext<Tail>
-        >
-        : ExtractContext<Tail>
-    )
+  export type Context<T extends RouteSet.Any> = Omit<
+    RouteSet.Descriptor<T>,
+    keyof ExtractContext<RouteSet.Items<T>>
+  > &
+    ExtractContext<RouteSet.Items<T>>
+
+  type ExtractContext<M extends Tuple> = M extends [infer Head, ...infer Tail extends Tuple]
+    ? Head extends Route<infer D, infer B, any, any, any>
+      ? ShallowMerge<Omit<D, keyof B> & B, ExtractContext<Tail>>
+      : ExtractContext<Tail>
     : {}
 }
 
@@ -164,55 +115,34 @@ const Proto: RouteSet.Proto = {
   },
 }
 
-export function isRouteSet(
-  input: unknown,
-): input is RouteSet.Any {
+export function isRouteSet(input: unknown): input is RouteSet.Any {
   return Predicate.hasProperty(input, TypeId)
 }
 
-export function isRoute(
-  input: unknown,
-): input is Route.Route {
-  return isRouteSet(input)
-    && Predicate.hasProperty(input, "handler")
+export function isRoute(input: unknown): input is Route.Route {
+  return isRouteSet(input) && Predicate.hasProperty(input, "handler")
 }
 
-export function set<
-  D extends RouteDescriptor.Any = {},
-  B = {},
-  I extends Route.Tuple = [],
->(
+export function set<D extends RouteDescriptor.Any = {}, B = {}, I extends Route.Tuple = []>(
   items: I = [] as unknown as I,
   descriptor: D = {} as D,
 ): RouteSet.RouteSet<D, B, I> {
-  return Object.assign(
-    Object.create(Proto),
-    {
-      [RouteItems]: items,
-      [RouteDescriptor]: descriptor,
-    },
-  ) as RouteSet.RouteSet<D, B, I>
+  return Object.assign(Object.create(Proto), {
+    [RouteItems]: items,
+    [RouteDescriptor]: descriptor,
+  }) as RouteSet.RouteSet<D, B, I>
 }
 
-export function make<
-  D extends RouteDescriptor.Any,
-  B,
-  A,
-  E = never,
-  R = never,
->(
+export function make<D extends RouteDescriptor.Any, B, A, E = never, R = never>(
   handler: Route.Handler<B & D, A, E, R>,
   descriptor?: D,
 ): Route.Route<D, B, A, E, R> {
   const items: any = []
-  const route: Route.Route<D, B, A, E, R> = Object.assign(
-    Object.create(Proto),
-    {
-      [RouteItems]: items,
-      [RouteDescriptor]: descriptor,
-      handler,
-    },
-  )
+  const route: Route.Route<D, B, A, E, R> = Object.assign(Object.create(Proto), {
+    [RouteItems]: items,
+    [RouteDescriptor]: descriptor,
+    handler,
+  })
 
   items.push(route)
 
@@ -221,36 +151,22 @@ export function make<
 
 export const empty = set()
 
-export function describe<
-  D extends RouteDescriptor.Any,
->(
-  descriptor: D,
-) {
+export function describe<D extends RouteDescriptor.Any>(descriptor: D) {
   return set([], descriptor)
 }
 
-export function items<
-  T extends RouteSet.Data<any, any, any>,
->(
-  self: T,
-): RouteSet.Items<T> {
+export function items<T extends RouteSet.Data<any, any, any>>(self: T): RouteSet.Items<T> {
   return self[RouteItems]
 }
 
-export function descriptor<
-  T extends RouteSet.Data<any, any, any>,
->(
+export function descriptor<T extends RouteSet.Data<any, any, any>>(
   self: T,
 ): T[typeof RouteDescriptor]
-export function descriptor<
-  T extends RouteSet.Data<any, any, any>,
->(
+export function descriptor<T extends RouteSet.Data<any, any, any>>(
   self: Iterable<T>,
-): T[typeof RouteDescriptor][]
+): Array<T[typeof RouteDescriptor]>
 export function descriptor(
-  self:
-    | RouteSet.Data<any, any, any>
-    | Iterable<RouteSet.Data<any, any, any>>,
+  self: RouteSet.Data<any, any, any> | Iterable<RouteSet.Data<any, any, any>>,
 ): RouteDescriptor.Any | RouteDescriptor.Any[] {
   if (RouteDescriptor in self) {
     return self[RouteDescriptor]
@@ -258,30 +174,20 @@ export function descriptor(
   return [...self].map((r) => r[RouteDescriptor])
 }
 
-export type ExtractBindings<
-  M extends Route.Tuple,
-> = M extends [
+export type ExtractBindings<M extends Route.Tuple> = M extends [
   infer Head,
   ...infer Tail extends Route.Tuple,
-] ? (
-    Head extends Route.Route<
-      any,
-      infer B,
-      any,
-      any,
-      any
-    > ? ShallowMerge<B, ExtractBindings<Tail>>
-      : ExtractBindings<Tail>
-  )
+]
+  ? Head extends Route.Route<any, infer B, any, any, any>
+    ? ShallowMerge<B, ExtractBindings<Tail>>
+    : ExtractBindings<Tail>
   : {}
 
 // Shallow merge two object types.
 // For overlapping keys, intersect the values.
-type ShallowMerge<A, B> =
-  & Omit<A, keyof B>
-  & {
-    [K in keyof B]: K extends keyof A ? A[K] & B[K] : B[K]
-  }
+type ShallowMerge<A, B> = Omit<A, keyof B> & {
+  [K in keyof B]: K extends keyof A ? A[K] & B[K] : B[K]
+}
 
 export type ExtractContext<
   Items extends Route.Tuple,
@@ -291,17 +197,7 @@ export type ExtractContext<
 export * from "./RouteHook.ts"
 export * from "./RouteSchema.ts"
 
-export {
-  add,
-  del,
-  get,
-  head,
-  options,
-  patch,
-  post,
-  put,
-  use,
-} from "./RouteMount.ts"
+export { add, del, get, head, options, patch, post, put, use } from "./RouteMount.ts"
 
 export const text = RouteBody.build<string, "text">({
   format: "text",
@@ -319,13 +215,9 @@ export const bytes = RouteBody.build<Uint8Array, "bytes">({
   format: "bytes",
 })
 
-export {
-  render,
-} from "./RouteBody.ts"
+export { render } from "./RouteBody.ts"
 
-export {
-  sse,
-} from "./RouteSse.ts"
+export { sse } from "./RouteSse.ts"
 
 export function redirect(
   url: string | URL,
@@ -339,24 +231,13 @@ export function redirect(
   })
 }
 
-export class Routes extends Context.Tag("effect-start/Routes")<
-  Routes,
-  RouteTree.RouteTree
->() {}
+export class Routes extends Context.Tag("effect-start/Routes")<Routes, RouteTree.RouteTree>() {}
 
 export function layer(routes: RouteTree.RouteMap | RouteTree.RouteTree) {
-  return Layer.sync(
-    Routes,
-    () =>
-      RouteTree.isRouteTree(routes)
-        ? routes
-        : RouteTree.make(routes),
-  )
+  return Layer.sync(Routes, () => (RouteTree.isRouteTree(routes) ? routes : RouteTree.make(routes)))
 }
 
-export {
-  make as tree,
-} from "./RouteTree.ts"
+export { make as tree } from "./RouteTree.ts"
 
 export function lazy<T extends RouteSet.Any>(
   load: () => Promise<{ default: T }>,