qwen-asr 0.1.0 → 0.2.0-alpha.2

package/README.md

@@ -9,8 +9,15 @@ inference engine for Qwen3-ASR (0.6B / 1.7B) speech-to-text.
 npm install -g qwen-asr
 ```
 
-Supported platform: Linux x86-64 with AVX2/FMA (x86-64-v3, Haswell or newer),
-glibc >= 2.28. OpenBLAS is statically linked; no other runtime dependencies.
+Supported platforms:
+
+- Linux x86-64 with AVX2/FMA (x86-64-v3, Haswell or newer), glibc >= 2.28.
+- Linux arm64 with ARMv8.2 (Cortex-A55/A76 or newer, e.g. Raspberry Pi 5,
+  Neoverse servers, Apple Silicon under Asahi Linux), glibc >= 2.28.
+  Raspberry Pi 3/4 are not supported.
+- On Linux, OpenBLAS is statically linked; no other runtime dependencies.
+- macOS 13.3+ on Apple Silicon or Intel (every Intel Mac that runs macOS 13
+  has the AVX2/FMA the binary needs), using the system Accelerate framework.
 
 ## Usage
 
@@ -27,7 +34,24 @@ qwen-asr -h
 See the [repository README](https://github.com/nexustar/qwen-asr#readme) for
 all options (segmented mode, streaming, language forcing, ...).
 
+## From Node
+
+Programs that run the binary themselves (rather than through the `qwen-asr`
+launcher) can get its path:
+
+```js
+const { binaryPath } = require('qwen-asr');
+
+const bin = binaryPath();  // e.g. .../prebuilds/darwin-arm64/qwen_asr
+```
+
+`binaryPath()` picks the arm64 binary for x64 Node under Rosetta, and throws
+an Error with `code` `QWEN_ASR_UNSUPPORTED_PLATFORM` (no binary for this
+OS / CPU architecture) or `QWEN_ASR_UNSUPPORTED_CPU` (CPU below the build
+baseline) when none can run here. Add the package to `optionalDependencies`
+so installs on other platforms still succeed.
+
 ## License
 
-MIT. The binary statically links OpenBLAS (BSD-3-Clause, see
-`prebuilds/linux-x64/LICENSE-OpenBLAS`).
+MIT. The Linux binaries statically link OpenBLAS (BSD-3-Clause, see
+`prebuilds/linux-*/LICENSE-OpenBLAS`).

package/bin/qwen-asr.js

@@ -2,33 +2,17 @@
 'use strict';
 
 const { spawnSync } = require('child_process');
-const fs = require('fs');
-const path = require('path');
+const { binaryPath } = require('..');
 
-const key = `${process.platform}-${process.arch}`;
-const bin = path.join(__dirname, '..', 'prebuilds', key, 'qwen_asr');
-
-if (!fs.existsSync(bin)) {
-  console.error(`qwen-asr: no prebuilt binary for ${key}.`);
+let bin;
+try {
+  bin = binaryPath();
+} catch (e) {
+  console.error(`qwen-asr: ${e.message}.`);
   console.error('Build from source: https://github.com/nexustar/qwen-asr');
   process.exit(1);
 }
 
-// Fail clearly instead of SIGILL without x86-64-v3
-if (key === 'linux-x64') {
-  let have = null;
-  try {
-    const m = /^flags\s*:(.*)$/m.exec(fs.readFileSync('/proc/cpuinfo', 'utf8'));
-    if (m) have = new Set(m[1].trim().split(/\s+/));
-  } catch (e) {}
-  const missing = have ? ['avx2', 'fma', 'f16c', 'bmi2'].filter(f => !have.has(f)) : [];
-  if (missing.length) {
-    console.error(`qwen-asr: this CPU lacks ${missing.join(', ')} (x86-64-v3 required).`);
-    console.error('Build from source: https://github.com/nexustar/qwen-asr');
-    process.exit(1);
-  }
-}
-
 const r = spawnSync(bin, process.argv.slice(2), { stdio: 'inherit', argv0: 'qwen-asr' });
 if (r.error) {
   console.error(`qwen-asr: ${r.error.message}`);

package/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Absolute path of the prebuilt qwen_asr binary for this machine.
+ *
+ * Throws an Error with `code` QWEN_ASR_UNSUPPORTED_PLATFORM (no binary for
+ * this OS / CPU architecture) or QWEN_ASR_UNSUPPORTED_CPU (the CPU is below
+ * the build baseline) when none can run here.
+ */
+export function binaryPath(): string;

package/index.js

@@ -0,0 +1,60 @@
+'use strict';
+
+// Locates the prebuilt qwen_asr binary for this machine. Used by the
+// qwen-asr launcher, and by programs that spawn the binary themselves.
+
+const { execFileSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+// Below the build baseline the binary dies with SIGILL, so check first
+// (arm64: LSE atomics as a proxy for ARMv8.2)
+const REQUIRED = {
+  'linux-x64': { field: 'flags', features: ['avx2', 'fma', 'f16c', 'bmi2'], level: 'x86-64-v3' },
+  'linux-arm64': { field: 'Features', features: ['atomics'], level: 'ARMv8.2' },
+};
+
+function platformKey() {
+  const key = `${process.platform}-${process.arch}`;
+  // x64 Node under Rosetta: use the native arm64 binary
+  if (key === 'darwin-x64') {
+    try {
+      const out = execFileSync('/usr/sbin/sysctl', ['-in', 'sysctl.proc_translated'], { encoding: 'utf8' });
+      if (out.trim() === '1') return 'darwin-arm64';
+    } catch (e) {}
+  }
+  return key;
+}
+
+function unsupported(code, message) {
+  const err = new Error(message);
+  err.code = code;
+  return err;
+}
+
+// Absolute path of the binary. Throws an Error with code
+// QWEN_ASR_UNSUPPORTED_PLATFORM or QWEN_ASR_UNSUPPORTED_CPU when none can
+// run here.
+function binaryPath() {
+  const key = platformKey();
+  const bin = path.join(__dirname, 'prebuilds', key, 'qwen_asr');
+  if (!fs.existsSync(bin)) {
+    throw unsupported('QWEN_ASR_UNSUPPORTED_PLATFORM', `no prebuilt binary for ${key}`);
+  }
+  const required = REQUIRED[key];
+  if (required) {
+    let have = null;
+    try {
+      const re = new RegExp(`^${required.field}\\s*:(.*)$`, 'm');
+      const m = re.exec(fs.readFileSync('/proc/cpuinfo', 'utf8'));
+      if (m) have = new Set(m[1].trim().split(/\s+/));
+    } catch (e) {}
+    const missing = have ? required.features.filter(f => !have.has(f)) : [];
+    if (missing.length) {
+      throw unsupported('QWEN_ASR_UNSUPPORTED_CPU', `this CPU lacks ${missing.join(', ')} (${required.level} required)`);
+    }
+  }
+  return bin;
+}
+
+exports.binaryPath = binaryPath;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qwen-asr",
-  "version": "0.1.0",
+  "version": "0.2.0-alpha.2",
   "description": "Qwen3-ASR speech-to-text in pure C (prebuilt CLI binary)",
   "license": "MIT",
   "repository": {
@@ -15,19 +15,25 @@
     "qwen3-asr",
     "transcription"
   ],
+  "main": "index.js",
+  "types": "index.d.ts",
   "bin": {
     "qwen-asr": "bin/qwen-asr.js"
   },
   "files": [
+    "index.js",
+    "index.d.ts",
     "bin",
     "prebuilds",
     "LICENSE"
   ],
   "os": [
-    "linux"
+    "linux",
+    "darwin"
   ],
   "cpu": [
-    "x64"
+    "x64",
+    "arm64"
   ],
   "engines": {
     "node": ">=16"

package/prebuilds/linux-arm64/LICENSE-OpenBLAS

@@ -0,0 +1,29 @@
+Copyright (c) 2011-2014, The OpenBLAS Project
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   1. Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+   2. Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in
+      the documentation and/or other materials provided with the
+      distribution.
+   3. Neither the name of the OpenBLAS project nor the names of 
+      its contributors may be used to endorse or promote products 
+      derived from this software without specific prior written 
+      permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.