effect 4.0.6 → 4.1.0

package/src/SchemaAST.ts

@@ -2739,8 +2739,10 @@ function isIndexSignatureParameter(ast: AST): ast is IndexSignatureParameter {
  *
  * **Gotchas**
  *
- * Using `Schema.optionalKey` on the value type is not allowed for index
- * signatures (throws at construction); use `Schema.optional` instead.
+ * Using `Schema.optionalKey` or `Schema.optional` on the value type is not
+ * allowed for index signatures (throws at construction). Index signatures
+ * already allow keys to be absent; use `Schema.UndefinedOr` to allow
+ * `undefined` values.
  *
  * @see {@link Objects}
  * @see {@link PropertySignature}
@@ -2773,8 +2775,10 @@ export const IndexSignature: new(parameter: AST, type: AST) => IndexSignature =
     }
     this.parameter = parameter
     this.type = type
-    if (isOptional(type) && !containsUndefined(type)) {
-      throw new Error("Cannot use `Schema.optionalKey` with index signatures, use `Schema.optional` instead.")
+    if (isOptional(type) || (type.encoding !== undefined && isOptional(toEncoded(type)))) {
+      throw new Error(
+        "Cannot use `Schema.optionalKey` or `Schema.optional` with index signatures. Index signatures already allow keys to be absent; use `Schema.UndefinedOr` to allow `undefined` values."
+      )
     }
   }
 }
@@ -4598,16 +4602,24 @@ function parseParameter(ast: AST): {
 } {
   const literals: Array<PropertyKey> = []
   const parameters: Array<AST> = []
+  function addLiteral(literal: PropertyKey) {
+    if (!literals.includes(literal)) {
+      literals.push(literal)
+    }
+  }
   function go(ast: AST) {
     switch (ast._tag) {
       case "Literal":
-        if (Predicate.isPropertyKey(ast.literal) && !literals.includes(ast.literal)) {
-          literals.push(ast.literal)
+        if (Predicate.isPropertyKey(ast.literal)) {
+          addLiteral(ast.literal)
         }
         return
       case "UniqueSymbol":
-        if (!literals.includes(ast.symbol)) {
-          literals.push(ast.symbol)
+        addLiteral(ast.symbol)
+        return
+      case "Enum":
+        for (const [, value] of ast.enums) {
+          addLiteral(value)
         }
         return
       case "Never":
@@ -4812,18 +4824,6 @@ export const flip = memoize((ast: AST): AST => {
   return "flip" in ast ? ast.flip(flip) : "recur" in ast ? ast.recur(flip) : ast
 })
 
-/** @internal */
-export function containsUndefined(ast: AST): boolean {
-  switch (ast._tag) {
-    case "Undefined":
-      return true
-    case "Union":
-      return ast.types.some(containsUndefined)
-    default:
-      return false
-  }
-}
-
 function fromConst<const T>(
   ast: AST,
   value: T

package/src/SchemaGetter.ts

@@ -1535,7 +1535,10 @@ export function stringifyJson(options?: StringifyJsonOptions): Getter<string, un
  * The getter is pure and never fails. It splits the string by `separator`
  * (default `,`) and then each pair at the first `keyValueSeparator` (default `=`),
  * preserving the rest of the value. An empty `keyValueSeparator` uses the first
- * two characters as the key and value. Pairs missing a key or value are skipped.
+ * two characters as the key and value. Pairs without a `keyValueSeparator` or
+ * with an empty key are skipped. Pairs with an empty value are skipped unless
+ * `keepEmptyValues` is `true`, in which case the value is `""`. When `trim` is
+ * `true`, keys and values are trimmed before these checks.
  *
  * **Example** (Parsing a key-value string)
  *
@@ -1557,23 +1560,32 @@ export function stringifyJson(options?: StringifyJsonOptions): Getter<string, un
 export function splitKeyValue<E extends string>(options?: {
   readonly separator?: string | undefined
   readonly keyValueSeparator?: string | undefined
+  readonly trim?: boolean | undefined
+  readonly keepEmptyValues?: boolean | undefined
 }): Getter<Record<string, string>, E> {
   const separator = options?.separator ?? ","
   const keyValueSeparator = options?.keyValueSeparator ?? "="
+  const trim = options?.trim ?? false
+  const keepEmptyValues = options?.keepEmptyValues ?? false
   return transform((input) =>
     input.split(separator).reduce((acc, pair) => {
+      let key: string
+      let value: string
       if (keyValueSeparator === "") {
-        const [key, value] = pair.split("")
-        if (key && value) InternalRecord.assignProperty(acc, key, value)
-        return acc
+        key = pair.slice(0, 1)
+        value = pair.slice(1, 2)
+      } else {
+        const index = pair.indexOf(keyValueSeparator)
+        if (index === -1) return acc
+        key = pair.slice(0, index)
+        value = pair.slice(index + keyValueSeparator.length)
       }
-      const index = pair.indexOf(keyValueSeparator)
-      if (index <= 0) return acc
-      const key = pair.slice(0, index)
-      const value = pair.slice(index + keyValueSeparator.length)
-      if (value) {
-        InternalRecord.assignProperty(acc, key, value)
+      if (trim) {
+        key = key.trim()
+        value = value.trim()
       }
+      if (key === "" || (value === "" && !keepEmptyValues)) return acc
+      InternalRecord.assignProperty(acc, key, value)
       return acc
     }, {} as Record<string, string>)
   )
@@ -2271,7 +2283,11 @@ function bracketPathToTokens(bracketPath: string): Array<string | number> {
     return [""]
   }
 
-  const replaced = bracketPath.replace(/\[(.*?)\]/g, ".$1")
+  // Consume unmatched bracket runs too, avoiding repeated scans for a closing bracket.
+  const replaced = bracketPath.replace(
+    /\[([^\]\r\n\u2028\u2029]*)(\])?/g,
+    (match, content, closing) => closing ? `.${content}` : match
+  )
   const parts = replaced.split(".")
   // if bracket path started with "[...]" we get ".foo" => ["", "foo"]; drop the synthetic first ""
   const start = replaced.startsWith(".") ? 1 : 0

package/src/SchemaParser.ts

@@ -1136,29 +1136,62 @@ function runSync<T>(effect: Effect.Effect<T, SchemaIssue.Issue>, message: string
   throw new Error("Schema validation failed", { cause: issue })
 }
 
+const constructorDefectMessage = "Constructor adapter can only throw schema issues"
+
+function throwConstructorDefect(error: unknown): never {
+  throw new Error(constructorDefectMessage, { cause: Cause.die(error) })
+}
+
 function makeConstructorSync<T, E>(
   ast: SchemaAST.AST
 ): (input: E, options?: Schema.MakeOptions) => T {
   let entry: CompilerRegistry.Entry | undefined
-  let parser: Parser | undefined
-  return (input, options) => {
-    entry ??= CompilerRegistry.resolve(ast)
-    const parseOptions = options?.disableChecks
-      ? options.parseOptions ? { ...options.parseOptions, disableChecks: true } : { disableChecks: true }
-      : options?.parseOptions ?? SchemaAST.defaultParseOptions
-    const make = entry.make
-    if (make !== undefined && input !== InternalParser.missing) {
-      let output: unknown
-      try {
-        output = make(input, parseOptions)
-      } catch (error) {
-        InternalSchemaCause.getSchemaIssueOrThrow(Cause.die(error), "Constructor adapter can only throw schema issues")
-        throw error
-      }
-      if (output !== CompilerRegistry.invalid && output !== InternalParser.missing) return output as T
+  return (input, options) => constructSync(entry ??= CompilerRegistry.resolve(ast), input, options)
+}
+
+function constructSync<T>(entry: CompilerRegistry.Entry, input: unknown, options: Schema.MakeOptions | undefined): T {
+  const parseOptions = options?.disableChecks
+    ? options.parseOptions ? { ...options.parseOptions, disableChecks: true } : { disableChecks: true }
+    : options?.parseOptions ?? SchemaAST.defaultParseOptions
+  const make = entry.make
+  if (make !== undefined && input !== InternalParser.missing) {
+    let output: unknown
+    try {
+      output = make(input, parseOptions)
+    } catch (error) {
+      throwConstructorDefect(error)
     }
-    const result = (parser ??= entry.makeEffect)(input, parseOptions)
-    return runSync(parserResult<T, never>(result, input), "Constructor adapter can only throw schema issues")
+    if (output !== CompilerRegistry.invalid && output !== InternalParser.missing) return output as T
+  }
+  return runSync(parserResult<T, never>(entry.makeEffect(input, parseOptions), input), constructorDefectMessage)
+}
+
+/**
+ * Constructs a class instance from its type-side declaration.
+ *
+ * When the declaration has no compiled constructor, the fields are validated first
+ * and the instance is built outside the parser, so stacks captured by the
+ * class constructor keep the caller's frames.
+ *
+ * @internal
+ */
+export function makeClassSync<T>(
+  ast: SchemaAST.AST,
+  input: unknown,
+  options: Schema.MakeOptions | undefined,
+  construct: (fields: object) => T
+): T {
+  const entry = CompilerRegistry.resolve(ast)
+  const descriptor = SchemaAST.getConstructorDescriptor(ast)
+  if (descriptor === undefined || entry.make !== undefined || entry.compiledMakeEffect !== undefined) {
+    return constructSync(entry, input, options)
+  }
+  if (descriptor.isConstructed(input)) return input as T
+  const fields = constructSync<object>((entry.resolve ?? CompilerRegistry.resolve)(descriptor.link.to), input, options)
+  try {
+    return construct(fields)
+  } catch (error) {
+    throwConstructorDefect(error)
   }
 }
 

package/src/SchemaRepresentation.ts

@@ -288,13 +288,19 @@ export interface Unknown extends Keyword<"Unknown"> {}
 export interface Any extends Keyword<"Any"> {}
 
 /**
- * A string representation.
+ * A string representation, optionally describing its content through a media
+ * type and a schema for the value encoded in the string.
  *
  * @stability stable
  * @category models
  * @since 4.0.0
  */
-export interface String extends Keyword<"String"> {}
+export interface String extends Keyword<"String"> {
+  readonly content?: {
+    readonly mediaType: string
+    readonly schema?: Representation | undefined
+  } | undefined
+}
 
 /**
  * A number representation.
@@ -922,6 +928,25 @@ export const isULIDReviver: FilterReviver<null> = makeReviverFilter(
   ({ annotations }) => Schema.isULID(annotations)
 )
 
+/**
+ * Reviver for persisted `isAscii` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isAscii}.
+ *
+ * @see {@link Schema.isAscii} for creating the corresponding check
+ *
+ * @stability unstable
+ * @category validation
+ * @since 4.0.6
+ */
+export const isAsciiReviver: FilterReviver<null> = makeReviverFilter(
+  "effect/schema/isAscii",
+  Schema.Null,
+  ({ annotations }) => Schema.isAscii(annotations)
+)
+
 /**
  * Reviver for persisted `isBase64` checks.
  *
@@ -2388,26 +2413,6 @@ export const MutableJsonReviver: DeclarationReviver<null> = makeFixedDeclaration
   Schema.MutableJson
 )
 
-const jsonSchemaRevivers: ReadonlyArray<AnyReviver> = [
-  JsonReviver,
-  isPatternReviver,
-  isFiniteReviver,
-  isGreaterThanReviver,
-  isGreaterThanOrEqualToReviver,
-  isLessThanReviver,
-  isLessThanOrEqualToReviver,
-  isMultipleOfReviver,
-  isIntReviver,
-  isMinLengthReviver,
-  isMaxLengthReviver,
-  isMinCodePointsReviver,
-  isMaxCodePointsReviver,
-  isMinPropertiesReviver,
-  isMaxPropertiesReviver,
-  isPropertyNamesReviver,
-  isUniqueReviver
-]
-
 /**
  * Options for importing JSON Schema Draft 2020-12 documents.
  *
@@ -2965,7 +2970,14 @@ const RepresentationUnion = Schema.Union([
   makeKeywordSchema("Never"),
   makeKeywordSchema("Unknown"),
   makeKeywordSchema("Any"),
-  makeKeywordSchema("String"),
+  Schema.Struct({
+    _tag: Schema.tag("String"),
+    ...KeywordFields,
+    content: Schema.optional(Schema.Struct({
+      mediaType: Schema.String,
+      schema: Schema.optional(RepresentationSchema)
+    }))
+  }),
   makeKeywordSchema("Number"),
   makeKeywordSchema("Boolean"),
   makeKeywordSchema("BigInt"),
@@ -3192,11 +3204,13 @@ export function fromRepresentations(
  * - 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.
  * - Unknown extension keywords are ignored and their semantics are not enforced.
- * - Only direct local references to top-level definitions in the form `#/$defs/<escaped-token>` are supported. Root
- *   references, external references, and pointers below a definition are rejected with the supported reference format.
- *   Missing definitions are reported by name. References reached inside nested schema
- *   resources introduced by `$id` are rejected instead of resolved against the top-level definitions.
- * - Built-in declarations and checks are reconstructed with importer-owned revivers.
+ * - 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
+ *   external references are rejected with the supported reference format. Missing definitions are reported by name.
+ *   References reached inside nested schema resources introduced by `$id` are rejected instead of resolved against the
+ *   top-level definitions.
+ * - Imported constraints use built-in schemas and checks.
  * - Pattern constraints reached during translation cause an error by default. Use `patterns: "apply"` only for trusted
  *   documents, or `patterns: "ignore"` to skip them. Ignoring patterns can both admit invalid values and reject valid
  *   values when `oneOf` branches start overlapping.
@@ -3214,7 +3228,7 @@ export function fromJsonSchemaDocument(
   document: JsonSchema.Document<"draft-2020-12">,
   options?: FromJsonSchemaOptions
 ): Schema.Top {
-  return InternalFromJsonSchemaDocument.fromJsonSchemaDocument(document, options, jsonSchemaRevivers)
+  return InternalFromJsonSchemaDocument.fromJsonSchemaDocument(document, options)
 }
 
 /**
@@ -3238,10 +3252,12 @@ export function fromJsonSchemaDocument(
  *   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.
- * - Only direct local references to top-level definitions in the form `#/$defs/<escaped-token>` are supported. Root
- *   references, external references, and pointers below a definition are rejected with the supported reference format.
- *   Missing definitions are reported by name. References reached inside nested schema
- *   resources introduced by `$id` are rejected instead of resolved against the top-level definitions.
+ * - 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
+ *   external references are rejected with the supported reference format. Missing definitions are reported by name.
+ *   References reached inside nested schema resources introduced by `$id` are rejected instead of resolved against the
+ *   top-level definitions.
  * - Pattern constraints reached during translation cause an error by default. Use `patterns: "apply"` only for trusted
  *   documents, or `patterns: "ignore"` to skip them. Ignoring patterns can both admit invalid values and reject valid
  *   values when `oneOf` branches start overlapping.
@@ -3258,5 +3274,5 @@ export function fromJsonSchemaMultiDocument(
   document: JsonSchema.MultiDocument<"draft-2020-12">,
   options?: FromJsonSchemaOptions
 ): readonly [Schema.Top, ...Array<Schema.Top>] {
-  return InternalFromJsonSchemaDocument.fromJsonSchemaMultiDocument(document, options, jsonSchemaRevivers)
+  return InternalFromJsonSchemaDocument.fromJsonSchemaMultiDocument(document, options)
 }

package/src/SchemaTransformation.ts

@@ -20,6 +20,7 @@ import * as Duration from "./Duration.ts"
 import * as Effect from "./Effect.ts"
 import { format, formatDate, formatJson } from "./Formatter.ts"
 import { dual } from "./Function.ts"
+import * as InternalContent from "./internal/schema/content.ts"
 import * as Option from "./Option.ts"
 import * as Pipeable from "./Pipeable.ts"
 import * as Predicate from "./Predicate.ts"
@@ -613,7 +614,10 @@ export function trim(): Transformation<string, string> {
  *
  * Decoding converts values such as `"my_field_name"` to `"myFieldName"`.
  * Encoding converts values such as `"myFieldName"` back to `"my_field_name"`.
- * The transformation is round-trippable for standard snake_case and camelCase.
+ * Lowercase snake_case values round-trip when single underscores separate the
+ * segments and every segment after the first starts with a letter. A segment
+ * that starts with a digit does not: `"foo_2_bar"` decodes to `"foo2Bar"`,
+ * which encodes to `"foo2_bar"`.
  *
  * **Example** (Converting snake case to camel case)
  *
@@ -808,9 +812,12 @@ export function uncapitalize(): Transformation<string, string> {
  * **Details**
  *
  * Decoding splits the string by `separator` (default `","`) into pairs, then
- * splits each pair by `keyValueSeparator` (default `"="`). Encoding joins the
- * record back into a string using the same separators. The transformation is
- * round-trippable when keys and values do not contain the separators.
+ * splits each pair by `keyValueSeparator` (default `"="`). Set `trim` to trim
+ * keys and values, and `keepEmptyValues` to keep pairs with an empty value as
+ * `""` instead of skipping them (see {@link SchemaGetter.splitKeyValue}).
+ * Encoding joins the record back into a string using the same separators. The
+ * transformation is round-trippable when keys and values do not contain the
+ * separators and, with `trim`, have no surrounding whitespace.
  *
  * **Example** (Parsing key-value pairs)
  *
@@ -836,6 +843,8 @@ export function uncapitalize(): Transformation<string, string> {
 export function splitKeyValue(options?: {
   readonly separator?: string | undefined
   readonly keyValueSeparator?: string | undefined
+  readonly trim?: boolean | undefined
+  readonly keepEmptyValues?: boolean | undefined
 }): Transformation<Record<string, string>, string> {
   return new Transformation(
     SchemaGetter.splitKeyValue(options),
@@ -1950,7 +1959,10 @@ export function fromJsonString(options?: {
 }): Transformation<unknown, string> {
   return new Transformation(
     SchemaGetter.parseJson(options ?? {}),
-    SchemaGetter.stringifyJson(options)
+    InternalContent.setContent(SchemaGetter.stringifyJson(options), {
+      mediaType: "application/json",
+      preserveSchema: options?.reviver === undefined && options?.replacer === undefined
+    })
   )
 }
 

package/src/ScopedCache.ts

@@ -29,7 +29,6 @@ import * as MutableHashMap from "./MutableHashMap.ts"
 import * as Option from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import * as Predicate from "./Predicate.ts"
-import { UnhandledLogLevel } from "./References.ts"
 import * as Scope from "./Scope.ts"
 
 const TypeId = "~effect/ScopedCache"
@@ -411,12 +410,9 @@ const hasExpired = <A, E>(entry: Entry<A, E>, fiber: Fiber.Fiber<unknown, unknow
 
 // Expiry and capacity eviction report cleanup failures without failing unrelated readers.
 const closeEvicted = <A, E>(entry: Entry<A, E>): Effect.Effect<void> =>
-  effect.catchCause(Scope.close(entry.scope, effect.exitVoid), reportUnhandledError)
-
-const reportUnhandledError = <E>(cause: Cause.Cause<E>): Effect.Effect<void> =>
-  core.withFiber((fiber) => {
-    const level = fiber.getRef(UnhandledLogLevel)
-    return level ? effect.logWithLevel(level)("Unhandled error in ScopedCache finalizer", cause) : effect.void
+  effect.ignoreCause(Scope.close(entry.scope, effect.exitVoid), {
+    log: "Unhandled",
+    message: "Unhandled error in ScopedCache finalizer"
   })
 
 const checkCapacity = <K, A, E>(
@@ -1184,7 +1180,7 @@ export const keys = <Key, A, E, R>(self: ScopedCache<Key, A, E, R>): Effect.Effe
         keys.push(key)
       } else {
         MutableHashMap.remove(state.map, key)
-        fibers.push(effect.forkUnsafe(fiber, Scope.close(entry.scope, effect.exitVoid), true, true))
+        fibers.push(effect.forkUnsafe(fiber, closeEvicted(entry), true, true))
       }
     }
     return fibers.length === 0 ? effect.succeed(keys) : effect.as(effect.fiberAwaitAll(fibers), keys)
@@ -1249,7 +1245,7 @@ export const entries = <Key, A, E, R>(self: ScopedCache<Key, A, E, R>): Effect.E
         }
       } else {
         MutableHashMap.remove(state.map, key)
-        fibers.push(effect.forkUnsafe(fiber, Scope.close(entry.scope, effect.exitVoid), true, true))
+        fibers.push(effect.forkUnsafe(fiber, closeEvicted(entry), true, true))
       }
     }
     return fibers.length === 0