effect 4.0.0-beta.102 → 4.0.0-beta.104

package/src/internal/executionPlan.ts

@@ -1,47 +1,131 @@
+import * as Duration from "../Duration.ts"
 import type { Effect } from "../Effect.ts"
 import * as Api from "../ExecutionPlan.ts"
-import { dual } from "../Function.ts"
+import type * as Exit from "../Exit.ts"
+import { dual, identity } from "../Function.ts"
 import * as Result from "../Result.ts"
 import * as Schedule from "../Schedule.ts"
+import { isEffect } from "./core.ts"
 import * as effect from "./effect.ts"
 import * as internalLayer from "./layer.ts"
 import * as internalSchedule from "./schedule.ts"
 
+/** @internal */
+export interface AttemptState {
+  readonly attempt: number
+  readonly stepAttempt: number
+  readonly stepIndex: number
+  readonly startNanos: bigint
+}
+
+/** @internal */
+export interface EventEmitter {
+  readonly begin: Effect<AttemptState, never, any>
+  readonly end: (state: AttemptState, exit: Exit.Exit<any, any>) => Effect<void, never, any>
+}
+
+/** @internal */
+export const makeEventEmitter = (
+  onEvent: (event: Api.Event<any>) => Effect<void, never, any>,
+  currentMetadata: () => Api.Metadata
+): EventEmitter => {
+  let lastStepIndex = -1
+  let stepAttempt = 0
+  return {
+    begin: effect.clockWith((clock) =>
+      effect.suspend(() => {
+        const meta = currentMetadata()
+        if (meta.stepIndex !== lastStepIndex) {
+          lastStepIndex = meta.stepIndex
+          stepAttempt = 0
+        }
+        stepAttempt++
+        const state: AttemptState = {
+          attempt: meta.attempt,
+          stepAttempt,
+          stepIndex: meta.stepIndex,
+          startNanos: clock.monotonicTimeNanosUnsafe()
+        }
+        return effect.as(
+          onEvent({
+            _tag: "AttemptStart",
+            attempt: state.attempt,
+            stepAttempt: state.stepAttempt,
+            stepIndex: state.stepIndex
+          }),
+          state
+        )
+      })
+    ),
+    end: (state, exit) =>
+      effect.clockWith((clock) => {
+        const duration = Duration.nanos(clock.monotonicTimeNanosUnsafe() - state.startNanos)
+        return onEvent(
+          exit._tag === "Success"
+            ? {
+              _tag: "AttemptSuccess",
+              attempt: state.attempt,
+              stepAttempt: state.stepAttempt,
+              stepIndex: state.stepIndex,
+              duration
+            }
+            : {
+              _tag: "AttemptFailure",
+              attempt: state.attempt,
+              stepAttempt: state.stepAttempt,
+              stepIndex: state.stepIndex,
+              duration,
+              cause: exit.cause
+            }
+        )
+      })
+  }
+}
+
 /** @internal */
 export const withExecutionPlan: {
-  <Input, Provides, PlanE, PlanR>(
+  <Input, Provides, PlanE, PlanR, RX = never>(
     plan: Api.ExecutionPlan<{
       provides: Provides
       input: Input
       error: PlanE
       requirements: PlanR
-    }>
+    }>,
+    options?: {
+      readonly onEvent?: ((event: Api.Event<Input | PlanE>) => Effect<void, never, RX>) | undefined
+    }
   ): <A, E extends Input, R>(effect: Effect<A, E, R>) => Effect<
     A,
     E | PlanE,
-    Exclude<R, Provides> | PlanR
+    Exclude<R, Provides> | PlanR | RX
   >
-  <A, E extends Input, R, Provides, Input, PlanE, PlanR>(
+  <A, E extends Input, R, Provides, Input, PlanE, PlanR, RX = never>(
     effect: Effect<A, E, R>,
     plan: Api.ExecutionPlan<{
       provides: Provides
       input: Input
       error: PlanE
       requirements: PlanR
-    }>
+    }>,
+    options?: {
+      readonly onEvent?: ((event: Api.Event<E | PlanE>) => Effect<void, never, RX>) | undefined
+    }
   ): Effect<
     A,
     E | PlanE,
-    Exclude<R, Provides> | PlanR
+    Exclude<R, Provides> | PlanR | RX
   >
-} = dual(2, <A, E extends Input, R, Provides, Input, PlanE, PlanR>(
+} = dual((args) => isEffect(args[0]), <A, E extends Input, R, Provides, Input, PlanE, PlanR, RX>(
   self: Effect<A, E, R>,
   plan: Api.ExecutionPlan<{
     provides: Provides
     input: Input
     error: PlanE
     requirements: PlanR
-  }>
+  }>,
+  options?: {
+    readonly onEvent?: ((event: Api.Event<E | PlanE>) => Effect<void, never, RX>) | undefined
+  }
 ) =>
   effect.suspend(() => {
     let i = 0
@@ -59,13 +143,24 @@ export const withExecutionPlan: {
         return meta
       })
     )
+    const emitter = options?.onEvent === undefined
+      ? undefined
+      : makeEventEmitter(options.onEvent, () => meta)
+    const instrument: (attempt: Effect<A, any, any>) => Effect<A, any, any> = emitter === undefined
+      ? identity
+      : (attempt) =>
+        effect.uninterruptibleMask((restore) =>
+          effect.flatMap(emitter.begin, (state) => effect.onExit(restore(attempt), (exit) => emitter.end(state, exit)))
+        )
     let result: Result.Result<A, any> | undefined
     return effect.flatMap(
       effect.whileLoop({
         while: () => i < plan.steps.length && (result === undefined || Result.isFailure(result)),
         body() {
           const step = plan.steps[i]
-          let nextEffect: Effect<A, any, any> = provideMeta(internalLayer.provide(self, step.provide as any))
+          let nextEffect: Effect<A, any, any> = provideMeta(
+            instrument(internalLayer.provide(self, step.provide as any))
+          )
           if (result) {
             let attempted = false
             const wrapped = nextEffect

package/src/internal/hashMap.ts

@@ -977,13 +977,8 @@ export const hasBy = dual<
   return false
 })
 
-/** @internal */
-export const set = dual<
-  <K, V>(key: K, value: V) => (self: HashMap<K, V>) => HashMap<K, V>,
-  <K, V>(self: HashMap<K, V>, key: K, value: V) => HashMap<K, V>
->(3, <K, V>(self: HashMap<K, V>, key: K, value: V): HashMap<K, V> => {
+const setHash = <K, V>(self: HashMap<K, V>, key: K, hash: number, value: V): HashMap<K, V> => {
   const impl = self as HashMapImpl<K, V>
-  const hash = Hash.hash(key)
   const added = { value: false }
 
   // Pass edit context: use current edit if editable, otherwise NaN (never matches any edit)
@@ -1005,6 +1000,14 @@ export const set = dual<
   }
 
   return new HashMapImpl(false, impl._edit, newRoot, impl._size + (added.value ? 1 : 0))
+}
+
+/** @internal */
+export const set = dual<
+  <K, V>(key: K, value: V) => (self: HashMap<K, V>) => HashMap<K, V>,
+  <K, V>(self: HashMap<K, V>, key: K, value: V) => HashMap<K, V>
+>(3, <K, V>(self: HashMap<K, V>, key: K, value: V): HashMap<K, V> => {
+  return setHash(self, key, Hash.hash(key), value)
 })
 
 /** @internal */
@@ -1104,10 +1107,10 @@ export const modifyHash = dual<
   const updated = f(current)
 
   if (Option.isNone(updated)) {
-    return hasHash(self, key, hash) ? remove(self, key) : self
+    return hasHash(self, key, hash) ? removeHash(self, key, hash) : self
   }
 
-  return set(self, key, updated.value)
+  return setHash(self, key, hash, updated.value)
 })
 
 /** @internal */
@@ -1130,13 +1133,8 @@ export const union = dual<
   return result
 })
 
-/** @internal */
-export const remove = dual<
-  <K>(key: K) => <V>(self: HashMap<K, V>) => HashMap<K, V>,
-  <K, V>(self: HashMap<K, V>, key: K) => HashMap<K, V>
->(2, <K, V>(self: HashMap<K, V>, key: K): HashMap<K, V> => {
+const removeHash = <K, V>(self: HashMap<K, V>, key: K, hash: number): HashMap<K, V> => {
   const impl = self as HashMapImpl<K, V>
-  const hash = Hash.hash(key)
   const removed = { value: false }
 
   const edit = impl._editable ? impl._edit : NaN
@@ -1157,6 +1155,14 @@ export const remove = dual<
   }
 
   return new HashMapImpl(false, impl._edit, newRoot, impl._size - 1)
+}
+
+/** @internal */
+export const remove = dual<
+  <K>(key: K) => <V>(self: HashMap<K, V>) => HashMap<K, V>,
+  <K, V>(self: HashMap<K, V>, key: K) => HashMap<K, V>
+>(2, <K, V>(self: HashMap<K, V>, key: K): HashMap<K, V> => {
+  return removeHash(self, key, Hash.hash(key))
 })
 
 /** @internal */

package/src/internal/matcher.ts

@@ -124,8 +124,8 @@ const makePredicate = (pattern: unknown): Predicate.Predicate<unknown> => {
       return true
     }
   } else if (pattern !== null && typeof pattern === "object") {
-    const keysAndPredicates = Object.entries(pattern).map(
-      ([k, p]) => [k, makePredicate(p)] as const
+    const keysAndPredicates = Reflect.ownKeys(pattern).map(
+      (key) => [key, makePredicate((pattern as any)[key])] as const
     )
     const len = keysAndPredicates.length
 

package/src/internal/persistence.ts

@@ -0,0 +1,2 @@
+/** @internal */
+export const sqlCleanupBatchSize = 1000

package/src/internal/references.ts

@@ -14,6 +14,7 @@ export const CurrentErrorReporters = Context.Reference<ReadonlySet<ErrorReporter
 
 /** @internal */
 export const CurrentStackFrame = Context.Reference<StackFrame | undefined>("effect/References/CurrentStackFrame", {
+  fiberCached: true,
   defaultValue: constUndefined
 })
 
@@ -47,13 +48,13 @@ export const CurrentLogAnnotations = Context.Reference<ReadonlyRecord<string, un
 /** @internal */
 export const CurrentLogLevel: Context.Reference<Severity> = Context.Reference<Severity>(
   "effect/References/CurrentLogLevel",
-  { defaultValue: () => "Info" }
+  { fiberCached: true, defaultValue: () => "Info" }
 )
 
 /** @internal */
 export const MinimumLogLevel = Context.Reference<
   LogLevel
->("effect/References/MinimumLogLevel", { defaultValue: () => "Info" })
+>("effect/References/MinimumLogLevel", { fiberCached: true, defaultValue: () => "Info" })
 
 /** @internal */
 export const UnhandledLogLevel: Context.Reference<Severity | undefined> = Context.Reference(

package/src/internal/schedule.ts

@@ -184,17 +184,17 @@ export const scheduleFrom = dual<
     schedule: Schedule.Schedule<Output, Input, Error, Env>
   ) => <E, R>(
     self: Effect<Input, E, R>
-  ) => Effect<Output, E, R | Env>,
+  ) => Effect<Output, E | Error, R | Env>,
   <Input, E, R, Output, Error, Env>(
     self: Effect<Input, E, R>,
     initial: Input,
     schedule: Schedule.Schedule<Output, Input, Error, Env>
-  ) => Effect<Output, E, R | Env>
+  ) => Effect<Output, E | Error, R | Env>
 >(3, <Input, E, R, Output, Error, Env>(
   self: Effect<Input, E, R>,
   initial: Input,
   schedule: Schedule.Schedule<Output, Input, Error, Env>
-): Effect<Output, E, R | Env> =>
+): Effect<Output, E | Error, R | Env> =>
   effect.flatMap(Schedule.toStepWithMetadata(schedule), (step) => {
     let meta = Schedule.CurrentMetadata.defaultValue()
     const selfWithMeta = effect.suspend(() => effect.provideService(self, Schedule.CurrentMetadata, meta))
@@ -213,7 +213,7 @@ export const scheduleFrom = dual<
           }) as Effect<never, E, R | Env>
         }
       ),
-      (error) => core.isDone(error) ? effect.succeed(error.value as Output) : effect.fail(error as E)
+      (error) => core.isDone(error) ? effect.succeed(error.value as Output) : effect.fail(error as E | Error)
     )
   }))
 

package/src/internal/schema/annotations.ts

@@ -21,6 +21,9 @@ export const IDENTIFIER_FALLBACK_KEY = "~identifier"
 /** @internal */
 export const SENTINELS_ANNOTATION_KEY = "~sentinels"
 
+/** @internal */
+export const CONSTRUCTOR_ANNOTATION_KEY = "~constructor"
+
 /** @internal */
 export const jsonSchemaAnnotationKeys = [
   "title",

package/src/internal/schema/fromJsonSchemaDocument.ts

@@ -214,8 +214,8 @@ function translateJsonSchemaMultiDocument(
   options?: SchemaRepresentation.FromJsonSchemaOptions,
   singleRoot = false
 ): SchemaRepresentation.MultiDocument {
-  const definitionCache = new Map<string, ImportedJsonSchemaRepresentation>()
-  const definitionsInProgress = new Set<string>()
+  const definitionCache = new Map<string, ImportedJsonSchemaRepresentation | null>()
+  const reachableDefinitions = new Map<string, Path>()
   const annotatedReferences: Array<{
     readonly reference: SchemaRepresentation.Reference
     readonly path: Path
@@ -227,16 +227,17 @@ function translateJsonSchemaMultiDocument(
     recursiveReferenceError?: string
   ): ImportedJsonSchemaRepresentation {
     const cached = definitionCache.get(key)
-    if (cached !== undefined) return cached
+    if (cached !== undefined) {
+      if (cached === null) {
+        throw errorWithPath(recursiveReferenceError ?? `Invalid reference ${key}`, [...path, "$ref"])
+      }
+      return cached
+    }
     if (!Object.hasOwn(document.definitions, key)) {
       throw errorWithPath(`Invalid reference ${key}`, [...path, "$ref"])
     }
-    if (definitionsInProgress.has(key)) {
-      throw errorWithPath(recursiveReferenceError ?? `Invalid reference ${key}`, [...path, "$ref"])
-    }
-    definitionsInProgress.add(key)
+    definitionCache.set(key, null)
     const representation = recur(document.definitions[key], ["definitions", key])
-    definitionsInProgress.delete(key)
     definitionCache.set(key, representation)
     return representation
   }
@@ -696,6 +697,7 @@ function translateJsonSchemaMultiDocument(
     if (typeof schema.$ref === "string") {
       const $ref = jsonSchemaReferenceKey(schema.$ref)
       if ($ref !== undefined) {
+        if (!reachableDefinitions.has($ref)) reachableDefinitions.set($ref, path)
         return { _tag: "Reference", $ref }
       }
     }
@@ -812,7 +814,7 @@ function translateJsonSchemaMultiDocument(
       addNumberCheck(checks, schema.minItems, "effect/schema/isMinLength", "minLength")
       addNumberCheck(checks, schema.maxItems, "effect/schema/isMaxLength", "maxLength")
     }
-    if (typeof schema.uniqueItems === "boolean") {
+    if (schema.uniqueItems === true) {
       checks.push(jsonSchemaFilter("effect/schema/isUnique", null))
     }
     return checks
@@ -890,12 +892,12 @@ function translateJsonSchemaMultiDocument(
   }
 
   const references: Record<string, Representation> = {}
-  for (const key of Object.keys(document.definitions)) {
-    InternalRecord.assignProperty(references, key, unknownJsonSchemas(translateDefinition(key, ["definitions", key])))
-  }
   const representations = document.schemas.map((schema, index) =>
     unknownJsonSchemas(recur(schema, singleRoot ? ["schema"] : ["schemas", index]))
   ) as [Representation, ...Array<Representation>]
+  for (const [key, path] of reachableDefinitions) {
+    InternalRecord.assignProperty(references, key, unknownJsonSchemas(translateDefinition(key, path)))
+  }
   for (const { reference, path } of annotatedReferences) {
     resolveReference(reference, path)
   }
@@ -952,6 +954,6 @@ export function fromJsonSchemaDocument(
 export function fromJsonSchemaMultiDocument(
   document: JsonSchema.MultiDocument<"draft-2020-12">,
   options?: SchemaRepresentation.FromJsonSchemaOptions
-): SchemaRepresentation.SchemaMultiDocument {
+): readonly [Schema.Top, ...Array<Schema.Top>] {
   return fromRepresentations(translateJsonSchemaMultiDocument(document, options), jsonSchemaRevivers)
 }

package/src/internal/schema/fromRepresentation.ts

@@ -12,7 +12,7 @@ type Path = ReadonlyArray<string | number>
 export function fromRepresentations(
   document: SchemaRepresentation.MultiDocument,
   revivers: ReadonlyArray<SchemaRepresentation.AnyReviver>
-): SchemaRepresentation.SchemaMultiDocument {
+): readonly [Schema.Top, ...Array<Schema.Top>] {
   return revivePersisted(document.representations, document.references, makeReviverMap(revivers), false)
 }
 
@@ -58,18 +58,17 @@ function revivePersisted(
   references: SchemaRepresentation.References,
   reviverMap: ReadonlyMap<string, SchemaRepresentation.AnyReviver>,
   singleRoot: boolean
-): SchemaRepresentation.SchemaMultiDocument {
+): readonly [Schema.Top, ...Array<Schema.Top>] {
   const slots = new Map<string, ReferenceSlot>()
-  const referenceKeys = Object.keys(references)
-
-  for (const key of referenceKeys) {
-    slots.set(key, new ReferenceSlot(key))
-  }
 
   function resolveReference(key: string, path: Path): Schema.Top {
-    const slot = slots.get(key)
+    let slot = slots.get(key)
     if (slot === undefined) {
-      throw errorWithPath(`Invalid reference ${key}`, [...path, "$ref"])
+      if (!Object.hasOwn(references, key)) {
+        throw errorWithPath(`Invalid reference ${key}`, [...path, "$ref"])
+      }
+      slot = new ReferenceSlot(key)
+      slots.set(key, slot)
     }
     if (slot.body !== undefined) {
       return slot.body
@@ -320,15 +319,10 @@ function revivePersisted(
     }
   }
 
-  const definitions: Record<string, Schema.Top> = {}
-  for (const key of referenceKeys) {
-    InternalRecord.assignProperty(definitions, key, resolveReference(key, ["references", key]))
-  }
-
   const schemas = representations.map((representation, index) =>
     recur(representation, singleRoot ? ["representation"] : ["representations", index])
   ) as [Schema.Top, ...Array<Schema.Top>]
-  return { schemas, definitions }
+  return schemas
 }
 
 /** @internal */
@@ -341,5 +335,5 @@ export function fromRepresentation(
     document.references,
     makeReviverMap(revivers),
     true
-  ).schemas[0]
+  )[0]
 }

package/src/internal/schema/parser.ts

@@ -0,0 +1,22 @@
+import * as Exit from "../../Exit.ts"
+import * as Option from "../../Option.ts"
+import { args } from "../core.ts"
+
+export const missing = Symbol()
+
+export { args }
+
+export type Success<A, E = never> = Exit.Success<A, E> & { readonly [args]: A }
+
+export const succeed = Exit.succeed as <A>(value: A) => Success<A>
+
+export const missingExit = succeed(missing)
+
+// Shared success for a present input returned unchanged. It must be resolved
+// before crossing an asynchronous or transformation boundary.
+export const sameExit: Success<unknown> = succeed(missing)
+
+export const toOption = <A>(value: A): Option.Option<A> => value === missing ? Option.none() : Option.some(value as A)
+
+export const fromOptionExit = <A>(option: Option.Option<A>): Success<A | typeof missing> =>
+  option._tag === "None" ? missingExit : succeed(option.value)

package/src/internal/schema/toArbitrary.ts

@@ -717,7 +717,9 @@ function base(ast: SchemaAST.AST, path: ReadonlyArray<PropertyKey>): LazyArbitra
               : out.map(Option.some)
           }
         )
-        let out = fc.tuple(...elementArbitraries).map(Array.getSomes)
+        let out = fc.tuple(...elementArbitraries).map((elements) =>
+          Array.getSomes(Array.takeWhile(elements, Option.isSome))
+        )
         // ---------------------------------------------
         // handle rest element
         // ---------------------------------------------

package/src/internal/schema/toJsonSchemaDocument.ts

@@ -1,4 +1,5 @@
 import * as Arr from "../../Array.ts"
+import * as Equal from "../../Equal.ts"
 import { escapeToken } from "../../JsonPointer.ts"
 import type * as JsonSchema from "../../JsonSchema.ts"
 import * as RegEx from "../../RegExp.ts"
@@ -142,12 +143,63 @@ function compileJsonSchema(
   options: Schema.ToJsonSchemaOptions | undefined
 ): JsonSchema.MultiDocument<"draft-2020-12"> {
   const definitions: Record<string, JsonSchema.JsonSchema> = {}
-  for (const key of Object.keys(references)) {
-    InternalRecord.assignProperty(definitions, key, recur(references[key], ["references", key]))
+  // 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>>()
+  const referenceKeys = Object.keys(references)
+  for (const key of referenceKeys) {
+    compileDefinition(key, ["references", key])
+  }
+  for (const key of referenceKeys) {
+    const compiled = definitionStates.get(key)!
+    if (typeof compiled !== "string") {
+      InternalRecord.assignProperty(definitions, key, 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 {
+    const compiled = definitionStates.get(key)
+    if (compiled !== undefined) return typeof compiled === "string" ? compiled : key
+    if (!Object.hasOwn(references, key)) {
+      throw errorWithPath(`Invalid reference ${key}`, [...path, "$ref"])
+    }
+
+    definitionStates.set(key, null)
+    const representation = references[key]
+    const schema = recur(representation, ["references", key])
+
+    const fallback = getIdentifierFallback(representation)
+    if (fallback !== undefined) {
+      const candidates = fallbackDefinitions.get(fallback)
+      const match = candidates?.find((candidate) => Equal.equals(definitionStates.get(candidate), schema))
+      if (match === undefined) {
+        if (candidates === undefined) fallbackDefinitions.set(fallback, [key])
+        else candidates.push(key)
+      } else {
+        definitionStates.set(key, match)
+        return match
+      }
+    }
+    definitionStates.set(key, schema)
+    return key
+  }
+
+  function getIdentifierFallback(
+    representation: SchemaRepresentation.Representation
+  ): string | undefined {
+    if (representation._tag === "Reference") return undefined
+    const annotations = representation.checks.length === 0
+      ? representation.annotations
+      : representation.checks[representation.checks.length - 1].annotations
+    return typeof annotations?.identifier !== "string" &&
+        typeof annotations?.[InternalAnnotations.IDENTIFIER_FALLBACK_KEY] === "string"
+      ? annotations[InternalAnnotations.IDENTIFIER_FALLBACK_KEY]
+      : undefined
+  }
+
   function annotationSchemas(
     representation: CheckRepresentationAnnotation | undefined,
     path: Path
@@ -183,11 +235,11 @@ function compileJsonSchema(
     path: Path
   ): JsonSchema.JsonSchema {
     if (representation._tag === "Reference") {
-      if (!Object.hasOwn(references, representation.$ref)) {
-        throw errorWithPath(`Invalid reference ${representation.$ref}`, [...path, "$ref"])
-      }
-      return { $ref: `#/$defs/${escapeToken(representation.$ref)}` }
+      const canonical = compileDefinition(representation.$ref, path)
+      return { $ref: `#/$defs/${escapeToken(canonical)}` }
     }
+    const cached = compiledRepresentations.get(representation)
+    if (cached !== undefined) return cached
 
     let output = on(representation, path)
     const ordinary = collectJsonSchemaAnnotations(representation.annotations, options)
@@ -201,6 +253,7 @@ function compileJsonSchema(
         output = appendJsonSchema(output, check)
       }
     }
+    compiledRepresentations.set(representation, output)
     return output
   }
 
@@ -370,6 +423,7 @@ function compileJsonSchema(
         if (!Object.hasOwn(references, parameter.$ref)) {
           throw errorWithPath(`Invalid reference ${parameter.$ref}`, [...path, "$ref"])
         }
+        compileDefinition(parameter.$ref, path)
         if (seenReferences.has(parameter.$ref)) return []
         const next = new Set(seenReferences).add(parameter.$ref)
         return getParameterPatterns(references[parameter.$ref], ["references", parameter.$ref], next)