Fix capitalization

.github/workflows/build.yaml

@@ -0,0 +1,103 @@
+name: "Build and deploy"
+on:
+    # push:
+    #     branches:
+    #         - master
+    #         - main
+    workflow_dispatch:
+        inputs:
+            cf_env:
+                description: Choose environment
+                type: choice
+                required: true
+                options:
+                    - dev
+                    - staging
+                    - prod
+                default: dev
+            branch:
+                description: Choose branch or tag, defaults to main
+                type: string
+                required: true
+                default: main
+            emsdk_version:
+                description: Emscripten SDK version, defaults to 4.0.20
+                type: string
+                required: false
+                default: "4.0.20"
+            preCommand:
+                description: Provide a bash script to execute before running wrangler
+                type: string
+                required: false
+                default: echo "No script provided for execution before running Wrangler. Moving along."
+            postCommand:
+                description: Provide a bash script to execute after running wrangler
+                type: string
+                required: false
+                default: echo "Nothing to execute after running Wrangler. Finishing..."
+jobs:
+    deploy:
+        runs-on: "ubuntu-latest"
+        steps:
+            - name: Checkout
+              uses: actions/checkout@v6
+              with:
+                  ref: ${{ inputs.branch }}
+                  submodules: 'true'
+
+            - name: Set environment variables
+              run: |
+                  if [[ "${{ inputs.cf_env }}" == "dev" ]]; then
+                    echo "CF_ACCOUNT=DEV_ACCOUNT_ID" >> "$GITHUB_ENV"
+                    echo "CF_TOKEN=JITSI_CF_DEV_TOKEN" >> "$GITHUB_ENV"
+                  elif [[ "${{ inputs.cf_env }}" == "staging" ]]; then
+                    echo "CF_ACCOUNT=STAGE_ACCOUNT_ID" >> "$GITHUB_ENV"
+                    echo "CF_TOKEN=JITSI_CF_STAGING_TOKEN" >> "$GITHUB_ENV"
+                  elif [[ "${{ inputs.cf_env }}" == "prod" ]]; then
+                    echo "CF_ACCOUNT=PROD_ACCOUNT_ID" >> "$GITHUB_ENV"
+                    echo "CF_TOKEN=JITSI_CF_PROD_TOKEN" >> "$GITHUB_ENV"
+                  else
+                    echo "Invalid environment specified: ${{ inputs.cf_env }}, exiting."
+                    exit 1
+                  fi
+
+            - name: Install Linux deps
+              run: |
+                sudo apt update
+                sudo apt -y install wget unzip
+
+            - uses: actions/setup-node@v4
+              with:
+                  node-version: 22
+                  cache: npm
+
+            - name: Install Node Dependencies
+              run: |
+                  npm ci
+
+            - name: Setup Emscripten SDK
+              run: |
+                wget https://github.com/emscripten-core/emsdk/archive/main.zip
+                unzip main.zip
+                cd emsdk-main
+                ./emsdk install ${{ inputs.emsdk_version }}
+                ./emsdk activate ${{ inputs.emsdk_version }}
+                source ./emsdk_env.sh
+                echo "EMSDK=$EMSDK" >> $GITHUB_ENV
+                echo "EM_CONFIG=$EM_CONFIG" >> $GITHUB_ENV
+                echo "$EMSDK:$EMSDK/upstream/emscripten" >> $GITHUB_PATH
+
+            - name: Build TS App
+              run: |
+                source "$EMSDK/emsdk_env.sh"
+                npm run build
+
+            - name: Wrangler Deploy
+              uses: cloudflare/wrangler-action@v3
+              with:
+                  wranglerVersion: "4.51.0"
+                  apiToken: ${{ secrets[env.CF_TOKEN] }}
+                  accountId: ${{ secrets[env.CF_ACCOUNT] }}
+                  preCommands: ${{ inputs.preCommand }}
+                  postCommands: ${{ inputs.postCommand }}
+                  command: deploy

Makefile

@@ -7,15 +7,17 @@ OPUS_DECODER_DIST=./dist
 
 OPUS_DECODER_EMSCRIPTEN_BUILD=$(OPUS_DECODER_BUILD)/EmscriptenWasm.tmp.js
 OPUS_DECODER_EMSCRIPTEN_WASM=$(OPUS_DECODER_BUILD)/EmscriptenWasm.tmp.wasm
+OPUS_DECODER_EMSCRIPTEN_WASM_MAP=$(OPUS_DECODER_BUILD)/EmscriptenWasm.tmp.wasm.map
 OPUS_DECODER_MODULE=$(OPUS_DECODER_DIST)/opus-decoder.js
 OPUS_DECODER_WASM=$(OPUS_DECODER_DIST)/opus-decoder.wasm
+OPUS_DECODER_WASM_MAP=$(OPUS_DECODER_DIST)/opus-decoder.wasm.map
 
 LIBOPUS_SRC=$(OPUS_DECODER_SRC)/opus
 LIBOPUS_BUILD=$(OPUS_DECODER_BUILD)/build-opus-wasm
 LIBOPUS_WASM_LIB=$(OPUS_DECODER_BUILD)/libopus.a
 
 clean:
-	rm -rf $(OPUS_DECODER_EMSCRIPTEN_BUILD) $(OPUS_DECODER_EMSCRIPTEN_WASM) $(OPUS_DECODER_MODULE) $(OPUS_DECODER_WASM) $(LIBOPUS_WASM_LIB)
+	rm -rf $(OPUS_DECODER_EMSCRIPTEN_BUILD) $(OPUS_DECODER_EMSCRIPTEN_WASM) $(OPUS_DECODER_EMSCRIPTEN_WASM_MAP) $(OPUS_DECODER_MODULE) $(OPUS_DECODER_WASM) $(OPUS_DECODER_WASM_MAP) $(LIBOPUS_WASM_LIB)
 	+emmake $(MAKE) -C $(LIBOPUS_BUILD) clean
 
 configure: libopus-configure
@@ -35,6 +37,10 @@ opus-decoder: opus-wasmlib $(OPUS_DECODER_EMSCRIPTEN_BUILD)
 	else \
 		echo "Warning: WASM file not found, you may need to adjust emscripten settings"; \
 	fi
+	@if [ -f "$(OPUS_DECODER_EMSCRIPTEN_WASM_MAP)" ]; then \
+		cp $(OPUS_DECODER_EMSCRIPTEN_WASM_MAP) $(OPUS_DECODER_WASM_MAP); \
+		echo "Copied WASM source map to $(OPUS_DECODER_WASM_MAP)"; \
+	fi
 
 # libopus
 opus-wasmlib: $(LIBOPUS_WASM_LIB)
@@ -44,12 +50,13 @@ define EMCC_OPTS
 -O2 \
 -msimd128 \
 --minify 0 \
+-gsource-map \
 -s WASM=1 \
 -s TEXTDECODER=2 \
 -s SINGLE_FILE=0 \
 -s MALLOC="emmalloc" \
 -s NO_FILESYSTEM=1 \
--s ENVIRONMENT=web \
+-s ENVIRONMENT=node \
 -s ASSERTIONS=1 \
 -s ABORTING_MALLOC=0 \
 -s EXIT_RUNTIME=0 \

package.json

@@ -18,7 +18,7 @@
 	"devDependencies": {
 		"@cloudflare/vitest-pool-workers": "^0.8.19",
 		"@types/node": "^24.7.2",
-		"prettier": "3.6.2",
+		"prettier": "^3.6.2",
 		"typescript": "^5.9.3",
 		"vitest": "~3.2.0",
 		"wrangler": "^4.38.0"

src/MetricCache.ts

@@ -0,0 +1,75 @@
+import { writeMetric, MetricEvent } from './metrics';
+
+/**
+ * Aggregates metric counts and periodically flushes them to Analytics Engine.
+ * Reduces write frequency by batching metrics over a time interval.
+ */
+export class MetricCache {
+	private analytics: AnalyticsEngineDataset | undefined;
+	private intervalMs: number;
+	private metrics: Map<string, { event: MetricEvent; count: number; lastWriteTime: number }>;
+
+	/**
+	 * @param analytics - The Analytics Engine dataset to write to
+	 * @param intervalMs - Time interval in milliseconds between metric writes (default: 1000ms)
+	 */
+	constructor(analytics: AnalyticsEngineDataset | undefined, intervalMs: number = 1000) {
+		this.analytics = analytics;
+		this.intervalMs = intervalMs;
+		this.metrics = new Map();
+	}
+
+	/**
+	 * Increments the count for a metric. If the time interval has elapsed since
+	 * the last write, flushes the accumulated count to Analytics Engine.
+	 *
+	 * @param event - The metric event to increment
+	 */
+	increment(event: MetricEvent): void {
+		const key = this.getKey(event);
+		const now = Date.now();
+		const metric = this.metrics.get(key);
+
+		if (!metric) {
+			// First time seeing this metric
+			this.metrics.set(key, { event, count: 1, lastWriteTime: now });
+		} else {
+			// Increment existing metric
+			metric.count++;
+
+			// Check if it's time to flush
+			if (now - metric.lastWriteTime >= this.intervalMs) {
+				writeMetric(this.analytics, metric.event, metric.count);
+				metric.count = 0;
+				metric.lastWriteTime = now;
+			}
+		}
+	}
+
+	/**
+	 * Flushes all accumulated metrics immediately, regardless of time interval.
+	 * Useful for cleanup on shutdown or before long idle periods.
+	 */
+	flush(): void {
+		for (const [_, metric] of this.metrics) {
+			if (metric.count > 0) {
+				writeMetric(this.analytics, metric.event, metric.count);
+				metric.count = 0;
+				metric.lastWriteTime = Date.now();
+			}
+		}
+	}
+
+	/**
+	 * Generates a unique key for a metric event based on its distinguishing properties.
+	 * Does not include sessionId to allow aggregation across sessions.
+	 */
+	private getKey(event: MetricEvent): string {
+		return JSON.stringify({
+			name: event.name,
+			worker: event.worker,
+			errorType: event.errorType ?? '',
+			targetName: event.targetName ?? '',
+		});
+	}
+}

src/OpusDecoder/OpusDecoder.ts

@@ -5,6 +5,14 @@
 // submodules and compiled into the dist files, may have different
 // licensing terms."
 
+// Provide Node.js globals for emscripten module.  HACK.
+if (typeof globalThis.__filename === 'undefined') {
+	globalThis.__filename = './opus-decoder.js';
+}
+if (typeof globalThis.__dirname === 'undefined') {
+	globalThis.__dirname = '.';
+}
+
 import OpusDecoderModule from '../../dist/opus-decoder.js';
 // @ts-ignore
 import wasm from '../../dist/opus-decoder.wasm';
@@ -68,22 +76,31 @@ export class OpusDecoder<SampleRate extends OpusDecoderSampleRate | undefined =
 	static opusModule = new Promise<OpusWasmInstance>((resolve, reject) => {
 		OpusDecoderModule({
 			instantiateWasm(info: WebAssembly.Imports, receive: (instance: WebAssembly.Instance) => void) {
-				let instance = new WebAssembly.Instance(wasm, info);
-				receive(instance);
-				return instance.exports;
+				try {
+					let instance = new WebAssembly.Instance(wasm, info);
+					receive(instance);
+					return instance.exports;
+				} catch (error) {
+					reject(error);
+					throw error;
+				}
 			},
-		}).then((module: any) => {
-			resolve({
-				opus_frame_decoder_create: module._opus_frame_decoder_create,
-				opus_frame_decoder_destroy: module._opus_frame_decoder_destroy,
-				opus_frame_decoder_reset: module._opus_frame_decoder_reset,
-				opus_frame_decode: module._opus_frame_decode,
-				malloc: module._malloc,
-				free: module._free,
-				HEAP: module.wasmMemory.buffer,
-				module,
+		})
+			.then((module: any) => {
+				resolve({
+					opus_frame_decoder_create: module._opus_frame_decoder_create,
+					opus_frame_decoder_destroy: module._opus_frame_decoder_destroy,
+					opus_frame_decoder_reset: module._opus_frame_decoder_reset,
+					opus_frame_decode: module._opus_frame_decode,
+					malloc: module._malloc,
+					free: module._free,
+					HEAP: module.wasmMemory.buffer,
+					module,
+				});
+			})
+			.catch((error) => {
+				reject(error);
 			});
-		});
 	});
 
 	private _sampleRate: OpusDecoderSampleRate;
@@ -98,7 +115,7 @@ export class OpusDecoder<SampleRate extends OpusDecoderSampleRate | undefined =
 	private wasm!: OpusWasmInstance;
 	private _input!: TypedArrayAllocation<Uint8Array>;
 	private _output!: TypedArrayAllocation<Int16Array>;
-	private _decoder!: number;
+	private _decoder: number | undefined;
 
 	constructor(
 		options: {
@@ -136,6 +153,8 @@ export class OpusDecoder<SampleRate extends OpusDecoderSampleRate | undefined =
 		const wasmInstance = await OpusDecoder.opusModule;
 		this.wasm = wasmInstance;
 
+		console.log('OpusDecoder WASM module loaded');
+
 		this._input = this.allocateTypedArray(this._inputSize, Uint8Array);
 
 		this._output = this.allocateTypedArray(this._channels * this._outputChannelSize, Int16Array);
@@ -150,6 +169,9 @@ export class OpusDecoder<SampleRate extends OpusDecoderSampleRate | undefined =
 	}
 
 	reset() {
+		if (this._decoder === undefined) {
+			throw new Error('Decoder freed or not initialized');
+		}
 		this.wasm.opus_frame_decoder_reset(this._decoder);
 	}
 
@@ -174,7 +196,10 @@ export class OpusDecoder<SampleRate extends OpusDecoderSampleRate | undefined =
 		});
 		this._pointers.clear();
 
-		this.wasm.opus_frame_decoder_destroy(this._decoder);
+		if (this._decoder !== undefined) {
+			this.wasm.opus_frame_decoder_destroy(this._decoder);
+			this._decoder = undefined;
+		}
 	}
 
 	addError(
@@ -197,6 +222,18 @@ export class OpusDecoder<SampleRate extends OpusDecoderSampleRate | undefined =
 	decodeFrame(opusFrame: Uint8Array): OpusDecodedAudio<SampleRate extends undefined ? OpusDecoderDefaultSampleRate : SampleRate> {
 		const errors: DecodeError[] = [];
 
+		if (this._decoder === undefined) {
+			this.addError(errors, 'Decoder freed or not initialized', 0, 0, 0, 0);
+			console.error('Decoder freed or not initialized');
+			return {
+				errors,
+				pcmData: new Int16Array(0),
+				channels: this._channels,
+				samplesDecoded: 0,
+				sampleRate: this._sampleRate,
+			} as OpusDecodedAudio<SampleRate extends undefined ? OpusDecoderDefaultSampleRate : SampleRate>;
+		}
+
 		this._input.buf.set(opusFrame);
 
 		let samplesDecoded = this.wasm.opus_frame_decode(
@@ -237,10 +274,23 @@ export class OpusDecoder<SampleRate extends OpusDecoderSampleRate | undefined =
 		opusFrame: Uint8Array | undefined,
 		samplesToConceal: number,
 	): OpusDecodedAudio<SampleRate extends undefined ? OpusDecoderDefaultSampleRate : SampleRate> {
+		const errors: DecodeError[] = [];
+
+		if (this._decoder === undefined) {
+			this.addError(errors, 'Decoder freed or not initialized', 0, 0, 0, 0);
+			console.error('Decoder freed or not initialized');
+			return {
+				errors,
+				pcmData: new Int16Array(0),
+				channels: this._channels,
+				samplesDecoded: 0,
+				sampleRate: this._sampleRate,
+			} as OpusDecodedAudio<SampleRate extends undefined ? OpusDecoderDefaultSampleRate : SampleRate>;
+		}
+
 		if (samplesToConceal > this._outputChannelSize) {
 			samplesToConceal = this._outputChannelSize;
 		}
-		const errors: DecodeError[] = [];
 		let samplesDecoded: number;
 		let inLength: number;
 		if (opusFrame !== undefined) {