effect 4.0.0-rc.113 → 4.0.0-rc.115

package/src/SchemaRepresentation.ts

@@ -2175,7 +2175,8 @@ const jsonSchemaRevivers: ReadonlyArray<AnyReviver> = [
  * **Gotchas**
  *
  * Use `patterns: "apply"` only for trusted documents because regular expression evaluation may block for an unbounded
- * amount of time. `patterns: "ignore"` weakens validation by accepting values that the source document may reject.
+ * amount of time. `patterns: "ignore"` can admit values the source rejects, but can also reject previously valid
+ * values inside `oneOf` when removing constraints makes multiple branches match.
  * Ignoring `patternProperties` also skips its value constraints and `additionalProperties`, because matching keys cannot
  * be determined without evaluating the patterns.
  * `onEnter` must return a JSON Schema object. Its result is used directly, and exceptions raised by the callback pass
@@ -2835,30 +2836,39 @@ export function fromRepresentations(
  *
  * **Details**
  *
- * For the Draft 2020-12 subset translated exactly by this importer, compiling the imported schema through
- * {@link toRepresentation} and {@link toJsonSchemaDocument} produces a document that accepts the same JSON values as
- * the input. This is a semantic round-trip guarantee; keyword layout, definitions, and annotations may be normalized.
+ * Translates a Draft 2020-12 subset using Effect schemas and built-in checks. Validation follows those checks and the
+ * decoder's parse options, so import and re-export do not guarantee identical accepted values or a lossless round trip.
+ * Import errors explain the unsupported constraint or reference and include its source path.
  *
  * **Gotchas**
  *
- * - `$dynamicRef`, `contains`, `dependentRequired`, `dependentSchemas`, `not`, active `if` / `then` / `else`,
- *   `unevaluatedItems`, and `unevaluatedProperties` throw an `Unsupported JSON Schema keyword` error. Inactive
+ * - `{ not: {} }` imports as `Never`. Other uses of `not` are unsupported.
+ * - When `additionalProperties` is `true`, `{}`, or omitted, additional values use `Schema.Json` and are retained.
+ *   Closed objects normally strip excess properties by default; pass `onExcessProperty: "error"` to reject them.
+ *   Closed empty objects instead use `Schema.Record(Schema.String, Schema.Never)` and reject string-keyed entries
+ *   regardless of that option.
+ *   Object keyword scopes still constrain declared properties in intersections. Combinations requiring index
+ *   signatures that exclude explicit properties or patterned keys are rejected with an explanation of the limitation.
+ * - Property count and name checks run on the decoded object, after excess properties have been stripped.
+ * - String length checks count UTF-16 code units. `integer` uses `Schema.isInt`, which requires safe integers.
+ *   Applied patterns use `Schema.isPattern` without adding a Unicode flag.
+ * - `$dynamicRef`, `contains`, `dependentRequired`, `dependentSchemas`, active `if` / `then` / `else`,
+ *   `unevaluatedItems`, and `unevaluatedProperties` are rejected with an error identifying the unsupported keyword. Inactive
  *   conditional keywords and `minContains` / `maxContains` without `contains` have no validation effect and are ignored.
- * - Objects and arrays used as `const` values or `enum` members throw an `Unsupported structured JSON Schema value`
- *   error.
+ * - 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, throw an
- *   `Unsupported intersection of overlapping unions` error.
+ *   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 throw an `Unsupported reference` error. A direct
- *   reference to a missing definition throws an `Invalid reference` error.
+ *   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.
  * - Pattern constraints reached during translation cause an error by default. Use `patterns: "apply"` only for trusted
- *   documents, or `patterns: "ignore"` to weaken validation explicitly; ignored patterns are outside the round-trip
- *   guarantee.
- * - `onEnter` results replace the corresponding input nodes, so the round-trip guarantee applies to the rewritten
- *   document.
+ *   documents, or `patterns: "ignore"` to skip them. Ignoring patterns can both admit invalid values and reject valid
+ *   values when `oneOf` branches start overlapping.
+ * - `onEnter` results replace the corresponding input nodes before translation.
  * - Callback results are used directly, and exceptions raised by a callback pass through unchanged.
  *
  * @see {@link fromJsonSchemaMultiDocument} for multiple roots sharing definitions
@@ -2881,21 +2891,26 @@ export function fromJsonSchemaDocument(
  *
  * Use when multiple imported roots share reachable definitions, aliases, or recursion.
  *
+ * **Details**
+ *
+ * Uses the same best-effort translation, built-in checks, and excess-property behavior as {@link fromJsonSchemaDocument}.
+ *
  * **Gotchas**
  *
  * - Only definitions reachable from a root are translated.
- * - Unsupported standard validation and applicator keywords throw an `Unsupported JSON Schema keyword` error. Unknown
+ * - Unsupported standard validation and applicator keywords are rejected with an error identifying the keyword. Unknown
  *   extension keywords are ignored and their semantics are not enforced.
- * - Objects and arrays used as `const` values or `enum` members throw an `Unsupported structured JSON Schema value`
- *   error.
+ * - 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, throw an
- *   `Unsupported intersection of overlapping unions` error.
+ *   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 throw an `Unsupported reference` error. A direct
- *   reference to a missing definition throws an `Invalid reference` error.
+ *   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.
  * - Pattern constraints reached during translation cause an error by default. Use `patterns: "apply"` only for trusted
- *   documents, or `patterns: "ignore"` to weaken validation explicitly.
+ *   documents, or `patterns: "ignore"` to skip them. Ignoring patterns can both admit invalid values and reject valid
+ *   values when `oneOf` branches start overlapping.
  * - Callback results are used directly, and exceptions raised by a callback pass through unchanged.
  *
  * @see {@link fromJsonSchemaDocument} for a single root

package/src/internal/arbitrary/schema.ts

@@ -14,16 +14,16 @@ import * as InternalRecord from "../record.ts"
 import * as Model from "./model.ts"
 import * as Regexp from "./regexp.ts"
 
-type Constraint = Schema.Annotations.ToArbitrary.Constraint<any>
+type FilterConstraint = Schema.Annotations.ToArbitrary.FilterConstraint<any>
 type GenerationConstraint = Schema.Annotations.ToArbitrary.GenerationConstraint<any>
 
 interface Checks {
-  readonly constraint: Constraint | undefined
+  readonly constraint: FilterConstraint | undefined
   readonly filters: ReadonlyArray<SchemaAST.Filter<any>>
 }
 
 const infinity = Number.POSITIVE_INFINITY
-const finiteNumberConstraint: Constraint = { number: "finite" }
+const finiteNumberConstraint: FilterConstraint = { number: "finite" }
 const optionMatch = { onFailure: Option.none, onSuccess: Option.some }
 
 const optionComputation = <A, E, R>(self: Effect.Effect<A, E, R>): Model.Computation<Option.Option<A>> => {
@@ -79,7 +79,7 @@ function mergeMaximum(self: number | undefined, that: number | undefined): numbe
   return self === undefined ? that : that === undefined ? self : Math.min(self, that)
 }
 
-function mergeConstraint(self: Constraint | undefined, that: Constraint): Constraint {
+function mergeConstraint(self: FilterConstraint | undefined, that: FilterConstraint): FilterConstraint {
   const order = that.order ?? self?.order
   if (self?.order !== undefined && that.order !== undefined && self.order !== that.order) {
     throw new Error("Cannot merge ordered arbitrary constraints with different Order instances")
@@ -142,7 +142,7 @@ function mergeConstraint(self: Constraint | undefined, that: Constraint): Constr
   }
 }
 
-function collectChecks(checks: SchemaAST.Checks | undefined, inherited: Constraint | undefined): Checks {
+function collectChecks(checks: SchemaAST.Checks | undefined, inherited: FilterConstraint | undefined): Checks {
   let constraint = inherited
   const filters: Array<SchemaAST.Filter<any>> = []
   const visit = (check: SchemaAST.Check<any>): void => {
@@ -180,7 +180,7 @@ function applyFilters(
     })
 }
 
-function validateConstraint(constraint: Constraint | undefined, path: ReadonlyArray<PropertyKey>): void {
+function validateConstraint(constraint: FilterConstraint | undefined, path: ReadonlyArray<PropertyKey>): void {
   if (constraint === undefined) return
   const cardinalities = [
     [constraint.minLength, constraint.maxLength],
@@ -207,7 +207,7 @@ function validateConstraint(constraint: Constraint | undefined, path: ReadonlyAr
   }
 }
 
-function withoutOrder(constraint: Constraint | undefined): GenerationConstraint | undefined {
+function withoutOrder(constraint: FilterConstraint | undefined): GenerationConstraint | undefined {
   if (constraint === undefined) return undefined
   const { order: _, ...out } = constraint
   return Object.keys(out).length === 0 ? undefined : out
@@ -352,7 +352,7 @@ function builtInDeclarationLink(
 }
 
 function lengthBounds(
-  constraint: Constraint | undefined,
+  constraint: FilterConstraint | undefined,
   keys: readonly [
     minimum: "minLength" | "minSize" | "minProperties",
     maximum: "maxLength" | "maxSize" | "maxProperties"
@@ -801,7 +801,7 @@ function randomString(state: Model.GenerationState, minimum: number, maximum: nu
   return value
 }
 
-function numberBounds(constraint: Constraint | undefined, integer: boolean, path: ReadonlyArray<PropertyKey>) {
+function numberBounds(constraint: FilterConstraint | undefined, integer: boolean, path: ReadonlyArray<PropertyKey>) {
   const ordered = constraint?.order === Order.Number ? constraint : undefined
   let minimum = ordered?.minimum as number | undefined
   let maximum = ordered?.maximum as number | undefined
@@ -1027,14 +1027,14 @@ function bigIntSample(
 /** @internal */
 export function compile<S extends Schema.Constraint>(schema: S): Model.Compiled<S["Type"]> {
   const rootAst = SchemaAST.toType(schema.ast)
-  const cache = new WeakMap<SchemaAST.AST, Map<Constraint | undefined, Model.Compiled<any>>>()
+  const cache = new WeakMap<SchemaAST.AST, Map<FilterConstraint | undefined, Model.Compiled<any>>>()
   const nodes: Array<Model.Compiled<any>> = []
   const suspendBodies = new Map<Model.Compiled<any>, Model.Compiled<any>>()
   const pending: Array<() => void> = []
   const recur = (
     ast: SchemaAST.AST,
     path: ReadonlyArray<PropertyKey>,
-    inherited?: Constraint
+    inherited?: FilterConstraint
   ): Model.Compiled<any> => {
     let entries = cache.get(ast)
     const cached = entries?.get(inherited)
@@ -1079,7 +1079,7 @@ export function compile<S extends Schema.Constraint>(schema: S): Model.Compiled<
   const compileBase = (
     ast: SchemaAST.AST,
     path: ReadonlyArray<PropertyKey>,
-    constraint: Constraint | undefined
+    constraint: FilterConstraint | undefined
   ): Model.Compiled<any> => {
     switch (ast._tag) {
       case "Never":
@@ -1336,7 +1336,7 @@ export function compile<S extends Schema.Constraint>(schema: S): Model.Compiled<
   const compileArrays = (
     ast: SchemaAST.Arrays,
     path: ReadonlyArray<PropertyKey>,
-    constraint: Constraint | undefined
+    constraint: FilterConstraint | undefined
   ): Model.Compiled<ReadonlyArray<any>> => {
     const uniqueBy = constraint?.uniqueBy
     const elements = ast.elements.map((element, index) => ({
@@ -1492,7 +1492,7 @@ export function compile<S extends Schema.Constraint>(schema: S): Model.Compiled<
   const compileObjects = (
     ast: SchemaAST.Objects,
     path: ReadonlyArray<PropertyKey>,
-    constraint: Constraint | undefined
+    constraint: FilterConstraint | undefined
   ): Model.Compiled<Record<PropertyKey, any>> => {
     const constrainedIndexes = ast.indexSignatures.flatMap((index, position) => {
       const constraint = collectChecks(index.type.checks, undefined).constraint
@@ -1517,7 +1517,7 @@ export function compile<S extends Schema.Constraint>(schema: S): Model.Compiled<
         if (cached !== undefined) return cached
         let specialized = compiled
         try {
-          let inherited: Constraint | undefined
+          let inherited: FilterConstraint | undefined
           for (const match of matching) inherited = mergeConstraint(inherited, match.constraint)
           const checks = collectChecks(type.checks, inherited)
           specialized = compileBase(type, path, checks.constraint)
@@ -1668,7 +1668,7 @@ export function compile<S extends Schema.Constraint>(schema: S): Model.Compiled<
   const compileDeclaration = (
     ast: SchemaAST.Declaration,
     path: ReadonlyArray<PropertyKey>,
-    constraint: Constraint | undefined
+    constraint: FilterConstraint | undefined
   ): Model.Compiled<any> => {
     validateConstraint(constraint, path)
     const typeParameters = ast.typeParameters.map((parameter, index) => recur(parameter, [...path, index]))

package/src/internal/effect.ts

@@ -50,6 +50,7 @@ import type { Primitive } from "./core.ts"
 import {
   args,
   causeAnnotate,
+  causeDie,
   causeEmpty,
   causeFromReasons,
   CauseImpl,
@@ -4371,20 +4372,27 @@ export const acquireDisposable = <A extends AsyncDisposable | Disposable, E, R>(
 
 /** @internal */
 export const cachedInvalidateWithTTL: {
+  <A, E>(timeToLive: (exit: Exit.Exit<A, E>) => Duration.Input): <R>(
+    self: Effect.Effect<A, E, R>
+  ) => Effect.Effect<[Effect.Effect<A, E, R>, Effect.Effect<void>]>
   (timeToLive: Duration.Input): <A, E, R>(
     self: Effect.Effect<A, E, R>
   ) => Effect.Effect<[Effect.Effect<A, E, R>, Effect.Effect<void>]>
+  <A, E>(timeToLive: Duration.Input | ((exit: Exit.Exit<A, E>) => Duration.Input)): <R>(
+    self: Effect.Effect<A, E, R>
+  ) => Effect.Effect<[Effect.Effect<A, E, R>, Effect.Effect<void>]>
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
-    timeToLive: Duration.Input
+    timeToLive: Duration.Input | ((exit: Exit.Exit<A, E>) => Duration.Input)
   ): Effect.Effect<[Effect.Effect<A, E, R>, Effect.Effect<void>]>
 } = dual(2, <A, E, R>(
   self: Effect.Effect<A, E, R>,
-  ttl: Duration.Input
+  ttl: Duration.Input | ((exit: Exit.Exit<A, E>) => Duration.Input)
 ): Effect.Effect<[Effect.Effect<A, E, R>, Effect.Effect<void>]> =>
   sync(() => {
-    const ttlMillis = Duration.toMillis(Duration.fromInputUnsafe(ttl))
-    const isFinite = Number.isFinite(ttlMillis)
+    const ttlMillis = typeof ttl === "function"
+      ? (exit: Exit.Exit<A, E>) => Duration.toMillis(Duration.fromInputUnsafe(ttl(exit)))
+      : constant(Duration.toMillis(Duration.fromInputUnsafe(ttl)))
     const latch = makeLatchUnsafe(false)
     let expiresAt = 0
     let running = false
@@ -4393,17 +4401,26 @@ export const cachedInvalidateWithTTL: {
     return [
       withFiber((fiber) => {
         const clock = fiber.getRef(ClockRef)
-        const now = isFinite ? clock.currentTimeMillisUnsafe() : 0
+        const now = expiresAt === Infinity ? 0 : clock.currentTimeMillisUnsafe()
         if (running || now < expiresAt) return exit ?? wait
         running = true
         latch.closeUnsafe()
         exit = undefined
         return onExit(self, (exit_) =>
           sync(() => {
-            running = false
-            expiresAt = clock.currentTimeMillisUnsafe() + ttlMillis
-            exit = exit_
-            latch.openUnsafe()
+            try {
+              const duration = ttlMillis(exit_)
+              expiresAt = clock.currentTimeMillisUnsafe() + duration
+              exit = exit_
+            } catch (error) {
+              const cause = causeDie(error)
+              // Publish the same combined cause that onExit returns to the owner.
+              exit = exitFailCause(exitIsFailure(exit_) ? causeCombine(exit_.cause, cause) : cause)
+              throw error
+            } finally {
+              running = false
+              latch.openUnsafe()
+            }
           }))
       }),
       sync(() => {
@@ -4416,18 +4433,24 @@ export const cachedInvalidateWithTTL: {
 
 /** @internal */
 export const cachedWithTTL: {
+  <A, E>(
+    timeToLive: (exit: Exit.Exit<A, E>) => Duration.Input
+  ): <R>(self: Effect.Effect<A, E, R>) => Effect.Effect<Effect.Effect<A, E, R>>
   (
     timeToLive: Duration.Input
   ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<Effect.Effect<A, E, R>>
+  <A, E>(
+    timeToLive: Duration.Input | ((exit: Exit.Exit<A, E>) => Duration.Input)
+  ): <R>(self: Effect.Effect<A, E, R>) => Effect.Effect<Effect.Effect<A, E, R>>
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
-    timeToLive: Duration.Input
+    timeToLive: Duration.Input | ((exit: Exit.Exit<A, E>) => Duration.Input)
   ): Effect.Effect<Effect.Effect<A, E, R>>
 } = dual(
   2,
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
-    timeToLive: Duration.Input
+    timeToLive: Duration.Input | ((exit: Exit.Exit<A, E>) => Duration.Input)
   ): Effect.Effect<Effect.Effect<A, E, R>> => map(cachedInvalidateWithTTL(self, timeToLive), (tuple) => tuple[0])
 )