effect 3.11.9 → 3.12.0

package/src/SchemaAST.ts

@@ -1797,7 +1797,12 @@ export class Refinement<From extends AST = AST> implements Annotated {
    * @since 3.10.0
    */
   toString() {
-    return Option.getOrElse(getExpected(this), () => `{ ${this.from} | filter }`)
+    return getIdentifierAnnotation(this).pipe(Option.getOrElse(() =>
+      Option.match(getOrElseExpected(this), {
+        onNone: () => `{ ${this.from} | filter }`,
+        onSome: (expected) => isRefinement(this.from) ? String(this.from) + " & " + expected : expected
+      })
+    ))
   }
   /**
    * @since 3.10.0
@@ -2213,7 +2218,7 @@ export const getNumberIndexedAccess = (ast: AST): AST => {
     case "Suspend":
       return getNumberIndexedAccess(ast.f())
   }
-  throw new Error(errors_.getASTUnsupportedSchema(ast))
+  throw new Error(errors_.getASTUnsupportedSchemaErrorMessage(ast))
 }
 
 const getTypeLiteralPropertySignature = (ast: TypeLiteral, name: PropertyKey): PropertySignature | undefined => {
@@ -2282,7 +2287,7 @@ export const getPropertyKeyIndexedAccess = (ast: AST, name: PropertyKey): Proper
     case "Refinement":
       return getPropertyKeyIndexedAccess(ast.from, name)
   }
-  throw new Error(errors_.getASTUnsupportedSchema(ast))
+  throw new Error(errors_.getASTUnsupportedSchemaErrorMessage(ast))
 }
 
 const getPropertyKeys = (ast: AST): Array<PropertyKey> => {
@@ -2327,7 +2332,7 @@ export const record = (key: AST, value: AST): {
         if (Predicate.isString(key.literal) || Predicate.isNumber(key.literal)) {
           propertySignatures.push(new PropertySignature(key.literal, value, false, true))
         } else {
-          throw new Error(errors_.getASTUnsupportedLiteral(key.literal))
+          throw new Error(errors_.getASTUnsupportedLiteralErrorMessage(key.literal))
         }
         break
       case "Enums": {
@@ -2343,7 +2348,7 @@ export const record = (key: AST, value: AST): {
         key.types.forEach(go)
         break
       default:
-        throw new Error(errors_.getASTUnsupportedKeySchema(key))
+        throw new Error(errors_.getASTUnsupportedKeySchemaErrorMessage(key))
     }
   }
   go(key)
@@ -2417,7 +2422,7 @@ export const pick = (ast: AST, keys: ReadonlyArray<PropertyKey>): TypeLiteral |
       }
     }
   }
-  throw new Error(errors_.getASTUnsupportedSchema(ast))
+  throw new Error(errors_.getASTUnsupportedSchemaErrorMessage(ast))
 }
 
 /**
@@ -2460,9 +2465,8 @@ export const partial = (ast: AST, options?: { readonly exact: true }): AST => {
     case "Suspend":
       return new Suspend(() => partial(ast.f(), options))
     case "Declaration":
-      throw new Error(errors_.getASTUnsupportedSchema(ast))
     case "Refinement":
-      throw new Error(errors_.getASTUnsupportedSchema(ast))
+      throw new Error(errors_.getASTUnsupportedSchemaErrorMessage(ast))
     case "Transformation": {
       if (
         isTypeLiteralTransformation(ast.transformation) &&
@@ -2470,7 +2474,7 @@ export const partial = (ast: AST, options?: { readonly exact: true }): AST => {
       ) {
         return new Transformation(partial(ast.from, options), partial(ast.to, options), ast.transformation)
       }
-      throw new Error(errors_.getASTUnsupportedSchema(ast))
+      throw new Error(errors_.getASTUnsupportedSchemaErrorMessage(ast))
     }
   }
   return ast
@@ -2499,9 +2503,8 @@ export const required = (ast: AST): AST => {
     case "Suspend":
       return new Suspend(() => required(ast.f()))
     case "Declaration":
-      throw new Error(errors_.getASTUnsupportedSchema(ast))
     case "Refinement":
-      throw new Error(errors_.getASTUnsupportedSchema(ast))
+      throw new Error(errors_.getASTUnsupportedSchemaErrorMessage(ast))
     case "Transformation": {
       if (
         isTypeLiteralTransformation(ast.transformation) &&
@@ -2509,7 +2512,7 @@ export const required = (ast: AST): AST => {
       ) {
         return new Transformation(required(ast.from), required(ast.to), ast.transformation)
       }
-      throw new Error(errors_.getASTUnsupportedSchema(ast))
+      throw new Error(errors_.getASTUnsupportedSchemaErrorMessage(ast))
     }
   }
   return ast
@@ -2876,7 +2879,7 @@ const _keyof = (ast: AST): Array<AST> => {
     case "Transformation":
       return _keyof(ast.to)
   }
-  throw new Error(errors_.getASTUnsupportedSchema(ast))
+  throw new Error(errors_.getASTUnsupportedSchemaErrorMessage(ast))
 }
 
 /** @internal */
@@ -2928,15 +2931,59 @@ export const rename = (ast: AST, mapping: { readonly [K in PropertyKey]?: Proper
     case "Transformation":
       return compose(ast, rename(typeAST(ast), mapping))
   }
-  throw new Error(errors_.getASTUnsupportedRenameSchema(ast))
+  throw new Error(errors_.getASTUnsupportedRenameSchemaErrorMessage(ast))
 }
 
 const formatKeyword = (ast: AST): string => Option.getOrElse(getExpected(ast), () => ast._tag)
 
-const getExpected = (ast: Annotated): Option.Option<string> => {
-  return getIdentifierAnnotation(ast).pipe(
-    Option.orElse(() => getTitleAnnotation(ast)),
+function getBrands(ast: Annotated): string {
+  return Option.match(getBrandAnnotation(ast), {
+    onNone: () => "",
+    onSome: (brands) => brands.map((brand) => ` & Brand<${util_.formatUnknown(brand)}>`).join("")
+  })
+}
+
+const getOrElseExpected = (ast: Annotated): Option.Option<string> =>
+  getTitleAnnotation(ast).pipe(
     Option.orElse(() => getDescriptionAnnotation(ast)),
-    Option.orElse(() => getAutoTitleAnnotation(ast))
+    Option.orElse(() => getAutoTitleAnnotation(ast)),
+    Option.map((s) => s + getBrands(ast))
   )
+
+const getExpected = (ast: Annotated): Option.Option<string> =>
+  Option.orElse(getIdentifierAnnotation(ast), () => getOrElseExpected(ast))
+
+/** @internal */
+export const pruneUndefined = (
+  ast: AST,
+  self: (ast: AST) => AST | undefined,
+  onTransformation: (ast: Transformation) => AST | undefined
+): AST | undefined => {
+  switch (ast._tag) {
+    case "UndefinedKeyword":
+      return neverKeyword
+    case "Union": {
+      const types: Array<AST> = []
+      let hasUndefined = false
+      for (const type of ast.types) {
+        const pruned = self(type)
+        if (pruned) {
+          hasUndefined = true
+          if (!isNeverKeyword(pruned)) {
+            types.push(pruned)
+          }
+        } else {
+          types.push(type)
+        }
+      }
+      if (hasUndefined) {
+        return Union.make(types)
+      }
+      break
+    }
+    case "Suspend":
+      return self(ast.f())
+    case "Transformation":
+      return onTransformation(ast)
+  }
 }

package/src/Stream.ts

@@ -8380,11 +8380,12 @@ export const scheduleWith: {
  *
  * // Creating a single-valued stream from a scoped resource
  * const stream = Stream.scoped(
- *   Effect.acquireUseRelease(
- *     Console.log("acquire"),
- *     () => Console.log("use"),
- *     () => Console.log("release")
- *   )
+ *  Effect.acquireRelease(
+ *    Console.log("acquire"),
+ *    () => Console.log("release")
+ *  )
+ * ).pipe(
+ *  Stream.flatMap(() => Console.log("use"))
  * )
  *
  * // Effect.runPromise(Stream.runCollect(stream)).then(console.log)

package/src/Tracer.ts

@@ -164,3 +164,17 @@ export const externalSpan: (
  */
 export const tracerWith: <A, E, R>(f: (tracer: Tracer) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, R> =
   defaultServices.tracerWith
+
+/**
+ * @since 3.12.0
+ * @category annotations
+ */
+export interface DisablePropagation {
+  readonly _: unique symbol
+}
+
+/**
+ * @since 3.12.0
+ * @category annotations
+ */
+export const DisablePropagation: Context.Reference<DisablePropagation, boolean> = internal.DisablePropagation

package/src/internal/cause.ts

@@ -1073,7 +1073,7 @@ export const prettyErrorMessage = (u: unknown): string => {
   return stringifyCircular(u)
 }
 
-const locationRegex = /\((.*)\)/
+const locationRegex = /\((.*)\)/g
 
 /** @internal */
 export const spanToTrace = globalValue("effect/Tracer/spanToTrace", () => new WeakMap())
@@ -1105,9 +1105,15 @@ const prettyErrorStack = (message: string, stack: string, span?: Span | undefine
       if (typeof stackFn === "function") {
         const stack = stackFn()
         if (typeof stack === "string") {
-          const locationMatch = stack.match(locationRegex)
-          const location = locationMatch ? locationMatch[1] : stack.replace(/^at /, "")
-          out.push(`    at ${current.name} (${location})`)
+          const locationMatchAll = stack.matchAll(locationRegex)
+          let match = false
+          for (const [, location] of locationMatchAll) {
+            match = true
+            out.push(`    at ${current.name} (${location})`)
+          }
+          if (!match) {
+            out.push(`    at ${current.name} (${stack.replace(/^at /, "")})`)
+          }
         } else {
           out.push(`    at ${current.name}`)
         }

package/src/internal/context.ts

@@ -295,6 +295,19 @@ export const merge = dual<
   return makeContext(map)
 })
 
+/** @internal */
+export const mergeAll = <T extends Array<unknown>>(
+  ...ctxs: [...{ [K in keyof T]: C.Context<T[K]> }]
+): C.Context<T[number]> => {
+  const map = new Map()
+  for (const ctx of ctxs) {
+    for (const [tag, s] of ctx.unsafeMap) {
+      map.set(tag, s)
+    }
+  }
+  return makeContext(map)
+}
+
 /** @internal */
 export const pick =
   <Services, S extends Array<C.ValidTagsById<Services>>>(...tags: S) =>

package/src/internal/core-effect.ts

@@ -1,5 +1,3 @@
-import type { Exit } from "effect/Exit"
-import { internalCall } from "effect/Utils"
 import * as Arr from "../Array.js"
 import type * as Cause from "../Cause.js"
 import * as Chunk from "../Chunk.js"
@@ -7,6 +5,7 @@ import * as Clock from "../Clock.js"
 import * as Context from "../Context.js"
 import * as Duration from "../Duration.js"
 import type * as Effect from "../Effect.js"
+import type { Exit } from "../Exit.js"
 import type * as Fiber from "../Fiber.js"
 import type * as FiberId from "../FiberId.js"
 import type * as FiberRef from "../FiberRef.js"
@@ -29,6 +28,7 @@ import type * as runtimeFlagsPatch from "../RuntimeFlagsPatch.js"
 import * as Tracer from "../Tracer.js"
 import type { NoInfer } from "../Types.js"
 import type { Unify } from "../Unify.js"
+import { internalCall } from "../Utils.js"
 import * as internalCause from "./cause.js"
 import { clockTag } from "./clock.js"
 import * as core from "./core.js"
@@ -2020,61 +2020,75 @@ export const linkSpans = dual<
 
 const bigint0 = BigInt(0)
 
+const filterDisablePropagation: (self: Option.Option<Tracer.AnySpan>) => Option.Option<Tracer.AnySpan> = Option.flatMap(
+  (span) =>
+    Context.get(span.context, internalTracer.DisablePropagation)
+      ? span._tag === "Span" ? filterDisablePropagation(span.parent) : Option.none()
+      : Option.some(span)
+)
+
 /** @internal */
 export const unsafeMakeSpan = <XA, XE>(
   fiber: FiberRuntime<XA, XE>,
   name: string,
   options: Tracer.SpanOptions
 ) => {
-  const enabled = fiber.getFiberRef(core.currentTracerEnabled)
-  if (enabled === false) {
-    return core.noopSpan(name)
-  }
-
+  const disablePropagation = !fiber.getFiberRef(core.currentTracerEnabled) ||
+    (options.context && Context.get(options.context, internalTracer.DisablePropagation))
   const context = fiber.getFiberRef(core.currentContext)
-  const services = fiber.getFiberRef(defaultServices.currentServices)
-
-  const tracer = Context.get(services, internalTracer.tracerTag)
-  const clock = Context.get(services, Clock.Clock)
-  const timingEnabled = fiber.getFiberRef(core.currentTracerTimingEnabled)
-
-  const fiberRefs = fiber.getFiberRefs()
-  const annotationsFromEnv = FiberRefs.get(fiberRefs, core.currentTracerSpanAnnotations)
-  const linksFromEnv = FiberRefs.get(fiberRefs, core.currentTracerSpanLinks)
-
   const parent = options.parent
     ? Option.some(options.parent)
     : options.root
     ? Option.none()
-    : Context.getOption(context, internalTracer.spanTag)
-
-  const links = linksFromEnv._tag === "Some" ?
-    options.links !== undefined ?
-      [
-        ...Chunk.toReadonlyArray(linksFromEnv.value),
-        ...(options.links ?? [])
-      ] :
-      Chunk.toReadonlyArray(linksFromEnv.value) :
-    options.links ?? Arr.empty()
-
-  const span = tracer.span(
-    name,
-    parent,
-    options.context ?? Context.empty(),
-    links,
-    timingEnabled ? clock.unsafeCurrentTimeNanos() : bigint0,
-    options.kind ?? "internal"
-  )
+    : filterDisablePropagation(Context.getOption(context, internalTracer.spanTag))
 
-  if (typeof options.captureStackTrace === "function") {
-    internalCause.spanToTrace.set(span, options.captureStackTrace)
-  }
+  let span: Tracer.Span
 
-  if (annotationsFromEnv._tag === "Some") {
-    HashMap.forEach(annotationsFromEnv.value, (value, key) => span.attribute(key, value))
+  if (disablePropagation) {
+    span = core.noopSpan({
+      name,
+      parent,
+      context: Context.add(options.context ?? Context.empty(), internalTracer.DisablePropagation, true)
+    })
+  } else {
+    const services = fiber.getFiberRef(defaultServices.currentServices)
+
+    const tracer = Context.get(services, internalTracer.tracerTag)
+    const clock = Context.get(services, Clock.Clock)
+    const timingEnabled = fiber.getFiberRef(core.currentTracerTimingEnabled)
+
+    const fiberRefs = fiber.getFiberRefs()
+    const annotationsFromEnv = FiberRefs.get(fiberRefs, core.currentTracerSpanAnnotations)
+    const linksFromEnv = FiberRefs.get(fiberRefs, core.currentTracerSpanLinks)
+
+    const links = linksFromEnv._tag === "Some" ?
+      options.links !== undefined ?
+        [
+          ...Chunk.toReadonlyArray(linksFromEnv.value),
+          ...(options.links ?? [])
+        ] :
+        Chunk.toReadonlyArray(linksFromEnv.value) :
+      options.links ?? Arr.empty()
+
+    span = tracer.span(
+      name,
+      parent,
+      options.context ?? Context.empty(),
+      links,
+      timingEnabled ? clock.unsafeCurrentTimeNanos() : bigint0,
+      options.kind ?? "internal"
+    )
+
+    if (annotationsFromEnv._tag === "Some") {
+      HashMap.forEach(annotationsFromEnv.value, (value, key) => span.attribute(key, value))
+    }
+    if (options.attributes !== undefined) {
+      Object.entries(options.attributes).forEach(([k, v]) => span.attribute(k, v))
+    }
   }
-  if (options.attributes !== undefined) {
-    Object.entries(options.attributes).forEach(([k, v]) => span.attribute(k, v))
+
+  if (typeof options.captureStackTrace === "function") {
+    internalCause.spanToTrace.set(span, options.captureStackTrace)
   }
 
   return span

package/src/internal/core.ts

@@ -1,4 +1,3 @@
-import { internalCall } from "effect/Utils"
 import * as Arr from "../Array.js"
 import type * as Cause from "../Cause.js"
 import * as Chunk from "../Chunk.js"
@@ -38,7 +37,7 @@ import * as RuntimeFlagsPatch from "../RuntimeFlagsPatch.js"
 import type * as Scope from "../Scope.js"
 import type * as Tracer from "../Tracer.js"
 import type { NoInfer, NotFunction } from "../Types.js"
-import { YieldWrap } from "../Utils.js"
+import { internalCall, YieldWrap } from "../Utils.js"
 import * as _blockedRequests from "./blockedRequests.js"
 import * as internalCause from "./cause.js"
 import * as deferred from "./deferred.js"
@@ -1428,13 +1427,23 @@ export const whileLoop = <A, E, R>(
 }
 
 /* @internal */
-export const gen: typeof Effect.gen = function() {
-  const f = arguments.length === 1 ? arguments[0] : arguments[1].bind(arguments[0])
-  return suspend(() => {
+export const fromIterator = <Eff extends YieldWrap<Effect.Effect<any, any, any>>, AEff>(
+  iterator: LazyArg<Iterator<Eff, AEff, never>>
+): Effect.Effect<
+  AEff,
+  [Eff] extends [never] ? never : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E : never,
+  [Eff] extends [never] ? never : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R : never
+> =>
+  suspend(() => {
     const effect = new EffectPrimitive(OpCodes.OP_ITERATOR) as any
-    effect.effect_instruction_i0 = f(pipe)
+    effect.effect_instruction_i0 = iterator()
     return effect
   })
+
+/* @internal */
+export const gen: typeof Effect.gen = function() {
+  const f = arguments.length === 1 ? arguments[0] : arguments[1].bind(arguments[0])
+  return fromIterator(() => f(pipe))
 }
 
 /* @internal */
@@ -3063,14 +3072,11 @@ export const currentSpanFromFiber = <A, E>(fiber: Fiber.RuntimeFiber<A, E>): Opt
   return span !== undefined && span._tag === "Span" ? Option.some(span) : Option.none()
 }
 
-const NoopSpanProto: Tracer.Span = {
+const NoopSpanProto: Omit<Tracer.Span, "parent" | "name" | "context"> = {
   _tag: "Span",
   spanId: "noop",
   traceId: "noop",
-  name: "noop",
   sampled: false,
-  parent: Option.none(),
-  context: Context.empty(),
   status: {
     _tag: "Ended",
     startTime: BigInt(0),
@@ -3086,8 +3092,8 @@ const NoopSpanProto: Tracer.Span = {
 }
 
 /** @internal */
-export const noopSpan = (name: string): Tracer.Span => {
-  const span = Object.create(NoopSpanProto)
-  span.name = name
-  return span
-}
+export const noopSpan = (options: {
+  readonly name: string
+  readonly parent: Option.Option<Tracer.AnySpan>
+  readonly context: Context.Context<never>
+}): Tracer.Span => Object.assign(Object.create(NoopSpanProto), options)

package/src/internal/doNotation.ts

@@ -1,6 +1,6 @@
-import type { NoInfer } from "effect/Types"
 import { dual } from "../Function.js"
 import type { Kind, TypeLambda } from "../HKT.js"
+import type { NoInfer } from "../Types.js"
 
 type Map<F extends TypeLambda> = {
   <A, B>(f: (a: A) => B): <R, O, E>(self: Kind<F, R, O, E, A>) => Kind<F, R, O, E, B>

package/src/internal/encoding/common.ts

@@ -23,6 +23,27 @@ export const DecodeException = (input: string, message?: string): Encoding.Decod
 /** @internal */
 export const isDecodeException = (u: unknown): u is Encoding.DecodeException => hasProperty(u, DecodeExceptionTypeId)
 
+/** @internal */
+export const EncodeExceptionTypeId: Encoding.EncodeExceptionTypeId = Symbol.for(
+  "effect/Encoding/errors/Encode"
+) as Encoding.EncodeExceptionTypeId
+
+/** @internal */
+export const EncodeException = (input: string, message?: string): Encoding.EncodeException => {
+  const out: Mutable<Encoding.EncodeException> = {
+    _tag: "EncodeException",
+    [EncodeExceptionTypeId]: EncodeExceptionTypeId,
+    input
+  }
+  if (isString(message)) {
+    out.message = message
+  }
+  return out
+}
+
+/** @internal */
+export const isEncodeException = (u: unknown): u is Encoding.EncodeException => hasProperty(u, EncodeExceptionTypeId)
+
 /** @interal */
 export const encoder = new TextEncoder()
 

package/src/internal/fiberRuntime.ts

@@ -1,4 +1,3 @@
-import { internalCall, yieldWrapGet } from "effect/Utils"
 import * as RA from "../Array.js"
 import * as Boolean from "../Boolean.js"
 import type * as Cause from "../Cause.js"
@@ -45,6 +44,7 @@ import type * as Scope from "../Scope.js"
 import type * as Supervisor from "../Supervisor.js"
 import type * as Tracer from "../Tracer.js"
 import type { Concurrency, NoInfer } from "../Types.js"
+import { internalCall, yieldWrapGet } from "../Utils.js"
 import * as _RequestBlock from "./blockedRequests.js"
 import * as internalCause from "./cause.js"
 import * as clock from "./clock.js"

package/src/internal/mailbox.ts

@@ -1,4 +1,3 @@
-import type { Scope } from "effect/Scope"
 import * as Arr from "../Array.js"
 import type { Cause } from "../Cause.js"
 import { NoSuchElementException } from "../Cause.js"
@@ -15,6 +14,7 @@ import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import { hasProperty } from "../Predicate.js"
 import type { Scheduler } from "../Scheduler.js"
+import type { Scope } from "../Scope.js"
 import type { Stream } from "../Stream.js"
 import * as channel from "./channel.js"
 import * as channelExecutor from "./channel/channelExecutor.js"

package/src/internal/pool.ts

@@ -1,4 +1,4 @@
-import type { Cause } from "effect/Cause"
+import type { Cause } from "../Cause.js"
 import * as Context from "../Context.js"
 import * as Duration from "../Duration.js"
 import type { Effect, Semaphore } from "../Effect.js"

package/src/internal/redacted.ts

@@ -1,8 +1,8 @@
-import { NodeInspectSymbol } from "effect/Inspectable"
 import * as Equal from "../Equal.js"
 import { pipe } from "../Function.js"
 import { globalValue } from "../GlobalValue.js"
 import * as Hash from "../Hash.js"
+import { NodeInspectSymbol } from "../Inspectable.js"
 import { pipeArguments } from "../Pipeable.js"
 import { hasProperty } from "../Predicate.js"
 import type * as Redacted from "../Redacted.js"

package/src/internal/runtime.ts

@@ -1,8 +1,8 @@
-import { equals } from "effect/Equal"
 import type * as ReadonlyArray from "../Array.js"
 import type * as Cause from "../Cause.js"
 import * as Context from "../Context.js"
 import type * as Effect from "../Effect.js"
+import { equals } from "../Equal.js"
 import * as Exit from "../Exit.js"
 import * as Fiber from "../Fiber.js"
 import * as FiberId from "../FiberId.js"

package/src/internal/schedule.ts

@@ -3,6 +3,7 @@ import * as Chunk from "../Chunk.js"
 import * as Clock from "../Clock.js"
 import * as Context from "../Context.js"
 import * as Cron from "../Cron.js"
+import type * as DateTime from "../DateTime.js"
 import * as Duration from "../Duration.js"
 import type * as Effect from "../Effect.js"
 import * as Either from "../Either.js"
@@ -413,8 +414,11 @@ export const mapInputEffect = dual<
     )))
 
 /** @internal */
-export const cron = (expression: string | Cron.Cron): Schedule.Schedule<[number, number]> => {
-  const parsed = Cron.isCron(expression) ? Either.right(expression) : Cron.parse(expression)
+export const cron: {
+  (expression: Cron.Cron): Schedule.Schedule<[number, number]>
+  (expression: string, tz?: DateTime.TimeZone | string): Schedule.Schedule<[number, number]>
+} = (expression: string | Cron.Cron, tz?: DateTime.TimeZone | string): Schedule.Schedule<[number, number]> => {
+  const parsed = Cron.isCron(expression) ? Either.right(expression) : Cron.parse(expression, tz)
   return makeWithState<[boolean, [number, number, number]], unknown, [number, number]>(
     [true, [Number.MIN_SAFE_INTEGER, 0, 0]],
     (now, _, [initial, previous]) => {
@@ -439,8 +443,8 @@ export const cron = (expression: string | Cron.Cron): Schedule.Schedule<[number,
       }
 
       next = Cron.next(cron, date).getTime()
-      const start = beginningOfMinute(next)
-      const end = endOfMinute(next)
+      const start = beginningOfSecond(next)
+      const end = endOfSecond(next)
       return core.succeed([
         [false, [next, start, end]],
         [start, end],

package/src/internal/schema/errors.ts

@@ -1,4 +1,4 @@
-import * as array_ from "effect/Array"
+import * as array_ from "../../Array.js"
 import type * as AST from "../../SchemaAST.js"
 import * as util_ from "./util.js"
 
@@ -150,14 +150,15 @@ export const getSchemaUnsupportedLiteralSpanErrorMessage = (ast: AST.AST) =>
 // ---------------------------------------------
 
 /** @internal */
-export const getASTUnsupportedSchema = (ast: AST.AST) => getUnsupportedSchemaErrorMessage(undefined, undefined, ast)
+export const getASTUnsupportedSchemaErrorMessage = (ast: AST.AST) =>
+  getUnsupportedSchemaErrorMessage(undefined, undefined, ast)
 
 /** @internal */
-export const getASTUnsupportedKeySchema = (ast: AST.AST) =>
+export const getASTUnsupportedKeySchemaErrorMessage = (ast: AST.AST) =>
   getErrorMessage("Unsupported key schema", undefined, undefined, ast)
 
 /** @internal */
-export const getASTUnsupportedLiteral = (literal: AST.LiteralValue) =>
+export const getASTUnsupportedLiteralErrorMessage = (literal: AST.LiteralValue) =>
   getErrorMessage("Unsupported literal", `literal value: ${util_.formatUnknown(literal)}`)
 
 /** @internal */
@@ -181,7 +182,7 @@ export const getASTDuplicatePropertySignatureTransformationErrorMessage = (key:
   getErrorMessage("Duplicate property signature transformation", `Duplicate key ${util_.formatUnknown(key)}`)
 
 /** @internal */
-export const getASTUnsupportedRenameSchema = (ast: AST.AST): string =>
+export const getASTUnsupportedRenameSchemaErrorMessage = (ast: AST.AST): string =>
   getUnsupportedSchemaErrorMessage(undefined, undefined, ast)
 
 /** @internal */

package/src/internal/schema/util.ts

@@ -1,6 +1,6 @@
-import * as array_ from "effect/Array"
-import * as Predicate from "effect/Predicate"
+import * as array_ from "../../Array.js"
 import type * as ParseResult from "../../ParseResult.js"
+import * as Predicate from "../../Predicate.js"
 import type * as AST from "../../SchemaAST.js"
 
 /** @internal */

package/src/internal/stm/core.ts

@@ -1,4 +1,3 @@
-import { internalCall } from "effect/Utils"
 import * as Cause from "../../Cause.js"
 import * as Context from "../../Context.js"
 import * as Effect from "../../Effect.js"
@@ -15,7 +14,7 @@ import { pipeArguments } from "../../Pipeable.js"
 import { hasProperty } from "../../Predicate.js"
 import type * as Scheduler from "../../Scheduler.js"
 import type * as STM from "../../STM.js"
-import { YieldWrap } from "../../Utils.js"
+import { internalCall, YieldWrap } from "../../Utils.js"
 import { ChannelTypeId } from "../core-stream.js"
 import { withFiberRuntime } from "../core.js"
 import { effectVariance, StreamTypeId } from "../effectable.js"