effect 4.0.0-beta.101 → 4.0.0-beta.103

package/src/internal/effect.ts

@@ -83,8 +83,8 @@ import {
 } from "./core.ts"
 import * as doNotation from "./doNotation.ts"
 import * as InternalMetric from "./metric.ts"
+import * as InternalRecord from "./record.ts"
 import {
-  CurrentConcurrency,
   CurrentErrorReporters,
   CurrentLogAnnotations,
   CurrentLogLevel,
@@ -98,7 +98,6 @@ import {
 } from "./references.ts"
 import { getStackTraceLimit, setStackTraceLimit } from "./stackTraceLimit.ts"
 import { addSpanStackTrace, makeStackCleaner } from "./tracer.ts"
-import { version } from "./version.ts"
 
 // ----------------------------------------------------------------------------
 // Cause
@@ -269,7 +268,7 @@ export const causeMap: {
     const failures = self.reasons.map((failure) => {
       if (isFailReason(failure)) {
         hasFail = true
-        return new Fail(f(failure.error))
+        return new Fail(f(failure.error), failure.annotations)
       }
       return failure
     })
@@ -490,7 +489,7 @@ const renderErrorCause = (cause: Error, prefix: string) => {
 // ----------------------------------------------------------------------------
 
 /** @internal */
-export const FiberTypeId = `~effect/Fiber/${version}` as const
+export const FiberTypeId = "~effect/Fiber" as const
 
 const fiberVariance = {
   _A: identity,
@@ -556,7 +555,7 @@ export class FiberImpl<A = any, E = any> implements Fiber.Fiber<A, E> {
   }
 
   getRef<X>(ref: Context.Reference<X>): X {
-    return Context.getReferenceUnsafe(this.context, ref)
+    return Context.get(this.context, ref)
   }
   addObserver(cb: (exit: Exit.Exit<A, E>) => void): () => void {
     if (this._exit) {
@@ -707,20 +706,26 @@ export class FiberImpl<A = any, E = any> implements Fiber.Fiber<A, E> {
     return pipeArguments(this, arguments)
   }
   setContext(context: Context.Context<never>): void {
+    const previous = this.context
     this.context = context
+    // Every key cached below opts in to Context caching, so contexts related
+    // only by non-caching adds cannot have changed any of them
+    if (previous !== undefined && Context.hasSameCache(previous, context)) return
     const scheduler = this.getRef(Scheduler.Scheduler)
     if (scheduler !== this.currentScheduler) {
       this.currentScheduler = scheduler
       this._dispatcher = undefined
     }
-    this.currentSpan = context.mapUnsafe.get(Tracer.ParentSpanKey)
+    // The string-keyed lookups keep the Tracer key values (and the native
+    // tracer behind Tracer.Tracer's default) out of every bundle
+    this.currentSpan = Context.getOrUndefinedUnsafe(context, Tracer.ParentSpanKey)
     this.currentLogLevel = this.getRef(CurrentLogLevel)
     this.minimumLogLevel = this.getRef(MinimumLogLevel)
-    this.currentStackFrame = context.mapUnsafe.get(CurrentStackFrame.key)
+    this.currentStackFrame = this.getRef(CurrentStackFrame)
     this.maxOpsBeforeYield = this.getRef(Scheduler.MaxOpsBeforeYield)
     this.currentPreventYield = this.getRef(Scheduler.PreventSchedulerYield)
-    this.runtimeMetrics = context.mapUnsafe.get(InternalMetric.FiberRuntimeMetricsKey)
-    const currentTracer = context.mapUnsafe.get(Tracer.TracerKey)
+    this.runtimeMetrics = Context.getOrUndefinedUnsafe(context, InternalMetric.FiberRuntimeMetricsKey)
+    const currentTracer = Context.getOrUndefinedUnsafe<Tracer.Tracer>(context, Tracer.TracerKey)
     this.currentTracerContext = currentTracer ? currentTracer["context"] : undefined
   }
   get currentSpanLocal(): Tracer.Span | undefined {
@@ -2111,6 +2116,32 @@ export const updateService: {
     })
 )
 
+/** @internal */
+export const updateServiceScoped = <I, A>(
+  service: Context.Key<I, A>,
+  update: (value: A) => A,
+  options?: {
+    readonly reset?: ((original: A, updated: A, current: A) => A) | undefined
+  } | undefined
+): Effect.Effect<void, never, I | Scope.Scope> =>
+  uninterruptible(withFiber((fiber) => {
+    const original = Context.getUnsafe(fiber.context, service)
+    const updated = update(original)
+    fiber.setContext(Context.add(fiber.context, service, updated))
+    return scopeAddFinalizerExit(Context.getUnsafe(fiber.context, scopeTag), (_) => {
+      const current = Context.getUnsafe(fiber.context, service)
+      let next: A
+      if (options?.reset === undefined) {
+        if (current !== updated) return void_
+        next = original
+      } else {
+        next = options.reset(original, updated, current)
+      }
+      fiber.setContext(Context.add(fiber.context, service, next))
+      return void_
+    })
+  }))
+
 /** @internal */
 export const context = <R = never>(): Effect.Effect<Context.Context<R>> => getContext as any
 const getContext = withFiber((fiber) => succeed(fiber.context))
@@ -2222,17 +2253,6 @@ export const provideServiceEffect: {
     flatMap(acquire, (implementation) => provideService(self, service, implementation))
 )
 
-/** @internal */
-export const withConcurrency: {
-  (
-    concurrency: "unbounded" | number
-  ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
-  <A, E, R>(
-    self: Effect.Effect<A, E, R>,
-    concurrency: "unbounded" | number
-  ): Effect.Effect<A, E, R>
-} = provideService(CurrentConcurrency)
-
 // ----------------------------------------------------------------------------
 // zipping
 // ----------------------------------------------------------------------------
@@ -3733,8 +3753,8 @@ export const timed = <A, E, R>(
   self: Effect.Effect<A, E, R>
 ): Effect.Effect<[duration: Duration.Duration, result: A], E, R> =>
   clockWith((clock) => {
-    const start = clock.currentTimeNanosUnsafe()
-    return map(self, (a) => [Duration.nanos(clock.currentTimeNanosUnsafe() - start), a])
+    const start = clock.monotonicTimeNanosUnsafe()
+    return map(self, (a) => [Duration.nanos(clock.monotonicTimeNanosUnsafe() - start), a])
   })
 
 // ----------------------------------------------------------------------------
@@ -4353,7 +4373,7 @@ export const all = <
         Object.entries(arg),
         ([key, effect]) =>
           map(options?.mode === "result" ? result(effect) : effect, (value) => {
-            out[key] = value
+            InternalRecord.assignProperty(out, key, value)
           }),
         {
           discard: true,
@@ -4615,10 +4635,8 @@ export const forEach: {
     readonly discard?: boolean | undefined
   }
 ): Effect.Effect<any, E, R> =>
-  withFiber((parent) => {
-    const concurrencyOption = options?.concurrency === "inherit"
-      ? parent.getRef(CurrentConcurrency)
-      : (options?.concurrency ?? 1)
+  suspend(() => {
+    const concurrencyOption = options?.concurrency ?? 1
     const concurrency = concurrencyOption === "unbounded"
       ? Number.POSITIVE_INFINITY
       : Math.max(1, concurrencyOption)
@@ -4667,7 +4685,6 @@ const forEachSequential = <A, B, E, R>(
 
 type IterateEagerOptions = {
   readonly concurrency?: number | undefined
-  readonly start?: number | undefined
   readonly end?: number | undefined
   readonly orderedStep?: boolean | undefined
 }
@@ -4683,14 +4700,37 @@ const iterateEagerImpl = <S, A, X, E, R, E2>(options: {
   const onItem = options.onItem
   const step = options.step
 
+  const runSequential = (
+    state: S,
+    items: ReadonlyArray<A>,
+    index: number,
+    end: number
+  ): Effect.Effect<void, E | E2, R> | undefined => {
+    for (; index < end; index++) {
+      const item = items[index]
+      const effect = onItem(state, item, index)
+      if (!effectIsExit(effect)) {
+        return flatMap(
+          exit(effect),
+          (itemExit) => step(state, item, itemExit, index) ?? runSequential(state, items, index + 1, end) ?? void_
+        )
+      }
+      const terminal = step(state, item, effect, index)
+      if (terminal) return terminal._tag === "Failure" ? terminal : undefined
+    }
+  }
+
   return (
     state: S,
     items: ReadonlyArray<A>,
     opts: IterateEagerOptions | undefined
   ): Effect.Effect<void, E | E2, R> | undefined => {
-    let index = opts?.start ?? 0
+    let index = 0
     const end = opts?.end ?? items.length
     const concurrency = opts?.concurrency ?? 1
+    if (concurrency === 1) {
+      return runSequential(state, items, 0, end)
+    }
     const orderedStep = opts?.orderedStep === true && concurrency > 1
     let done = false
     let parentFiber: Fiber.Fiber<any, any> | undefined
@@ -4737,14 +4777,6 @@ const iterateEagerImpl = <S, A, X, E, R, E2>(options: {
           terminal = runStep(item, eff, index)
           if (terminal) break
 
-          // Use flatMap for concurrency of 1
-        } else if (concurrency === 1) {
-          return flatMap(exit(eff), (exit) => {
-            terminal = runStep(item, exit, index)
-            index++
-            return terminal ?? go() ?? void_
-          })
-
           // We have an effect, so enter "async" mode
         } else if (!parentFiber) {
           return callback((cb) => {
@@ -5191,16 +5223,17 @@ export const forkUnsafe = <FA, FE, A, E, R>(
   daemon = false,
   uninterruptible: boolean | "inherit" = false
 ): FiberImpl<A, E> => {
-  const interruptible = uninterruptible === "inherit" ? parent.interruptible : !uninterruptible
-  const child = new FiberImpl<A, E>(parent.context, interruptible)
+  const parentRuntime = parent as FiberImpl<FA, FE>
+  const interruptible = uninterruptible === "inherit" ? parentRuntime.interruptible : !uninterruptible
+  const child = new FiberImpl<A, E>(parentRuntime.context, interruptible)
   if (immediate) {
     child.evaluate(effect as any)
   } else {
-    parent.currentDispatcher.scheduleTask(() => child.evaluate(effect as any), 0)
+    parentRuntime.currentDispatcher.scheduleTask(() => child.evaluate(effect as any), 0)
   }
   if (!daemon && !child._exit) {
-    parent.children().add(child)
-    child.addObserver(() => parent._children!.delete(child))
+    parentRuntime.children().add(child)
+    child.addObserver(() => parentRuntime._children!.delete(child))
   }
   return child
 }
@@ -5489,7 +5522,7 @@ const succeedFalse = succeed(false)
 
 class Latch implements _Latch.Latch {
   waiters: Array<(_: Effect.Effect<void>) => void> = []
-  scheduled = false
+  scheduled: Array<(_: Effect.Effect<void>) => void> | undefined = undefined
   private _isOpen: boolean
 
   constructor(isOpen: boolean) {
@@ -5497,17 +5530,35 @@ class Latch implements _Latch.Latch {
   }
 
   private scheduleUnsafe(fiber: Fiber.Fiber<unknown, unknown>) {
-    if (this.scheduled || this.waiters.length === 0) {
+    if (this.waiters.length === 0) {
       return succeedTrue
     }
-    this.scheduled = true
-    fiber.currentDispatcher.scheduleTask(this.flushWaiters, 0)
+    if (this.scheduled === undefined) {
+      this.scheduled = this.waiters
+      fiber.currentDispatcher.scheduleTask(this.flushScheduled, 0)
+    } else {
+      for (let i = 0; i < this.waiters.length; i++) {
+        this.scheduled.push(this.waiters[i])
+      }
+    }
+    this.waiters = []
     return succeedTrue
   }
-  private flushWaiters = () => {
-    this.scheduled = false
+  private flushScheduled = () => {
+    if (this.scheduled === undefined) return
+    const waiters = this.scheduled
+    this.scheduled = undefined
+    for (let i = 0; i < waiters.length; i++) {
+      waiters[i](exitVoid)
+    }
+  }
+  private flushWaiters() {
+    // swap both arrays out before any resume runs: a resumed waiter can
+    // reentrantly close the latch and register new waiters, which must not
+    // be drained by this flush
     const waiters = this.waiters
     this.waiters = []
+    this.flushScheduled()
     for (let i = 0; i < waiters.length; i++) {
       waiters[i](exitVoid)
     }
@@ -5531,9 +5582,14 @@ class Latch implements _Latch.Latch {
     }
     this.waiters.push(resume)
     return sync(() => {
-      const index = this.waiters.indexOf(resume)
+      let index = this.waiters.indexOf(resume)
       if (index !== -1) {
         this.waiters.splice(index, 1)
+      } else if (this.scheduled !== undefined) {
+        index = this.scheduled.indexOf(resume)
+        if (index !== -1) {
+          this.scheduled.splice(index, 1)
+        }
       }
     })
   })
@@ -5885,11 +5941,11 @@ export const annotateSpans: {
     ...args: [Record<string, unknown>] | [key: string, value: unknown]
   ): Effect.Effect<A, E, R> =>
     updateService(effect, TracerSpanAnnotations, (annotations) => {
-      const newAnnotations = { ...annotations }
+      const newAnnotations = args.length === 1 ? { ...annotations, ...args[0] } : { ...annotations }
       if (args.length === 1) {
-        Object.assign(newAnnotations, args[0])
+        return newAnnotations
       } else {
-        newAnnotations[args[0]] = args[1]
+        InternalRecord.assignProperty(newAnnotations, args[0], args[1])
       }
       return newAnnotations
     })
@@ -5942,9 +5998,13 @@ class ClockImpl implements Clock.Clock {
   }
   readonly currentTimeMillis: Effect.Effect<number> = sync(() => this.currentTimeMillisUnsafe())
   currentTimeNanosUnsafe(): bigint {
-    return processOrPerformanceNow()
+    return wallTimeNanos()
   }
   readonly currentTimeNanos: Effect.Effect<bigint> = sync(() => this.currentTimeNanosUnsafe())
+  monotonicTimeNanosUnsafe(): bigint {
+    return monotonicNowNanos()
+  }
+  readonly monotonicTimeNanos: Effect.Effect<bigint> = sync(() => this.monotonicTimeNanosUnsafe())
   sleep(duration: Duration.Duration): Effect.Effect<void> {
     return this.sleepMillis(Duration.toMillis(duration))
   }
@@ -5961,27 +6021,45 @@ class ClockImpl implements Clock.Clock {
   }
 }
 
-const performanceNowNanos = (function() {
-  const bigint1e6 = BigInt(1_000_000)
-  if (typeof performance === "undefined" || typeof performance.now === "undefined") {
-    return () => BigInt(Date.now()) * bigint1e6
+const nanosPerMilli = BigInt(1_000_000)
+
+const monotonicNowNanos = (function() {
+  const processHrtime = (globalThis as {
+    readonly process?: { readonly hrtime?: { readonly bigint?: () => bigint } }
+  }).process?.hrtime
+  if (typeof processHrtime?.bigint === "function") {
+    return () => processHrtime.bigint!()
+  }
+  if (typeof performance !== "undefined" && typeof performance.now === "function") {
+    return () => BigInt(Math.round(performance.now() * 1_000_000))
   }
-  let origin: bigint
+  let previous = BigInt(0)
   return () => {
-    origin ??= (BigInt(Date.now()) * bigint1e6) - BigInt(Math.round(performance.now() * 1_000_000))
-    return origin + BigInt(Math.round(performance.now() * 1_000_000))
+    const current = BigInt(Date.now()) * nanosPerMilli
+    if (current > previous) {
+      previous = current
+    }
+    return previous
   }
 })()
-const processOrPerformanceNow = (function() {
-  const processHrtime =
-    typeof process === "object" && "hrtime" in process && typeof process.hrtime.bigint === "function" ?
-      process.hrtime :
-      undefined
-  if (!processHrtime) {
-    return performanceNowNanos
-  }
-  const origin = (BigInt(Date.now()) * BigInt(1e6)) - processHrtime.bigint()
-  return () => origin + processHrtime.bigint()
+
+const wallTimeNanos = (function() {
+  const reanchorThresholdNanos = BigInt(1_000_000_000)
+  let origin: bigint | undefined
+  return () => {
+    const monotonic = monotonicNowNanos()
+    const wall = BigInt(Date.now()) * nanosPerMilli
+    if (origin === undefined) {
+      origin = wall - monotonic
+    } else {
+      const projected = origin + monotonic
+      const skew = wall > projected ? wall - projected : projected - wall
+      if (skew > reanchorThresholdNanos) {
+        origin = wall - monotonic
+      }
+    }
+    return origin + monotonic
+  }
 })()
 
 /** @internal */
@@ -5998,6 +6076,9 @@ export const currentTimeMillis: Effect.Effect<number> = clockWith((clock) => clo
 /** @internal */
 export const currentTimeNanos: Effect.Effect<bigint> = clockWith((clock) => clock.currentTimeNanos)
 
+/** @internal */
+export const monotonicTimeNanos: Effect.Effect<bigint> = clockWith((clock) => clock.monotonicTimeNanos)
+
 // ----------------------------------------------------------------------------
 // Errors
 // ----------------------------------------------------------------------------
@@ -6160,7 +6241,7 @@ export const annotateLogsScoped: {
     const next = { ...prev }
     for (let i = 0; i < entries.length; i++) {
       const [key, value] = entries[i]
-      next[key] = value
+      InternalRecord.assignProperty(next, key, value)
     }
     fiber.setContext(Context.add(fiber.context, CurrentLogAnnotations, next))
     return scopeAddFinalizerExit(Context.getUnsafe(fiber.context, scopeTag), (_) => {
@@ -6169,8 +6250,8 @@ export const annotateLogsScoped: {
       for (let i = 0; i < entries.length; i++) {
         const [key, value] = entries[i]
         if (current[key] !== value) continue
-        if (key in prev) {
-          next[key] = prev[key]
+        if (Object.hasOwn(prev, key)) {
+          InternalRecord.assignProperty(next, key, prev[key])
         } else {
           delete next[key]
         }
@@ -6334,10 +6415,10 @@ export const consolePretty = (options?: {
 }) => {
   // evaluated lazily so the module-level bundle stays free of `process`
   // property accesses, which bundlers must retain as possible side effects
-  const hasProcessStdout = typeof process === "object" &&
-    process !== null &&
-    typeof process.stdout === "object" &&
-    process.stdout !== null
+  const process = (globalThis as {
+    readonly process?: { readonly stdout?: { readonly isTTY?: boolean } }
+  }).process
+  const hasProcessStdout = typeof process?.stdout === "object" && process.stdout !== null
   const processStdoutIsTTY = hasProcessStdout &&
     process.stdout.isTTY === true
   const hasProcessStdoutOrDeno = hasProcessStdout || "Deno" in globalThis
@@ -6355,7 +6436,7 @@ const prettyLoggerTty = (options: {
   readonly colors: boolean
   readonly formatDate: (date: Date) => string
 }) => {
-  const processIsBun = typeof process === "object" && "isBun" in process && process.isBun === true
+  const processIsBun = (globalThis as { readonly process?: { readonly isBun?: boolean } }).process?.isBun === true
   const color = options.colors ? withColor : withColorNoop
   return loggerMake<unknown, void>(
     ({ cause, date, fiber, logLevel, message: message_ }) => {
@@ -6514,7 +6595,7 @@ export const tracerLogger = loggerMake<unknown, void>(({ cause, fiber, logLevel,
   if (span === undefined || span._tag === "ExternalSpan") return
   const attributes: Record<string, unknown> = {}
   for (const [key, value] of Object.entries(annotations)) {
-    attributes[key] = value
+    InternalRecord.assignProperty(attributes, key, value)
   }
   attributes["effect.fiberId"] = fiber.id
   attributes["effect.logLevel"] = logLevel.toUpperCase()

package/src/internal/matcher.ts

@@ -396,7 +396,7 @@ export const discriminators = <D extends string>(field: D) =>
   fields: P
 ) => {
   const predicate = makeWhen(
-    (arg: any) => arg != null && arg[field] in fields,
+    (arg: any) => arg != null && Object.hasOwn(fields, arg[field]),
     (data: any) => (fields as any)[data[field]](data)
   )
 

package/src/internal/persistence.ts

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

package/src/internal/record.ts

@@ -1,9 +1,5 @@
-/**
- * @since 4.0.0
- */
-
 /** @internal */
-export function set<K extends PropertyKey, A>(self: Record<K, A>, key: K, value: A): Record<K, A> {
+export function assignProperty(self: object, key: PropertyKey, value: unknown): void {
   if (key === "__proto__") {
     Object.defineProperty(self, key, {
       value,
@@ -12,7 +8,15 @@ export function set<K extends PropertyKey, A>(self: Record<K, A>, key: K, value:
       configurable: true
     })
   } else {
-    self[key] = value
+    ;(self as any)[key] = value
+  }
+}
+
+/** @internal */
+export function assignProperties(self: object, source: object): void {
+  for (const key of Reflect.ownKeys(source)) {
+    if (Object.prototype.propertyIsEnumerable.call(source, key)) {
+      assignProperty(self, key, (source as any)[key])
+    }
   }
-  return self
 }

package/src/internal/references.ts

@@ -6,11 +6,6 @@ import type { ReadonlyRecord } from "../Record.ts"
 import type { StackFrame } from "../References.ts"
 import type { SpanLink } from "../Tracer.ts"
 
-/** @internal */
-export const CurrentConcurrency = Context.Reference<"unbounded" | number>("effect/References/CurrentConcurrency", {
-  defaultValue: () => "unbounded"
-})
-
 /** @internal */
 export const CurrentErrorReporters = Context.Reference<ReadonlySet<ErrorReporter>>(
   "effect/ErrorReporter/CurrentErrorReporters",
@@ -19,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
 })
 
@@ -52,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/schema/annotations.ts

@@ -12,9 +12,35 @@ export function resolveAt<A>(key: string) {
   return (ast: SchemaAST.AST): A | undefined => resolve(ast)?.[key] as A | undefined
 }
 
+/** @internal */
+export const STRUCTURAL_ANNOTATION_KEY = "~structural"
+
+/** @internal */
+export const IDENTIFIER_FALLBACK_KEY = "~identifier"
+
+/** @internal */
+export const SENTINELS_ANNOTATION_KEY = "~sentinels"
+
+/** @internal */
+export const jsonSchemaAnnotationKeys = [
+  "title",
+  "description",
+  "default",
+  "examples",
+  "readOnly",
+  "writeOnly",
+  "format",
+  "contentEncoding",
+  "contentMediaType",
+  "contentSchema"
+] as const
+
 /** @internal */
 export const resolveIdentifier = resolveAt<string>("identifier")
 
+/** @internal */
+export const resolveIdentifierFallback = resolveAt<string>(IDENTIFIER_FALLBACK_KEY)
+
 /** @internal */
 export const resolveTitle = resolveAt<string>("title")
 
@@ -35,3 +61,21 @@ export const getExpected = memoize((ast: SchemaAST.AST): string => {
 export function collectBrands(annotations: Schema.Annotations.Annotations | undefined): ReadonlyArray<string> {
   return annotations !== undefined && Array.isArray(annotations.brands) ? annotations.brands : []
 }
+
+/** @internal */
+export const annotationExcludedKeys = new Set([
+  SENTINELS_ANNOTATION_KEY,
+  STRUCTURAL_ANNOTATION_KEY,
+  "representation",
+  "arbitrary",
+  "brands",
+  "toJsonSchema",
+  "toCode",
+  "toArbitrary",
+  "toEquivalence",
+  "toFormatter",
+  "toCodec",
+  "toCodecJson",
+  "toCodecStringTree",
+  "toCodecIso"
+])