@blockcast/mmt-render 0.1.0-main.c0e9e40265a1

package/src/audio/render-messages.ts

@@ -0,0 +1,110 @@
+/**
+ * Typed contract for AudioWorklet ↔ main-thread messages.
+ * Used by both the worklet processor (render-worklet.ts) and by consumers
+ * through audio-render-pipeline.ts.
+ */
+
+/** Main → worklet. */
+export type FromMain =
+  | InitMessage
+  | DataMessage
+  | StartMessage
+  | LatencyMessage
+  | ResetMessage
+  | DiagRequestMessage
+
+/** Worklet → main. */
+export type ToMain = WriteAckMessage | StateMessage | DiagMessage
+
+export interface InitMessage {
+  type: 'init'
+  /** Main-thread playout generation. State from older generations is stale. */
+  generation: number
+  /** Channel count. */
+  channels: number
+  /** Sample rate in Hz. */
+  rate: number
+  /** Buffer latency in ms. */
+  latencyMs: number
+  /** Exact PCM startup threshold derived from catalog delivery units. */
+  startupFrames?: number
+  /** Exact PCM storage ceiling, including one successor delivery burst. */
+  capacityFrames?: number
+  /** Start in unstalled state (source-switch reconfig). Default false. */
+  startUnstalled?: boolean
+  /** Buffer and acknowledge PCM without rendering until a matching start message. */
+  holdUntilStart?: boolean
+  /** Deprecated compatibility input. Clock recovery is not performed. */
+  warmupReads?: number
+  /** Enable telemetry reporting. Default false. */
+  diag?: boolean
+}
+
+export interface DataMessage {
+  type: 'data'
+  /** Per-channel PCM (Float32) for the next chunk. */
+  data: Float32Array[]
+  /** Presentation timestamp of the first sample in µs. */
+  timestamp: number
+}
+
+export interface WriteAckMessage {
+  type: 'writeAck'
+  /** Playout generation that accepted the PCM. */
+  generation: number
+  /** Exact unread PCM sample count after accepting the write. */
+  bufferedFrames: number
+  /** Cumulative PCM frames accepted since the last init/reset. */
+  writtenFrames: number
+}
+
+export interface StartMessage {
+  type: 'start'
+  /** Playout generation to release. Stale start messages are ignored. */
+  generation: number
+}
+
+export interface LatencyMessage {
+  type: 'latency'
+  /** New buffer latency in ms. */
+  latencyMs: number
+}
+
+export interface ResetMessage {
+  type: 'reset'
+  /** Main-thread playout generation after this reset. */
+  generation: number
+  /** Start immediately instead of waiting for a full configured buffer. */
+  startUnstalled?: boolean
+}
+
+export interface DiagRequestMessage {
+  type: 'requestDiag'
+}
+
+export interface StateMessage {
+  type: 'state'
+  /** Playout generation that produced this state snapshot. */
+  generation: number
+  /** Timestamp of the next MMTP media sample after emitted PCM, in µs. */
+  timestamp?: number
+  /** Is the ring buffer waiting to fill? */
+  stalled: boolean
+  /** Exact unread PCM sample count. */
+  bufferedFrames: number
+  /** Cumulative PCM frames accepted since the last init/reset. */
+  writtenFrames: number
+}
+
+export interface DiagMessage {
+  type: 'ringBufDiag'
+  /** Playout generation that produced this diagnostic snapshot. */
+  generation: number
+  reads: number
+  avgFill: number
+  capacity: number
+  skipsPerSec: number
+  dupsPerSec: number
+  overflowSamplesPerSec: number
+  underflowSamplesPerSec: number
+}

package/src/audio/render-worklet.ts

@@ -0,0 +1,161 @@
+/**
+ * Shared AudioWorklet render processor.
+ *
+ * This file is bundled into a self-contained IIFE at build time
+ * (dist/worklet/render-worklet.js) because AudioWorkletGlobalScope cannot
+ * resolve bare specifiers. The AudioRingBuffer dependency is inlined at
+ * bundle time; do not import from @blockcast packages at runtime.
+ *
+ * Consumers load the prebuilt bundle via audioWorklet.addModule(url) where
+ * url is obtained from `@blockcast/mmt-render/audio/worklet-url`.
+ */
+
+import { AudioRingBuffer } from './audio-ring-buffer.js'
+import type { FromMain, ToMain } from './render-messages.js'
+
+class Render extends AudioWorkletProcessor {
+  #buffer?: AudioRingBuffer
+  #underflow = 0
+  #diagUnderflow = 0
+  #started = false
+  #stateCounter = 0
+  #diagEnabled = false
+  #diagCounter = 0
+  #generation = 0
+  #writtenFrames = 0
+  #heldUntilStart = false
+  #resumeAfterReset = false
+
+  constructor() {
+    super()
+    this.port.onmessage = (event: MessageEvent<FromMain>) => {
+      const msg = event.data
+      if (msg.type === 'init') {
+        const heldUntilStart = msg.holdUntilStart ?? false
+        const latencyFrames = Math.ceil(msg.rate * (msg.latencyMs / 1000))
+        const startupFrames = msg.startupFrames ?? latencyFrames
+        // Keep one latency window above the release threshold so PCM accepted
+        // during the writeAck -> start round trip cannot evict the prefill head.
+        const capacityFrames =
+          msg.capacityFrames ?? Math.max(latencyFrames, startupFrames) + latencyFrames
+        if (!Number.isSafeInteger(startupFrames) || startupFrames <= 0) {
+          throw new Error('invalid startup frames')
+        }
+        if (!Number.isSafeInteger(capacityFrames) || capacityFrames < startupFrames) {
+          throw new Error('invalid capacity frames')
+        }
+        this.#generation = msg.generation
+        this.#buffer = new AudioRingBuffer({
+          channels: msg.channels,
+          rate: msg.rate,
+          latencyMs: msg.latencyMs,
+          // The explicit start gate owns the one-time startup prefill. Once
+          // released, resume from an underrun as soon as new PCM is accepted.
+          startupFrames,
+          resumeFrames: heldUntilStart ? 1 : undefined,
+          capacityFrames,
+          startUnstalled: msg.startUnstalled,
+          warmupReads: msg.warmupReads,
+          diag: msg.diag ?? false,
+        })
+        this.#diagEnabled = msg.diag ?? false
+        this.#underflow = 0
+        this.#diagUnderflow = 0
+        this.#started = false
+        this.#writtenFrames = 0
+        this.#heldUntilStart = heldUntilStart
+        this.#resumeAfterReset = heldUntilStart
+      } else if (msg.type === 'data') {
+        if (!this.#buffer) return
+        this.#buffer.write(msg.timestamp, msg.data)
+        this.#writtenFrames += msg.data[0]?.length ?? 0
+        if (this.#heldUntilStart || this.#diagEnabled) {
+          this.port.postMessage({
+            type: 'writeAck',
+            generation: this.#generation,
+            bufferedFrames: this.#buffer.length,
+            writtenFrames: this.#writtenFrames,
+          })
+        }
+      } else if (msg.type === 'start') {
+        if (msg.generation === this.#generation) this.#heldUntilStart = false
+      } else if (msg.type === 'latency') {
+        if (!this.#buffer) return
+        this.#buffer.resize(msg.latencyMs)
+      } else if (msg.type === 'reset') {
+        this.#generation = msg.generation
+        this.#buffer?.reset(msg.startUnstalled ?? false, this.#resumeAfterReset)
+        this.#underflow = 0
+        this.#diagUnderflow = 0
+        this.#started = false
+        this.#writtenFrames = 0
+        this.#heldUntilStart = false
+      } else if (msg.type === 'requestDiag') {
+        this.#flushDiag()
+      }
+    }
+  }
+
+  process(_inputs: Float32Array[][], outputs: Float32Array[][]): boolean {
+    const output = outputs[0]
+    const samplesRead = this.#heldUntilStart ? 0 : (this.#buffer?.read(output) ?? 0)
+
+    if (samplesRead > 0) this.#started = true
+    if (samplesRead < output[0].length && this.#started) {
+      const missing = output[0].length - samplesRead
+      this.#underflow += missing
+      this.#diagUnderflow += missing
+    } else if (this.#underflow > 0 && this.#buffer) {
+      // eslint-disable-next-line no-console
+      console.warn(`audio underflow: ${Math.round((1000 * this.#underflow) / this.#buffer.rate)}ms`)
+      this.#underflow = 0
+    }
+
+    // State update ~60/sec (every 5 processes at 128-sample quantum @ 48kHz ≈ 2.67ms each)
+    this.#stateCounter++
+    if (this.#buffer && this.#stateCounter >= 5) {
+      this.#stateCounter = 0
+      const msg: ToMain = {
+        type: 'state',
+        generation: this.#generation,
+        timestamp: this.#heldUntilStart ? undefined : this.#buffer.timestampUs,
+        stalled: this.#heldUntilStart || this.#buffer.stalled,
+        bufferedFrames: this.#buffer.length,
+        writtenFrames: this.#writtenFrames,
+      }
+      this.port.postMessage(msg)
+    }
+
+    // Diag telemetry every ~1s if enabled.
+    if (this.#diagEnabled && this.#buffer) {
+      this.#diagCounter++
+      if (this.#diagCounter >= 375) {
+        this.#diagCounter = 0
+        this.#flushDiag()
+      }
+    }
+
+    return true
+  }
+
+  #flushDiag(): void {
+    if (!this.#buffer) return
+    const d = this.#buffer.getDiagAndReset()
+    if (!d && this.#diagUnderflow === 0) return
+    const msg: ToMain = {
+      type: 'ringBufDiag',
+      generation: this.#generation,
+      reads: d?.reads ?? 0,
+      avgFill: d?.avgFill ?? 0,
+      capacity: d?.capacity ?? this.#buffer.capacity,
+      skipsPerSec: d?.skips ?? 0,
+      dupsPerSec: d?.dups ?? 0,
+      overflowSamplesPerSec: d?.overflowSamples ?? 0,
+      underflowSamplesPerSec: this.#diagUnderflow,
+    }
+    this.#diagUnderflow = 0
+    this.port.postMessage(msg)
+  }
+}
+
+registerProcessor('mmt-render', Render)

package/src/audio/worklet-url.ts

@@ -0,0 +1,30 @@
+/**
+ * Helper for loading the prebuilt AudioWorklet bundle.
+ *
+ * Two equivalent loading patterns supported:
+ *
+ *   1. Vite-style static URL (recommended for bundled apps):
+ *        import workletUrl from '@blockcast/mmt-render/audio/worklet.js?url'
+ *        await ctx.audioWorklet.addModule(workletUrl)
+ *      Vite resolves the `?url` suffix + the package's "./audio/worklet.js"
+ *      export to the prebuilt IIFE file.
+ *
+ *   2. Runtime import.meta.url resolution (no bundler):
+ *        import { workletModuleUrl } from '@blockcast/mmt-render/audio/worklet-url'
+ *        await ctx.audioWorklet.addModule(workletModuleUrl())
+ *
+ * Both resolve to dist/worklet/render-worklet.js.
+ */
+
+/**
+ * Returns a URL (or URL string) pointing to the prebuilt worklet bundle.
+ * Resolves relative to this module's location via import.meta.url.
+ */
+export function workletModuleUrl(): string {
+  // dist layout: dist/audio/worklet-url.js → dist/worklet/render-worklet.js
+  const base = new URL('../worklet/render-worklet.js', import.meta.url)
+  return base.href
+}
+
+/** Processor name registered in the worklet bundle. */
+export const WORKLET_PROCESSOR_NAME = 'mmt-render'

package/src/index.ts

@@ -0,0 +1,13 @@
+/**
+ * @blockcast/mmt-render — shared MMT render pipeline for MoQ players.
+ *
+ * Subpath exports:
+ *   - ./pacing                FrameCountPacer, InterleaveTiming
+ *   - ./audio                 AudioRenderPipeline, AudioRingBuffer, worklet helpers
+ *   - ./video                 VideoRenderPipeline, KeyframeGate
+ *   - ./audio/worklet.js      Prebuilt self-contained AudioWorklet bundle
+ */
+
+export * from './pacing/index.js'
+export * from './audio/index.js'
+export * from './video/index.js'

package/src/pacing/au-duration.ts

@@ -0,0 +1,34 @@
+/**
+ * Nominal Access Unit duration helpers for common audio + video codecs.
+ *
+ * Kept in the pacing subpath (no mmt-container dep) so lean consumers like
+ * moqtail's player.ts can import the pacer + AU duration without pulling
+ * in the full audio-render-pipeline (which depends on @blockcast/mmt-container).
+ */
+
+/**
+ * Nominal AU duration in ms for common audio codecs at the given sample rate.
+ * AAC-LC: 1024 samples. Opus (default 20ms): 960 samples @ 48kHz.
+ * Throws for unknown codecs so callers supply correct timing.
+ */
+export function auDurationMsFromCodec(codec: string, sampleRate: number): number {
+  if (!(sampleRate > 0)) throw new Error('sampleRate must be > 0')
+  if (codec.startsWith('opus') || codec.startsWith('Opus')) {
+    return (960 / sampleRate) * 1000
+  }
+  if (codec.startsWith('mp4a') || codec.startsWith('AAC') || codec.startsWith('aac')) {
+    return (1024 / sampleRate) * 1000
+  }
+  if (codec.startsWith('flac') || codec.startsWith('fLaC')) {
+    return (4096 / sampleRate) * 1000
+  }
+  throw new Error(`unknown audio codec for AU duration derivation: ${codec}`)
+}
+
+/**
+ * Nominal picture duration in ms from framerate.
+ */
+export function pictureDurationMs(framerate: number): number {
+  if (!(framerate > 0)) throw new Error('framerate must be > 0')
+  return 1000 / framerate
+}

package/src/pacing/frame-pacer.ts

@@ -0,0 +1,129 @@
+/**
+ * FrameCountPacer — media-agnostic wall-clock pacer for MMT A/V decode loops.
+ *
+ * Why not use MPU timestamps? Under FEC interleaving, encoders pack multiple
+ * Access Units (AUs) per MMTP MPU with a single mpu_timestamp. The observed
+ * timestamp delta between MPUs is a fraction of the real per-AU duration
+ * (e.g. 10.22ms between MPUs for 21.33ms AAC frames at D=2 interleave).
+ * Pacing on that delta sees "media ≈ wall" and never sleeps, letting burst
+ * relay delivery saturate the decoder / ring buffer.
+ *
+ * The Sony libatsc3 pattern (atsc3_mmt_context_mfu_depacketizer) solves this
+ * by anchoring wall-clock time to the first received AU and counting AUs:
+ *   media_elapsed_ms = au_count × nominal_au_duration_ms
+ * The MPU timestamp is used elsewhere as an absolute-time anchor, never as
+ * an incremental clock.
+ *
+ * The sleep threshold comes from the catalog's FEC interleaveDepthMs (via
+ * FecBlockMapper.pacingThresholdMs). When no FEC is configured, a
+ * NullBlockMapper yields threshold=0 and this pacer never sleeps.
+ *
+ * One pacer instance = one track (e.g. audio, video) on one player.
+ */
+
+import type { FecBlockMapper } from '@blockcast/mmt-fec'
+
+export interface FrameCountPacerOpts {
+  /** Required: AU duration (audio) or picture interval (video), in ms. */
+  frameDurationMs: number
+  /** FEC mapper from @blockcast/mmt-fec. NullBlockMapper disables pacing. */
+  mapper: FecBlockMapper
+  /**
+   * Number of frames to let through before pacing starts. Lets startup
+   * burst drain populate the ring buffer / decoder queue. Default 0.
+   */
+  warmupFrames?: number
+}
+
+export interface PacerSnapshot {
+  /** Frames observed (from notifyFrame). */
+  frameCount: number
+  /** Computed media time: frameCount × frameDurationMs. */
+  mediaMs: number
+  /** Wall-clock time since anchor. */
+  wallMs: number
+  /** mediaMs - wallMs. Positive → decoder ahead of realtime. */
+  aheadMs: number
+  /** Pacing threshold (ms) from the FEC mapper. */
+  thresholdMs: number
+  /** Has the first frame been observed (wall anchor set)? */
+  anchored: boolean
+}
+
+export class FrameCountPacer {
+  readonly frameDurationMs: number
+  readonly thresholdMs: number
+  readonly warmupFrames: number
+
+  #frameCount = 0
+  #anchorWallMs = 0
+  #anchored = false
+
+  constructor(opts: FrameCountPacerOpts) {
+    if (!(opts.frameDurationMs > 0)) {
+      throw new Error('frameDurationMs must be > 0')
+    }
+    this.frameDurationMs = opts.frameDurationMs
+    this.thresholdMs = opts.mapper.pacingThresholdMs
+    this.warmupFrames = Math.max(0, opts.warmupFrames ?? 0)
+  }
+
+  /** Call on every emitted decoded frame (AU or picture). Anchors on first call. */
+  notifyFrame(): void {
+    if (!this.#anchored) {
+      this.#anchorWallMs = now()
+      this.#anchored = true
+    }
+    this.#frameCount++
+  }
+
+  /**
+   * Compute sleep ms before reading the next MoQ object.
+   * Returns 0 when:
+   *   - pacing is disabled (NullBlockMapper → threshold=0)
+   *   - the anchor is not yet set
+   *   - still in warmup
+   *   - decoder is not ahead of wall clock by more than threshold
+   * Otherwise returns aheadMs - thresholdMs/2 (leaves half the threshold as headroom).
+   */
+  computeSleepMs(): number {
+    if (this.thresholdMs <= 0) return 0
+    if (!this.#anchored) return 0
+    if (this.#frameCount <= this.warmupFrames) return 0
+
+    const mediaMs = this.#frameCount * this.frameDurationMs
+    const wallMs = now() - this.#anchorWallMs
+    const aheadMs = mediaMs - wallMs
+    if (aheadMs <= this.thresholdMs) return 0
+    return aheadMs - this.thresholdMs / 2
+  }
+
+  /** Reset anchor + counter. Call on source switch (MoQ ↔ multicast). */
+  reset(): void {
+    this.#frameCount = 0
+    this.#anchorWallMs = 0
+    this.#anchored = false
+  }
+
+  get snapshot(): PacerSnapshot {
+    const mediaMs = this.#frameCount * this.frameDurationMs
+    const wallMs = this.#anchored ? now() - this.#anchorWallMs : 0
+    return {
+      frameCount: this.#frameCount,
+      mediaMs,
+      wallMs,
+      aheadMs: mediaMs - wallMs,
+      thresholdMs: this.thresholdMs,
+      anchored: this.#anchored,
+    }
+  }
+}
+
+function now(): number {
+  // performance.now() is available in main thread, workers, and AudioWorklet.
+  // Fall back to Date.now() for exotic runtimes (shouldn't happen in browsers).
+  if (typeof performance !== 'undefined' && typeof performance.now === 'function') {
+    return performance.now()
+  }
+  return Date.now()
+}

package/src/pacing/index.ts

@@ -0,0 +1,5 @@
+export { FrameCountPacer } from './frame-pacer.js'
+export type { FrameCountPacerOpts, PacerSnapshot } from './frame-pacer.js'
+export { InterleaveTiming } from './interleave-timing.js'
+export type { InterleaveTimingOpts } from './interleave-timing.js'
+export { auDurationMsFromCodec, pictureDurationMs } from './au-duration.js'

package/src/pacing/interleave-timing.ts

@@ -0,0 +1,95 @@
+/**
+ * InterleaveTiming — per-AU presentation-time reconstruction.
+ *
+ * When encoders pack multiple AUs per MMTP MPU with a single mpu_timestamp
+ * (normal for FEC-interleaved audio, and for video with multi-picture MPUs),
+ * the raw mpu_timestamp is ambiguous for per-AU scheduling. The FEC block
+ * math (draft-ramadan-moq-fec-00 §8.3) combined with the Sony libatsc3
+ * pattern recovers correct per-AU time:
+ *
+ *   au_index_in_block = groupInBlock × symbolsPerGroup + objectId
+ *   ssId              = sbn × K + au_index_in_block
+ *   presentationUs    = anchorMpuUs + ssId × frameDurationUs
+ *
+ * The anchor (anchorMpuUs) is the mpu_timestamp of the first observed AU.
+ * Every downstream per-AU time is then deterministic from FEC coordinates
+ * + codec frame duration — identical whether the AU arrives via MoQ unicast
+ * (group_id/object_id) or multicast UDP (SS_ID from FEC Payload ID).
+ *
+ * Consumers: CMAF segment assembler (block boundary → segment cut points),
+ * debug overlays, cross-path FEC combining, sync diagnostics.
+ */
+
+import type { FecBlockMapper } from '@blockcast/mmt-fec'
+
+export interface InterleaveTimingOpts {
+  /** Track's FEC mapper (provides K, D, symbolsPerGroup). */
+  mapper: FecBlockMapper
+  /** Nominal AU duration in microseconds. */
+  frameDurationUs: number
+  /** Wall-time anchor: the mpu_timestamp of the first observed AU (µs). */
+  anchorMpuUs: number
+}
+
+export class InterleaveTiming {
+  readonly mapper: FecBlockMapper
+  readonly frameDurationUs: number
+  readonly anchorMpuUs: number
+
+  constructor(opts: InterleaveTimingOpts) {
+    if (!(opts.frameDurationUs > 0)) {
+      throw new Error('frameDurationUs must be > 0')
+    }
+    if (!Number.isFinite(opts.anchorMpuUs)) {
+      throw new Error('anchorMpuUs must be finite')
+    }
+    this.mapper = opts.mapper
+    this.frameDurationUs = opts.frameDurationUs
+    this.anchorMpuUs = opts.anchorMpuUs
+  }
+
+  /**
+   * Presentation time (µs) for an AU at MoQ coords (group_id, object_id).
+   * Per draft §8.3 + Sony anchor.
+   */
+  presentationUs(groupId: number, objectId: number): number {
+    const coords = this.mapper.derive(groupId, objectId)
+    return this.anchorMpuUs + coords.ssId * this.frameDurationUs
+  }
+
+  /**
+   * Presentation time (µs) for an AU identified by its flat SS_ID
+   * (multicast FEC Payload ID path).
+   */
+  presentationUsFromSsId(ssId: number): number {
+    return this.anchorMpuUs + ssId * this.frameDurationUs
+  }
+
+  /**
+   * Inverse: which (group_id, object_id) AU is scheduled at the given
+   * wall offset (µs) from anchor? Clamps to ssId≥0.
+   */
+  frameAtOffset(offsetUs: number): { groupId: number; objectId: number; ssId: number } {
+    const rawSsId = Math.max(0, Math.floor(offsetUs / this.frameDurationUs))
+    const { sbn, esi } = this.mapper.fromSsId(rawSsId)
+    // Invert §8.3: esi = groupInBlock * symbolsPerGroup + objectId
+    const spg = this.mapper.symbolsPerGroup
+    const groupInBlock = Math.floor(esi / spg)
+    const objectId = esi - groupInBlock * spg
+    const groupId = sbn * this.mapper.d + groupInBlock
+    return { groupId, objectId, ssId: rawSsId }
+  }
+
+  /**
+   * Block start/end in microseconds. Source blocks span `D × GOP_duration`
+   * of wall time; this returns the anchored wall range [startUs, endUs).
+   */
+  blockTimeRangeUs(sbn: number): { startUs: number; endUs: number } {
+    const firstSsId = sbn * this.mapper.k
+    const lastSsId = (sbn + 1) * this.mapper.k
+    return {
+      startUs: this.anchorMpuUs + firstSsId * this.frameDurationUs,
+      endUs: this.anchorMpuUs + lastSsId * this.frameDurationUs,
+    }
+  }
+}

package/src/video/index.ts

@@ -0,0 +1,7 @@
+export { KeyframeGate } from './keyframe-gate.js'
+export { VideoRenderPipeline } from './video-render-pipeline.js'
+export type {
+  VideoRenderPipelineOpts,
+  VideoFrameMeta,
+  VideoFrameCallback,
+} from './video-render-pipeline.js'

package/src/video/keyframe-gate.ts

@@ -0,0 +1,35 @@
+/**
+ * KeyframeGate — drops delta frames until a keyframe arrives.
+ *
+ * Required when subscribing mid-stream: the relay may deliver P/B frames
+ * from the middle of a GOP before the first IDR. Feeding those into
+ * VideoDecoder before an init yields "key frame required" errors.
+ *
+ * Call reset() to re-arm the gate after a decoder error (requestKeyframe).
+ */
+
+export class KeyframeGate {
+  #open = false
+
+  get isOpen(): boolean {
+    return this.#open
+  }
+
+  /**
+   * Decide whether to pass a frame through.
+   * Opens permanently once the first keyframe is seen.
+   */
+  allow(keyframe: boolean): boolean {
+    if (this.#open) return true
+    if (keyframe) {
+      this.#open = true
+      return true
+    }
+    return false
+  }
+
+  /** Re-close the gate. Next keyframe reopens it. */
+  reset(): void {
+    this.#open = false
+  }
+}