effect 4.0.0-beta.10 → 4.0.0-beta.11

package/src/unstable/cli/internal/completions/CommandDescriptor.ts

@@ -157,11 +157,16 @@ export const fromCommand = (cmd: Command.Any): CommandDescriptor => {
     }
   }
 
-  const subcommands: Array<CommandDescriptor> = cmd.subcommands.map(fromCommand)
+  const subcommands: Array<CommandDescriptor> = []
+  for (const group of cmd.subcommands) {
+    for (const subcommand of group.commands) {
+      subcommands.push(fromCommand(subcommand))
+    }
+  }
 
   return {
     name: cmd.name,
-    description: cmd.description,
+    description: cmd.shortDescription ?? cmd.description,
     flags,
     arguments: args,
     subcommands

package/src/unstable/cli/internal/parser.ts

@@ -273,8 +273,16 @@ const createFlagRegistry = (params: ReadonlyArray<FlagParam>): FlagRegistry => {
 }
 
 const buildSubcommandIndex = (
-  subcommands: ReadonlyArray<Command<string, unknown, unknown, unknown>>
-): Map<string, Command<string, unknown, unknown, unknown>> => new Map(subcommands.map((sub) => [sub.name, sub]))
+  subcommands: Command.Any["subcommands"]
+): Map<string, Command<string, unknown, unknown, unknown>> => {
+  const index = new Map<string, Command<string, unknown, unknown, unknown>>()
+  for (const group of subcommands) {
+    for (const subcommand of group.commands) {
+      index.set(subcommand.name, subcommand)
+    }
+  }
+  return index
+}
 
 /* ========================================================================== */
 /* Flag Accumulator                                                           */
@@ -506,7 +514,7 @@ const resolveFirstValue = (
   // Not a subcommand. Check if this looks like a typo.
   const expectsArgs = toImpl(command).config.arguments.length > 0
   if (!expectsArgs && subIndex.size > 0) {
-    const suggestions = suggest(value, command.subcommands.map((s) => s.name))
+    const suggestions = suggest(value, Array.from(subIndex.keys()))
     state.errors.push(
       new CliError.UnknownSubcommand({
         subcommand: value,

package/src/unstable/http/Headers.ts

@@ -44,22 +44,37 @@ export interface Headers extends Redactable.Redactable {
   readonly [key: string]: string
 }
 
-const Proto = Object.assign(Object.create(null), Inspectable.BaseProto, {
-  [TypeId]: TypeId,
-  [Redactable.symbolRedactable](
-    this: Headers,
-    context: ServiceMap.ServiceMap<never>
-  ): Record<string, string | Redacted.Redacted<string>> {
-    return redact(this, ServiceMap.get(context, CurrentRedactedNames))
+const Proto = Object.create(null)
+
+Object.defineProperties(Proto, {
+  [TypeId]: {
+    value: TypeId
+  },
+  [Redactable.symbolRedactable]: {
+    value(this: Headers, context: ServiceMap.ServiceMap<never>): Record<string, string | Redacted.Redacted<string>> {
+      return redact(this, ServiceMap.get(context, CurrentRedactedNames))
+    }
+  },
+  toJSON: {
+    value(this: Headers) {
+      return Redactable.redact(this)
+    }
+  },
+  [Equal.symbol]: {
+    value(this: Headers, that: Headers): boolean {
+      return Equivalence(this, that)
+    }
   },
-  toJSON() {
-    return Redactable.redact(this)
+  [Hash.symbol]: {
+    value(this: Headers): number {
+      return Hash.structure(this)
+    }
   },
-  [Equal.symbol](this: Headers, that: Headers): boolean {
-    return Equivalence(this, that)
+  toString: {
+    value: Inspectable.BaseProto.toString
   },
-  [Hash.symbol](this: Headers): number {
-    return Hash.structure(this)
+  [Inspectable.NodeInspectSymbol]: {
+    value: Inspectable.BaseProto[Inspectable.NodeInspectSymbol]
   }
 })
 

package/src/unstable/http/HttpEffect.ts

@@ -6,6 +6,7 @@ import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
 import * as Fiber from "../../Fiber.ts"
 import { dual } from "../../Function.ts"
+import { reportCauseUnsafe } from "../../internal/effect.ts"
 import * as Layer from "../../Layer.ts"
 import * as Scope from "../../Scope.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
@@ -34,6 +35,7 @@ export const toHandled = <E, R, EH, RH>(
   const handleCause = (cause: Cause<E | EH | HttpServerError>) =>
     Effect.flatMapEager(causeResponse(cause), ([response, cause]) => {
       const fiber = Fiber.getCurrent()!
+      reportCauseUnsafe(fiber, cause)
       const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest)
       const handler = fiber.getRef(PreResponseHandlers)
       const cont = cause.reasons.length === 0 ? Effect.succeed(response) : Effect.failCause(cause)
@@ -80,13 +82,16 @@ export const toHandled = <E, R, EH, RH>(
     Effect.matchCauseEffect(tracer(middleware(responded)), {
       onFailure(cause): Effect.Effect<void, EH, RH> {
         const fiber = Fiber.getCurrent()!
+        reportCauseUnsafe(fiber, cause)
         const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest)
-        if (handledSymbol in request) {
-          return Effect.void
-        }
+        if (handledSymbol in request) return Effect.void
         return Effect.matchCauseEffectEager(causeResponse(cause), {
-          onFailure: (_cause) => handleResponse(request, Response.empty({ status: 500 })),
-          onSuccess: ([response]) => handleResponse(request, response)
+          onFailure(_) {
+            return handleResponse(request, Response.empty({ status: 500 }))
+          },
+          onSuccess([response]) {
+            return handleResponse(request, response)
+          }
         })
       },
       onSuccess(response): Effect.Effect<void, EH, RH> {

package/src/unstable/http/HttpServerError.ts

@@ -4,6 +4,7 @@
 import * as Cause from "../../Cause.ts"
 import * as Data from "../../Data.ts"
 import * as Effect from "../../Effect.ts"
+import * as ErrorReporter from "../../ErrorReporter.ts"
 import type * as Exit from "../../Exit.ts"
 import { hasProperty } from "../../Predicate.ts"
 import type * as Request from "./HttpServerRequest.ts"
@@ -32,35 +33,24 @@ export class HttpServerError extends Data.TaggedError("HttpServerError")<{
     }
   }
 
-  /**
-   * @since 4.0.0
-   */
   readonly [TypeId] = TypeId
 
-  /**
-   * @since 4.0.0
-   */
   override stack = `${this.name}: ${this.message}`
 
-  /**
-   * @since 4.0.0
-   */
   get request(): Request.HttpServerRequest {
     return this.reason.request
   }
 
-  /**
-   * @since 4.0.0
-   */
   get response(): Response.HttpServerResponse | undefined {
     return "response" in this.reason ? this.reason.response : undefined
   }
 
-  /**
-   * @since 4.0.0
-   */
-  [Respondable.TypeId]() {
-    return this.reason[Respondable.TypeId]()
+  [Respondable.symbol]() {
+    return this.reason[Respondable.symbol]()
+  }
+
+  override get [ErrorReporter.ignore](): boolean {
+    return this.reason[ErrorReporter.ignore] ?? false
   }
 
   override get message(): string {
@@ -80,7 +70,7 @@ export class RequestParseError extends Data.TaggedError("RequestParseError")<{
   /**
    * @since 4.0.0
    */
-  [Respondable.TypeId]() {
+  [Respondable.symbol]() {
     return Effect.succeed(Response.empty({ status: 400 }))
   }
 
@@ -102,13 +92,12 @@ export class RouteNotFound extends Data.TaggedError("RouteNotFound")<{
   readonly description?: string
   readonly cause?: unknown
 }> implements Respondable.Respondable {
-  /**
-   * @since 4.0.0
-   */
-  [Respondable.TypeId]() {
+  [Respondable.symbol]() {
     return Effect.succeed(Response.empty({ status: 404 }))
   }
 
+  override readonly [ErrorReporter.ignore] = true
+
   get methodAndUrl() {
     return `${this.request.method} ${this.request.url}`
   }
@@ -130,7 +119,7 @@ export class InternalError extends Data.TaggedError("InternalError")<{
   /**
    * @since 4.0.0
    */
-  [Respondable.TypeId]() {
+  [Respondable.symbol]() {
     return Effect.succeed(Response.empty({ status: 500 }))
   }
 
@@ -159,10 +148,7 @@ export class ResponseError extends Data.TaggedError("ResponseError")<{
   readonly description?: string
   readonly cause?: unknown
 }> implements Respondable.Respondable {
-  /**
-   * @since 4.0.0
-   */
-  [Respondable.TypeId]() {
+  [Respondable.symbol]() {
     return Effect.succeed(Response.empty({ status: 500 }))
   }
 

package/src/unstable/http/HttpServerRespondable.ts

@@ -12,21 +12,21 @@ import * as Response from "./HttpServerResponse.ts"
  * @since 4.0.0
  * @category Type IDs
  */
-export const TypeId = "~effect/http/HttpServerRespondable"
+export const symbol = "~effect/http/HttpServerRespondable"
 
 /**
  * @since 4.0.0
  * @category models
  */
 export interface Respondable {
-  readonly [TypeId]: () => Effect.Effect<HttpServerResponse, unknown>
+  [symbol](): Effect.Effect<HttpServerResponse, unknown>
 }
 
 /**
  * @since 4.0.0
  * @category guards
  */
-export const isRespondable = (u: unknown): u is Respondable => hasProperty(u, TypeId)
+export const isRespondable = (u: unknown): u is Respondable => hasProperty(u, symbol)
 
 const badRequest = Response.empty({ status: 400 })
 const notFound = Response.empty({ status: 404 })
@@ -39,7 +39,7 @@ export const toResponse = (self: Respondable): Effect.Effect<HttpServerResponse>
   if (Response.isHttpServerResponse(self)) {
     return Effect.succeed(self)
   }
-  return Effect.orDie(self[TypeId]())
+  return Effect.orDie(self[symbol]())
 }
 
 /**
@@ -50,7 +50,7 @@ export const toResponseOrElse = (u: unknown, orElse: HttpServerResponse): Effect
   if (Response.isHttpServerResponse(u)) {
     return Effect.succeed(u)
   } else if (isRespondable(u)) {
-    return Effect.catchCause(u[TypeId](), () => Effect.succeed(orElse))
+    return Effect.catchCause(u[symbol](), () => Effect.succeed(orElse))
     // add support for some commmon types
   } else if (Schema.isSchemaError(u)) {
     return Effect.succeed(badRequest)
@@ -68,7 +68,7 @@ export const toResponseOrElseDefect = (u: unknown, orElse: HttpServerResponse):
   if (Response.isHttpServerResponse(u)) {
     return Effect.succeed(u)
   } else if (isRespondable(u)) {
-    return Effect.catchCause(u[TypeId](), () => Effect.succeed(orElse))
+    return Effect.catchCause(u[symbol](), () => Effect.succeed(orElse))
   }
   return Effect.succeed(orElse)
 }

package/src/unstable/http/HttpServerResponse.ts

@@ -2,6 +2,7 @@
  * @since 4.0.0
  */
 import * as Effect from "../../Effect.ts"
+import * as ErrorReporter from "../../ErrorReporter.ts"
 import type * as FileSystem from "../../FileSystem.ts"
 import { dual } from "../../Function.ts"
 import type * as Inspectable from "../../Inspectable.ts"
@@ -28,7 +29,7 @@ const TypeId = "~effect/http/HttpServerResponse"
  * @since 4.0.0
  * @category models
  */
-export interface HttpServerResponse extends Inspectable.Inspectable, Pipeable {
+export interface HttpServerResponse extends Inspectable.Inspectable, Pipeable, ErrorReporter.Reportable {
   readonly [TypeId]: typeof TypeId
   readonly status: number
   readonly statusText?: string | undefined
@@ -834,6 +835,7 @@ const Proto: Omit<
 > = {
   ...PipeInspectableProto,
   [TypeId]: TypeId,
+  [ErrorReporter.ignore]: true,
   toJSON(this: HttpServerResponse) {
     return {
       _id: "HttpServerResponse",

package/src/unstable/httpapi/HttpApiBuilder.ts

@@ -549,6 +549,7 @@ function handlerToRoute(
       return Response.isHttpServerResponse(response) ? response : yield* encodeSuccess(response)
     })
   ).pipe(
+    Effect.withErrorReporting,
     Effect.catch((error) => {
       if (Schema.isSchemaError(error)) {
         error = HttpApiSchemaError.fromSchemaError(error)

package/src/unstable/httpapi/HttpApiError.ts

@@ -1,6 +1,7 @@
 /**
  * @since 4.0.0
  */
+import * as ErrorReporter from "../../ErrorReporter.ts"
 import * as Schema from "../../Schema.ts"
 import * as HttpApiSchema from "./HttpApiSchema.ts"
 
@@ -21,6 +22,8 @@ export class HttpApiSchemaError extends Schema.ErrorClass<HttpApiSchemaError>("e
   static fromSchemaError(error: Schema.SchemaError): HttpApiSchemaError {
     return new HttpApiSchemaError({ message: error.message })
   }
+
+  override readonly [ErrorReporter.ignore] = true
 }
 
 /**
@@ -32,7 +35,9 @@ export class BadRequest extends Schema.ErrorClass<BadRequest>("effect/HttpApiErr
 }, {
   description: "BadRequest",
   httpApiStatus: 400
-}) {}
+}) {
+  override readonly [ErrorReporter.ignore] = true
+}
 
 /**
  * @category NoContent errors
@@ -51,7 +56,9 @@ export class Unauthorized extends Schema.ErrorClass<Unauthorized>("effect/HttpAp
 }, {
   description: "Unauthorized",
   httpApiStatus: 401
-}) {}
+}) {
+  override readonly [ErrorReporter.ignore] = true
+}
 
 /**
  * @category NoContent errors
@@ -70,7 +77,9 @@ export class Forbidden extends Schema.ErrorClass<Forbidden>("effect/HttpApiError
 }, {
   description: "Forbidden",
   httpApiStatus: 403
-}) {}
+}) {
+  override readonly [ErrorReporter.ignore] = true
+}
 
 /**
  * @category NoContent errors
@@ -89,7 +98,9 @@ export class NotFound extends Schema.ErrorClass<NotFound>("effect/HttpApiError/N
 }, {
   description: "NotFound",
   httpApiStatus: 404
-}) {}
+}) {
+  override readonly [ErrorReporter.ignore] = true
+}
 
 /**
  * @category NoContent errors
@@ -108,7 +119,9 @@ export class MethodNotAllowed extends Schema.ErrorClass<MethodNotAllowed>("effec
 }, {
   description: "MethodNotAllowed",
   httpApiStatus: 405
-}) {}
+}) {
+  override readonly [ErrorReporter.ignore] = true
+}
 
 /**
  * @category NoContent errors
@@ -127,7 +140,9 @@ export class NotAcceptable extends Schema.ErrorClass<NotAcceptable>("effect/Http
 }, {
   description: "NotAcceptable",
   httpApiStatus: 406
-}) {}
+}) {
+  override readonly [ErrorReporter.ignore] = true
+}
 
 /**
  * @category NoContent errors
@@ -146,7 +161,9 @@ export class RequestTimeout extends Schema.ErrorClass<RequestTimeout>("effect/Ht
 }, {
   description: "RequestTimeout",
   httpApiStatus: 408
-}) {}
+}) {
+  override readonly [ErrorReporter.ignore] = true
+}
 
 /**
  * @category NoContent errors
@@ -165,7 +182,9 @@ export class Conflict extends Schema.ErrorClass<Conflict>("effect/HttpApiError/C
 }, {
   description: "Conflict",
   httpApiStatus: 409
-}) {}
+}) {
+  override readonly [ErrorReporter.ignore] = true
+}
 
 /**
  * @since 4.0.0
@@ -184,7 +203,9 @@ export class Gone extends Schema.ErrorClass<Gone>("effect/HttpApiError/Gone")({
 }, {
   description: "Gone",
   httpApiStatus: 410
-}) {}
+}) {
+  override readonly [ErrorReporter.ignore] = true
+}
 
 /**
  * @category NoContent errors

package/src/unstable/observability/OtlpLogger.ts

@@ -3,6 +3,7 @@
  */
 import * as Arr from "../../Array.ts"
 import * as Cause from "../../Cause.ts"
+import { Clock } from "../../Clock.ts"
 import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import type * as Layer from "../../Layer.ts"
@@ -66,7 +67,8 @@ export const make: (
   })
 
   const opts = {
-    excludeLogSpans: options.excludeLogSpans ?? false
+    excludeLogSpans: options.excludeLogSpans ?? false,
+    clock: yield* Clock
   }
   return Logger.make((options) => {
     exporter.push(makeLogRecord(options, opts))
@@ -104,11 +106,13 @@ export interface LogsData {
 
 // internal
 
-const makeLogRecord = (options: Logger.Logger.Options<unknown>, opts: {
+const makeLogRecord = (options: Logger.Options<unknown>, opts: {
   readonly excludeLogSpans: boolean
+  readonly clock: Clock
 }): ILogRecord => {
-  const now = options.date.getTime()
-  const nanosString = `${now}000000`
+  const now = opts.clock.currentTimeNanosUnsafe()
+  const nanosString = now.toString()
+  const nowMillis = options.date.getTime()
 
   const attributes = OtlpResource.entriesToAttributes(Object.entries(options.fiber.getRef(CurrentLogAnnotations)))
   attributes.push({
@@ -119,7 +123,7 @@ const makeLogRecord = (options: Logger.Logger.Options<unknown>, opts: {
     for (const [label, startTime] of options.fiber.getRef(CurrentLogSpans)) {
       attributes.push({
         key: `logSpan.${label}`,
-        value: { stringValue: `${now - startTime}ms` }
+        value: { stringValue: `${nowMillis - startTime}ms` }
       })
     }
   }

package/src/unstable/reactivity/AtomRegistry.ts

@@ -56,6 +56,8 @@ export interface AtomRegistry {
   }) => () => void
   readonly reset: () => void
   readonly dispose: () => void
+  onNodeAdded?: ((node: Node<any>) => void) | undefined
+  onNodeRemoved?: ((node: Node<any>) => void) | undefined
 }
 
 /**
@@ -65,6 +67,10 @@ export interface AtomRegistry {
 export interface Node<A> {
   readonly atom: Atom.Atom<A>
   readonly value: () => A
+  parents: Array<Node<any>>
+  children: Array<Node<any>>
+  listeners: Set<() => void>
+  currentState(): "uninitialized" | "stale" | "valid" | "removed"
 }
 
 /**
@@ -290,6 +296,8 @@ class RegistryImpl implements AtomRegistry {
   readonly defaultIdleTTL: number | undefined
   readonly scheduler: Scheduler
   readonly schedulerAsync: Scheduler
+  onNodeAdded?: ((node: Node<any>) => void) | undefined
+  onNodeRemoved?: ((node: Node<any>) => void) | undefined
 
   constructor(
     initialValues?: Iterable<readonly [Atom.Atom<any>, any]>,
@@ -386,6 +394,7 @@ class RegistryImpl implements AtomRegistry {
     if (node === undefined) {
       node = this.createNode(atom)
       this.nodes.set(key, node)
+      this.onNodeAdded?.(node)
     } else if (this.atomHasTtl(atom)) {
       this.removeNodeTimeout(node)
     }
@@ -436,6 +445,7 @@ class RegistryImpl implements AtomRegistry {
     } else {
       this.nodes.delete(atomKey(node.atom))
       node.remove()
+      this.onNodeRemoved?.(node)
     }
   }
 
@@ -450,6 +460,7 @@ class RegistryImpl implements AtomRegistry {
       if (idleTTL <= 0) {
         this.nodes.delete(atomKey(node.atom))
         node.remove()
+        this.onNodeRemoved?.(node)
         return
       }
     }
@@ -496,6 +507,7 @@ class RegistryImpl implements AtomRegistry {
       }
       this.nodeTimeoutBucket.delete(node)
       this.nodes.delete(atomKey(node.atom))
+      this.onNodeRemoved?.(node)
       this.#currentSweepTTL = node.atom.idleTTL ?? this.defaultIdleTTL!
       node.remove()
       this.#currentSweepTTL = null
@@ -507,7 +519,10 @@ class RegistryImpl implements AtomRegistry {
     this.timeoutBuckets.clear()
     this.nodeTimeoutBucket.clear()
 
-    this.nodes.forEach((node) => node.remove())
+    this.nodes.forEach((node) => {
+      node.remove()
+      this.onNodeRemoved?.(node)
+    })
     this.nodes.clear()
   }
 
@@ -554,6 +569,19 @@ class NodeImpl<A> {
   listeners: Set<() => void> = new Set()
   skipInvalidation = false
 
+  currentState() {
+    switch (this.state) {
+      case NodeState.uninitialized:
+        return "uninitialized"
+      case NodeState.stale:
+        return "stale"
+      case NodeState.valid:
+        return "valid"
+      default:
+        return "removed"
+    }
+  }
+
   get canBeRemoved(): boolean {
     return !this.atom.keepAlive && this.listeners.size === 0 && this.children.length === 0 && this.state !== 0
   }

package/src/unstable/rpc/RpcServer.ts

@@ -8,6 +8,7 @@ import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
 import * as Fiber from "../../Fiber.ts"
 import { constant, constTrue, constVoid, identity } from "../../Function.ts"
+import { reportCauseUnsafe } from "../../internal/effect.ts"
 import * as Latch from "../../Latch.ts"
 import * as Layer from "../../Layer.ts"
 import type * as Option from "../../Option.ts"
@@ -273,6 +274,9 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
           requestId: request.id,
           exit
         })
+      if (exit._tag === "Failure") {
+        reportCauseUnsafe(Fiber.getCurrent()!, exit.cause)
+      }
       return close ? Effect.ensuring(write, close) : write
     })
     if (enableTracing) {