work with frozen intrinsics

Author: arlyon

packages/ai/ai/src/Tool.ts

@@ -1499,6 +1499,33 @@ function filter(obj: any) {
   return obj
 }
 
+// Utility for safely manipulating Error.stackTraceLimit in environments
+// where intrinsics may be frozen (e.g., SES/hardened JavaScript)
+const isStackTraceLimitWritable = (): boolean => {
+  const desc = Object.getOwnPropertyDescriptor(Error, "stackTraceLimit")
+  if (desc === undefined) {
+    return Object.isExtensible(Error)
+  }
+  return Object.prototype.hasOwnProperty.call(desc, "writable")
+    ? desc.writable === true
+    : desc.set !== undefined
+}
+
+const canWriteStackTraceLimit = isStackTraceLimitWritable()
+
+const withStackTraceLimit = <T>(limit: number, fn: () => T): T => {
+  if (!canWriteStackTraceLimit) {
+    return fn()
+  }
+  const prevLimit = Error.stackTraceLimit
+  try {
+    Error.stackTraceLimit = limit
+    return fn()
+  } finally {
+    Error.stackTraceLimit = prevLimit
+  }
+}
+
 /**
  * **Unsafe**: This function will throw an error if an insecure property is
  * found in the parsed JSON or if the provided JSON text is not parseable.
@@ -1508,11 +1535,5 @@ 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
-  try {
-    return _parse(text)
-  } finally {
-    Error.stackTraceLimit = stackTraceLimit
-  }
+  return withStackTraceLimit(0, () => _parse(text))
 }

packages/effect/src/Effect.ts

@@ -40,6 +40,7 @@ import * as option_ from "./internal/option.js"
 import * as query from "./internal/query.js"
 import * as runtime_ from "./internal/runtime.js"
 import * as schedule_ from "./internal/schedule.js"
+import * as StackTraceLimit from "./internal/stackTraceLimit.js"
 import * as internalTracer from "./internal/tracer.js"
 import type * as Layer from "./Layer.js"
 import type * as LogLevel from "./LogLevel.js"
@@ -13509,10 +13510,7 @@ export const Tag: <const Id extends string>(id: Id) => <
       : [X] extends [PromiseLike<infer A>] ? Effect<A, Cause.UnknownException, Self>
       : Effect<X, never, Self>
   } = (id) => () => {
-    const limit = Error.stackTraceLimit
-    Error.stackTraceLimit = 2
-    const creationError = new Error()
-    Error.stackTraceLimit = limit
+    const creationError = StackTraceLimit.withStackTraceLimit(2, () => new Error())
     function TagClass() {}
     Object.setPrototypeOf(TagClass, TagProto)
     TagClass.key = id
@@ -13668,10 +13666,7 @@ export const Service: <Self = never>() => [Self] extends [never] ? MissingSelfGe
   return function() {
     const [id, maker] = arguments
     const proxy = "accessors" in maker ? maker["accessors"] : false
-    const limit = Error.stackTraceLimit
-    Error.stackTraceLimit = 2
-    const creationError = new Error()
-    Error.stackTraceLimit = limit
+    const creationError = StackTraceLimit.withStackTraceLimit(2, () => new Error())
 
     let patchState: "unchecked" | "plain" | "patched" = "unchecked"
     const TagClass: any = function(this: any, service: any) {
@@ -14628,16 +14623,10 @@ export const fn:
     name: string,
     options?: Tracer.SpanOptions
   ) => fn.Gen & fn.NonGen) = function(nameOrBody: Function | string, ...pipeables: Array<any>) {
-    const limit = Error.stackTraceLimit
-    Error.stackTraceLimit = 2
-    const errorDef = new Error()
-    Error.stackTraceLimit = limit
+    const errorDef = StackTraceLimit.withStackTraceLimit(2, () => new Error())
     if (typeof nameOrBody !== "string") {
       return defineLength(nameOrBody.length, function(this: any, ...args: Array<any>) {
-        const limit = Error.stackTraceLimit
-        Error.stackTraceLimit = 2
-        const errorCall = new Error()
-        Error.stackTraceLimit = limit
+        const errorCall = StackTraceLimit.withStackTraceLimit(2, () => new Error())
         return fnApply({
           self: this,
           body: nameOrBody,
@@ -14659,10 +14648,7 @@ export const fn:
         body.length,
         ({
           [name](this: any, ...args: Array<any>) {
-            const limit = Error.stackTraceLimit
-            Error.stackTraceLimit = 2
-            const errorCall = new Error()
-            Error.stackTraceLimit = limit
+            const errorCall = StackTraceLimit.withStackTraceLimit(2, () => new Error())
             return fnApply({
               self: this,
               body,

packages/effect/src/Micro.ts

@@ -21,6 +21,7 @@ import { format, NodeInspectSymbol, toStringUnknown } from "./Inspectable.js"
 import * as InternalContext from "./internal/context.js"
 import * as doNotation from "./internal/doNotation.js"
 import { StructuralPrototype } from "./internal/effectable.js"
+import * as StackTraceLimit from "./internal/stackTraceLimit.js"
 import * as Option from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
 import { pipeArguments } from "./Pipeable.js"
@@ -2984,10 +2985,7 @@ export const withTrace: {
   (name: string): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, R>
   <A, E, R>(self: Micro<A, E, R>, name: string): Micro<A, E, R>
 } = function() {
-  const prevLimit = globalThis.Error.stackTraceLimit
-  globalThis.Error.stackTraceLimit = 2
-  const error = new globalThis.Error()
-  globalThis.Error.stackTraceLimit = prevLimit
+  const error = StackTraceLimit.withStackTraceLimit(2, () => new globalThis.Error())
   function generate(name: string, cause: MicroCause<any>) {
     const stack = error.stack
     if (!stack) {

packages/effect/src/internal/cause.ts

@@ -17,6 +17,7 @@ import type { AnySpan, Span } from "../Tracer.js"
 import type { NoInfer } from "../Types.js"
 import { getBugErrorMessage } from "./errors.js"
 import * as OpCodes from "./opCodes/cause.js"
+import * as StackTraceLimit from "./stackTraceLimit.js"
 
 // -----------------------------------------------------------------------------
 // Models
@@ -900,8 +901,8 @@ export class PrettyError extends globalThis.Error implements Cause.PrettyError {
   span: undefined | Span = undefined
   constructor(originalError: unknown) {
     const originalErrorIsObject = typeof originalError === "object" && originalError !== null
-    const prevLimit = Error.stackTraceLimit
-    Error.stackTraceLimit = 1
+    const prevLimit = StackTraceLimit.getStackTraceLimit()
+    StackTraceLimit.setStackTraceLimit(1)
     super(
       prettyErrorMessage(originalError),
       originalErrorIsObject && "cause" in originalError && typeof originalError.cause !== "undefined"
@@ -911,7 +912,9 @@ export class PrettyError extends globalThis.Error implements Cause.PrettyError {
     if (this.message === "") {
       this.message = "An error has occurred"
     }
-    Error.stackTraceLimit = prevLimit
+    if (prevLimit !== undefined) {
+      StackTraceLimit.setStackTraceLimit(prevLimit)
+    }
     this.name = originalError instanceof Error ? originalError.name : "Error"
     if (originalErrorIsObject) {
       if (spanSymbol in originalError) {

packages/effect/src/internal/context.ts

@@ -12,6 +12,7 @@ import type * as STM from "../STM.js"
 import type { NoInfer } from "../Types.js"
 import { EffectPrototype, effectVariance } from "./effectable.js"
 import * as option from "./option.js"
+import * as StackTraceLimit from "./stackTraceLimit.js"
 
 /** @internal */
 export const TagTypeId: C.TagTypeId = Symbol.for("effect/Context/Tag") as C.TagTypeId
@@ -67,10 +68,7 @@ export const ReferenceProto: any = {
 
 /** @internal */
 export const makeGenericTag = <Identifier, Service = Identifier>(key: string): C.Tag<Identifier, Service> => {
-  const limit = Error.stackTraceLimit
-  Error.stackTraceLimit = 2
-  const creationError = new Error()
-  Error.stackTraceLimit = limit
+  const creationError = StackTraceLimit.withStackTraceLimit(2, () => new Error())
   const tag = Object.create(TagProto)
   Object.defineProperty(tag, "stack", {
     get() {
@@ -83,10 +81,7 @@ export const makeGenericTag = <Identifier, Service = Identifier>(key: string): C
 
 /** @internal */
 export const Tag = <const Id extends string>(id: Id) => <Self, Shape>(): C.TagClass<Self, Id, Shape> => {
-  const limit = Error.stackTraceLimit
-  Error.stackTraceLimit = 2
-  const creationError = new Error()
-  Error.stackTraceLimit = limit
+  const creationError = StackTraceLimit.withStackTraceLimit(2, () => new Error())
 
   function TagClass() {}
   Object.setPrototypeOf(TagClass, TagProto)
@@ -104,10 +99,7 @@ export const Reference = <Self>() =>
 <const Id extends string, Service>(id: Id, options: {
   readonly defaultValue: () => Service
 }): C.ReferenceClass<Self, Id, Service> => {
-  const limit = Error.stackTraceLimit
-  Error.stackTraceLimit = 2
-  const creationError = new Error()
-  Error.stackTraceLimit = limit
+  const creationError = StackTraceLimit.withStackTraceLimit(2, () => new Error())
 
   function ReferenceClass() {}
   Object.setPrototypeOf(ReferenceClass, ReferenceProto)

packages/effect/src/internal/core-effect.ts

@@ -38,6 +38,7 @@ import * as fiberRefsPatch from "./fiberRefs/patch.js"
 import type { FiberRuntime } from "./fiberRuntime.js"
 import * as metricLabel from "./metric/label.js"
 import * as runtimeFlags from "./runtimeFlags.js"
+import * as StackTraceLimit from "./stackTraceLimit.js"
 import * as internalTracer from "./tracer.js"
 
 /* @internal */
@@ -2241,10 +2242,7 @@ export const functionWithSpan = <Args extends Array<any>, Ret extends Effect.Eff
   (function(this: any) {
     let captureStackTrace: LazyArg<string | undefined> | boolean = options.captureStackTrace ?? false
     if (options.captureStackTrace !== false) {
-      const limit = Error.stackTraceLimit
-      Error.stackTraceLimit = 2
-      const error = new Error()
-      Error.stackTraceLimit = limit
+      const error = StackTraceLimit.withStackTraceLimit(2, () => new Error())
       let cache: false | string = false
       captureStackTrace = () => {
         if (cache !== false) {

packages/effect/src/internal/layer.ts

@@ -33,6 +33,7 @@ import * as OpCodes from "./opCodes/layer.js"
 import * as ref from "./ref.js"
 import * as runtime from "./runtime.js"
 import * as runtimeFlags from "./runtimeFlags.js"
+import * as StackTraceLimit from "./stackTraceLimit.js"
 import * as synchronized from "./synchronizedRef.js"
 import * as tracer from "./tracer.js"
 
@@ -693,10 +694,10 @@ const mockImpl = <I, S extends object>(tag: Context.Tag<I, S>, service: Layer.Pa
         if (prop in target) {
           return target[prop as keyof S]
         }
-        const prevLimit = Error.stackTraceLimit
-        Error.stackTraceLimit = 2
-        const error = new Error(`${tag.key}: Unimplemented method "${prop.toString()}"`)
-        Error.stackTraceLimit = prevLimit
+        const error = StackTraceLimit.withStackTraceLimit(
+          2,
+          () => new Error(`${tag.key}: Unimplemented method "${prop.toString()}"`)
+        )
         error.name = "UnimplementedError"
         return makeUnimplemented(error)
       },

packages/effect/src/internal/runtime.ts

@@ -23,6 +23,7 @@ import * as executionStrategy from "./executionStrategy.js"
 import * as FiberRuntime from "./fiberRuntime.js"
 import * as fiberScope from "./fiberScope.js"
 import * as OpCodes from "./opCodes/effect.js"
+import * as StackTraceLimit from "./stackTraceLimit.js"
 import * as runtimeFlags from "./runtimeFlags.js"
 import * as supervisor_ from "./supervisor.js"
 
@@ -179,11 +180,7 @@ class AsyncFiberExceptionImpl<A, E = never> extends Error implements Runtime.Asy
 }
 
 const asyncFiberException = <A, E>(fiber: Fiber.RuntimeFiber<A, E>): Runtime.AsyncFiberException<A, E> => {
-  const limit = Error.stackTraceLimit
-  Error.stackTraceLimit = 0
-  const error = new AsyncFiberExceptionImpl(fiber)
-  Error.stackTraceLimit = limit
-  return error
+  return StackTraceLimit.withStackTraceLimit(0, () => new AsyncFiberExceptionImpl(fiber))
 }
 
 /** @internal */
@@ -230,11 +227,7 @@ class FiberFailureImpl extends Error implements Runtime.FiberFailure {
 
 /** @internal */
 export const fiberFailure = <E>(cause: Cause.Cause<E>): Runtime.FiberFailure => {
-  const limit = Error.stackTraceLimit
-  Error.stackTraceLimit = 0
-  const error = new FiberFailureImpl(cause)
-  Error.stackTraceLimit = limit
-  return error
+  return StackTraceLimit.withStackTraceLimit(0, () => new FiberFailureImpl(cause))
 }
 
 /** @internal */

packages/effect/src/internal/stackTraceLimit.ts

@@ -0,0 +1,66 @@
+/**
+ * Utility for safely manipulating Error.stackTraceLimit in environments
+ * where intrinsics may be frozen (e.g., SES/hardened JavaScript).
+ * @internal
+ */
+
+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()
+
+/**
+ * Safely set Error.stackTraceLimit if possible, otherwise no-op.
+ * @internal
+ */
+export const setStackTraceLimit = (value: number): void => {
+  if (canWriteStackTraceLimit) {
+    Error.stackTraceLimit = value
+  }
+}
+
+/**
+ * Get the current Error.stackTraceLimit value.
+ * Returns undefined if the property doesn't exist.
+ * @internal
+ */
+export const getStackTraceLimit = (): number | undefined => {
+  return Error.stackTraceLimit
+}
+
+/**
+ * Execute a function with a temporarily modified Error.stackTraceLimit.
+ * If the limit cannot be modified (frozen intrinsics), executes the function without modification.
+ * @internal
+ */
+export const withStackTraceLimit = <T>(limit: number, fn: () => T): T => {
+  if (!canWriteStackTraceLimit) {
+    return fn()
+  }
+
+  const prevLimit = Error.stackTraceLimit
+  try {
+    Error.stackTraceLimit = limit
+    return fn()
+  } finally {
+    Error.stackTraceLimit = prevLimit
+  }
+}

packages/effect/src/internal/tracer.ts

@@ -6,6 +6,7 @@ import type * as Exit from "../Exit.js"
 import { constFalse } from "../Function.js"
 import type * as Option from "../Option.js"
 import type * as Tracer from "../Tracer.js"
+import * as StackTraceLimit from "./stackTraceLimit.js"
 
 /** @internal */
 export const TracerTypeId: Tracer.TracerTypeId = Symbol.for("effect/Tracer") as Tracer.TracerTypeId
@@ -122,10 +123,7 @@ export const addSpanStackTrace = (options: Tracer.SpanOptions | undefined): Trac
   } else if (options?.captureStackTrace !== undefined && typeof options.captureStackTrace !== "boolean") {
     return options
   }
-  const limit = Error.stackTraceLimit
-  Error.stackTraceLimit = 3
-  const traceError = new Error()
-  Error.stackTraceLimit = limit
+  const traceError = StackTraceLimit.withStackTraceLimit(3, () => new Error())
   let cache: false | string = false
   return {
     ...options,