effect 4.0.0-beta.83 → 4.0.0-beta.85

package/src/internal/stackTraceLimit.ts

@@ -0,0 +1,63 @@
+/**
+ * Utility for safely manipulating `Error.stackTraceLimit` in environments
+ * where intrinsics may be frozen (e.g., SES / hardened JavaScript or
+ * deterministic sandboxes such as Temporal). When the property is non-writable,
+ * mutating it throws, so all manipulation here degrades to a best-effort,
+ * silent no-op.
+ *
+ * Mirrors the guard Node uses internally:
+ * https://github.com/nodejs/node/blob/e77694631f1642c302f664703197b5aabc65b482/lib/internal/errors.js#L246
+ *
+ * The error is constructed inline at each call site (rather than inside a
+ * closure here) so the captured stack trace keeps pointing at the real caller
+ * instead of this module.
+ *
+ * @internal
+ */
+import type { ErrorWithStackTraceLimit } from "./tracer.ts"
+
+const ObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor
+const ObjectPrototypeHasOwnProperty = Object.prototype.hasOwnProperty
+const ObjectIsExtensible = Object.isExtensible
+
+/**
+ * Check if `Error.stackTraceLimit` is writable.
+ * Returns `false` if the property is frozen, non-writable, or `Error` is non-extensible.
+ *
+ * @internal
+ */
+export const isStackTraceLimitWritable = (): boolean => {
+  const desc = ObjectGetOwnPropertyDescriptor(Error, "stackTraceLimit")
+  if (desc === undefined) {
+    return ObjectIsExtensible(Error)
+  }
+
+  return ObjectPrototypeHasOwnProperty.call(desc, "writable")
+    ? desc.writable === true
+    : desc.set !== undefined
+}
+
+// Cache the check result since it won't change during runtime
+const canWriteStackTraceLimit = isStackTraceLimitWritable()
+
+/**
+ * Get the current `Error.stackTraceLimit` value.
+ * Returns `undefined` if the property doesn't exist.
+ *
+ * @internal
+ */
+export const getStackTraceLimit = (): number | undefined => (Error as ErrorWithStackTraceLimit).stackTraceLimit
+
+/**
+ * Safely set `Error.stackTraceLimit` if possible, otherwise no-op.
+ *
+ * Accepts `undefined` so a value read via {@link getStackTraceLimit} can be
+ * restored faithfully.
+ *
+ * @internal
+ */
+export const setStackTraceLimit = (value: number | undefined): void => {
+  if (canWriteStackTraceLimit) {
+    ;(Error as ErrorWithStackTraceLimit).stackTraceLimit = value
+  }
+}

package/src/internal/tracer.ts

@@ -1,4 +1,5 @@
 import type * as Tracer from "../Tracer.ts"
+import { getStackTraceLimit, setStackTraceLimit } from "./stackTraceLimit.ts"
 
 export interface ErrorWithStackTraceLimit {
   stackTraceLimit?: number | undefined
@@ -13,10 +14,10 @@ export const addSpanStackTrace = <A extends Tracer.TraceOptions>(
   } else if (options?.captureStackTrace !== undefined && typeof options.captureStackTrace !== "boolean") {
     return options
   }
-  const limit = (Error as ErrorWithStackTraceLimit).stackTraceLimit
-  ;(Error as ErrorWithStackTraceLimit).stackTraceLimit = 3
+  const limit = getStackTraceLimit()
+  setStackTraceLimit(3)
   const traceError = new Error()
-  ;(Error as ErrorWithStackTraceLimit).stackTraceLimit = limit
+  setStackTraceLimit(limit)
   return {
     ...options,
     captureStackTrace: spanCleaner(() => traceError.stack)

package/src/testing/TestSchema.ts

@@ -154,7 +154,7 @@ export class Asserts<S extends Schema.Top> {
    *
    * FastCheck generates arbitrary values matching the schema's `Type`. The assertion fails if any generated value does not round-trip. Pass `options.params` to control FastCheck parameters such as `numRuns`.
    *
-   * **Example** (Round-trip verification)
+   * **Example** (Verifying round trips)
    *
    * ```ts
    * import { Schema } from "effect"
@@ -338,7 +338,7 @@ export class Decoding<S extends Schema.Top> {
    *
    * Use to verify successful decoding for one input case.
    *
-   * **Example** (Identity and transformed decoding)
+   * **Example** (Testing identity and transformed decoding)
    *
    * ```ts
    * import { Schema } from "effect"
@@ -478,7 +478,7 @@ export class Encoding<S extends Schema.Top> {
    *
    * Use to verify successful encoding for one input case.
    *
-   * **Example** (Identity and transformed encoding)
+   * **Example** (Testing identity and transformed encoding)
    *
    * ```ts
    * import { Schema } from "effect"

package/src/unstable/ai/AiError.ts

@@ -181,7 +181,7 @@ export class NetworkError extends Schema.ErrorClass<NetworkError>(
  * Provider-specific metadata is namespaced by provider name. Each provider
  * value can contain arbitrary mutable JSON metadata or `null`.
  *
- * **Example** (Metadata shape)
+ * **Example** (Inspecting metadata shape)
  *
  * ```ts
  * const metadata = {

package/src/unstable/ai/Chat.ts

@@ -46,7 +46,7 @@ import type * as Tool from "./Tool.ts"
  * enabling persistent conversational AI interactions with full context
  * management.
  *
- * **Example** (Using the Chat service)
+ * **Example** (Accessing the Chat service)
  *
  * ```ts
  * import { Effect } from "effect"

package/src/unstable/ai/Tool.ts

@@ -14,6 +14,7 @@
 import * as Context from "../../Context.ts"
 import type * as Effect from "../../Effect.ts"
 import { constFalse, constTrue, identity } from "../../Function.ts"
+import * as StackTraceLimit from "../../internal/stackTraceLimit.ts"
 import type * as JsonSchema from "../../JsonSchema.ts"
 import { pipeArguments } from "../../Pipeable.ts"
 import * as Predicate from "../../Predicate.ts"
@@ -1997,12 +1998,12 @@ function filter(obj: any) {
  */
 export const unsafeSecureJsonParse = (text: string): unknown => {
   // Performance optimization, see https://github.com/fastify/secure-json-parse/pull/90
-  const { stackTraceLimit } = Error
-  Error.stackTraceLimit = 0
+  const prevLimit = StackTraceLimit.getStackTraceLimit()
+  StackTraceLimit.setStackTraceLimit(0)
   try {
     return _parse(text)
   } finally {
-    Error.stackTraceLimit = stackTraceLimit
+    StackTraceLimit.setStackTraceLimit(prevLimit)
   }
 }
 

package/src/unstable/cli/Prompt.ts

@@ -1422,7 +1422,7 @@ const runLoop = Effect.fnUntraced(
       yield* Effect.orDie(terminal.display(msg))
       if (loop.events) {
         const takeInput = Queue.take(input).pipe(
-          Effect.map((event) => ({ _tag: "Input" as const, event }))
+          Effect.map((input) => ({ _tag: "Input" as const, input }))
         )
         const result = yield* Effect.raceFirst(
           takeInput,

package/src/unstable/httpapi/HttpApiMiddleware.ts

@@ -15,6 +15,7 @@
 /** @effect-diagnostics classSelfMismatch:off */
 import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
+import { getStackTraceLimit, setStackTraceLimit } from "../../internal/stackTraceLimit.ts"
 import * as Layer from "../../Layer.ts"
 import { hasProperty } from "../../Predicate.ts"
 import type * as Schema from "../../Schema.ts"
@@ -352,10 +353,10 @@ export const Service = <
   } | undefined
 ) => {
   const Err = globalThis.Error as any
-  const limit = Err.stackTraceLimit
-  Err.stackTraceLimit = 2
+  const limit = getStackTraceLimit()
+  setStackTraceLimit(2)
   const creationError = new Err()
-  Err.stackTraceLimit = limit
+  setStackTraceLimit(limit)
 
   class Service extends Context.Service<Self, any>()(id) {}
   const self = Service as any

package/src/unstable/httpapi/HttpApiScalar.ts

@@ -87,7 +87,7 @@ export type ScalarConfig = {
   /**
    * Path to a favicon image.
    *
-   * **Example** (Relative favicon)
+   * **Example** (Setting a relative favicon)
    *
    * ```ts
    * const favicon = "/favicon.svg"
@@ -107,7 +107,7 @@ export type ScalarConfig = {
    * Browsers can derive the origin from `window.location.origin`; server
    * rendering needs this value supplied explicitly.
    *
-   * **Example** (Local server URL)
+   * **Example** (Setting a local server URL)
    *
    * ```ts
    * const baseServerURL = "http://localhost:3000"

package/src/unstable/persistence/PersistedQueue.ts

@@ -508,7 +508,7 @@ export const makeStoreRedis = Effect.fnUntraced(function*(
             id,
             JSON.stringify({ id, element, attempts: 0 })
           )
-          : redis.send("LPUSH", `${prefix}${name}`, JSON.stringify({ id, element, attempts: 0 })),
+          : redis.send("RPUSH", `${prefix}${name}`, JSON.stringify({ id, element, attempts: 0 })),
         ({ cause }) =>
           new PersistedQueueError({
             message: "Failed to offer element to persisted queue",

package/src/unstable/rpc/Rpc.ts

@@ -955,7 +955,7 @@ export const make = <
 /**
  * Creates a custom `Rpc` constructor that can transform the output schemas.
  *
- * **Example** (Paginated RPC constructor)
+ * **Example** (Defining a paginated RPC constructor)
  *
  * ```ts
  * import { Schema } from "effect"

package/src/unstable/rpc/RpcGroup.ts

@@ -303,14 +303,13 @@ const RpcGroupProto = {
       const services = yield* Effect.context<never>()
       const handlers = Effect.isEffect(build) ? yield* build : build
       const contextMap = new Map<string, unknown>()
-      for (const [tag, handler] of Object.entries(handlers)) {
-        const rpc = self.requests.get(tag)!
+      self.requests.forEach((rpc, tag) => {
         contextMap.set(rpc.key, {
           tag: rpc._tag,
-          handler,
+          handler: handlers[tag],
           context: services
         })
-      }
+      })
       return Context.makeUnsafe(contextMap)
     })
   },

package/src/unstable/rpc/RpcMiddleware.ts

@@ -11,6 +11,7 @@
  */
 import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
+import { getStackTraceLimit, setStackTraceLimit } from "../../internal/stackTraceLimit.ts"
 import * as Layer from "../../Layer.ts"
 import * as Schema from "../../Schema.ts"
 import { Scope } from "../../Scope.ts"
@@ -292,10 +293,10 @@ export const Service = <
   }
 ) => {
   const Err = globalThis.Error as any
-  const limit = Err.stackTraceLimit
-  Err.stackTraceLimit = 2
+  const limit = getStackTraceLimit()
+  setStackTraceLimit(2)
   const creationError = new Err()
-  Err.stackTraceLimit = limit
+  setStackTraceLimit(limit)
 
   function ServiceClass() {}
   const ServiceClass_ = ServiceClass as any as Mutable<AnyService>

package/src/unstable/sql/SqlResolver.ts

@@ -17,6 +17,7 @@ import * as Equal from "../../Equal.ts"
 import * as Exit from "../../Exit.ts"
 import * as Hash from "../../Hash.ts"
 import * as MutableHashMap from "../../MutableHashMap.ts"
+import * as Option from "../../Option.ts"
 import * as Request from "../../Request.ts"
 import * as RequestResolver from "../../RequestResolver.ts"
 import * as Schema from "../../Schema.ts"
@@ -376,8 +377,20 @@ const partitionRequestsById = function*<In, A, E, R, InE>(
 
   for (let i = 0; i < len; i++) {
     entry = requests[i]
-    yield (Effect.provideContext(handle(encode(entry.request.payload)), entry.context) as Effect.Effect<void>)
-    MutableHashMap.set(byIdMap, entry.request.payload, entry)
+    const existing = MutableHashMap.get(byIdMap, entry.request.payload)
+    if (Option.isSome(existing)) {
+      const duplicate = entry
+      MutableHashMap.set(byIdMap, entry.request.payload, {
+        ...existing.value,
+        completeUnsafe(exit) {
+          existing.value.completeUnsafe(exit)
+          duplicate.completeUnsafe(exit)
+        }
+      })
+    } else {
+      yield (Effect.provideContext(handle(encode(entry.request.payload)), entry.context) as Effect.Effect<void>)
+      MutableHashMap.set(byIdMap, entry.request.payload, entry)
+    }
   }
 
   return [inputs, byIdMap] as const

package/src/unstable/workflow/Activity.ts

@@ -49,6 +49,7 @@ export interface Activity<
   readonly successSchema: Success
   readonly errorSchema: Error
   readonly exitSchema: Schema.Exit<Success, Error, Schema.Defect>
+  readonly exitSchemaPartial: Schema.Exit<Success, Error, Schema.Unknown>
   readonly annotations: Context.Context<never>
   annotate<I, S>(
     key: Context.Key<I, S>,
@@ -153,6 +154,7 @@ export const make = <
     successSchema,
     errorSchema,
     exitSchema: Schema.Exit(successSchemaJson, errorSchemaJson, Schema.Defect()),
+    exitSchemaPartial: Schema.Exit(successSchemaJson, errorSchemaJson, Schema.Unknown),
     annotations: options.annotations ?? Context.empty(),
     annotate(tag: Context.Key<any, any>, value: any) {
       return make({

package/src/unstable/workflow/WorkflowEngine.ts

@@ -478,7 +478,7 @@ export const makeUnsafe = (options: Encoded): WorkflowEngine["Service"] =>
         return result
       }
       const exit = yield* Effect.orDie(
-        Schema.decodeEffect(activity.exitSchema)(toJsonExit(result.exit))
+        Schema.decodeEffect(activity.exitSchemaPartial)(toJsonExit(result.exit))
       )
       return new Workflow.Complete({ exit })
     }),