effect 4.0.0-beta.105 → 4.0.0-beta.107

package/src/ScopedRef.ts

@@ -219,7 +219,9 @@ export const set: {
         Scope.provide(scope),
         Effect.tapCause((cause) => Scope.close(scope, Exit.failCause(cause)))
       )
-      yield* Scope.close(self.backing.backing.ref.current[0], Exit.void)
+      yield* Scope.close(self.backing.backing.ref.current[0], Exit.void).pipe(
+        Effect.tapCause((cause) => Scope.close(scope, Exit.failCause(cause)))
+      )
       self.backing.backing.ref.current = [scope, value]
     },
     Effect.uninterruptible,

package/src/Stream.ts

@@ -19270,39 +19270,16 @@ export const mkString = <E, R>(self: Stream<string, E, R>): Effect.Effect<string
  * await Effect.runPromise(program) // => [1, 2, 3, 4]
  * ```
  *
+ * **Gotchas**
+ *
+ * This materializes the full content in memory. The source stream must not
+ * reuse or mutate emitted buffers, which are retained until collection completes.
+ *
  * @category destructors
  * @since 4.0.0
  */
 export const mkArrayBuffer = <E, R>(self: Stream<Uint8Array, E, R>): Effect.Effect<ArrayBuffer, E, R> =>
-  Effect.map(
-    Channel.runFold(
-      self.channel,
-      (): {
-        bytes: number
-        readonly arrays: Array<Uint8Array>
-      } => ({
-        bytes: 0,
-        arrays: []
-      }),
-      (acc, chunk) => {
-        for (let i = 0; i < chunk.length; i++) {
-          acc.bytes += chunk[i].length
-          acc.arrays.push(chunk[i])
-        }
-        return acc
-      }
-    ),
-    ({ arrays, bytes }) => {
-      const result = new Uint8Array(bytes)
-      let offset = 0
-      for (let i = 0; i < arrays.length; i++) {
-        const array = arrays[i]
-        result.set(array, offset)
-        offset += array.length
-      }
-      return result.buffer
-    }
-  )
+  Effect.map(Channel.mkUint8Array(self.channel), (bytes) => bytes.buffer)
 
 /**
  * Concatenates the stream's `Uint8Array` chunks into a single `Uint8Array`.
@@ -19321,11 +19298,16 @@ export const mkArrayBuffer = <E, R>(self: Stream<Uint8Array, E, R>): Effect.Effe
  * await Effect.runPromise(program)
  * ```
  *
+ * **Gotchas**
+ *
+ * This materializes the full content in memory. The source stream must not
+ * reuse or mutate emitted buffers, which are retained until collection completes.
+ *
  * @category destructors
  * @since 4.0.0
  */
 export const mkUint8Array = <E, R>(self: Stream<Uint8Array, E, R>): Effect.Effect<Uint8Array, E, R> =>
-  Effect.map(mkArrayBuffer(self), (buffer) => new Uint8Array(buffer))
+  Channel.mkUint8Array(self.channel)
 
 /**
  * Converts the stream to a `ReadableStream` using the provided services.

package/src/TxQueue.ts

@@ -1700,7 +1700,7 @@ export const clear = <A, E>(self: TxEnqueue<A, E>): Effect.Effect<Array<A>, Excl
  */
 export const shutdown = <A, E>(self: TxEnqueue<A, E>): Effect.Effect<boolean> =>
   Effect.gen(function*() {
-    yield* Effect.ignore(clear(self))
+    yield* Effect.ignoreCause(clear(self))
     return yield* interrupt(self)
   }).pipe(Effect.tx)
 

package/src/internal/effect.ts

@@ -822,7 +822,7 @@ export const fiberJoin = <A, E>(self: Fiber.Fiber<A, E>): Effect.Effect<A, E> =>
 /** @internal */
 export const fiberJoinAll = <A extends Iterable<Fiber.Fiber<any, any>>>(self: A): Effect.Effect<
   Arr.ReadonlyArray.With<A, A extends Iterable<Fiber.Fiber<infer _A, infer _E>> ? _A : never>,
-  A extends Fiber.Fiber<infer _A, infer _E> ? _E : never
+  A extends Iterable<Fiber.Fiber<infer _A, infer _E>> ? _E : never
 > =>
   callback((resume) => {
     const fibers = Array.from(self)
@@ -5862,11 +5862,8 @@ export const useSpan: {
   return withFiber((fiber) => {
     const span = makeSpanUnsafe(fiber, name, options)
     const clock = fiber.getRef(ClockRef)
-    return onExit(internalCall(() => evaluate(span)), (exit) =>
-      sync(() => {
-        if (span.status._tag === "Ended") return
-        span.end(clock.currentTimeNanosUnsafe(), exit)
-      }))
+    const timingEnabled = fiber.getRef(TracerTimingEnabled)
+    return onExit(internalCall(() => evaluate(span)), (exit) => endSpan(span, exit, clock, timingEnabled))
   })
 }
 

package/src/internal/executionPlan.ts

@@ -31,6 +31,7 @@ export const makeEventEmitter = (
 ): EventEmitter => {
   let lastStepIndex = -1
   let stepAttempt = 0
+  const emit = (event: Api.Event<any>) => effect.ignoreCause(onEvent(event))
   return {
     begin: effect.clockWith((clock) =>
       effect.suspend(() => {
@@ -47,7 +48,7 @@ export const makeEventEmitter = (
           startNanos: clock.monotonicTimeNanosUnsafe()
         }
         return effect.as(
-          onEvent({
+          emit({
             _tag: "AttemptStart",
             attempt: state.attempt,
             stepAttempt: state.stepAttempt,
@@ -60,7 +61,7 @@ export const makeEventEmitter = (
     end: (state, exit) =>
       effect.clockWith((clock) => {
         const duration = Duration.nanos(clock.monotonicTimeNanosUnsafe() - state.startNanos)
-        return onEvent(
+        return emit(
           exit._tag === "Success"
             ? {
               _tag: "AttemptSuccess",

package/src/internal/rcRef.ts

@@ -94,7 +94,7 @@ export const make = <A, E, R>(options: {
   })
 
 const getState = <A, E>(self: RcRefImpl<A, E>) =>
-  Effect.uninterruptibleMask((restore) => {
+  Effect.uninterruptibleMask(function loop(restore): Effect.Effect<State.Acquired<A>, E> {
     switch (self.state._tag) {
       case "Closed": {
         return Effect.interrupt
@@ -107,22 +107,30 @@ const getState = <A, E>(self: RcRefImpl<A, E>) =>
       }
       case "Empty": {
         const scope = Scope.makeUnsafe()
-        return self.semaphore.withPermits(1)(
-          restore(Effect.provideContext(
-            self.acquire as Effect.Effect<A, E>,
-            Context.add(self.context, Scope.Scope, scope)
-          )).pipe(Effect.map((value) => {
-            const state: State.Acquired<A> = {
-              _tag: "Acquired",
-              value,
-              scope,
-              fiber: undefined,
-              refCount: 1,
-              invalidated: false
+        return self.semaphore.withPermit(
+          Effect.suspend(() => {
+            if (self.state._tag !== "Empty") {
+              return loop(restore)
             }
-            self.state = state
-            return state
-          }))
+            return restore(Effect.provideContext(
+              self.acquire as Effect.Effect<A, E>,
+              Context.add(self.context, Scope.Scope, scope)
+            )).pipe(
+              Effect.map((value) => {
+                const state: State.Acquired<A> = {
+                  _tag: "Acquired",
+                  value,
+                  scope,
+                  fiber: undefined,
+                  refCount: 1,
+                  invalidated: false
+                }
+                self.state = state
+                return state
+              }),
+              Effect.onExit((exit) => Exit.isFailure(exit) ? Scope.close(scope, exit) : Effect.void)
+            )
+          })
         )
       }
     }

package/src/internal/schema/fromJsonSchemaDocument.ts

@@ -743,7 +743,7 @@ function translateJsonSchemaMultiDocument(
       case "string":
         return {
           _tag: "String",
-          checks: collectStringChecks(schema)
+          checks: collectStringChecks(schema, path)
         }
       case "number":
       case "integer":
@@ -757,23 +757,26 @@ function translateJsonSchemaMultiDocument(
       case "boolean":
         return { _tag: "Boolean", checks: [] }
       case "array": {
+        const prefixItems = Array.isArray(schema.prefixItems) ? schema.prefixItems : undefined
         const minItems = typeof schema.minItems === "number" ? schema.minItems : 0
-        const elements = Array.isArray(schema.prefixItems)
-          ? schema.prefixItems.map((element, index) => ({
-            isOptional: index + 1 > minItems,
-            type: recur(element, [...path, "prefixItems", index])
-          }))
-          : []
-        const rest = schema.items !== undefined
-          ? [recur(schema.items, [...path, "items"])]
-          : schema.prefixItems !== undefined && typeof schema.maxItems === "number"
-          ? []
-          : [unknown]
+        const elements = prefixItems?.map((element, index) => ({
+          isOptional: index + 1 > minItems,
+          type: recur(element, [...path, "prefixItems", index])
+        })) ?? []
+        const isTupleClosed = schema.items === false ||
+          (schema.items === undefined &&
+            prefixItems !== undefined &&
+            schema.maxItems === prefixItems.length)
+        const isMaxItemsRedundant = isTupleClosed &&
+          typeof schema.maxItems === "number" &&
+          schema.maxItems >= elements.length
         return {
           _tag: "Arrays",
           elements,
-          rest,
-          checks: collectArrayChecks(schema)
+          rest: isTupleClosed
+            ? []
+            : [schema.items === undefined ? unknown : recur(schema.items, [...path, "items"])],
+          checks: collectArrayChecks(schema, isMaxItemsRedundant)
         }
       }
       case "object":
@@ -788,12 +791,23 @@ function translateJsonSchemaMultiDocument(
     }
   }
 
-  function collectStringChecks(schema: JsonSchema.JsonSchema): Array<Check> {
+  function importPatternChecks(pattern: string, path: Path): Array<Check> {
+    switch (options?.patterns ?? "error") {
+      case "error":
+        throw errorWithPath(`Pattern encountered while patterns is set to "error"`, path)
+      case "ignore":
+        return []
+      case "apply":
+        return [jsonSchemaFilter("effect/schema/isPattern", { source: pattern, flags: "" })]
+    }
+  }
+
+  function collectStringChecks(schema: JsonSchema.JsonSchema, path: Path): Array<Check> {
     const checks: Array<Check> = []
     addNumberCheck(checks, schema.minLength, "effect/schema/isMinLength", "minLength")
     addNumberCheck(checks, schema.maxLength, "effect/schema/isMaxLength", "maxLength")
     if (typeof schema.pattern === "string") {
-      checks.push(jsonSchemaFilter("effect/schema/isPattern", { source: schema.pattern, flags: "" }))
+      checks.push(...importPatternChecks(schema.pattern, [...path, "pattern"]))
     }
     return checks
   }
@@ -808,10 +822,12 @@ function translateJsonSchemaMultiDocument(
     return checks
   }
 
-  function collectArrayChecks(schema: JsonSchema.JsonSchema): Array<Check> {
+  function collectArrayChecks(schema: JsonSchema.JsonSchema, isMaxItemsRedundant: boolean): Array<Check> {
     const checks: Array<Check> = []
     if (schema.prefixItems === undefined) {
       addNumberCheck(checks, schema.minItems, "effect/schema/isMinLength", "minLength")
+    }
+    if (!isMaxItemsRedundant) {
       addNumberCheck(checks, schema.maxItems, "effect/schema/isMaxLength", "maxLength")
     }
     if (schema.uniqueItems === true) {
@@ -851,10 +867,12 @@ function translateJsonSchemaMultiDocument(
       !Array.isArray(schema.patternProperties)
     ) {
       for (const [pattern, value] of Object.entries(schema.patternProperties)) {
+        const checks = importPatternChecks(pattern, [...path, "patternProperties", pattern])
+        if (checks.length === 0) return [{ parameter: string, type: unknown }]
         signatures.push({
           parameter: {
             _tag: "String",
-            checks: [jsonSchemaFilter("effect/schema/isPattern", { source: pattern, flags: "" })]
+            checks
           },
           type: recur(value, [...path, "patternProperties", pattern])
         })

package/src/internal/schema/toArbitrary.ts

@@ -34,20 +34,6 @@ type LazyOption<T> = (
   recursionStack: RecursionStack
 ) => FastCheck.Arbitrary<T> | undefined
 
-export interface MutableReport {
-  readonly warnings: Array<Schema.Annotations.ToArbitrary.Warning>
-}
-
-/** @internal */
-export function makeReport(): MutableReport {
-  return { warnings: [] }
-}
-
-/** @internal */
-export function toReport(report: MutableReport): Schema.Annotations.ToArbitrary.Report {
-  return { warnings: report.warnings.slice() }
-}
-
 function arbitraryError(what: string) {
   return new Error(`Unable to derive an arbitrary for ${what}`)
 }
@@ -394,64 +380,6 @@ function finiteNumberContext(ctx: Context): Context {
   }
 }
 
-function reportChecks(report: MutableReport, checks: SchemaAST.Checks | undefined, path: ReadonlyArray<PropertyKey>) {
-  function visit(check: SchemaAST.Check<any>, covered: boolean) {
-    const arbitrary = check.annotations?.arbitrary
-    const nextCovered = covered || arbitrary?.constraint !== undefined || arbitrary?.candidate !== undefined
-    if (check._tag !== "Filter") {
-      for (const child of check.checks) {
-        visit(child, nextCovered)
-      }
-    } else if (!nextCovered) {
-      const description = check.annotations?.representation?.id ?? check.annotations?.identifier ??
-        check.annotations?.expected
-      report.warnings.push({ _tag: "OpaqueFilter", path, ...(description === undefined ? {} : { description }) })
-    }
-  }
-  checks?.forEach((check) => visit(check, false))
-}
-
-/** @internal */
-export function collectReport(ast: SchemaAST.AST, report: MutableReport) {
-  const stack = new WeakSet<SchemaAST.AST>()
-  function visit(ast: SchemaAST.AST, path: ReadonlyArray<PropertyKey>) {
-    if (stack.has(ast)) {
-      return
-    }
-    stack.add(ast)
-    reportChecks(report, ast.checks, path)
-    switch (ast._tag) {
-      case "Declaration":
-        ast.typeParameters.forEach((tp) => visit(tp, path))
-        break
-      case "Arrays": {
-        for (const [i, type] of [...ast.elements, ...ast.rest].entries()) {
-          visit(type, [...path, i])
-        }
-        break
-      }
-      case "Objects":
-        ast.propertySignatures.forEach((ps) => visit(ps.type, [...path, ps.name]))
-        ast.indexSignatures.forEach((is) => {
-          visit(is.parameter, path)
-          visit(is.type, path)
-        })
-        break
-      case "Union":
-        ast.types.forEach((type) => visit(type, path))
-        break
-      case "TemplateLiteral":
-        ast.parts.forEach((part, i) => visit(SchemaAST.toEncoded(part), [...path, i]))
-        break
-      case "Suspend":
-        visit(ast.thunk(), path)
-        break
-    }
-    stack.delete(ast)
-  }
-  visit(ast, [])
-}
-
 function applyCandidates(
   fc: typeof FastCheck,
   ctx: Context,

package/src/internal/schema/toJsonSchemaDocument.ts

@@ -1,7 +1,8 @@
 import * as Arr from "../../Array.ts"
 import * as Equal from "../../Equal.ts"
-import { escapeToken } from "../../JsonPointer.ts"
+import { escapeToken, unescapeToken } from "../../JsonPointer.ts"
 import type * as JsonSchema from "../../JsonSchema.ts"
+import { rewriteRefs } from "../../JsonSchema.ts"
 import * as RegEx from "../../RegExp.ts"
 import type * as Schema from "../../Schema.ts"
 import * as SchemaAST from "../../SchemaAST.ts"
@@ -21,6 +22,11 @@ const jsonSchemaAnnotationExcludedKeys = new Set([
   ...InternalAnnotations.jsonSchemaAnnotationKeys
 ])
 
+/** @internal */
+export const toRepresentationOptions = {
+  isAnonymousReferenceAllowed: (ast: SchemaAST.AST): boolean => !SchemaAST.isDeclaration(ast)
+}
+
 function collectJsonSchemaAnnotations(
   annotations: Schema.Annotations.Annotations | undefined,
   options: Schema.ToJsonSchemaOptions | undefined
@@ -142,22 +148,26 @@ function compileJsonSchema(
   references: SchemaRepresentation.References,
   options: Schema.ToJsonSchemaOptions | undefined
 ): JsonSchema.MultiDocument<"draft-2020-12"> {
-  const definitions: Record<string, JsonSchema.JsonSchema> = {}
   // null = compiling, string = canonical key, object = compiled schema
   const definitionStates = new Map<string, JsonSchema.JsonSchema | string | null>()
   const compiledRepresentations = new WeakMap<SchemaRepresentation.Representation, JsonSchema.JsonSchema>()
   const fallbackDefinitions = new Map<string, Array<string>>()
+  let hasAliases = false
   const referenceKeys = Object.keys(references)
   for (const key of referenceKeys) {
     compileDefinition(key, ["references", key])
   }
+  const schemas = Arr.map(
+    representations,
+    (representation, index) => finalizeJsonSchema(recur(representation, rootPaths[index]))
+  )
+  const definitions: Record<string, JsonSchema.JsonSchema> = {}
   for (const key of referenceKeys) {
     const compiled = definitionStates.get(key)!
     if (typeof compiled !== "string") {
-      InternalRecord.assignProperty(definitions, key, compiled)
+      InternalRecord.assignProperty(definitions, key, finalizeJsonSchema(compiled))
     }
   }
-  const schemas = Arr.map(representations, (representation, index) => recur(representation, rootPaths[index]))
   return { dialect: "draft-2020-12", schemas, definitions }
 
   function compileDefinition(key: string, path: Path): string {
@@ -179,6 +189,7 @@ function compileJsonSchema(
         if (candidates === undefined) fallbackDefinitions.set(fallback, [key])
         else candidates.push(key)
       } else {
+        hasAliases = true
         definitionStates.set(key, match)
         return match
       }
@@ -187,6 +198,15 @@ function compileJsonSchema(
     return key
   }
 
+  function finalizeJsonSchema(schema: JsonSchema.JsonSchema): JsonSchema.JsonSchema {
+    if (!hasAliases) return schema
+    return rewriteRefs(schema, ($ref) =>
+      $ref.replace(/^#\/\$defs\/([^/]*)/, (match, token) => {
+        const canonical = definitionStates.get(unescapeToken(token))
+        return typeof canonical === "string" ? `#/$defs/${escapeToken(canonical)}` : match
+      }))
+  }
+
   function getIdentifierFallback(
     representation: SchemaRepresentation.Representation
   ): string | undefined {

package/src/internal/schema/toRepresentation.ts

@@ -7,17 +7,24 @@ import * as InternalAnnotations from "./annotations.ts"
 
 /** @internal */
 export function toRepresentation(
-  ast: SchemaAST.AST
+  ast: SchemaAST.AST,
+  options?: Options
 ): SchemaRepresentation.Document {
-  const { references, representations } = toRepresentations([ast])
+  const { references, representations } = toRepresentations([ast], options)
   return { representation: representations[0], references }
 }
 
 /** @internal */
 export function toRepresentations(
-  asts: readonly [SchemaAST.AST, ...Array<SchemaAST.AST>]
+  asts: readonly [SchemaAST.AST, ...Array<SchemaAST.AST>],
+  options?: Options
 ): SchemaRepresentation.MultiDocument {
-  return fromASTs(asts)
+  return fromASTs(asts, options)
+}
+
+/** @internal */
+export interface Options {
+  readonly isAnonymousReferenceAllowed?: ((ast: SchemaAST.AST) => boolean) | undefined
 }
 
 type CheckRepresentationAnnotation = SchemaRepresentation.CheckRepresentationAnnotation<
@@ -28,11 +35,49 @@ function annotationsField<A>(annotations: A | undefined): { readonly annotations
   return annotations === undefined ? undefined : { annotations }
 }
 
-// Preserve repeated structural nodes as references without adding noise for leaf nodes.
-function isShareable(ast: SchemaAST.AST): boolean {
-  return SchemaAST.isArrays(ast) ||
-    SchemaAST.isObjects(ast) ||
-    (SchemaAST.isUnion(ast) && ast.types.some(isShareable))
+function hasShareableStructure(
+  ast: SchemaAST.AST,
+  isAnonymousReferenceAllowed: Options["isAnonymousReferenceAllowed"]
+): boolean {
+  if (isAnonymousReferenceAllowed?.(ast) === false) return false
+  switch (ast._tag) {
+    case "Arrays":
+    case "Objects":
+    case "Suspend":
+      return true
+    case "Declaration":
+      return true
+    case "Union":
+      return ast.types.some((ast) => hasShareableStructure(ast, isAnonymousReferenceAllowed))
+    default:
+      return false
+  }
+}
+
+function isWorthReferencing(bodyCost: number, occurrences: number): boolean {
+  return occurrences * bodyCost > bodyCost + occurrences + 1
+}
+
+function isAnonymousReferenceEligible(
+  ast: SchemaAST.AST,
+  occurrences: number,
+  isAnonymousReferenceAllowed: Options["isAnonymousReferenceAllowed"]
+): boolean {
+  if (isAnonymousReferenceAllowed?.(ast) === false) return false
+  if (hasShareableStructure(ast, isAnonymousReferenceAllowed)) return true
+  switch (ast._tag) {
+    case "Union":
+      return isWorthReferencing(ast.types.length + 1, occurrences)
+    case "Enum":
+      return isWorthReferencing(ast.enums.length + 1, occurrences)
+    case "TemplateLiteral":
+      return isWorthReferencing(ast.parts.length + 1, occurrences)
+    case "Literal":
+      return typeof ast.literal === "string" &&
+        isWorthReferencing(ast.literal.length / 32 + 1, occurrences)
+    default:
+      return false
+  }
 }
 
 interface ReferenceIdentifier {
@@ -54,17 +99,15 @@ function resolveReferenceIdentifier(
 }
 
 function fromASTs(
-  asts: readonly [SchemaAST.AST, ...Array<SchemaAST.AST>]
+  asts: readonly [SchemaAST.AST, ...Array<SchemaAST.AST>],
+  options: Options | undefined
 ): SchemaRepresentation.MultiDocument {
   const references: Record<string, SchemaRepresentation.Representation> = {}
   const anonymousReferences = new Map<SchemaAST.AST, string>()
   const referenceOwners = new Map<string, SchemaAST.AST>()
-  const valueIds = new Map<unknown, number>()
-  const canonicalByKey = new Map<string, SchemaAST.AST>()
-  let nextValueId = 0
   const buildingReferences = new Set<string>()
   const visiting = new Set<SchemaAST.AST>()
-  const visited = new Set<SchemaAST.AST>()
+  const occurrences = new Map<SchemaAST.AST, number>()
   const shared = new Set<SchemaAST.AST>()
 
   for (const ast of asts) visit(ast)
@@ -84,35 +127,6 @@ function fromASTs(
     return candidate
   }
 
-  function getValueId(value: unknown): number {
-    if (typeof value === "number" && globalThis.Number.isNaN(value)) {
-      return nextValueId++
-    }
-    const found = valueIds.get(value)
-    if (found !== undefined) return found
-    const id = nextValueId++
-    valueIds.set(value, id)
-    return id
-  }
-
-  function getIdentityKey(ast: SchemaAST.AST): string {
-    let identity = ast._tag
-    for (const [key, value] of Object.entries(ast)) {
-      if (key !== "_tag" && key !== "context") identity += `:${getValueId(value)}`
-    }
-    return identity
-  }
-
-  function getCanonicalAST(ast: SchemaAST.AST): SchemaAST.AST {
-    const key = getIdentityKey(ast)
-    const canonical = canonicalByKey.get(key)
-    if (canonical === undefined) {
-      canonicalByKey.set(key, ast)
-      return ast
-    }
-    return canonical
-  }
-
   function annotateReference(
     ast: SchemaAST.AST,
     referenceIdentifier: ReferenceIdentifier,
@@ -143,12 +157,16 @@ function fromASTs(
 
   function visit(input: SchemaAST.AST): void {
     const ast = SchemaAST.getLastEncoding(input)
-    const owner = getCanonicalAST(ast)
-    if (visited.has(owner)) {
-      if (isShareable(ast)) shared.add(owner)
+    const owner = SchemaAST.getContextOwner(ast)
+    const count = (occurrences.get(owner) ?? 0) + 1
+    occurrences.set(owner, count)
+    if (count > 1) {
+      if (
+        !shared.has(owner) &&
+        isAnonymousReferenceEligible(owner, count, options?.isAnonymousReferenceAllowed)
+      ) shared.add(owner)
       return
     }
-    visited.add(owner)
     visitChecks(ast.checks)
     switch (ast._tag) {
       case "Declaration":
@@ -178,7 +196,7 @@ function fromASTs(
 
   function recur(input: SchemaAST.AST): SchemaRepresentation.Representation {
     const ast = SchemaAST.getLastEncoding(input)
-    const owner = getCanonicalAST(ast)
+    const owner = SchemaAST.getContextOwner(ast)
     const referenceIdentifier = resolveReferenceIdentifier(input, ast)
     if (referenceIdentifier !== undefined) {
       const reference = getReference(referenceIdentifier.identifier, owner)

package/src/testing/TestSchema.ts

@@ -172,7 +172,7 @@ export class Asserts<S extends Schema.Constraint> {
   }) {
     const decodeUnknownEffect = SchemaParser.decodeUnknownEffect(this.schema)
     const encodeEffect = SchemaParser.encodeEffect(this.schema)
-    const arbitrary = Schema.toArbitrary(this.schema)
+    const arbitrary = Schema.toArbitrary(this.schema)(FastCheck)
     return FastCheck.assert(
       FastCheck.asyncProperty(arbitrary, async (t) => {
         const r = await Effect.runPromise(
@@ -280,7 +280,7 @@ export class Asserts<S extends Schema.Constraint> {
       }) {
         const params = options?.params
         const is = Schema.is(schema)
-        const arb = Schema.toArbitrary(schema)
+        const arb = Schema.toArbitrary(schema)(FastCheck)
         FastCheck.assert(FastCheck.property(arb, (a) => is(a)), { numRuns: 20, ...params })
       }
     }