effect 4.0.0-beta.84 → 4.0.0-beta.85

package/src/internal/schema/arbitrary.ts

@@ -382,6 +382,18 @@ function oneOf<T>(fc: typeof FastCheck, arbitraries: ReadonlyArray<FastCheck.Arb
   return arbitraries.length === 0 ? undefined : arbitraries.length === 1 ? arbitraries[0] : fc.oneof(...arbitraries)
 }
 
+const finiteNumberConstraint: Constraint = {
+  noInfinity: true,
+  noNaN: true
+}
+
+function finiteNumberContext(ctx: Context): Context {
+  return {
+    ...ctx,
+    constraint: finiteNumberConstraint
+  }
+}
+
 function reportChecks(report: MutableReport, checks: SchemaAST.Checks | undefined, path: ReadonlyArray<PropertyKey>) {
   function visit(check: SchemaAST.Check<any>, covered: boolean) {
     const arbitrary = check.annotations?.arbitrary
@@ -430,6 +442,9 @@ export function collectReport(ast: SchemaAST.AST, report: MutableReport) {
       case "Union":
         ast.types.forEach((type) => visit(type, path))
         break
+      case "TemplateLiteral":
+        ast.parts.forEach((part, i) => visit(SchemaAST.toEncoded(part), [...path, i]))
+        break
       case "Suspend":
         visit(ast.thunk(), path)
         break
@@ -605,8 +620,14 @@ function base(ast: SchemaAST.AST, path: ReadonlyArray<PropertyKey>): LazyArbitra
       return same((fc) => fc.oneof(fc.object(), fc.array(fc.anything())))
     case "Enum":
       return recur(SchemaAST.enumsToLiterals(ast), path)
-    case "TemplateLiteral":
-      return same((fc) => fc.stringMatching(SchemaAST.getTemplateLiteralRegExp(ast)))
+    case "TemplateLiteral": {
+      const parts = ast.parts.map((part, i) => recur(SchemaAST.toEncoded(part), [...path, i]))
+      return same((fc, ctx, recursionStack) =>
+        fc.tuple(...parts.map((part) => part(fc, finiteNumberContext(ctx), recursionStack))).map((segments) =>
+          segments.map((segment) => globalThis.String(segment)).join("")
+        )
+      )
+    }
     case "Arrays": {
       const elements = ast.elements.map((ast, i) => ({
         ast,

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/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/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/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/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>