effect 4.0.0-beta.101 → 4.0.0-beta.102

package/src/SchemaGetter.ts

@@ -1015,13 +1015,10 @@ type StringifyJsonOptions = {
  * **Details**
  *
  * - Skips `None` inputs.
- * - On thrown stringify failures, such as circular references, fails with
+ * - If `JSON.stringify` throws or returns `undefined`, fails with
  *   `SchemaIssue.InvalidValue`.
  * - Supports optional `replacer` and `space` options, matching
  *   `JSON.stringify`.
- * - If `JSON.stringify` returns `undefined`, such as for `undefined`,
- *   functions, symbols, or a replacer that removes the root value, that
- *   `undefined` result is returned rather than converted into an `Issue`.
  *
  * **Example** (Stringifying JSON)
  *
@@ -1040,7 +1037,13 @@ type StringifyJsonOptions = {
 export function stringifyJson(options?: StringifyJsonOptions): Getter<string, unknown> {
   return onSome((input) =>
     Effect.try({
-      try: () => Option.some(JSON.stringify(input, options?.replacer, options?.space)),
+      try: () => {
+        const output = JSON.stringify(input, options?.replacer, options?.space)
+        if (output === undefined) {
+          throw new TypeError("Value cannot be represented as JSON")
+        }
+        return Option.some(output)
+      },
       catch: (e) => new SchemaIssue.InvalidValue(Option.some(input), { message: globalThis.String(e) })
     })
   )
@@ -1085,7 +1088,7 @@ export function splitKeyValue<E extends string>(options?: {
     input.split(separator).reduce((acc, pair) => {
       const [key, value] = pair.split(keyValueSeparator)
       if (key && value) {
-        acc[key] = value
+        InternalRecord.assignProperty(acc, key, value)
       }
       return acc
     }, {} as Record<string, string>)
@@ -1554,7 +1557,7 @@ export function dateTimeUtcFromInput<E extends DateTime.DateTime.Input>(): Gette
  * // Getter<TreeObject<string | Blob>, FormData>
  * ```
  *
- * @see {@link encodeFormData} for the inverse operation
+ * @see {@link encodeFormData} for the corresponding encoder
  * @see {@link makeTreeRecord} for the underlying bracket-path parser
  * @see {@link decodeURLSearchParams} for the URLSearchParams variant
  *
@@ -1592,7 +1595,7 @@ const collectFormDataEntries = collectBracketPathEntries((value): value is strin
  * // Getter<FormData, unknown>
  * ```
  *
- * @see {@link decodeFormData} for the inverse operation
+ * @see {@link decodeFormData} for the corresponding decoder
  * @see {@link collectBracketPathEntries} for the underlying flattener
  * @see {@link encodeURLSearchParams} for the URLSearchParams variant
  *
@@ -1635,7 +1638,7 @@ export function encodeFormData(): Getter<FormData, unknown> {
  * // Getter<TreeObject<string>, URLSearchParams>
  * ```
  *
- * @see {@link encodeURLSearchParams} for the inverse operation
+ * @see {@link encodeURLSearchParams} for the corresponding encoder
  * @see {@link makeTreeRecord} for the underlying bracket-path parser
  * @see {@link decodeFormData} for the FormData variant
  *
@@ -1670,7 +1673,7 @@ const collectURLSearchParamsEntries = collectBracketPathEntries(Predicate.isStri
  * // Getter<URLSearchParams, unknown>
  * ```
  *
- * @see {@link decodeURLSearchParams} for the inverse operation
+ * @see {@link decodeURLSearchParams} for the corresponding decoder
  * @see {@link collectBracketPathEntries} for the underlying flattener
  * @see {@link encodeFormData} for the FormData variant
  *
@@ -1704,20 +1707,6 @@ function bracketPathToTokens(bracketPath: string): Array<string | number> {
     .map((part) => (INDEX_REGEXP.test(part) ? globalThis.Number(part) : part))
 }
 
-function getOrCreateContainer(
-  self: any,
-  key: PropertyKey,
-  shouldBeArray: boolean
-): any {
-  const current = Object.hasOwn(self, key) ? self[key] : undefined
-  if (current !== undefined) {
-    return current
-  }
-  const container = shouldBeArray ? [] : {}
-  InternalRecord.set(self, key, container)
-  return container
-}
-
 /**
  * Builds a nested tree object from a list of bracket-path entries.
  *
@@ -1740,6 +1729,10 @@ function getOrCreateContainer(
  *   - `"foo[]"` → append to array `foo`
  *   - `""` → real empty key
  * - Duplicate keys for the same path are merged into arrays.
+ * - If a structural path conflicts with a previous leaf or a different container
+ *   type, the later structural path replaces the conflicting value.
+ * - The notation has no escaping for `.`, `[` or `]`, so keys containing these
+ *   delimiters cannot be round-tripped without changing their structure.
  *
  * **Example** (Building a tree from bracket paths)
  *
@@ -1754,7 +1747,7 @@ function getOrCreateContainer(
  * // { user: { name: "Alice", tags: ["admin", "editor"] } }
  * ```
  *
- * @see {@link collectBracketPathEntries} for the inverse operation (tree to flat entries)
+ * @see {@link collectBracketPathEntries} for flattening trees into bracket-path entries
  * @see {@link decodeFormData} for a higher-level FormData decoder
  * @see {@link decodeURLSearchParams} for a higher-level URLSearchParams decoder
  *
@@ -1765,6 +1758,19 @@ export function makeTreeRecord<A>(
   bracketPathEntries: ReadonlyArray<readonly [bracketPath: string, value: A]>
 ): Schema.TreeRecord<A> {
   const out: any = {}
+  const containers = new WeakSet<object>()
+
+  function getOrCreateContainer(self: any, key: PropertyKey, shouldBeArray: boolean): any {
+    const current = Object.hasOwn(self, key) ? self[key] : undefined
+    if (containers.has(current) && Array.isArray(current) === shouldBeArray) {
+      return current
+    }
+    const container = shouldBeArray ? [] : {}
+    containers.add(container)
+    InternalRecord.assignProperty(self, key, container)
+    return container
+  }
+
   bracketPathEntries.forEach(([key, value]) => {
     const tokens = bracketPathToTokens(key)
     let cur: any = out
@@ -1789,9 +1795,9 @@ export function makeTreeRecord<A>(
         if (hasOwn && Array.isArray(cur[token])) {
           cur[token].push(value)
         } else if (hasOwn) {
-          InternalRecord.set(cur, token, [cur[token], value])
+          InternalRecord.assignProperty(cur, token, [cur[token], value])
         } else {
-          InternalRecord.set(cur, token, value)
+          InternalRecord.assignProperty(cur, token, value)
         }
       } else {
         const next = tokens[i + 1]
@@ -1815,7 +1821,6 @@ export function makeTreeRecord<A>(
  *
  * **Details**
  *
- * - This is the inverse of {@link makeTreeRecord}.
  * - Takes a nested object and produces flat `[bracketPath, value]` pairs suitable for
  *   `FormData` or `URLSearchParams`.
  * - Returns a curried function: first call provides the leaf type guard, second call provides the object.
@@ -1823,6 +1828,8 @@ export function makeTreeRecord<A>(
  * - If all elements of an array are leaves, encodes them as multiple entries with the same key
  *   (e.g. `tags=a&tags=b`). Otherwise uses indexed bracket paths (e.g. `items[0]`, `items[1]`).
  * - Non-leaf values that aren't objects or arrays are silently skipped.
+ * - Empty arrays and objects produce no entries, and path delimiters in property
+ *   names are not escaped. The resulting format is therefore lossy.
  *
  * **Example** (Flattening an object to bracket paths)
  *
@@ -1834,7 +1841,7 @@ export function makeTreeRecord<A>(
  * // [["user[name]", "Alice"], ["user[tags]", "admin"], ["user[tags]", "editor"]]
  * ```
  *
- * @see {@link makeTreeRecord} for the inverse operation (flat entries to tree)
+ * @see {@link makeTreeRecord} for building trees from bracket-path entries
  * @see {@link encodeFormData} for a higher-level FormData encoder
  * @see {@link encodeURLSearchParams} for a higher-level URLSearchParams encoder
  *

package/src/SchemaIssue.ts

@@ -53,7 +53,7 @@ const TypeId = "~effect/SchemaIssue/Issue"
  * @since 4.0.0
  */
 export function isIssue(u: unknown): u is Issue {
-  return hasProperty(u, TypeId)
+  return hasProperty(u, TypeId) && u[TypeId] === TypeId
 }
 
 /**

package/src/SchemaParser.ts

@@ -31,8 +31,7 @@ const toConstructorAST = memoize((ast: SchemaAST.AST): SchemaAST.AST => {
       const getLink = ast.annotations?.[SchemaAST.ClassTypeId]
       if (Predicate.isFunction(getLink)) {
         const link = getLink(ast.typeParameters)
-        const to = toConstructorAST(link.to)
-        return SchemaAST.replaceEncoding(ast, to === link.to ? [link] : [new SchemaAST.Link(to, link.transformation)])
+        return SchemaAST.replaceEncoding(ast, [SchemaAST.mapLink(link, toConstructorAST)])
       }
       return ast
     }
@@ -1026,11 +1025,6 @@ const recur = memoize(
         return parser(ou, options)
       }
     }
-    const isStructural = SchemaAST.isArrays(ast) || SchemaAST.isObjects(ast) ||
-      (SchemaAST.isDeclaration(ast) && ast.typeParameters.length > 0)
-    const structuralChecks = checks && isStructural ?
-      checks.filter((check) => check.annotations?.[SchemaAST.STRUCTURAL_ANNOTATION_KEY]) :
-      undefined
     return (ou, options) => {
       if (astOptions) {
         options = { ...options, ...astOptions }
@@ -1072,24 +1066,6 @@ const recur = memoize(
         }
 
         if (checks && !options?.disableChecks) {
-          if (options?.errors === "all" && structuralChecks && structuralChecks.length > 0 && Option.isSome(localOu)) {
-            sroa = mapSchemaIssueEffect(sroa, (issue) => {
-              const issues: Array<SchemaIssue.Issue> = []
-              SchemaAST.collectIssues(
-                structuralChecks,
-                localOu.value,
-                issues,
-                ast,
-                options
-              )
-              const out: SchemaIssue.Issue = Arr.isArrayNonEmpty(issues)
-                ? issue._tag === "Composite" && issue.ast === ast
-                  ? new SchemaIssue.Composite(ast, issue.actual, [...issue.issues, ...issues])
-                  : new SchemaIssue.Composite(ast, localOu, [issue, ...issues])
-                : issue
-              return out
-            })
-          }
           sroa = Effect.flatMapEager(sroa, (oa) => {
             if (Option.isSome(oa)) {
               const value = oa.value