effect 4.0.0-beta.103 → 4.0.0-beta.105

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "effect",
   "type": "module",
-  "version": "4.0.0-beta.103",
+  "version": "4.0.0-beta.105",
   "license": "MIT",
   "description": "The missing standard library for TypeScript, for writing production-grade software.",
   "homepage": "https://effect.website",
@@ -60,14 +60,16 @@
     "dist/**/*.js",
     "dist/**/*.js.map",
     "dist/**/*.d.ts",
-    "dist/**/*.d.ts.map"
+    "dist/**/*.d.ts.map",
+    "AGENTS.md",
+    "CLAUDE.md",
+    "ai-docs/**/*"
   ],
   "publishConfig": {
     "access": "public",
     "provenance": true
   },
   "devDependencies": {
-    "@types/ini": "^4.1.1",
     "@types/node": "^26.1.2",
     "ajv": "^8.20.0",
     "ajv-draft-04": "^1.0.0",
@@ -79,14 +81,9 @@
   "dependencies": {
     "@standard-schema/spec": "^1.1.0",
     "fast-check": "^4.9.0",
-    "find-my-way-ts": "^0.1.6",
-    "ini": "^7.0.0",
     "kubernetes-types": "^1.30.0",
     "msgpackr": "^2.0.4",
-    "multipasta": "^0.2.8",
-    "toml": "^4.1.2",
-    "uuid": "^14.0.1",
-    "yaml": "^2.9.0"
+    "uuid": "^14.0.1"
   },
   "scripts": {
     "codegen": "effect-utils codegen",

package/src/Brand.ts

@@ -12,7 +12,7 @@ import * as Option from "./Option.ts"
 import * as Result from "./Result.ts"
 import type * as Schema from "./Schema.ts"
 import * as SchemaAST from "./SchemaAST.ts"
-import type * as SchemaIssue from "./SchemaIssue.ts"
+import * as SchemaIssue from "./SchemaIssue.ts"
 import type * as Types from "./Types.ts"
 
 const TypeId = "~effect/Brand"
@@ -92,8 +92,8 @@ export interface Constructor<in out B extends Brand<any>> {
  *
  * **Details**
  *
- * The error wraps a `SchemaIssue.Issue`, exposes `message` through
- * `issue.toString()`, and formats as `BrandError(<message>)`.
+ * The error wraps a `SchemaIssue.Issue`, renders `message` with the default
+ * schema issue formatter, and formats as `BrandError(<message>)`.
  *
  * **Gotchas**
  *
@@ -131,7 +131,7 @@ export class BrandError {
    * @since 4.0.0
    */
   get message() {
-    return this.issue.toString()
+    return SchemaIssue.defaultFormatter(this.issue)
   }
   /**
    * Formats the brand error together with its validation message.

package/src/Cache.ts

@@ -305,7 +305,7 @@ export const make = <
 > =>
   makeWith<Key, A, E, R, ServiceMode>(options.lookup, {
     ...options,
-    timeToLive: options.timeToLive ? () => options.timeToLive! : defaultTimeToLive
+    timeToLive: options.timeToLive !== undefined ? () => options.timeToLive! : defaultTimeToLive
   })
 
 const Proto = {

package/src/Channel.ts

@@ -10830,7 +10830,7 @@ export const bindTo: {
  */
 export const runCount = <OutElem, OutErr, OutDone, Env>(
   self: Channel<OutElem, OutErr, OutDone, unknown, unknown, unknown, Env>
-): Effect.Effect<void, OutErr, Env> => runFold(self, () => 0, (acc) => acc + 1)
+): Effect.Effect<number, OutErr, Env> => runFold(self, () => 0, (acc) => acc + 1)
 
 /**
  * Runs a channel and discards all output elements, returning only the final result.

package/src/Config.ts

@@ -17,6 +17,7 @@ import * as LogLevel_ from "./LogLevel.ts"
 import * as Option from "./Option.ts"
 import * as Predicate from "./Predicate.ts"
 import * as Rec from "./Record.ts"
+import * as Result from "./Result.ts"
 import * as Schema from "./Schema.ts"
 import * as SchemaAST from "./SchemaAST.ts"
 import * as SchemaGetter from "./SchemaGetter.ts"
@@ -193,13 +194,15 @@ const evaluationFailure = (error: ConfigError, hasInput: boolean): EvaluationFai
   hasInput
 })
 
+const isSourceError = (u: unknown): u is ConfigProvider.SourceError => Predicate.isTagged(u, "SourceError")
+
 const catchSourceError = <A, E, R>(
   self: Effect.Effect<A, E, R>,
   hasInput: boolean
 ): Effect.Effect<A, E | EvaluationFailure, R> =>
   self.pipe(
     Effect.catchDefect((defect) =>
-      defect instanceof ConfigProvider.SourceError
+      isSourceError(defect)
         ? Effect.fail(evaluationFailure(new ConfigError(defect), hasInput))
         : Effect.die(defect)
     )
@@ -630,14 +633,14 @@ export function all<const Arg extends Iterable<Config<any>> | Record<string, Con
   if (Array.isArray(configs)) {
     return make((provider, pathPrefix) =>
       Effect.flatMapEager(
-        Effect.all(configs.map((config) => evaluateAt(config, provider, pathPrefix))),
+        Effect.all(configs.map((config) => Effect.result(evaluateAt(config, provider, pathPrefix)))),
         resolveArray
       )
     ) as any
   } else {
     return make((provider, pathPrefix) =>
       Effect.flatMapEager(
-        Effect.all(Rec.map(configs, (config) => evaluateAt(config, provider, pathPrefix))),
+        Effect.all(Rec.map(configs, (config) => Effect.result(evaluateAt(config, provider, pathPrefix)))),
         resolveRecord
       )
     ) as any
@@ -645,12 +648,19 @@ export function all<const Arg extends Iterable<Config<any>> | Record<string, Con
 }
 
 const resolveArray = (
-  resolutions: ReadonlyArray<Resolution<any>>
+  results: ReadonlyArray<Result.Result<Resolution<any>, EvaluationFailure>>
 ): Effect.Effect<Resolution<Array<any>>, EvaluationFailure> => {
   const values: Array<any> = []
+  let firstFailure: EvaluationFailure | undefined
   let firstAbsent: Absent | undefined
   let hasInput = false
-  for (const resolution of resolutions) {
+  for (const result of results) {
+    if (Result.isFailure(result)) {
+      firstFailure ??= result.failure
+      hasInput = hasInput || result.failure.hasInput
+      continue
+    }
+    const resolution = result.success
     if (resolution._tag === "Absent") {
       firstAbsent ??= resolution
     } else {
@@ -658,6 +668,9 @@ const resolveArray = (
       hasInput = hasInput || resolution.hasInput
     }
   }
+  if (firstFailure !== undefined) {
+    return Effect.fail(evaluationFailure(firstFailure.error, hasInput))
+  }
   if (firstAbsent !== undefined) {
     return hasInput ? Effect.fail(evaluationFailure(firstAbsent.error, true)) : Effect.succeed(firstAbsent)
   }
@@ -665,13 +678,20 @@ const resolveArray = (
 }
 
 const resolveRecord = (
-  resolutions: Record<string, Resolution<any>>
+  results: Record<string, Result.Result<Resolution<any>, EvaluationFailure>>
 ): Effect.Effect<Resolution<Record<string, any>>, EvaluationFailure> => {
   const values: Record<string, any> = {}
+  let firstFailure: EvaluationFailure | undefined
   let firstAbsent: Absent | undefined
   let hasInput = false
-  for (const key in resolutions) {
-    const resolution = resolutions[key]
+  for (const key in results) {
+    const result = results[key]
+    if (Result.isFailure(result)) {
+      firstFailure ??= result.failure
+      hasInput = hasInput || result.failure.hasInput
+      continue
+    }
+    const resolution = result.success
     if (resolution._tag === "Absent") {
       firstAbsent ??= resolution
     } else {
@@ -679,6 +699,9 @@ const resolveRecord = (
       hasInput = hasInput || resolution.hasInput
     }
   }
+  if (firstFailure !== undefined) {
+    return Effect.fail(evaluationFailure(firstFailure.error, hasInput))
+  }
   if (firstAbsent !== undefined) {
     return hasInput ? Effect.fail(evaluationFailure(firstAbsent.error, true)) : Effect.succeed(firstAbsent)
   }

package/src/ConfigProvider.ts

@@ -1354,9 +1354,12 @@ function interpolate(envValue: string, parsed: Record<string, string>): string {
 
   if (match !== null) {
     const [_, group, variableName, defaultValue] = match
+    const value = Object.hasOwn(parsed, variableName) && parsed[variableName] !== ""
+      ? parsed[variableName]
+      : defaultValue ?? ""
 
     return interpolate(
-      envValue.replace(group, defaultValue || (Object.hasOwn(parsed, variableName) ? parsed[variableName] : "")),
+      envValue.replace(group, value),
       parsed
     )
   }

package/src/Context.ts

@@ -17,7 +17,6 @@ import { dual, type LazyArg } from "./Function.ts"
 import * as Hash from "./Hash.ts"
 import type { Inspectable } from "./Inspectable.ts"
 import { exitSucceed, PipeInspectableProto, withFiber } from "./internal/core.ts"
-import { getStackTraceLimit, setStackTraceLimit } from "./internal/stackTraceLimit.ts"
 import * as Option from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { hasProperty } from "./Predicate.ts"
@@ -67,7 +66,6 @@ export interface Key<out Identifier, out Shape> extends Effect<Shape, never, Ide
   readonly Service: Shape
   readonly Identifier: Identifier
   readonly key: string
-  readonly stack?: string | undefined
 }
 
 /**
@@ -394,19 +392,9 @@ export const Service: {
     >
     & { readonly make: Make }
 } = function() {
-  const prevLimit = getStackTraceLimit()
-  setStackTraceLimit(2)
-  const err = new Error()
-  setStackTraceLimit(prevLimit)
   function KeyClass() {}
   const self = KeyClass as any as Types.Mutable<Reference<any>>
   Object.setPrototypeOf(self, ServiceProto)
-  // @effect-diagnostics-next-line floatingEffect:off
-  Object.defineProperty(self, "stack", {
-    get() {
-      return err.stack
-    }
-  })
   const init = (key: string, options?: {
     readonly defaultValue?: any
     readonly make?: any
@@ -439,8 +427,7 @@ const ServiceProto: any = {
   toJSON<I, A>(this: Service<I, A>) {
     return {
       _id: "Service",
-      key: this.key,
-      stack: this.stack
+      key: this.key
     }
   },
   of<Service>(this: void, self: Service): Service {
@@ -1094,7 +1081,7 @@ export const addOrOmit: {
    * @category combining
    * @since 4.0.0
    */
-  <I, S>(key: Key<I, S>, service: Option.Option<Types.NoInfer<S>>): <Services>(self: Context<Services>) => Context<Services | I>
+  <I, S>(key: Key<I, S>, service: Option.Option<Types.NoInfer<S>>): <Services>(self: Context<Services>) => Context<Exclude<Services, I>>
   /**
    * Adds or removes a service depending on an `Option`.
    *
@@ -1134,15 +1121,15 @@ export const addOrOmit: {
     self: Context<Services>,
     key: Key<I, S>,
     service: Option.Option<Types.NoInfer<S>>
-  ): Context<Services | I>
+  ): Context<Exclude<Services, I>>
 } = dual(3, <Services, I, S>(
   self: Context<Services>,
   key: Key<I, S>,
   service: Option.Option<Types.NoInfer<S>>
-): Context<Services | I> =>
+): Context<Exclude<Services, I>> =>
   service._tag === "None"
-    ? omit(key)(self) as any
-    : add(self, key, service.value))
+    ? omit(key)(self)
+    : add(self, key, service.value) as any)
 
 /**
  * Gets the service for a key, or evaluates the fallback when a non-reference
@@ -1593,15 +1580,6 @@ const serviceNotFoundError = (service: Key<any, any>) => {
   const error = new Error(
     `Service not found${service.key ? `: ${String(service.key)}` : ""}`
   )
-  if (service.stack) {
-    const lines = service.stack.split("\n")
-    if (lines.length > 2) {
-      const afterAt = lines[2].match(/at (.*)/)
-      if (afterAt) {
-        error.message = error.message + ` (defined at ${afterAt[1]})`
-      }
-    }
-  }
   if (error.stack) {
     const lines = error.stack.split("\n")
     lines.splice(1, 3)

package/src/Cron.ts

@@ -12,7 +12,7 @@ import * as Data from "./Data.ts"
 import type * as DateTime from "./DateTime.ts"
 import * as Equal from "./Equal.ts"
 import * as Equ from "./Equivalence.ts"
-import { format } from "./Formatter.ts"
+import { format as formatValue } from "./Formatter.ts"
 import { constVoid, dual, pipe } from "./Function.ts"
 import * as Hash from "./Hash.ts"
 import { type Inspectable, NodeInspectSymbol } from "./Inspectable.ts"
@@ -152,7 +152,7 @@ const CronProto = {
     return toPojo(this)
   },
   toString(this: Cron) {
-    return `Cron(${format(toPojo(this))})`
+    return `Cron(${formatValue(toPojo(this))})`
   },
   toJSON(this: Cron) {
     const out = toPojo(this)
@@ -612,6 +612,69 @@ export const parse = (cron: string, tz?: DateTime.TimeZone | string): Result.Res
  */
 export const parseUnsafe = (cron: string, tz?: DateTime.TimeZone | string): Cron => Result.getOrThrow(parse(cron, tz))
 
+/**
+ * Formats a `Cron` instance as a cron expression.
+ *
+ * **Details**
+ *
+ * The default seconds field (`0`) is omitted unless `includeSeconds` is `true`.
+ * Other seconds configurations are always included.
+ *
+ * **Gotchas**
+ *
+ * Formatting drops the timezone information and the `and` restriction between
+ * days and weekdays. Parsing the result is therefore not guaranteed to produce
+ * an equivalent schedule.
+ *
+ * **Example** (Formatting a cron expression)
+ *
+ * ```ts import.meta.vitest
+ * import { Cron } from "effect"
+ *
+ * const cron = Cron.parseUnsafe("23 0-20/2 * * 0", "UTC")
+ *
+ * Cron.format(cron) // => "23 0-20/2 * * 0"
+ * Cron.format(cron, { includeSeconds: true }) // => "0 23 0-20/2 * * 0"
+ * ```
+ *
+ * @category getters
+ * @since 4.0.0
+ */
+export const format = (cron: Cron, options?: {
+  readonly includeSeconds?: boolean | undefined
+}): string => {
+  const segments = [cron.seconds, cron.minutes, cron.hours, cron.days, cron.months, cron.weekdays]
+    .map(formatSegment)
+  return (
+    options?.includeSeconds !== true && cron.seconds.size === 1 && cron.seconds.has(0) ? segments.slice(1) : segments
+  ).join(" ")
+}
+
+const formatSegment = (values: ReadonlySet<number>): string => {
+  if (values.size === 0) {
+    return "*"
+  }
+  const array = Array.from(values)
+  const segments: Array<string> = []
+  let index = 0
+  while (index < array.length) {
+    const start = array[index]!
+    const step = array[index + 1]! - start
+    if (index + 2 < array.length && array[index + 2]! - array[index + 1]! === step) {
+      let end = index + 2
+      while (end + 1 < array.length && array[end + 1]! - array[end]! === step) {
+        end++
+      }
+      segments.push(`${start}-${array[end]}${step === 1 ? "" : `/${step}`}`)
+      index = end + 1
+    } else {
+      segments.push(`${start}`)
+      index++
+    }
+  }
+  return segments.join(",")
+}
+
 /**
  * Returns `true` when a date/time matches a `Cron` schedule.
  *

package/src/Crypto.ts

@@ -222,15 +222,24 @@ export const make = (
 
   const randomBytes: Crypto["randomBytes"] = (size) => Effect.map(validateSize("randomBytes", size), randomBytesUnsafe)
 
-  const nextDoubleUnsafe = (): number => {
-    const bytes = randomBytesUnsafe(7)
-    const value = ((bytes[0] & 0x1f) * 2 ** 48) + (bytes[1] * 2 ** 40) + (bytes[2] * 2 ** 32) +
-      (bytes[3] * 2 ** 24) + (bytes[4] * 2 ** 16) + (bytes[5] * 2 ** 8) + bytes[6]
-    return value / 2 ** 53
-  }
+  const readUint53 = (bytes: Uint8Array): number =>
+    ((bytes[0] & 0x1f) * 2 ** 48) + (bytes[1] * 2 ** 40) + (bytes[2] * 2 ** 32) +
+    (bytes[3] * 2 ** 24) + (bytes[4] * 2 ** 16) + (bytes[5] * 2 ** 8) + bytes[6]
+
+  const nextDoubleUnsafe = (): number => readUint53(randomBytesUnsafe(7)) / 2 ** 53
 
-  const nextIntUnsafe = (): number =>
-    Math.floor(nextDoubleUnsafe() * (Number.MAX_SAFE_INTEGER - Number.MIN_SAFE_INTEGER + 1)) + Number.MIN_SAFE_INTEGER
+  const nextIntUnsafe = (): number => {
+    while (true) {
+      const bytes = randomBytesUnsafe(7)
+      const value = readUint53(bytes)
+      if ((bytes[0] & 0x20) === 0) {
+        return value + Number.MIN_SAFE_INTEGER
+      }
+      if (value < Number.MAX_SAFE_INTEGER) {
+        return value + 1
+      }
+    }
+  }
 
   return Crypto.of({
     [TypeId]: TypeId,

package/src/Duration.ts

@@ -27,6 +27,8 @@ const TypeId = "~effect/time/Duration"
 
 const bigint0 = BigInt(0)
 const bigint1 = BigInt(1)
+const bigint2 = BigInt(2)
+const bigint10 = BigInt(10)
 const bigint24 = BigInt(24)
 const bigint60 = BigInt(60)
 const bigint1e3 = BigInt(1_000)
@@ -38,8 +40,20 @@ const roundTiesAwayFromZero = (input: number): bigint =>
 
 const roundMillisToNanos = (millis: number): bigint => roundTiesAwayFromZero(millis * 1_000_000)
 
-const parseNanos = (input: string, scale: bigint): bigint =>
-  input.includes(".") ? roundTiesAwayFromZero(Number(input) * Number(scale)) : BigInt(input) * scale
+const parseNanos = (input: string, scale: bigint): bigint => {
+  const decimalIndex = input.indexOf(".")
+  if (decimalIndex === -1) return BigInt(input) * scale
+
+  const isNegative = input[0] === "-"
+  const fractional = input.slice(decimalIndex + 1)
+  const fractionalScale = bigint10 ** BigInt(fractional.length)
+  const scaled = (
+    BigInt(input.slice(isNegative ? 1 : 0, decimalIndex)) * fractionalScale + BigInt(fractional)
+  ) * scale
+  const rounded = scaled / fractionalScale +
+    (scaled % fractionalScale * bigint2 >= fractionalScale ? bigint1 : bigint0)
+  return isNegative ? -rounded : rounded
+}
 
 const nanosToHrTime = (nanos: bigint): [seconds: number, nanos: number] => {
   const sign = nanos < bigint0 ? -bigint1 : bigint1