@blockcast/mmt-container 0.3.0 → 0.4.0-main.1cd3cdea89da

package/dist/fec-worker-setup.js

@@ -87,60 +87,37 @@ var init_fec_worker_client = __esm({
       }
       /**
        * Configure the Worker with FEC parameters and WASM module.
+       * `interleaveMs: 0` is a valid no-span catalog value; in that mode the
+       * caller supplies a positive receiver-local `deliveryWindowMs`.
        * wasmModule is transferred (not neutered — WebAssembly.Module is shareable).
-       * altaPublicKey is PKCS#8 SPKI DER bytes (self-describing — algorithm detected from OID).
-       *   Transferred (detached from sender).
-       * altaWasmModule is structured-cloneable (NOT transferable — do not add to transfer list).
        */
-      configure(config, wasmModule, altaPublicKey, altaWasmModule) {
+      configure(config, wasmModule) {
         if (this.#disposed)
           throw new Error("[FecWorkerClient] disposed");
         this.#flushSymbols();
         const cmd = {
           type: "configure",
           config,
-          wasmModule,
-          altaPublicKey,
-          altaWasmModule
+          wasmModule
         };
-        const transferList = [];
-        if (altaPublicKey)
-          transferList.push(altaPublicKey);
-        this.#worker.postMessage(cmd, transferList);
+        this.#worker.postMessage(cmd);
       }
       /**
        * Feed a source symbol to the Worker. data ArrayBuffer is transferred (zero-copy).
        * Caller must not access data after this call — it is transferred with the
        * task's symbol batch, before any later command of this client.
-       *
-       * Optional `alta` carries the detached ALTA authenticator bytes and the
-       * byte offset in `data` where the signed payload ends. The auth buffer is
-       * transferred zero-copy alongside `data`. Use {@link getMmtpAltaTrailer}
-       * upstream (mmtp-router) to extract it from the wire packet.
        */
-      feedSource(ssId, data, ts, alta) {
+      feedSource(ssId, data, ts) {
         if (this.#disposed)
           throw new Error("[FecWorkerClient] feedSource on a disposed client");
-        if (alta) {
-          this.#queueSymbol({
-            type: "feedSource",
-            ssId,
-            data,
-            ts,
-            altaAuth: alta.auth,
-            altaPayloadEnd: alta.payloadEnd
-          }, data, alta.auth);
-        } else {
-          this.#queueSymbol({ type: "feedSource", ssId, data, ts }, data);
-        }
+        this.#queueSymbol({ type: "feedSource", ssId, data, ts }, data);
       }
       /**
        * Feed a repair symbol to the Worker. data ArrayBuffer is transferred (zero-copy).
        * Caller must not access data after this call — it is detached.
        *
        * Carries the wire-level Repair FEC Payload ID fields (ISO 23008-1 §C.5.3):
-       * - ssStart:   SS_ID of first source symbol in the block (= SBN * configured K
-       *              under `k-padded-v1`; any uint32, the block key, under `iso-ssbg1-v1`)
+       * - ssStart:   SS_ID of first source symbol in the block (any uint32; the block key)
        * - ssbLength: authored source-symbol count (1..configured K)
        * - rsId:      repair symbol index within the block
        */
@@ -149,15 +126,13 @@ var init_fec_worker_client = __esm({
           throw new Error("[FecWorkerClient] feedRepair on a disposed client");
         this.#queueSymbol({ type: "feedRepair", ssStart, ssbLength, rsId, data, ts }, data);
       }
-      #queueSymbol(symbol, data, auth) {
+      #queueSymbol(symbol, data) {
         if (!this.#batchSymbols) {
-          this.#worker.postMessage(symbol, auth ? [data, auth] : [data]);
+          this.#worker.postMessage(symbol, [data]);
           return;
         }
         this.#pendingSymbols.push(symbol);
         this.#pendingTransfer.push(data);
-        if (auth)
-          this.#pendingTransfer.push(auth);
         if (this.#flushQueued)
           return;
         this.#flushQueued = true;
@@ -190,7 +165,7 @@ var init_fec_worker_client = __esm({
       }
       /**
        * Trigger cleanup after a block's inactivity deadline. `currentSbn` is the
-       * block key: the SBN under `k-padded-v1`, the SS_Start under `iso-ssbg1-v1`.
+       * block key, the block's SS_Start.
        *
        * While one queue-drain barrier is in flight, later SBNs are coalesced into
        * the next command without losing their individual acknowledgement identity.
@@ -501,16 +476,11 @@ var init_dist = __esm({
   }
 });
 
-// ../mmt-alta-parse/dist/index.js
+// ../mmt-base/dist/mmtp.js
 var MPU_HEADER_SIZE = 8;
 var MPU_LENGTH_FIELD_SIZE = 2;
 var MPU_HEADER_REMAINDER_SIZE = MPU_HEADER_SIZE - MPU_LENGTH_FIELD_SIZE;
 
-// ../mmt-base/dist/mmtp.js
-var MPU_HEADER_SIZE2 = 8;
-var MPU_LENGTH_FIELD_SIZE2 = 2;
-var MPU_HEADER_REMAINDER_SIZE2 = MPU_HEADER_SIZE2 - MPU_LENGTH_FIELD_SIZE2;
-
 // ../mmt-base/dist/ntp-short.js
 var NTP_SHORT_BITS = 32;
 var NTP_SHORT_MODULUS = 2 ** NTP_SHORT_BITS;
@@ -518,96 +488,112 @@ var NTP_SHORT_HALF_RANGE = 2 ** (NTP_SHORT_BITS - 1);
 
 // ../mmt-base/dist/fec-block-profile.js
 var FEC_BLOCK_PROFILES = Object.freeze([
-  "k-padded-v1",
   "iso-ssbg1-v1"
 ]);
 function isFecBlockProfile(value) {
-  return value === "k-padded-v1" || value === "iso-ssbg1-v1";
+  return value === "iso-ssbg1-v1";
 }
 function parseFecBlockProfile(value, where) {
   if (isFecBlockProfile(value))
     return value;
   if (value === void 0) {
-    throw new Error(`${where} is required: name the FEC block profile ("k-padded-v1" or "iso-ssbg1-v1")`);
+    throw new Error(`${where} is required: name the FEC block profile ("iso-ssbg1-v1")`);
   }
-  throw new Error(`${where} must be "k-padded-v1" or "iso-ssbg1-v1" (got ${JSON.stringify(value)})`);
+  throw new Error(`${where} must be "iso-ssbg1-v1" (got ${JSON.stringify(value)})`);
 }
 
 // src/fec-worker-setup.ts
-import { deriveFecRetentionBlocks } from "@blockcast/mmt-fec";
+import {
+  deriveFecRetentionBlocks,
+  LOCAL_FEC_RETENTION_BLOCKS,
+  LOCAL_FEC_TIMEOUT_MS
+} from "@blockcast/mmt-fec";
 
 // src/track-session.ts
 import { fecBlockBudgetMs } from "@blockcast/mmt-fec";
 function computeFecDeliveryWindowMs(config) {
-  const fecInterleaveMs = config.interleaveDepthMs;
   const fecK = config.sourceSymbols;
-  if (!Number.isFinite(fecInterleaveMs) || fecInterleaveMs <= 0) {
+  if (!Number.isFinite(fecK) || fecK <= 0) {
     throw new Error(
-      `[TrackSession] fecInterleaveMs=${fecInterleaveMs}. Derive a positive FEC interleave window from the stream catalog.`
+      `[TrackSession] fecK=${fecK}. Derive a positive FEC source-symbol count from the stream catalog.`
     );
   }
-  if (!Number.isFinite(fecK) || fecK <= 0) {
+  return fecSpanDeliveryWindowMs(config.interleaveDepthMs, config.jitterBufferMs);
+}
+function fecSpanDeliveryWindowMs(interleaveDepthMs, jitterBufferMs) {
+  if (!Number.isFinite(interleaveDepthMs) || interleaveDepthMs <= 0) {
     throw new Error(
-      `[TrackSession] fecK=${fecK}. Derive a positive FEC source-symbol count from the stream catalog.`
+      `[TrackSession] fecInterleaveMs=${interleaveDepthMs}. Derive a positive FEC interleave window from the stream catalog.`
     );
   }
-  if (config.jitterBufferMs === void 0) return Math.ceil(fecInterleaveMs);
-  return fecBlockBudgetMs(fecInterleaveMs, config.jitterBufferMs);
+  if (jitterBufferMs === void 0) return Math.ceil(interleaveDepthMs);
+  return fecBlockBudgetMs(interleaveDepthMs, jitterBufferMs);
 }
 
 // src/fec-worker-setup.ts
 async function setupFecWorkerForTrack(opts) {
-  if (!Number.isFinite(opts.fecInterleaveMs) || opts.fecInterleaveMs <= 0) {
+  if (!Number.isFinite(opts.fecInterleaveMs) || !Number.isSafeInteger(opts.fecInterleaveMs) || opts.fecInterleaveMs < 0) {
     throw new Error(
-      `[FEC] interleaveDepthMs (opts.fecInterleaveMs) must be finite and > 0 (got ${opts.fecInterleaveMs})`
+      `[FEC] interleaveDepthMs (opts.fecInterleaveMs) must be a finite non-negative integer (got ${opts.fecInterleaveMs})`
     );
   }
-  if (!Number.isFinite(opts.mediaUnitDurationMs) || opts.mediaUnitDurationMs <= 0) {
+  if (opts.fecReorderToleranceMs !== void 0 && (!Number.isFinite(opts.fecReorderToleranceMs) || opts.fecReorderToleranceMs < 0)) {
     throw new Error(
-      `[FEC] mediaUnitDurationMs must be finite and > 0 (got ${opts.mediaUnitDurationMs})`
+      `[FEC] fecReorderToleranceMs must be finite and >= 0 (got ${opts.fecReorderToleranceMs})`
+    );
+  }
+  const hasCatalogTiming = opts.fecInterleaveMs > 0;
+  const validateWorkerGeometry = () => {
+    if (!Number.isSafeInteger(opts.fecK) || opts.fecK <= 0) {
+      throw new Error(`[FEC] fecK must be a finite positive integer (got ${opts.fecK})`);
+    }
+    if (!Number.isSafeInteger(opts.fecSymbolSize) || opts.fecSymbolSize <= 0 || opts.fecSymbolSize % 8 !== 0) {
+      throw new Error(
+        `[FEC] fecSymbolSize must be a positive 8-byte-aligned integer (got ${opts.fecSymbolSize})`
+      );
+    }
+    if (!Number.isSafeInteger(opts.fecRepairCount) || opts.fecRepairCount <= 0) {
+      throw new Error(
+        `[FEC] fecRepairCount must be a finite positive integer (got ${opts.fecRepairCount})`
+      );
+    }
+  };
+  let deliveryWindowMs;
+  let interleaveDepthBlocks;
+  if (!hasCatalogTiming) {
+    validateWorkerGeometry();
+    deliveryWindowMs = LOCAL_FEC_TIMEOUT_MS;
+    interleaveDepthBlocks = LOCAL_FEC_RETENTION_BLOCKS;
+  } else {
+    const mediaUnitDurationMs = opts.mediaUnitDurationMs;
+    if (typeof mediaUnitDurationMs !== "number" || !Number.isFinite(mediaUnitDurationMs) || mediaUnitDurationMs <= 0) {
+      throw new Error(
+        `[FEC] mediaUnitDurationMs must be finite and > 0 (got ${mediaUnitDurationMs})`
+      );
+    }
+    validateWorkerGeometry();
+    deliveryWindowMs = computeFecDeliveryWindowMs({
+      interleaveDepthMs: opts.fecInterleaveMs,
+      sourceSymbols: opts.fecK,
+      repairSymbols: opts.fecRepairCount,
+      symbolSize: opts.fecSymbolSize,
+      mediaUnitsPerSecond: 1e3 / mediaUnitDurationMs,
+      jitterBufferMs: opts.fecReorderToleranceMs
+    });
+    interleaveDepthBlocks = deriveFecRetentionBlocks(
+      deliveryWindowMs,
+      opts.fecInterleaveMs
     );
   }
   const blockProfile = parseFecBlockProfile(
     opts.fecBlockProfile,
     `[FEC] ${opts.trackName} fec.blockProfile`
   );
-  const deliveryWindowMs = computeFecDeliveryWindowMs({
-    interleaveDepthMs: opts.fecInterleaveMs,
-    sourceSymbols: opts.fecK,
-    repairSymbols: opts.fecRepairCount,
-    symbolSize: opts.fecSymbolSize,
-    mediaUnitsPerSecond: 1e3 / opts.mediaUnitDurationMs,
-    jitterBufferMs: opts.fecReorderToleranceMs
-  });
-  const interleaveDepthBlocks = deriveFecRetentionBlocks(
-    deliveryWindowMs,
-    opts.fecInterleaveMs
-  );
   const origin = typeof location !== "undefined" && location.origin ? location.origin : "http://localhost";
   const workerUrl = new URL(opts.assetUrls.fecWorker, origin);
   const FecWorkerCtor = await Promise.resolve().then(() => (init_dist(), dist_exports));
   const client = opts.clientFactory ? opts.clientFactory(workerUrl) : new FecWorkerCtor.FecWorkerClient(workerUrl);
   const rqWasm = await WebAssembly.compileStreaming(fetch(opts.assetUrls.rqWasm));
-  let altaKeyBuffer;
-  let altaWasmModule;
-  if (opts.altaPublicKeySpki) {
-    const b64 = opts.altaPublicKeySpki.replace(/-/g, "+").replace(/_/g, "/");
-    const padded = b64.padEnd(Math.ceil(b64.length / 4) * 4, "=");
-    try {
-      const keyBytes = Uint8Array.from(atob(padded), (c) => c.charCodeAt(0));
-      if (keyBytes.length >= 32 && keyBytes.length <= 256) {
-        altaKeyBuffer = keyBytes.buffer;
-        altaWasmModule = await WebAssembly.compileStreaming(fetch(opts.assetUrls.altaWasm));
-      } else {
-        console.warn(
-          `[fec-worker-setup] ALTA SPKI wrong length for "${opts.trackName}": ${keyBytes.length} (expected 32..256) \u2014 ALTA disabled`
-        );
-      }
-    } catch (e) {
-      console.warn(`[fec-worker-setup] ALTA key decode / WASM compile failed for "${opts.trackName}":`, e);
-    }
-  }
-  const altaEnabled = !!(altaKeyBuffer && altaWasmModule);
   const fecTrackConfig = {
     codec: opts.codec ?? "unknown",
     trackName: opts.trackName,
@@ -626,19 +612,19 @@ async function setupFecWorkerForTrack(opts) {
     deliveryWindowMs,
     fecMode: "subframe",
     repairTrack: opts.repairTrackName,
-    altaEnabled,
     relayBlockSigEnabled: false
   };
-  client.configure(fecTrackConfig, rqWasm, altaKeyBuffer, altaWasmModule);
+  client.configure(fecTrackConfig, rqWasm);
   try {
     opts.multicastManager.setFecWorker(opts.packetId, client, opts.trackType, {
       blockProfile,
       k: opts.fecK,
       symbolSize: opts.fecSymbolSize,
       interleaveDepthMs: opts.fecInterleaveMs,
-      // FEC timing is expressed in media units. For audio this is the access-unit
-      // cadence (for example 1024/48kHz), not a video-only framerate field.
-      fps: 1e3 / opts.mediaUnitDurationMs,
+      // No-span tracks have no catalog media cadence. The manager still gets
+      // the local cleanup budget, but it must not use a guessed fps for timing
+      // or classification.
+      ...hasCatalogTiming ? { fps: 1e3 / opts.mediaUnitDurationMs } : {},
       timeoutMs: deliveryWindowMs
     }, opts.trackName);
   } catch (e) {
@@ -651,7 +637,6 @@ async function setupFecWorkerForTrack(opts) {
   let disposed = false;
   return {
     client,
-    altaEnabled,
     dispose: () => {
       if (disposed) return;
       disposed = true;