@qvac/decoder-audio 0.4.0 → 0.6.0

package/package.json

@@ -1,20 +1,29 @@
 {
   "name": "@qvac/decoder-audio",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "",
   "license": "Apache-2.0",
   "author": "Tether",
   "type": "commonjs",
   "main": "index.js",
   "scripts": {
-    "test:dts": "tsc index.d.ts --noEmit --esModuleInterop --skipLibCheck",
-    "test:unit": "brittle-bare test/unit/*.test.js",
-    "test": "npm run test:unit && npm run test:integration",
+    "build": "npm run build:ts",
+    "build:ts": "tsc -p tsconfig.build.json",
+    "check:generated": "node scripts/check-generated.mjs",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "test:dts": "tsc --noEmit -p tsconfig.dts.json",
+    "test:types": "npm run typecheck && npm run test:dts && npm run check:generated",
+    "test:unit": "npm run build:ts && brittle-bare test/unit/*.test.js && npm run test:package",
+    "test:package": "node --test test/package/package-contract.test.js",
+    "test": "npm run test:types && npm run test:unit && npm run test:integration",
     "coverage:unit": "brittle-bare --coverage --cov-dir=coverage/unit test/unit/*.test.js && mkdir -p .nyc_output && cp coverage/unit/coverage-final.json .nyc_output/out.json && npx nyc report --reporter=html --report-dir=coverage/html",
     "coverage": "brittle-bare --coverage --cov-dir=coverage/unit test/unit/*.test.js && mkdir -p .nyc_output && cp coverage/unit/coverage-final.json .nyc_output/out.json && npx nyc report --reporter=html --report-dir=coverage/html",
-    "lint": "standard \"test/**/*.js\" \"*.js\" \"scripts/**/*.js\"",
-    "lint:fix": "standard --fix \"test/**/*.js\" \"*.js\" \"scripts/**/*.js\"",
-    "test:integration": "npm run test:integration:generate && brittle-bare test/integration/*.test.js",
+    "lint": "npm run lint:js && npm run lint:ts && npm run test:types",
+    "lint:js": "prettier --check \"test/**/*.js\" \"scripts/**/*.js\" && lunte \"test/**/*.js\" \"scripts/**/*.js\"",
+    "lint:ts": "eslint \"src/**/*.ts\" --max-warnings=0",
+    "lint:ts:fix": "eslint \"src/**/*.ts\" --fix",
+    "format": "prettier --write \"test/**/*.js\" \"scripts/**/*.js\"",
+    "test:integration": "npm run build:ts && npm run test:integration:generate && brittle-bare test/integration/*.test.js",
     "test:integration:generate": "brittle -r test/integration/all.js test/integration/*.test.js && npm run test:mobile:generate",
     "test:mobile:generate": "bare ./scripts/generate-mobile-integration-tests.js",
     "test:mobile:validate": "node scripts/validate-mobile-tests.js"
@@ -37,23 +46,28 @@
   },
   "devDependencies": {
     "@types/node": "^22.14.1",
+    "bare-abort-controller": "^1.1.2",
     "bare-os": "^3.6.2",
-    "bare-url": "^2.1.6",
+    "bare-process": "^4.2.2",
     "brittle": "^3.13.1",
+    "eslint": "^9.39.4",
+    "eslint-import-resolver-typescript": "^4.4.5",
+    "eslint-plugin-import": "^2.32.0",
+    "lunte": "^1.8.0",
     "nyc": "^17.1.0",
-    "standard": "^17.1.2",
-    "typescript": "^5.3.0"
+    "prettier": "^3.6.2",
+    "prettier-config-holepunch": "^2.0.0",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.63.0"
   },
   "dependencies": {
     "@qvac/error": "^0.1.0",
-    "@qvac/infer-base": "^0.4.0",
+    "@qvac/infer-base": "^0.6.0",
     "@qvac/logging": "^0.1.0",
-    "bare-assert": "^1.1.0",
-    "bare-channel": "^5.2.2",
     "bare-ffmpeg": "^1.0.0-32",
     "bare-fs": "^4.5.1",
     "bare-path": "^3.0.0",
-    "bare-process": "^4.2.2"
+    "bare-url": "^2.1.6"
   },
   "repository": {
     "type": "git",
@@ -61,6 +75,6 @@
     "directory": "packages/decoder-audio"
   },
   "bugs": "https://github.com/tetherto/qvac/issues",
-  "homepage": "https://github.com/tetherto/qvac/tree/main/packages/decoder-audio#readme",
+  "homepage": "https://qvac.tether.io",
   "types": "index.d.ts"
 }

package/test/mobile/integration-runtime.cjs

@@ -4,6 +4,30 @@ const path = require('bare-path')
 const fs = require('bare-fs')
 const { pathToFileURL } = require('bare-url')
 
+// A dlopen failure (or any unhandled error) MUST fail the run, not just get
+// logged: Bare surfaces addon-load failures as an unhandledRejection on the
+// worklet thread. Without a hard exit the run can SIGABRT (ambiguous timeout)
+// or a log-only handler would falsely pass. Catch, record the first failure,
+// and force a non-zero exit on drain.
+let _integrationFatalError = null
+const _bareHost = typeof globalThis !== 'undefined' ? globalThis.Bare : undefined
+if (_bareHost && typeof _bareHost.on === 'function') {
+  _bareHost.on('unhandledRejection', (reason) => {
+    if (!_integrationFatalError) _integrationFatalError = reason || new Error('unhandledRejection')
+    console.error('[integration-runner] Unhandled rejection:', reason instanceof Error ? reason.stack : reason)
+  })
+  _bareHost.on('uncaughtException', (err) => {
+    if (!_integrationFatalError) _integrationFatalError = err || new Error('uncaughtException')
+    console.error('[integration-runner] Uncaught exception:', err instanceof Error ? err.stack : err)
+  })
+  _bareHost.on('beforeExit', () => {
+    if (!_integrationFatalError) return
+    console.error('[integration-runner] FATAL: failing run due to an earlier unhandled error.')
+    if (typeof _bareHost.exit === 'function') _bareHost.exit(1)
+    else if (typeof globalThis.process !== 'undefined' && globalThis.process.exit) globalThis.process.exit(1)
+  })
+}
+
 async function runIntegrationModule (relativeModulePath, options = {}) {
   const modulePath = path.join(__dirname, relativeModulePath)
 

package/utils/createStreamAccumulator.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Creates a stream accumulator that processes incoming audio data in chunks of a specified size.
+ * The accumulator maintains a buffer of incoming data and emits chunks when the target size is reached.
+ *
+ * @param options - Configuration options for the stream accumulator
+ * @returns An object with methods to process data and finish the stream
+ * @throws {QvacErrorDecoderAudio} If the target buffer size is smaller than the minimum required size
+ */
+declare function createStreamAccumulator({ onChunk, onFinish, targetBufferSize, }: createStreamAccumulator.StreamAccumulatorOptions): createStreamAccumulator.StreamAccumulator;
+declare namespace createStreamAccumulator {
+    interface StreamAccumulatorOptions {
+        /** Called with each full chunk, and with the remainder on `finish()`. */
+        onChunk: (chunk: Uint8Array) => void | Promise<void>;
+        /** Called once after the final chunk has been emitted. */
+        onFinish: () => void | Promise<void>;
+        /** Chunk size in bytes. Must be at least 64000. */
+        targetBufferSize?: number;
+    }
+    interface StreamAccumulator {
+        processData(data: Buffer): Promise<void>;
+        finish(): Promise<void>;
+    }
+}
+export = createStreamAccumulator;

package/utils/createStreamAccumulator.js

@@ -1,64 +1,51 @@
-const { QvacErrorDecoderAudio, ERR_CODES } = require('./error')
-
-const TARGET_SECONDS = 1 // Desired chunk size in seconds
-const SAMPLE_RATE = 16000 // PCM audio sample rate
-const BYTES_PER_SAMPLE = 4 // PCM S16LE (16-bit)
-const TARGET_BUFFER_SIZE = TARGET_SECONDS * SAMPLE_RATE * BYTES_PER_SAMPLE
-
+"use strict";
+const error_1 = require("./error");
+const TARGET_SECONDS = 1; // Desired chunk size in seconds
+const SAMPLE_RATE = 16000; // PCM audio sample rate
+const BYTES_PER_SAMPLE = 4; // PCM S16LE (16-bit)
+const TARGET_BUFFER_SIZE = TARGET_SECONDS * SAMPLE_RATE * BYTES_PER_SAMPLE;
 /**
  * Creates a stream accumulator that processes incoming audio data in chunks of a specified size.
  * The accumulator maintains a buffer of incoming data and emits chunks when the target size is reached.
  *
- * @param {Object} options - Configuration options for the stream accumulator
- * @param {Function} options.onChunk - Callback function called when a chunk of data is ready to be processed
- * @param {Function} options.onFinish - Callback function called when all data has been processed
- * @param {number} [options.targetBufferSize=TARGET_BUFFER_SIZE] - Target size for each chunk in bytes
- * @returns {Object} An object with methods to process data and finish the stream
- * @throws {Error} If the target buffer size is smaller than the minimum required size
+ * @param options - Configuration options for the stream accumulator
+ * @returns An object with methods to process data and finish the stream
+ * @throws {QvacErrorDecoderAudio} If the target buffer size is smaller than the minimum required size
  */
-function createStreamAccumulator ({
-  onChunk,
-  onFinish,
-  targetBufferSize = TARGET_BUFFER_SIZE
-}) {
-  if (targetBufferSize < TARGET_BUFFER_SIZE) {
-    throw new QvacErrorDecoderAudio({ code: ERR_CODES.BUFFER_SIZE_TOO_SMALL })
-  }
-
-  let accumulator = Buffer.alloc(0)
-
-  return {
-    /**
-     * Process incoming data and emit chunks when target size is reached.
-     * Accumulates incoming data until it reaches the target buffer size,
-     * then emits a chunk and continues with the remaining data.
-     *
-     * @param {Buffer} data - The incoming data to process
-     * @returns {Promise<void>} A promise that resolves when the chunk is processed
-     */
-    async processData (data) {
-      accumulator = Buffer.concat([accumulator, data])
-
-      while (accumulator.length >= targetBufferSize) {
-        const chunk = accumulator.subarray(0, targetBufferSize)
-        await onChunk(new Uint8Array(chunk))
-        accumulator = accumulator.subarray(targetBufferSize)
-      }
-    },
-
-    /**
-     * Finish processing and emit any remaining data.
-     * Processes any remaining data in the accumulator and calls the finish callback.
-     *
-     * @returns {Promise<void>} A promise that resolves when all remaining data is processed
-     */
-    async finish () {
-      if (accumulator.length > 0) {
-        await onChunk(new Uint8Array(accumulator))
-      }
-      await onFinish()
+function createStreamAccumulator({ onChunk, onFinish, targetBufferSize = TARGET_BUFFER_SIZE, }) {
+    if (targetBufferSize < TARGET_BUFFER_SIZE) {
+        throw new error_1.QvacErrorDecoderAudio({ code: error_1.ERR_CODES.BUFFER_SIZE_TOO_SMALL });
     }
-  }
+    let accumulator = Buffer.alloc(0);
+    return {
+        /**
+         * Process incoming data and emit chunks when target size is reached.
+         * Accumulates incoming data until it reaches the target buffer size,
+         * then emits a chunk and continues with the remaining data.
+         *
+         * @param data - The incoming data to process
+         * @returns A promise that resolves when the chunk is processed
+         */
+        async processData(data) {
+            accumulator = Buffer.concat([accumulator, data]);
+            while (accumulator.length >= targetBufferSize) {
+                const chunk = accumulator.subarray(0, targetBufferSize);
+                await onChunk(new Uint8Array(chunk));
+                accumulator = accumulator.subarray(targetBufferSize);
+            }
+        },
+        /**
+         * Finish processing and emit any remaining data.
+         * Processes any remaining data in the accumulator and calls the finish callback.
+         *
+         * @returns A promise that resolves when all remaining data is processed
+         */
+        async finish() {
+            if (accumulator.length > 0) {
+                await onChunk(new Uint8Array(accumulator));
+            }
+            await onFinish();
+        },
+    };
 }
-
-module.exports = createStreamAccumulator
+module.exports = createStreamAccumulator;

package/utils/error.d.ts

@@ -0,0 +1,19 @@
+import QvacError = require("@qvac/error");
+declare const QvacErrorBase: typeof QvacError.QvacErrorBase;
+export declare class QvacErrorDecoderAudio extends QvacErrorBase {
+}
+export declare const ERR_CODES: Readonly<{
+    FAILED_TO_LOAD_WEIGHTS: 11001;
+    FAILED_TO_ACTIVATE: 11002;
+    FAILED_TO_PAUSE: 11003;
+    FAILED_TO_CANCEL: 11004;
+    FAILED_TO_APPEND: 11005;
+    FAILED_TO_GET_STATUS: 11006;
+    FAILED_TO_DESTROY: 11007;
+    BUFFER_SIZE_TOO_SMALL: 11008;
+    UNSUPPORTED_AUDIO_FORMAT: 11009;
+    DECODER_NOT_LOADED: 11010;
+    STREAM_INDEX_OUT_OF_BOUNDS: 11011;
+    JOB_CANCELLED: 11012;
+}>;
+export {};

package/utils/error.js

@@ -1,81 +1,77 @@
-'use strict'
-
-const { QvacErrorBase, addCodes } = require('@qvac/error')
-const { name, version } = require('../package.json')
-
-class QvacErrorDecoderAudio extends QvacErrorBase { }
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERR_CODES = exports.QvacErrorDecoderAudio = void 0;
+/* eslint-disable @typescript-eslint/no-require-imports -- @qvac/error exposes a CommonJS export shape. */
+const QvacError = require("@qvac/error");
+/* eslint-enable @typescript-eslint/no-require-imports */
+const { QvacErrorBase, addCodes } = QvacError;
+class QvacErrorDecoderAudio extends QvacErrorBase {
+}
+exports.QvacErrorDecoderAudio = QvacErrorDecoderAudio;
+// eslint-disable-next-line @typescript-eslint/no-require-imports -- package metadata is read from the package root at runtime.
+const { name, version } = require("../package.json");
 // This library has error code range from 11,001 to 12,000
-const ERR_CODES = Object.freeze({
-  FAILED_TO_LOAD_WEIGHTS: 11001,
-  FAILED_TO_ACTIVATE: 11002,
-  FAILED_TO_PAUSE: 11003,
-  FAILED_TO_CANCEL: 11004,
-  FAILED_TO_APPEND: 11005,
-  FAILED_TO_GET_STATUS: 11006,
-  FAILED_TO_DESTROY: 11007,
-  BUFFER_SIZE_TOO_SMALL: 11008,
-  UNSUPPORTED_AUDIO_FORMAT: 11009,
-  DECODER_NOT_LOADED: 11010,
-  STREAM_INDEX_OUT_OF_BOUNDS: 11011,
-  JOB_CANCELLED: 11012
-})
-
+exports.ERR_CODES = Object.freeze({
+    FAILED_TO_LOAD_WEIGHTS: 11001,
+    FAILED_TO_ACTIVATE: 11002,
+    FAILED_TO_PAUSE: 11003,
+    FAILED_TO_CANCEL: 11004,
+    FAILED_TO_APPEND: 11005,
+    FAILED_TO_GET_STATUS: 11006,
+    FAILED_TO_DESTROY: 11007,
+    BUFFER_SIZE_TOO_SMALL: 11008,
+    UNSUPPORTED_AUDIO_FORMAT: 11009,
+    DECODER_NOT_LOADED: 11010,
+    STREAM_INDEX_OUT_OF_BOUNDS: 11011,
+    JOB_CANCELLED: 11012,
+});
 addCodes({
-  [ERR_CODES.FAILED_TO_LOAD_WEIGHTS]: {
-    name: 'FAILED_TO_LOAD_WEIGHTS',
-    message: (message) => `Failed to load weights, error: ${message}`
-  },
-  [ERR_CODES.FAILED_TO_ACTIVATE]: {
-    name: 'FAILED_TO_ACTIVATE',
-    message: (message) => `Failed to activate model, error: ${message}`
-  },
-  [ERR_CODES.FAILED_TO_PAUSE]: {
-    name: 'FAILED_TO_PAUSE',
-    message: (message) => `Failed to pause inference, error: ${message}`
-  },
-  [ERR_CODES.FAILED_TO_CANCEL]: {
-    name: 'FAILED_TO_CANCEL',
-    message: (message) => `Failed to cancel inference, error: ${message}`
-  },
-  [ERR_CODES.FAILED_TO_APPEND]: {
-    name: 'FAILED_TO_APPEND',
-    message: (message) => `Failed to append data to processing queue, error: ${message}`
-  },
-  [ERR_CODES.FAILED_TO_GET_STATUS]: {
-    name: 'FAILED_TO_GET_STATUS',
-    message: (message) => `Failed to get decoder status, error: ${message}`
-  },
-  [ERR_CODES.FAILED_TO_DESTROY]: {
-    name: 'FAILED_TO_DESTROY',
-    message: (message) => `Failed to destroy instance, error: ${message}`
-  },
-  [ERR_CODES.BUFFER_SIZE_TOO_SMALL]: {
-    name: 'BUFFER_SIZE_TOO_SMALL',
-    message: 'Target buffer size is too small'
-  },
-  [ERR_CODES.UNSUPPORTED_AUDIO_FORMAT]: {
-    name: 'UNSUPPORTED_AUDIO_FORMAT',
-    message: (format) => `Unsupported audio format: ${format}`
-  },
-  [ERR_CODES.DECODER_NOT_LOADED]: {
-    name: 'DECODER_NOT_LOADED',
-    message: 'Decoder not loaded. Call load() first.'
-  },
-  [ERR_CODES.STREAM_INDEX_OUT_OF_BOUNDS]: {
-    name: 'STREAM_INDEX_OUT_OF_BOUNDS',
-    message: (index) => `Stream index out of bounds: ${index}`
-  },
-  [ERR_CODES.JOB_CANCELLED]: {
-    name: 'JOB_CANCELLED',
-    message: 'Decoder job cancelled'
-  }
-}, {
-  name,
-  version
-})
-
-module.exports = {
-  ERR_CODES,
-  QvacErrorDecoderAudio
-}
+    [exports.ERR_CODES.FAILED_TO_LOAD_WEIGHTS]: {
+        name: "FAILED_TO_LOAD_WEIGHTS",
+        message: (message) => `Failed to load weights, error: ${message}`,
+    },
+    [exports.ERR_CODES.FAILED_TO_ACTIVATE]: {
+        name: "FAILED_TO_ACTIVATE",
+        message: (message) => `Failed to activate model, error: ${message}`,
+    },
+    [exports.ERR_CODES.FAILED_TO_PAUSE]: {
+        name: "FAILED_TO_PAUSE",
+        message: (message) => `Failed to pause inference, error: ${message}`,
+    },
+    [exports.ERR_CODES.FAILED_TO_CANCEL]: {
+        name: "FAILED_TO_CANCEL",
+        message: (message) => `Failed to cancel inference, error: ${message}`,
+    },
+    [exports.ERR_CODES.FAILED_TO_APPEND]: {
+        name: "FAILED_TO_APPEND",
+        message: (message) => `Failed to append data to processing queue, error: ${message}`,
+    },
+    [exports.ERR_CODES.FAILED_TO_GET_STATUS]: {
+        name: "FAILED_TO_GET_STATUS",
+        message: (message) => `Failed to get decoder status, error: ${message}`,
+    },
+    [exports.ERR_CODES.FAILED_TO_DESTROY]: {
+        name: "FAILED_TO_DESTROY",
+        message: (message) => `Failed to destroy instance, error: ${message}`,
+    },
+    [exports.ERR_CODES.BUFFER_SIZE_TOO_SMALL]: {
+        name: "BUFFER_SIZE_TOO_SMALL",
+        message: "Target buffer size is too small",
+    },
+    [exports.ERR_CODES.UNSUPPORTED_AUDIO_FORMAT]: {
+        name: "UNSUPPORTED_AUDIO_FORMAT",
+        message: (format) => `Unsupported audio format: ${format}`,
+    },
+    [exports.ERR_CODES.DECODER_NOT_LOADED]: {
+        name: "DECODER_NOT_LOADED",
+        message: "Decoder not loaded. Call load() first.",
+    },
+    [exports.ERR_CODES.STREAM_INDEX_OUT_OF_BOUNDS]: {
+        name: "STREAM_INDEX_OUT_OF_BOUNDS",
+        message: (index) => `Stream index out of bounds: ${index}`,
+    },
+    [exports.ERR_CODES.JOB_CANCELLED]: {
+        name: "JOB_CANCELLED",
+        message: "Decoder job cancelled",
+    },
+}, { name, version });