@blockcast/mmt-container 2.2.0-main.a88c3a0aa4f3 → 2.2.0-main.efb4fa4521af

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blockcast/mmt-container",
-  "version": "2.2.0-main.a88c3a0aa4f3",
+  "version": "2.2.0-main.efb4fa4521af",
   "description": "MMTP/LOC container parsing for MMT over MoQ and SSM",
   "type": "module",
   "main": "dist/index.js",
@@ -169,10 +169,10 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@blockcast/fec-worker": "2.2.0-main.a88c3a0aa4f3",
-    "@blockcast/mmt-base": "2.2.0-main.a88c3a0aa4f3",
-    "@blockcast/mmt-fec": "2.2.0-main.a88c3a0aa4f3",
-    "@blockcast/mmt-manifest-verify": "2.2.0-main.a88c3a0aa4f3",
+    "@blockcast/fec-worker": "2.2.0-main.efb4fa4521af",
+    "@blockcast/mmt-base": "2.2.0-main.efb4fa4521af",
+    "@blockcast/mmt-fec": "2.2.0-main.efb4fa4521af",
+    "@blockcast/mmt-manifest-verify": "2.2.0-main.efb4fa4521af",
     "@noble/curves": "^1.9.7",
     "@noble/hashes": "^1.8.0",
     "ajv": "^8.17.1",

package/schemas/catalog.schema.json

@@ -138,6 +138,10 @@
           "$ref": "#/$defs/positiveInteger",
           "description": "Keyframe interval in the track's timescale ticks (moqcast-draft §4.4.3). Exact where keyframeIntervalMs rounds (e.g. 30000/1001 video); when both are present, keyframeIntervalTicks wins."
         },
+        "deliveryMode": {
+          "type": "string",
+          "description": "How the publisher sends this track's objects (draft-ramadan-moq-fec-catalog-00 §3.3, proposed in moqcast-draft#26): \"datagram\" or \"stream\". A receiver treats a missing or unrecognized value as \"datagram\", so any string is admitted here rather than rejected. Allowed on source, repair and symbol tracks."
+        },
         "fec": { "$ref": "#/$defs/fec" }
       },
       "allOf": [

package/src/index.ts

@@ -602,11 +602,22 @@ export {
 	type MmtpFecSessionConfig,
 	type MmtpFecSessionDecoder,
 	type MmtpFecSessionDecoderConstructor,
+	type MmtpFecSessionMessageConfig,
+	type MmtpFecSessionMessageUpdate,
 	type MmtpFecSessionMixedPathStats,
 	type MmtpFecSessionPath,
 	type MmtpFecSessionPathCounts,
 	type MmtpFecSessionStats,
 } from "./mmtp-fec-session.js";
+// MoQ repair-layer subscriptions by measured loss (BLO-35456)
+export {
+	RepairLayerSubscriptions,
+	type MoqRepairDelivery,
+	type RepairLayerSource,
+	type RepairLayerSubscriptionsOptions,
+	type RepairLayerSubscriptionsSnapshot,
+	type RepairTrackSubscription,
+} from "./repair-layer-subscriptions.js";
 
 export {
 	catalogAmtNetworkSource,

package/src/mmtp-fec-session.ts

@@ -23,6 +23,15 @@
  * uses. A packet below B_0 at or after the anchor fails the session closed:
  * `stats.failClosed` reports why, and every later repair is refused.
  *
+ * Catalog-less (draft-ramadan-moq-mmt-02 8.3, 13.2): a receiver holding
+ * layer 0 under the AL-FEC message alone builds the session from the message's
+ * fec_flow entry (`alFecFlow`) instead. K, T, the code point and the repair
+ * packet_id come from that entry, and layer 0 is held at
+ * maximum_p_for_repair_flow, standing for O_0 + P_0, by the anchored clause of
+ * draft-ramadan-moq-fec-core-00 7.3.2 alone. A later version that raises the
+ * field raises the held total (updateAlFecFlow()); the message carries no
+ * millisecond budget, so the caller states the retention (fec-core-00 9.4).
+ *
  * Every repair packet that cannot be used is counted under the reason it was
  * refused, and every block ends under exactly one outcome, so a stream whose
  * FEC is doing nothing can be told apart from one with nothing to repair.
@@ -30,6 +39,8 @@
 
 import {
   admitMmtpRepairObject,
+  alFecRaptorQFlowConfig,
+  FEC_CODE_RAPTORQ,
   isoBlockContains,
   isoBlocksBehindLowerBound,
   parseFecBlockProfile,
@@ -39,6 +50,8 @@ import {
   serial32Precedes,
   ssbg1FitsSymbol,
   trimSsbg1SourceSymbol,
+  type AlFecFlow,
+  type AlFecRaptorQFlowConfig,
   type FecBlockProfile,
 } from '@blockcast/mmt-base'
 import { deriveFecRetentionBlocks, fecBlockBudgetMs } from '@blockcast/mmt-fec'
@@ -105,6 +118,25 @@ export interface MmtpFecSessionConfig {
   heldLayers?: readonly number[]
 }
 
+/**
+ * A catalog-less session: one fec_flow entry of the AL-FEC message
+ * (`parseAlFecMessage(...).flows[i]`), draft-ramadan-moq-mmt-02 8.3.
+ */
+export interface MmtpFecSessionMessageConfig {
+  /** The source track's entry; it must pass `alFecRaptorQFlowConfig`. */
+  alFecFlow: AlFecFlow
+  /**
+   * The decoder retention in blocks. The message carries no elapsed-time
+   * budget (mmt-02 7.5), so open-block state is bounded by local policy
+   * (fec-core-00 9.4); required, never defaulted.
+   */
+  retentionBlocks: number
+  Decoder: MmtpFecSessionDecoderConstructor
+}
+
+/** What updateAlFecFlow() did with a later version of the message. */
+export type MmtpFecSessionMessageUpdate = 'raised' | 'unchanged' | 'refused'
+
 /**
  * The path a symbol arrived on: its MoQT subscription, or the multicast
  * group (native SSM or AMT) carrying the same asset. The caller states it;
@@ -197,12 +229,17 @@ export class MmtpFecSession {
   readonly algorithm: 'raptorq' | 'reed-solomon'
   readonly sourceSymbols: number
   /** P_0 = B_0, the held total every repair packet is checked against. */
-  readonly repairSymbols: number
+  get repairSymbols(): number {
+    return this.#repairSymbols
+  }
   readonly symbolSize: number
   /** The decoder's retention, in blocks, derived from the catalog budget. */
   readonly retentionBlocks: number
 
   #decoder: MmtpFecSessionDecoder | null
+  #repairSymbols: number
+  /** The message entry a catalog-less session was built from; undefined under a catalog. */
+  #message: AlFecRaptorQFlowConfig | undefined
   /** Blocks a repair has defined and that are not settled yet, by SS_Start. */
   #blocks = new Map<number, BlockState>()
   /** SS_Starts of settled blocks, so a later repair for one is refused. */
@@ -240,7 +277,26 @@ export class MmtpFecSession {
    *   the scheme, the block profile, K, P_0 (`repairSymbols`), T,
    *   `interleaveDepthMs` or `reorderToleranceMs`. None is defaulted.
    */
-  constructor(config: MmtpFecSessionConfig) {
+  constructor(config: MmtpFecSessionConfig | MmtpFecSessionMessageConfig) {
+    if (config && 'alFecFlow' in config) {
+      const message = alFecRaptorQFlowConfig(config.alFecFlow)
+      if (!message) {
+        throw new Error('MmtpFecSession: the AL-FEC entry is outside draft-ramadan-moq-mmt-02 8.3 (iso-ssbg1-v1)')
+      }
+      this.#message = message
+      // Coding byte 0x14 is the iso-ssbg1-v1 profile (mmt-02 8.3).
+      this.blockProfile = parseFecBlockProfile('iso-ssbg1-v1', 'alFecFlow')
+      this.algorithm = message.fecCodeId === FEC_CODE_RAPTORQ ? 'raptorq' : 'reed-solomon'
+      this.sourceSymbols = message.maximumK
+      this.#repairSymbols = message.maximumP
+      this.symbolSize = message.repairSymbolSize
+      this.retentionBlocks = requirePositiveInteger(config.retentionBlocks, 'retentionBlocks')
+      this.#repairPacketId = message.repairFlowId
+      this.#heldLayers = layerZero(message.maximumP)
+      this.#anchorHorizon = heldLayerAnchorHorizon(this.retentionBlocks, this.sourceSymbols)
+      this.#decoder = buildDecoder(config.Decoder, this)
+      return
+    }
     const fec = config?.fec
     if (!fec || typeof fec !== 'object') {
       throw new Error('MmtpFecSession: the catalog fec instance is required')
@@ -251,7 +307,7 @@ export class MmtpFecSession {
     }
     this.algorithm = fec.scheme
     this.sourceSymbols = requirePositiveInteger(fec.sourceSymbols, 'fec.sourceSymbols')
-    this.repairSymbols = requirePositiveInteger(fec.repairSymbols, 'fec.repairSymbols')
+    this.#repairSymbols = requirePositiveInteger(fec.repairSymbols, 'fec.repairSymbols')
     this.symbolSize = requirePositiveInteger(fec.symbolSize, 'fec.symbolSize')
     const interleaveDepthMs = requireNumber(fec.interleaveDepthMs, 'fec.interleaveDepthMs')
     const reorderToleranceMs = requireNumber(fec.reorderToleranceMs, 'fec.reorderToleranceMs')
@@ -271,17 +327,38 @@ export class MmtpFecSession {
       config.heldLayers,
     )
     this.#anchorHorizon = heldLayerAnchorHorizon(this.retentionBlocks, this.sourceSymbols)
-    if (typeof config.Decoder !== 'function') {
-      throw new Error('MmtpFecSession: a decoder constructor (wasm_bindgen.MmtFecDecoder) is required')
-    }
-    const decoder = new config.Decoder(this.retentionBlocks, this.blockProfile, this.algorithm)
-    try {
-      decoder.configure_params(this.sourceSymbols, this.symbolSize)
-    } catch (error) {
-      decoder.free()
-      throw error
+    this.#decoder = buildDecoder(config.Decoder, this)
+  }
+
+  /**
+   * A later version of the AL-FEC message, catalog-less sessions only. A
+   * maximum_p_for_repair_flow above the held total raises it (`raised`): the
+   * anchored check restarts at the new total, so a block generated under the
+   * previous one stays valid before the first block carrying the new total
+   * (fec-core-00 7.3.2, mmt-02 8.3). A field at or below it changes nothing
+   * (`unchanged`): no publisher lowers it, and the check catches a wire that
+   * does. An entry with another asset, repair flow, code point, K or T, or
+   * one outside 8.3, is `refused`: that is a new source encoding, which needs
+   * a new session. A latched fail-closed stays latched either way.
+   */
+  updateAlFecFlow(flow: AlFecFlow): MmtpFecSessionMessageUpdate {
+    const held = this.#message
+    if (!held) throw new Error('MmtpFecSession: updateAlFecFlow() needs a session built from an AL-FEC entry')
+    const next = alFecRaptorQFlowConfig(flow)
+    if (
+      !next ||
+      next.sourcePacketIds[0] !== held.sourcePacketIds[0] ||
+      next.repairFlowId !== held.repairFlowId ||
+      next.fecCodeId !== held.fecCodeId ||
+      next.maximumK !== held.maximumK ||
+      next.repairSymbolSize !== held.repairSymbolSize
+    ) {
+      return 'refused'
     }
-    this.#decoder = decoder
+    if (next.maximumP <= this.#repairSymbols) return 'unchanged'
+    this.#repairSymbols = next.maximumP
+    this.#heldLayers = layerZero(next.maximumP)
+    return 'raised'
   }
 
   /** True once release() ran. */
@@ -386,7 +463,7 @@ export class MmtpFecSession {
       // An RSB_length below a held layer's total goes to the 7.3.2 stop, not
       // to the discard; the block state is unchanged either way.
       const verdict = this.#heldLayers.failsClosed(
-        repairTrackName, frame.ssStart, frame.rsbLength, this.#anchorHorizon, this.#newestSource,
+        this.#trackFor(repairTrackName), frame.ssStart, frame.rsbLength, this.#anchorHorizon, this.#newestSource,
       )
       if (verdict) {
         this.#stats.failClosed = verdict
@@ -399,7 +476,7 @@ export class MmtpFecSession {
     // fec-01 6.3.9, after the 4.5 discards and the size check, before a block
     // is placed. Without a track name only the anchored rule (b) applies.
     const verdict = this.#heldLayers.admit(
-      repairTrackName,
+      this.#trackFor(repairTrackName),
       frame.ssStart,
       frame.rsbLength,
       this.#anchorHorizon,
@@ -464,6 +541,11 @@ export class MmtpFecSession {
     return true
   }
 
+  /** Catalog-less: layer 0 has no own-track clause (mmt-02 8.3), so no track name is judged. */
+  #trackFor(repairTrackName: string | undefined): string | undefined {
+    return this.#message ? undefined : repairTrackName
+  }
+
   #drop(reason: string): Uint8Array[] {
     this.#stats.dropped[reason] = (this.#stats.dropped[reason] ?? 0) + 1
     return []
@@ -600,6 +682,24 @@ export class MmtpFecSession {
   }
 }
 
+function layerZero(total: number): HeldLayerAdmission {
+  return new HeldLayerAdmission([{ layer: 0, repairTrackName: '', rsIdOffset: 0, repairSymbols: total }])
+}
+
+function buildDecoder(Decoder: MmtpFecSessionDecoderConstructor, session: MmtpFecSession): MmtpFecSessionDecoder {
+  if (typeof Decoder !== 'function') {
+    throw new Error('MmtpFecSession: a decoder constructor (wasm_bindgen.MmtFecDecoder) is required')
+  }
+  const decoder = new Decoder(session.retentionBlocks, session.blockProfile, session.algorithm)
+  try {
+    decoder.configure_params(session.sourceSymbols, session.symbolSize)
+  } catch (error) {
+    decoder.free()
+    throw error
+  }
+  return decoder
+}
+
 function requirePositiveInteger(value: unknown, path: string): number {
   if (typeof value !== 'number' || !Number.isSafeInteger(value) || value <= 0) {
     throw new Error(`MmtpFecSession: ${path} must be a positive integer (got ${String(value)})`)

package/src/multicast-manager.ts

@@ -98,6 +98,8 @@ export interface MulticastRepairEndpoint {
   mode?: string;
   amtRelay?: string;
   amtRelayPort?: number;
+  /** The media join's `'driad'` discovery (no relay pinned), carried so the repair group rides the same relay. */
+  amtDiscovery?: 'driad';
   /** The repair packet IDs this group carries. */
   packetIds: number[];
   /** Each repair packet ID bound to the media packet ID it repairs. */
@@ -2427,6 +2429,7 @@ export class MulticastManager {
         mode: endpoint.mode as MulticastEndpointConfig["mode"],
         amtRelay: endpoint.amtRelay,
         amtRelayPort: endpoint.amtRelayPort ?? (endpoint.amtRelay?.trim() ? DEFAULT_AMT_RELAY_PORT : undefined),
+        amtDiscovery: endpoint.amtDiscovery,
         packetIds: endpoint.packetIds,
         tracks: endpoint.tracks.map(({ name, packetId }) => ({ name, packetId })),
         // A protected repair group's records ride in band on its port (7.2.3).

package/src/repair-layer-subscriptions.ts

@@ -0,0 +1,253 @@
+/**
+ * MoQ repair-layer subscriptions by measured loss (BLO-35456).
+ *
+ * MoQ is per-track subscribe, so a repair layer the receiver does not
+ * subscribe costs nothing past the relay. This is the mechanism that decides
+ * which of a source's repair tracks to hold: it measures loss from the MMTP
+ * `packet_sequence_number` gaps the receiver already sees on the source track
+ * (no new signalling), holds base layers 0..n-1 (draft-ramadan-moq-fec 6.3,
+ * `resolveRepairLayers`), and holds the keyframe overlay track while any base
+ * layer is held. The policy here is deliberately the simplest per-layer
+ * add/drop; the join policy proper is BLO-35457.
+ *
+ * Every repair packet is handed to `feed` with the repair track it arrived on,
+ * so libmmt routes an overlay packet to the overlay instance and never to the
+ * base (`MmtpRouter.feedRepairPacket(..., repairTrackName)`).
+ *
+ * `stream` delivery means QUIC retransmits: no repair track is ever
+ * subscribed (FEC only for unreliable transports).
+ *
+ * ABR switch R -> R' (`switchSource`): R's subscriptions are closed, the layer
+ * count carries to R', and any packet R's subscriptions deliver after the
+ * switch is dropped, never fed.
+ */
+
+import { serial32Distance } from '@blockcast/mmt-base'
+import type { RepairLayerParams, RepairOverlayParams } from './repair-layers.js'
+
+export type MoqRepairDelivery = 'datagram' | 'stream'
+
+/** The source's FEC shape, as `fecParams` resolves it. */
+export interface RepairLayerSource {
+  /** K: source symbols per base block. */
+  fecK: number
+  /** Base layers, layer 0 first (`TrackFecParams.repairLayers`). */
+  repairLayers?: readonly RepairLayerParams[]
+  /** Keyframe overlays (`TrackFecParams.repairOverlays`); at most one is used. */
+  repairOverlays?: readonly RepairOverlayParams[]
+}
+
+export interface RepairTrackSubscription {
+  close(): void
+}
+
+export interface RepairLayerSubscriptionsOptions {
+  source: RepairLayerSource
+  delivery: MoqRepairDelivery
+  /** Subscribe one repair track; every object payload goes to `onPacket`. */
+  subscribe(
+    repairTrackName: string,
+    priority: number,
+    onPacket: (packet: Uint8Array) => void,
+  ): RepairTrackSubscription
+  /** Hand one repair packet to the decoder, e.g. `processRepairFromMoQ`. */
+  feed(packet: Uint8Array, repairTrackName: string): void
+  /** Expected source packets per loss window. Default 500. */
+  windowPackets?: number
+  /** Repair held per unit of measured loss. Default 2. */
+  margin?: number
+  /** Consecutive windows wanting fewer layers before one is dropped. Default 3. */
+  dropAfterWindows?: number
+}
+
+export interface RepairLayerSubscriptionsSnapshot {
+  delivery: MoqRepairDelivery
+  layerCount: number
+  subscribedTracks: string[]
+  repairPackets: number
+  repairBytes: number
+  /** Packets a closed subscription delivered after its switch or drop. */
+  staleDropped: number
+  /** Loss rate of the last closed window; null before the first. */
+  lossRate: number | null
+}
+
+const SERIAL32_HALF = 0x80000000
+
+export class RepairLayerSubscriptions {
+  readonly #opts: RepairLayerSubscriptionsOptions
+  readonly #windowPackets: number
+  readonly #margin: number
+  readonly #dropAfterWindows: number
+  #source: RepairLayerSource
+  #layerCount = 0
+  #subs = new Map<string, { sub: RepairTrackSubscription }>()
+  #disposed = false
+  #lastSeq: number | undefined
+  #expected = 0
+  #lost = 0
+  #wantFewer = 0
+  #lossRate: number | null = null
+  #repairPackets = 0
+  #repairBytes = 0
+  #staleDropped = 0
+
+  constructor(opts: RepairLayerSubscriptionsOptions) {
+    this.#opts = opts
+    this.#source = opts.source
+    this.#windowPackets = opts.windowPackets ?? 500
+    this.#margin = opts.margin ?? 2
+    this.#dropAfterWindows = opts.dropAfterWindows ?? 3
+  }
+
+  get layerCount(): number {
+    return this.#layerCount
+  }
+
+  /**
+   * One source packet's MMTP `packet_sequence_number`, in arrival order.
+   * The sequence is per `packet_id`: pass the packets of ONE packet_id only,
+   * or interleaved sequences read as loss.
+   */
+  noteSourceSequence(seq: number): void {
+    if (this.#disposed || this.#opts.delivery === 'stream') return
+    seq >>>= 0
+    if (this.#lastSeq === undefined) {
+      this.#lastSeq = seq
+      return
+    }
+    const d = serial32Distance(this.#lastSeq, seq)
+    if (d === 0) return
+    const back = d >= SERIAL32_HALF ? 2 ** 32 - d : 0
+    if (d > this.#windowPackets && (back === 0 || back > this.#windowPackets)) {
+      // A step wider than one window, either way, is a discontinuity (a
+      // publisher restart), not loss or reorder: restart the window from here.
+      // ponytail: a real outage longer than a window is also read as a restart;
+      // FEC cannot repair that anyway.
+      this.#lastSeq = seq
+      this.#expected = 0
+      this.#lost = 0
+      return
+    }
+    if (back === 0) {
+      this.#expected += d
+      this.#lost += d - 1
+      this.#lastSeq = seq
+    } else if (this.#lost > 0) {
+      // A late packet fills a hole counted as lost. Holes are not tracked
+      // individually, so one whose window already closed cancels a hole in
+      // this window instead: a bias toward lower loss of at most the reorder
+      // depth per window.
+      this.#lost -= 1
+    }
+    if (this.#expected >= this.#windowPackets) this.#closeWindow()
+  }
+
+  /** ABR switch R -> R': close R's tracks, carry the layer count to R'. */
+  switchSource(next: RepairLayerSource): void {
+    if (this.#disposed) return
+    this.#closeAll()
+    this.#source = next
+    this.#lastSeq = undefined
+    this.#expected = 0
+    this.#lost = 0
+    this.#wantFewer = 0
+    this.#layerCount = Math.min(this.#layerCount, this.#layers().length)
+    this.#reconcile()
+  }
+
+  snapshot(): RepairLayerSubscriptionsSnapshot {
+    return {
+      delivery: this.#opts.delivery,
+      layerCount: this.#layerCount,
+      subscribedTracks: [...this.#subs.keys()],
+      repairPackets: this.#repairPackets,
+      repairBytes: this.#repairBytes,
+      staleDropped: this.#staleDropped,
+      lossRate: this.#lossRate,
+    }
+  }
+
+  dispose(): void {
+    if (this.#disposed) return
+    this.#closeAll()
+    this.#disposed = true
+  }
+
+  #layers(): readonly RepairLayerParams[] {
+    return this.#source.repairLayers ?? []
+  }
+
+  #closeWindow(): void {
+    const rate = this.#lost / this.#expected
+    this.#lossRate = rate
+    this.#expected = 0
+    this.#lost = 0
+    const target = this.#targetLayers(rate)
+    if (target > this.#layerCount) {
+      this.#wantFewer = 0
+      this.#layerCount = target
+    } else if (target < this.#layerCount) {
+      this.#wantFewer += 1
+      if (this.#wantFewer >= this.#dropAfterWindows) {
+        this.#wantFewer = 0
+        this.#layerCount -= 1
+      }
+    } else {
+      this.#wantFewer = 0
+    }
+    this.#reconcile()
+  }
+
+  /** Fewest base layers whose summed P covers margin x the measured loss of K. */
+  #targetLayers(rate: number): number {
+    if (rate <= 0) return 0
+    const needed = Math.ceil(rate * this.#source.fecK * this.#margin)
+    const layers = this.#layers()
+    let held = 0
+    for (let n = 0; n < layers.length; n++) {
+      held += layers[n]!.repairSymbols
+      if (held >= needed) return n + 1
+    }
+    return layers.length
+  }
+
+  /** Stream delivery never leaves layer count 0, so it never subscribes. */
+  #reconcile(): void {
+    const want = new Map<string, number>()
+    for (const layer of this.#layers().slice(0, this.#layerCount)) {
+      want.set(layer.repairTrackName, layer.priority)
+    }
+    const overlay = this.#source.repairOverlays?.[0]
+    if (this.#layerCount > 0 && overlay) want.set(overlay.repairTrackName, overlay.priority)
+
+    for (const [name, entry] of this.#subs) {
+      if (!want.has(name)) {
+        entry.sub.close()
+        this.#subs.delete(name)
+      }
+    }
+    for (const [name, priority] of want) {
+      if (this.#subs.has(name)) continue
+      const entry = {} as { sub: RepairTrackSubscription }
+      entry.sub = this.#opts.subscribe(name, priority, (packet) => this.#onPacket(name, entry, packet))
+      this.#subs.set(name, entry)
+    }
+  }
+
+  /** Fenced on the entry itself, so a closed subscription is stale even if its track is re-added. */
+  #onPacket(name: string, entry: { sub: RepairTrackSubscription }, packet: Uint8Array): void {
+    if (this.#disposed || this.#subs.get(name) !== entry) {
+      this.#staleDropped += 1
+      return
+    }
+    this.#repairPackets += 1
+    this.#repairBytes += packet.byteLength
+    this.#opts.feed(packet, name)
+  }
+
+  #closeAll(): void {
+    for (const entry of this.#subs.values()) entry.sub.close()
+    this.#subs.clear()
+  }
+}