effect 4.1.0 → 4.1.2

package/src/JsonSchema.ts

@@ -506,9 +506,23 @@ export function fromSchemaOpenApi3_0(schema: JsonSchema): Document<"draft-2020-1
  * @since 4.0.0
  */
 export function toDocumentDraft07(document: Document<"draft-2020-12">): Document<"draft-07"> {
+  return toDocumentDraft07WithDefinitionsPath(document)
+}
+
+/**
+ * Converts to Draft-07 with definitions located at `definitionsPath`, such as
+ * `["components", "schemas"]` after {@link toMultiDocumentComponents}, so
+ * references into them stay in place. Defaults to `$defs` → `definitions`.
+ *
+ * @internal
+ */
+export function toDocumentDraft07WithDefinitionsPath(
+  document: Document<"draft-2020-12">,
+  definitionsPath?: ReadonlyArray<string>
+): Document<"draft-07"> {
   return {
     dialect: "draft-07",
-    ...convertDocument(document, draft07Adapter)
+    ...convertDocument(document, draft07Adapter, undefined, definitionsPath)
   }
 }
 
@@ -620,6 +634,25 @@ export function toDocumentDraft04(document: Document<"draft-2020-12">): Document
  * @since 4.0.0
  */
 export function toMultiDocumentOpenApi3_1(multiDocument: MultiDocument<"draft-2020-12">): MultiDocument<"openapi-3.1"> {
+  return {
+    dialect: "openapi-3.1",
+    ...toMultiDocumentComponents(multiDocument, {
+      target: "OpenAPI 3.1",
+      checkSchema(schema) {
+        rejectKeywordCollisions(schema, OPEN_API_31_TARGET_COLLISIONS, "OpenAPI 3.1", "Draft 2020-12")
+      }
+    })
+  }
+}
+
+/** @internal */
+export function toMultiDocumentComponents(
+  multiDocument: Pick<MultiDocument<"draft-2020-12">, "schemas" | "definitions">,
+  options: {
+    readonly target: string
+    readonly checkSchema?: ((schema: JsonSchema) => void) | undefined
+  }
+): Pick<MultiDocument<"draft-2020-12">, "schemas" | "definitions"> {
   const definitionKeys = Object.keys(multiDocument.definitions)
   const keyMap = new Map<string, string>()
   const usedKeys = new Set(definitionKeys.filter((key) => VALID_OPEN_API_COMPONENTS_SCHEMAS_KEY_REGEXP.test(key)))
@@ -649,7 +682,7 @@ export function toMultiDocumentOpenApi3_1(multiDocument: MultiDocument<"draft-20
     const isRootResource = createsResource(schema.$id)
     const localDefinitions = Predicate.isObject(schema.$defs) ? schema.$defs : undefined
     return transformSchema(schema, (schema, inEmbeddedResource) => {
-      rejectKeywordCollisions(schema, OPEN_API_31_TARGET_COLLISIONS, "OpenAPI 3.1", "Draft 2020-12")
+      options.checkSchema?.(schema)
       rewriteSchemaRef(schema, (reference, keyword) => {
         const path = reference.startsWith("#") ? parseUriFragment(reference) : undefined
         if (path === undefined || path[0] !== "$defs" || path.length < 2) return reference
@@ -661,7 +694,7 @@ export function toMultiDocumentOpenApi3_1(multiDocument: MultiDocument<"draft-20
             Object.hasOwn(multiDocument.definitions, key) &&
             (localDefinitions === undefined || !Object.hasOwn(localDefinitions, key))
           ) {
-            unsupported(keyword, "OpenAPI 3.1", "a schema resource cannot reference the shared definitions pool")
+            unsupported(keyword, options.target, "a schema resource cannot reference the shared definitions pool")
           }
           return reference
         }
@@ -673,7 +706,7 @@ export function toMultiDocumentOpenApi3_1(multiDocument: MultiDocument<"draft-20
   }
 
   const schemas = multiDocument.schemas.map((schema) => rewrite(schema, true)) as unknown as MultiDocument<
-    "openapi-3.1"
+    "draft-2020-12"
   >["schemas"]
   const definitions: Definitions = {}
   for (const key of definitionKeys) {
@@ -685,7 +718,6 @@ export function toMultiDocumentOpenApi3_1(multiDocument: MultiDocument<"draft-20
   }
 
   return {
-    dialect: "openapi-3.1",
     schemas,
     definitions
   }
@@ -957,13 +989,19 @@ function convertSchema(root: JsonSchema, adapter: Adapter, options?: ConverterOp
 function convertDocument(
   document: Document<"draft-2020-12">,
   adapter: Adapter,
-  options?: ConverterOptions
+  options?: ConverterOptions,
+  definitionsPath?: Path
 ): { readonly schema: JsonSchema; readonly definitions: Definitions } {
   return runConverter(adapter, { ...options, trackIds: true }, (convert) => ({
     schema: convert(document.schema) as JsonSchema,
     definitions: mapObject(
       document.definitions,
-      (definition, key) => convert(definition, ["$defs", key], ["definitions", key]) as JsonSchema
+      (definition, key) =>
+        convert(
+          definition,
+          [...(definitionsPath ?? ["$defs"]), key],
+          [...(definitionsPath ?? ["definitions"]), key]
+        ) as JsonSchema
     ) as Definitions
   }))
 }

package/src/MutableRef.ts

@@ -12,7 +12,6 @@
  */
 import * as Equal from "./Equal.ts"
 import * as Dual from "./Function.ts"
-import * as Hash from "./Hash.ts"
 import { type Inspectable, toJson } from "./Inspectable.ts"
 import { PipeInspectableProto } from "./internal/core.ts"
 import type { Pipeable } from "./Pipeable.ts"
@@ -75,15 +74,9 @@ export interface MutableRef<out T> extends Pipeable, Inspectable {
   current: T
 }
 
-const MutableRefProto: Omit<MutableRef<unknown>, "current"> & Equal.Equal = {
+const MutableRefProto: Omit<MutableRef<unknown>, "current"> = {
   [TypeId]: TypeId,
   ...PipeInspectableProto,
-  [Equal.symbol](that: unknown): boolean {
-    return this === that
-  },
-  [Hash.symbol](): number {
-    return Hash.random(this)
-  },
   toJSON<A>(this: MutableRef<A>) {
     return {
       _id: "MutableRef",

package/src/Path.ts

@@ -385,9 +385,14 @@ function normalizeStringPosix(path: string, allowAboveRoot: boolean) {
   return res
 }
 
+function formatExt(ext: string | undefined) {
+  if (!ext) return ""
+  return ext.startsWith(".") ? ext : `.${ext}`
+}
+
 function _format(sep: string, pathObject: Partial<Path.Parsed>) {
   const dir = pathObject.dir || pathObject.root
-  const base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "")
+  const base = pathObject.base || (pathObject.name || "") + formatExt(pathObject.ext)
   if (!dir) {
     return base
   }

package/src/Pool.ts

@@ -378,7 +378,8 @@ export const makeWithStrategy = <A, E, R>(options: {
 }): Effect.Effect<Pool<A, E>, never, Scope.Scope | R> =>
   Effect.uninterruptibleMask(Effect.fnUntraced(function*(restore) {
     const services = yield* Effect.context<R | Scope.Scope>()
-    const scope = Context.get(services, Scope.Scope)
+    // A child scope keeps the pool usable in later finalizers of the outer scope
+    const scope = Scope.forkUnsafe(Context.get(services, Scope.Scope))
     const acquire = Effect.updateContext(
       options.acquire,
       (input) => Context.merge(services, input)

package/src/Ref.ts

@@ -12,9 +12,7 @@
  * @since 2.0.0
  */
 import * as Effect from "./Effect.ts"
-import * as Equal from "./Equal.ts"
 import { dual, identity } from "./Function.ts"
-import * as Hash from "./Hash.ts"
 import { PipeInspectableProto } from "./internal/core.ts"
 import * as MutableRef from "./MutableRef.ts"
 import type * as Option from "./Option.ts"
@@ -112,12 +110,6 @@ const RefProto = {
     _A: identity
   },
   ...PipeInspectableProto,
-  [Equal.symbol](that: unknown): boolean {
-    return this === that
-  },
-  [Hash.symbol](): number {
-    return Hash.random(this)
-  },
   toJSON(this: Ref<any>) {
     return {
       _id: "Ref",

package/src/Schedule.ts

@@ -889,7 +889,8 @@ export const cron: {
       return Cause.done(Duration.zero)
     }
     return effect.sync(() => {
-      const next = Cron.next(cron, now).getTime()
+      let next = Cron.next(cron, now).getTime()
+      if (Duration.isZero(Duration.millis(next - now))) next = Cron.next(cron, next).getTime()
       const duration = Duration.millis(next - now)
       return [duration, duration]
     })
@@ -1157,7 +1158,7 @@ export const fixed = (interval: Duration.Input): Schedule<number> => {
         }
         const runningBehind = meta.now > (lastRun + window)
         const boundary = window - ((meta.now - start) % window)
-        const delay = runningBehind ? 0 : boundary === 0 ? window : boundary
+        const delay = runningBehind ? 0 : Duration.isZero(Duration.millis(boundary)) ? window : boundary
         lastRun = runningBehind ? meta.now : meta.now + delay
         return [meta.attempt - 1, Duration.millis(delay)] as const
       })
@@ -1901,10 +1902,11 @@ export {
 export const windowed = (interval: Duration.Input): Schedule<number> => {
   const window = Duration.toMillis(Duration.fromInputUnsafe(interval))
   return fromStepWithMetadata(effect.succeed((meta) =>
-    effect.sync(() => [
-      meta.attempt - 1,
-      window === 0 ? Duration.zero : Duration.millis(window - (meta.elapsed % window))
-    ])
+    effect.sync(() => {
+      if (window === 0) return [meta.attempt - 1, Duration.zero] as const
+      const delay = Duration.millis(window - (meta.elapsed % window))
+      return [meta.attempt - 1, Duration.isZero(delay) ? Duration.millis(window) : delay] as const
+    })
   ))
 }
 

package/src/Schema.ts

@@ -10949,7 +10949,8 @@ export interface BigDecimalFromString extends decodeTo<BigDecimal, String> {
  *
  * **Gotchas**
  *
- * An empty string decodes as zero.
+ * An empty string decodes as zero. Strings with a scale outside ±10,000, such
+ * as `"1e300000000"`, are rejected.
  *
  * @see {@link BigDecimal} for validating values that are already BigDecimal values
  * @see {@link BigIntFromString} for parsing base-10 integer strings into bigint values
@@ -14531,7 +14532,7 @@ const CryptoJsonWebKey = Struct({
     d: CryptoJsonWebKeyMember,
     t: CryptoJsonWebKeyMember
   })))
-}) as unknown as Codec<JsonWebKey>
+}) as unknown as Codec<KeyFormat_.JsonWebKey>
 
 const cryptoFormatData = <R extends KeyFormat_.Role, Data>(format: KeyFormat_.Format<R, "decode", Data>): Codec<Data> =>
   (format._tag === "jwk" ? CryptoJsonWebKey : format.pem ? String : Uint8Array) as Codec<any>

package/src/SchemaRepresentation.ts

@@ -3202,7 +3202,8 @@ export function fromRepresentations(
  * - Objects and arrays used as `const` values or `enum` members are rejected. Only strings, numbers, booleans, and null
  *   are supported.
  * - Intersections of overlapping unions are limited to disjoint root-type partitions and finite primitive `anyOf`
- *   literal sets. Other union intersections, including cases that would duplicate a nested choice, are rejected.
+ *   literal sets, which may also be duplicated across branches. Other union intersections, including cases that would
+ *   duplicate any other nested choice, are rejected.
  * - Unknown extension keywords are ignored and their semantics are not enforced.
  * - Only local references to top-level definitions in the form `#/$defs/<escaped-token>` are supported, optionally
  *   followed by a pointer below the definition. A pointer target becomes a definition keyed by its escaped tokens, such
@@ -3251,7 +3252,8 @@ export function fromJsonSchemaDocument(
  * - Objects and arrays used as `const` values or `enum` members are rejected. Only strings, numbers, booleans, and null
  *   are supported.
  * - Intersections of overlapping unions are limited to disjoint root-type partitions and finite primitive `anyOf`
- *   literal sets. Other union intersections, including cases that would duplicate a nested choice, are rejected.
+ *   literal sets, which may also be duplicated across branches. Other union intersections, including cases that would
+ *   duplicate any other nested choice, are rejected.
  * - Only local references to top-level definitions in the form `#/$defs/<escaped-token>` are supported, optionally
  *   followed by a pointer below the definition. A pointer target becomes a definition keyed by its escaped tokens, such
  *   as `Name/properties/field`, and is rejected if a top-level definition already uses that key. Root references and

package/src/SchemaTransformation.ts

@@ -1707,8 +1707,8 @@ export const urlFromString: Transformation<URL, string> = transformEffect<URL, s
  * **Details**
  *
  * Decoding calls `BigDecimal.fromString(s)` and fails with `InvalidValue` if
- * the string is not a valid `BigDecimal` representation. Encoding returns
- * `BigDecimal.format(bd)`.
+ * the string is not a valid `BigDecimal` representation or its scale is
+ * outside ±10,000. Encoding returns `BigDecimal.format(bd)`.
  *
  * @stability stable
  * @category transforming

package/src/Stream.ts

@@ -15245,12 +15245,13 @@ export const groupAdjacentBy: {
           return loop
         })
       )
-      let done = false
-      return Pull.catchDone(Effect.suspend(() => done ? Cause.done() : loop), () => {
-        done = true
-        const out = group
+      let cause: Cause.Cause<E | Cause.Done> | undefined
+      return Effect.catchCause(Effect.suspend(() => cause ? Effect.failCause(cause) : loop), (cause_) => {
+        cause = cause_
+        if (group === undefined) return Effect.failCause(cause_)
+        const out = Arr.of([currentKey, group] as const)
         group = undefined
-        return out && Arr.isArrayNonEmpty(out) ? Effect.succeed(Arr.of([currentKey, out])) : Cause.done()
+        return Effect.succeed(out)
       })
     })))