effect 4.0.6 → 4.1.0

package/src/Equal.ts

@@ -12,7 +12,7 @@
  */
 import type { Equivalence } from "./Equivalence.ts"
 import * as Hash from "./Hash.ts"
-import { byReferenceInstances, getAllObjectKeys, viewBytes } from "./internal/equal.ts"
+import { bufferBytes, byReferenceInstances, getAllObjectKeys, isArrayBufferLike, viewBytes } from "./internal/equal.ts"
 import { hasProperty } from "./Predicate.ts"
 
 /**
@@ -257,6 +257,13 @@ function compareStructure(self: object, that: object): boolean {
       return false
     }
     return compareArrays(self, that)
+  } else if (isArrayBufferLike(self)) {
+    if (!isArrayBufferLike(that) || (self instanceof ArrayBuffer) !== (that instanceof ArrayBuffer)) {
+      return false
+    }
+    const selfBytes = bufferBytes(self)
+    const thatBytes = bufferBytes(that)
+    return selfBytes !== undefined && thatBytes !== undefined && compareTypedArrays(selfBytes, thatBytes)
   } else if (ArrayBuffer.isView(self)) {
     const selfIsDataView = self instanceof DataView
     if (

package/src/Exit.ts

@@ -463,7 +463,7 @@ export const isFailure: <A, E>(self: Exit<A, E>) => self is Failure<A, E> = effe
  * @category guards
  * @since 4.0.0
  */
-export const hasFails: <A, E>(self: Exit<A, E>) => self is Failure<A, E> = effect.exitHasFails
+export const hasFails: <A, E>(self: Exit<A, E>) => boolean = effect.exitHasFails
 
 /**
  * Checks whether a failed Exit contains defects (Die reasons).
@@ -494,7 +494,7 @@ export const hasFails: <A, E>(self: Exit<A, E>) => self is Failure<A, E> = effec
  * @category guards
  * @since 4.0.0
  */
-export const hasDies: <A, E>(self: Exit<A, E>) => self is Failure<A, E> = effect.exitHasDies
+export const hasDies: <A, E>(self: Exit<A, E>) => boolean = effect.exitHasDies
 
 /**
  * Checks whether a failed Exit contains interruptions (Interrupt reasons).
@@ -525,7 +525,7 @@ export const hasDies: <A, E>(self: Exit<A, E>) => self is Failure<A, E> = effect
  * @category guards
  * @since 4.0.0
  */
-export const hasInterrupts: <A, E>(self: Exit<A, E>) => self is Failure<A, E> = effect.exitHasInterrupts
+export const hasInterrupts: <A, E>(self: Exit<A, E>) => boolean = effect.exitHasInterrupts
 
 /**
  * Extracts the Success variant from an Exit as a Result.

package/src/FileSystem.ts

@@ -17,6 +17,7 @@ import * as Cause from "./Cause.ts"
 import * as Context from "./Context.ts"
 import * as Effect from "./Effect.ts"
 import { pipe } from "./Function.ts"
+import * as Glob from "./internal/glob.ts"
 import * as Layer from "./Layer.ts"
 import * as Option from "./Option.ts"
 import { badArgument, type PlatformError, systemError } from "./PlatformError.ts"
@@ -130,13 +131,36 @@ export interface FileSystem {
     gid: number
   ) => Effect.Effect<void, PlatformError>
   /**
-   * Glob a directory.
+   * Finds paths under `root` that match a glob pattern.
+   *
+   * **Details**
+   *
+   * Patterns follow `Glob.make`: wildcards skip names that start with `.`
+   * unless the pattern segment starts with `.` or `dot` is `true`, and
+   * `dir/**` includes `dir` itself. Results are `/`-separated paths relative
+   * to `root` (or absolute for an absolute pattern), visited depth-first with
+   * each directory's entries sorted by name. `**` does not traverse symbolic
+   * links to directories, but a link named by another segment is followed.
+   * Paths that match an `exclude` pattern are dropped, and excluded
+   * directories are not read. Entries whose type cannot be determined, such
+   * as broken links, are treated as files.
+   *
+   * Read failures at the root or a leading literal directory propagate. Missing
+   * paths return an empty result; unreadable wildcard-reached directories are
+   * skipped.
+   *
+   * **Gotchas**
+   *
+   * Wildcard matching is case-sensitive. Leading literal segments use `stat`,
+   * so their case sensitivity follows the file system and results retain the
+   * pattern's spelling.
    */
   readonly glob: (
     pattern: string,
     options?: {
       readonly root?: string | undefined
       readonly exclude?: ReadonlyArray<string> | undefined
+      readonly dot?: boolean | undefined
     }
   ) => Effect.Effect<Array<string>, PlatformError>
   /**
@@ -254,6 +278,22 @@ export interface FileSystem {
       readonly recursive?: boolean | undefined
     }
   ) => Effect.Effect<Array<string>, PlatformError>
+  /**
+   * Lists a directory with the type of each entry.
+   *
+   * **Details**
+   *
+   * Returns the same bare names as `readDirectory(path)`, excluding `.` and
+   * `..`, in no particular order. Types describe entries, not symlink targets.
+   * `"Unknown"` is allowed when the listing cannot determine the type, and
+   * `glob` then falls back to `stat`.
+   *
+   * **Gotchas**
+   *
+   * Wrappers that change `readDirectory`, such as by prefixing paths, must
+   * apply the same change here for `glob` to list the correct directory.
+   */
+  readonly readDirectoryEntries: (path: string) => Effect.Effect<ReadonlyArray<DirectoryEntry>, PlatformError>
   /**
    * Read the contents of a file.
    */
@@ -485,6 +525,21 @@ export type OpenFlag =
  */
 export const FileSystem: Context.Service<FileSystem, FileSystem> = Context.Service("effect/FileSystem")
 
+/**
+ * A directory entry with its type, independent of any symlink target.
+ * `"Unknown"` means the listing could not determine the type.
+ *
+ * @see {@link FileSystem} `readDirectoryEntries`, which returns these entries
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.0
+ */
+export interface DirectoryEntry {
+  readonly name: string
+  readonly type: File.Type
+}
+
 /**
  * Creates a FileSystem implementation from a partial implementation.
  *
@@ -497,8 +552,10 @@ export const FileSystem: Context.Service<FileSystem, FileSystem> = Context.Servi
  * **Details**
  *
  * This function takes a partial FileSystem implementation and automatically provides
- * default implementations for `exists`, `readFileString`, `stream`, `sink`, and
- * `writeFileString` methods based on the provided core methods.
+ * default implementations for `exists`, `glob`, `readFileString`, `stream`, `sink`,
+ * and `writeFileString` methods based on the provided core methods. `glob` walks
+ * the tree with `readDirectoryEntries`, using `stat` and `readLink` for entries
+ * whose type is `"Unknown"`.
  *
  * @see {@link makeNoop} for a testing stub that accepts method overrides without requiring a complete implementation
  * @see {@link layerNoop} for providing a no-op `FileSystem` as a `Layer` in tests
@@ -508,11 +565,12 @@ export const FileSystem: Context.Service<FileSystem, FileSystem> = Context.Servi
  * @since 4.0.0
  */
 export const make = (
-  impl: Omit<FileSystem, typeof TypeId | "exists" | "readFileString" | "stream" | "sink" | "writeFileString">
+  impl: Omit<FileSystem, typeof TypeId | "exists" | "glob" | "readFileString" | "stream" | "sink" | "writeFileString">
 ): FileSystem =>
   FileSystem.of({
     ...impl,
     [TypeId]: TypeId,
+    glob: Glob.make(impl),
     exists: (path) =>
       pipe(
         impl.access(path),
@@ -702,6 +760,9 @@ export const makeNoop = (fileSystem: Partial<FileSystem>): FileSystem =>
     readDirectory(path) {
       return Effect.fail(notFound("readDirectory", path))
     },
+    readDirectoryEntries(path) {
+      return Effect.fail(notFound("readDirectoryEntries", path))
+    },
     readFile(path) {
       return Effect.fail(notFound("readFile", path))
     },

package/src/Formatter.ts

@@ -309,10 +309,11 @@ export function formatJson(input: unknown, options?: {
   readonly space?: number | string | undefined
 }): string {
   const ancestors: Array<object> = []
+  const sources = new WeakMap<object, object>()
   return JSON.stringify(
     input,
     function(this: object, key: string, value: unknown) {
-      const original = Object.getOwnPropertyDescriptor(this, key)?.value
+      const original = Object.getOwnPropertyDescriptor(sources.get(this) ?? this, key)?.value
       const redacted = Predicate.hasProperty(original, symbolRedactable)
         ? redact(original)
         : redact(value)
@@ -339,18 +340,10 @@ export function formatJson(input: unknown, options?: {
       if (!hasGetter(current) || isJsonPrimitiveWrapper(current)) {
         return current
       }
-      // JSON.stringify reads a getter once, then calls toJSON on the result
-      // before the replacer sees it. Intercept that read to redact the value
-      // first, instead of re-reading the getter in the replacer, which could
-      // repeat side effects or return a different value.
-      const serialized = new Proxy(current, {
-        get(target, key) {
-          const value = Reflect.get(target, key, target)
-          return Object.getOwnPropertyDescriptor(target, key)?.get !== undefined ? redact(value) : value
-        }
-      })
-      ancestors.push(serialized)
-      return serialized
+      const view = redactingView(current)
+      sources.set(view, current)
+      ancestors.push(view)
+      return view
     },
     options?.space
   ) ?? "null"
@@ -365,6 +358,28 @@ function hasGetter(object: object): boolean {
   return false
 }
 
+// JSON.stringify reads a getter once, then calls toJSON on the result before
+// the replacer sees it, so getter results are redacted at the read. A Proxy
+// would do, but not every engine has one, so each key becomes a getter that
+// reads the source lazily, with the source as receiver.
+function redactingView(object: object): object {
+  const view = Array.isArray(object) ? [] : {}
+  // JSON.stringify reads every array index, regardless of enumerability
+  const keys = Array.isArray(object)
+    ? Array.from({ length: object.length }, (_, i) => String(i))
+    : Object.keys(object)
+  for (const key of keys) {
+    Object.defineProperty(view, key, {
+      enumerable: true,
+      get: () => {
+        const value = Reflect.get(object, key)
+        return Object.getOwnPropertyDescriptor(object, key)?.get !== undefined ? redact(value) : value
+      }
+    })
+  }
+  return view
+}
+
 function isJsonPrimitiveWrapper(object: object): boolean {
   // Built-in valueOf checks internal slots across realms without calling user code.
   for (const valueOf of [Number.prototype.valueOf, Boolean.prototype.valueOf, String.prototype.valueOf]) {

package/src/Glob.ts

@@ -0,0 +1,205 @@
+/**
+ * Matches `/`-separated paths without accessing the file system, using the
+ * same pattern syntax as `FileSystem.glob`.
+ *
+ * @stability experimental
+ * @since 4.0.0
+ */
+import { format } from "./Formatter.ts"
+import { dual } from "./Function.ts"
+import { type Inspectable, NodeInspectSymbol } from "./Inspectable.ts"
+import * as internal from "./internal/glob.ts"
+import { type Pipeable, pipeArguments } from "./Pipeable.ts"
+
+const TypeId = "~effect/Glob"
+
+/**
+ * A compiled glob pattern.
+ *
+ * **Details**
+ *
+ * `pattern` is the source text and `dot` records whether wildcards match names
+ * that start with `.`. Match paths against it with {@link match}.
+ *
+ * @see {@link make} for compiling a pattern
+ *
+ * @stability experimental
+ * @category models
+ * @since 4.0.0
+ */
+export interface Glob extends Pipeable, Inspectable {
+  readonly [TypeId]: typeof TypeId
+  readonly pattern: string
+  readonly dot: boolean
+}
+
+interface GlobImpl extends Glob {
+  readonly compiled: internal.Compiled
+}
+
+const GlobProto = {
+  [TypeId]: TypeId,
+  toJSON(this: Glob) {
+    return { _id: "Glob", pattern: this.pattern, dot: this.dot }
+  },
+  toString(this: Glob) {
+    return `Glob(${format(this.toJSON())})`
+  },
+  [NodeInspectSymbol](this: Glob) {
+    return this.toJSON()
+  },
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+/**
+ * Compiles a glob pattern into a reusable `Glob`.
+ *
+ * **Details**
+ *
+ * Patterns use `/` as the separator. `*` matches any run of characters within
+ * one path segment, `?` matches one character, and `[...]` matches one
+ * character from a set, with `!` or `^` negating it and POSIX classes such as
+ * `[[:digit:]]` allowed. `{a,b}` expands to each alternative and may nest. A
+ * segment that is exactly `**` matches zero or more whole segments. A trailing
+ * `/` matches only directories, and `\` makes the next character literal.
+ *
+ * **Gotchas**
+ *
+ * Wildcards and `**` skip names that start with `.` unless the pattern segment
+ * itself starts with `.` or `dot` is `true`; they never match `.` or `..`.
+ * `x/.` is the same as `x/`, and a `.` or `..` segment after `**` makes the
+ * pattern match nothing, as does the empty pattern. UNC patterns and paths
+ * such as `//server/share` are not supported and never match. Braces and
+ * commas inside `[...]` are class members. Extended glob syntax and leading
+ * `!` negation are not interpreted, but ordinary wildcards still apply within
+ * them (for example, `?(a)` matches `x(a)`). Malformed syntax, such as an
+ * unclosed `[`, matches literally. Braces also stay literal if expansion would
+ * exceed 10,000 alternatives.
+ *
+ * **Example** (Matching source files)
+ *
+ * ```ts import.meta.vitest
+ * import { Glob } from "effect"
+ *
+ * const sources = Glob.make("src/**\/*.{ts,tsx}")
+ *
+ * Glob.match(sources, "src/index.ts") // => true
+ * Glob.match(sources, "src/ui/Button.tsx") // => true
+ * Glob.match(sources, "src/.cache/index.ts") // => false
+ * Glob.match(sources, "test/index.ts") // => false
+ * ```
+ *
+ * @stability experimental
+ * @category constructors
+ * @since 4.0.0
+ */
+export const make = (pattern: string, options?: {
+  /** Whether wildcards and `**` match names that start with `.`. */
+  readonly dot?: boolean | undefined
+}): Glob => {
+  const dot = options?.dot ?? false
+  const self = Object.create(GlobProto)
+  self.pattern = pattern
+  self.dot = dot
+  self.compiled = internal.compile([pattern], dot)
+  return self
+}
+
+/**
+ * Tests whether a `/`-separated path matches a `Glob`.
+ *
+ * **Details**
+ *
+ * Empty segments and `./` segments in the path are ignored. A trailing `/`
+ * marks the path as a directory, which a pattern ending in `/` requires.
+ *
+ * **Example** (Filtering paths)
+ *
+ * ```ts import.meta.vitest
+ * import { Glob, pipe } from "effect"
+ *
+ * const tests = Glob.make("**\/*.test.ts")
+ * const paths = ["src/a.ts", "src/a.test.ts", "test/b.test.ts"]
+ *
+ * paths.filter((path) => Glob.match(tests, path)) // => ["src/a.test.ts", "test/b.test.ts"]
+ * pipe(tests, Glob.match("./src/a.test.ts")) // => true
+ * ```
+ *
+ * @stability experimental
+ * @category predicates
+ * @since 4.0.0
+ */
+export const match: {
+  /**
+   * Tests whether a `/`-separated path matches a `Glob`.
+   *
+   * **Details**
+   *
+   * Empty segments and `./` segments in the path are ignored. A trailing `/`
+   * marks the path as a directory, which a pattern ending in `/` requires.
+   *
+   * **Example** (Filtering paths)
+   *
+   * ```ts import.meta.vitest
+   * import { Glob, pipe } from "effect"
+   *
+   * const tests = Glob.make("**\/*.test.ts")
+   * const paths = ["src/a.ts", "src/a.test.ts", "test/b.test.ts"]
+   *
+   * paths.filter((path) => Glob.match(tests, path)) // => ["src/a.test.ts", "test/b.test.ts"]
+   * pipe(tests, Glob.match("./src/a.test.ts")) // => true
+   * ```
+   *
+   * @stability experimental
+   * @category predicates
+   * @since 4.0.0
+   */
+  (path: string): (self: Glob) => boolean
+  /**
+   * Tests whether a `/`-separated path matches a `Glob`.
+   *
+   * **Details**
+   *
+   * Empty segments and `./` segments in the path are ignored. A trailing `/`
+   * marks the path as a directory, which a pattern ending in `/` requires.
+   *
+   * **Example** (Filtering paths)
+   *
+   * ```ts import.meta.vitest
+   * import { Glob, pipe } from "effect"
+   *
+   * const tests = Glob.make("**\/*.test.ts")
+   * const paths = ["src/a.ts", "src/a.test.ts", "test/b.test.ts"]
+   *
+   * paths.filter((path) => Glob.match(tests, path)) // => ["src/a.test.ts", "test/b.test.ts"]
+   * pipe(tests, Glob.match("./src/a.test.ts")) // => true
+   * ```
+   *
+   * @stability experimental
+   * @category predicates
+   * @since 4.0.0
+   */
+  (self: Glob, path: string): boolean
+} = dual(2, (self: Glob, path: string): boolean => internal.match((self as GlobImpl).compiled, path))
+
+/**
+ * Escapes glob syntax so a string matches only itself.
+ *
+ * **Example** (Matching a literal file name)
+ *
+ * ```ts import.meta.vitest
+ * import { Glob } from "effect"
+ *
+ * const name = "report[1].txt"
+ *
+ * Glob.match(Glob.make(name), name) // => false
+ * Glob.match(Glob.make(Glob.escape(name)), name) // => true
+ * ```
+ *
+ * @stability experimental
+ * @category utils
+ * @since 4.0.0
+ */
+export const escape = (input: string): string => input.replace(/[\\*?[\]{}]/g, "\\$&")

package/src/Hash.ts

@@ -11,7 +11,7 @@
  * @since 2.0.0
  */
 import { dual } from "./Function.ts"
-import { byReferenceInstances, getAllObjectKeys, viewBytes } from "./internal/equal.ts"
+import { bufferBytes, byReferenceInstances, getAllObjectKeys, isArrayBufferLike, viewBytes } from "./internal/equal.ts"
 import { addBackEdge, backEdges } from "./internal/hash.ts"
 import { hasProperty } from "./Predicate.ts"
 
@@ -144,6 +144,9 @@ export const hash: <A>(self: A) => number = <A>(self: A) => {
             h = (self as Hash)[symbol]()
           } else if (typeof self === "function") {
             h = random(self)
+          } else if (isArrayBufferLike(self)) {
+            const bytes = bufferBytes(self)
+            h = bytes === undefined ? random(self) : array(bytes)
           } else if (self instanceof DataView) {
             h = array(viewBytes(self))
           } else if (Array.isArray(self) || ArrayBuffer.isView(self)) {

package/src/JsonPatch.ts

@@ -303,12 +303,16 @@ function isJsonObject(value: unknown): value is Schema.JsonObject {
  *
  * - `""` (empty pointer) refers to the root and returns `[]`
  * - Non-empty pointers must start with `/`
+ * - `~` must be followed by `0` or `1`
  */
 function tokenize(pointer: string): Array<string> {
   if (pointer === "") return []
   if (pointer.charCodeAt(0) !== 47 /* "/" */) {
     throw new Error(`Invalid JSON Pointer, it must start with "/": ${JSON.stringify(pointer)}`)
   }
+  if (/~(?![01])/.test(pointer)) {
+    throw new Error(`Invalid JSON Pointer escape: ${JSON.stringify(pointer)}`)
+  }
   return pointer.split("/").slice(1).map(unescapeToken)
 }
 

package/src/JsonSchema.ts

@@ -9,6 +9,7 @@
  * @stability stable
  * @since 4.0.0
  */
+import * as InternalJsonSchema from "./internal/jsonSchema.ts"
 import * as InternalRecord from "./internal/record.ts"
 import { formatUriFragment, parseUriFragment } from "./JsonPointer.ts"
 import * as Predicate from "./Predicate.ts"
@@ -725,30 +726,14 @@ function transformSchema(
     for (const key of Object.keys(node)) {
       const value = node[key]
       let transformed = value
-      switch (key) {
-        case "$defs":
-        case "properties":
-        case "patternProperties":
-        case "dependentSchemas":
+      switch (InternalJsonSchema.getSubschemaKind(key)) {
+        case "map":
           transformed = mapObject(value, (value) => walk(value, inEmbeddedResource)) ?? value
           break
-        case "allOf":
-        case "anyOf":
-        case "oneOf":
-        case "prefixItems":
+        case "array":
           transformed = Array.isArray(value) ? value.map((value) => walk(value, inEmbeddedResource)) : value
           break
-        case "not":
-        case "additionalProperties":
-        case "propertyNames":
-        case "unevaluatedProperties":
-        case "items":
-        case "contains":
-        case "unevaluatedItems":
-        case "if":
-        case "then":
-        case "else":
-        case "contentSchema":
+        case "schema":
           transformed = walk(value, inEmbeddedResource)
       }
       InternalRecord.assignProperty(out, key, transformed)
@@ -1236,6 +1221,7 @@ function draft07Adapter(source: JsonSchema, context: Context): JsonSchema {
       case "unevaluatedItems":
         unsupported(key, "Draft-07", "the target dialect has no equivalent")
       case "required":
+      case "enum":
         if (Array.isArray(value) && value.length === 0) break
         InternalRecord.assignProperty(out, key, value)
         break
@@ -1261,6 +1247,8 @@ function draft07Adapter(source: JsonSchema, context: Context): JsonSchema {
   convertDependencies(source, out, context, "draft-07")
   convertLegacyId(source, out, "$id", "Draft-07")
 
+  if (Array.isArray(source.enum) && source.enum.length === 0) appendAllOf(out, { not: {} })
+
   convertReference(out, reference, context)
 
   return out
@@ -1559,30 +1547,14 @@ function hasSchemaIdentifier(node: unknown): boolean {
   if (Object.hasOwn(node, "$id") || Object.hasOwn(node, "$anchor")) return true
   for (const key of Object.keys(node)) {
     const value = node[key]
-    switch (key) {
-      case "$defs":
-      case "properties":
-      case "patternProperties":
-      case "dependentSchemas":
+    switch (InternalJsonSchema.getSubschemaKind(key)) {
+      case "map":
         if (Predicate.isObject(value) && Object.values(value).some(hasSchemaIdentifier)) return true
         break
-      case "allOf":
-      case "anyOf":
-      case "oneOf":
-      case "prefixItems":
+      case "array":
         if (Array.isArray(value) && value.some(hasSchemaIdentifier)) return true
         break
-      case "not":
-      case "additionalProperties":
-      case "propertyNames":
-      case "unevaluatedProperties":
-      case "items":
-      case "contains":
-      case "unevaluatedItems":
-      case "if":
-      case "then":
-      case "else":
-      case "contentSchema":
+      case "schema":
         if (hasSchemaIdentifier(value)) return true
     }
   }