@vowifi-rs/vowifi 0.1.6

package/README.md

@@ -0,0 +1,47 @@
+# @vowifi-rs/vowifi
+
+Node.js binding for the hardware-independent `vowifi-client` facade.
+
+```js
+const { VowifiSession } = require('@vowifi-rs/vowifi')
+
+const session = await VowifiSession.connect({
+  subscription: { imsi, mcc, mnc, imei, imeisv },
+  aka: async ({ rand, autn }) => device.authenticateAka(rand, autn),
+})
+
+const result = await session.sendSms({ recipient: '777', text: 'BAL', smsc })
+const event = await session.nextEvent()
+await session.shutdown()
+```
+
+The package does not scan serial ports or own a modem. The host supplies subscription identity and
+one asynchronous AKA callback. `examples/serial-uicc-aka.js` demonstrates a development adapter
+using the `serialport` dev dependency; it is not part of the production API.
+
+Run the local checks with:
+
+```powershell
+pnpm install
+pnpm run build
+pnpm test
+```
+
+`examples/one-nz-balance.js` is an opt-in real-network regression. It reads its identity and port
+from `VOWIFI_*` environment variables, sends `BAL` to One NZ short code `777`, waits for the reply,
+and performs an explicit IMS deregistration.
+
+## Release
+
+Releases are published by GitHub Actions from tags matching `v*.*.*`. Update
+the version in `package.json`, push the commit, then push the matching tag:
+
+```bash
+git tag v0.1.1
+git push origin v0.1.1
+```
+
+The repository secret `NPM_TOKEN` must be an npm token with publish access to
+the `@vowifi-rs` scope. The workflow builds the Windows x64, Linux x64, and
+Linux arm64 native packages, then publishes the root package and its optional
+platform packages.

package/index.d.ts

@@ -0,0 +1,110 @@
+/// <reference types="node" />
+
+export interface SubscriptionIdentity {
+  imsi: string
+  mcc: string
+  mnc: string
+  imei?: string
+  imeisv?: string
+  spn?: string
+  gid1?: string
+  gid2?: string
+  iccid?: string
+}
+
+export interface CarrierProfile extends Record<string, unknown> {
+  schemaVersion: number
+  id: string
+  displayName: string
+}
+
+export interface OperationalConfig {
+  ioTimeoutMs?: number
+  ikeInitialTimeoutMs?: number
+  ikeAttempts?: number
+  registrationTimeoutMs?: number
+  refreshAtPercent?: number
+  recoveryAttempts?: number
+  recoveryInitialDelayMs?: number
+  recoveryMaxDelayMs?: number
+}
+
+export type NetworkEgress =
+  | { kind: 'direct'; localAddress?: string }
+  | { kind: 'socks5'; proxy: string; username?: string; password?: string }
+
+export interface AkaRequest {
+  rand: Buffer
+  autn: Buffer
+}
+
+export type AkaResult =
+  | { kind: 'success'; res: Buffer; ck: Buffer; ik: Buffer; kc?: Buffer }
+  | { kind: 'synchronizationFailure'; auts: Buffer }
+  | { kind: 'rejected'; sw1: number; sw2: number }
+
+export interface ConnectOptions {
+  subscription: SubscriptionIdentity
+  carrierProfile?: 'auto' | string
+  carrierOverrides?: CarrierProfile[]
+  explicitEpdgHostnames?: string[]
+  egress?: NetworkEgress
+  operational?: OperationalConfig
+  aka(request: AkaRequest): Promise<AkaResult>
+}
+
+export type SessionState =
+  | { kind: 'stopped' | 'connecting' | 'online' | 'recovering' | 'stopping' }
+  | { kind: 'failed'; message?: string }
+
+export type SmsContent =
+  | { kind: 'text'; text: string }
+  | { kind: 'binary'; data: Buffer }
+
+export interface SmsMessage {
+  sender: string
+  protocolIdentifier: number
+  dataCodingScheme: number
+  serviceCentreTimestamp: Buffer
+  content: SmsContent
+}
+
+export type VowifiEvent =
+  | { kind: 'registered'; expiresSeconds: number }
+  | { kind: 'refreshed'; expiresSeconds: number; securityReplaced: boolean }
+  | { kind: 'deregistered' }
+  | { kind: 'incomingSms'; message: SmsMessage }
+
+export interface SmsSendOptions {
+  recipient: string
+  text: string
+  smsc?: string
+}
+
+export type SmsSendResult =
+  | { kind: 'rpConfirmed'; parts: number; statuses: [] }
+  | { kind: 'sipAcceptedUnconfirmed'; parts: number; statuses: number[] }
+
+export interface ResolvedCarrierProfile {
+  profile: CarrierProfile
+  source: 'builtin' | 'override' | 'custom' | 'fallback'
+  matchedBy: string[]
+}
+
+export class VowifiSession {
+  private constructor()
+  static connect(options: ConnectOptions): Promise<VowifiSession>
+  readonly carrierProfileId: string
+  status(): SessionState
+  nextEvent(): Promise<VowifiEvent | null>
+  sendSms(message: SmsSendOptions): Promise<SmsSendResult>
+  shutdown(): Promise<void>
+}
+
+export function initLogging(filter?: string): boolean
+
+export function resolveCarrierProfile(options: {
+  subscription: SubscriptionIdentity
+  carrierProfile?: 'auto' | string
+  carrierOverrides?: CarrierProfile[]
+}): ResolvedCarrierProfile

package/index.js

@@ -0,0 +1,78 @@
+'use strict'
+
+const native = require('./native.js')
+
+function normalizeError(error) {
+  if (!(error instanceof Error)) return error
+  const match = /^([A-Z][A-Z_]+):\s*/.exec(error.message)
+  if (match) {
+    error.code = match[1]
+    error.message = error.message.slice(match[0].length)
+  }
+  return error
+}
+
+async function nativeCall(operation) {
+  try {
+    return await operation()
+  } catch (error) {
+    throw normalizeError(error)
+  }
+}
+
+class VowifiSession {
+  #native
+
+  constructor(inner) {
+    this.#native = inner
+  }
+
+  static async connect(options) {
+    if (!options || typeof options.aka !== 'function') {
+      const error = new TypeError('connect options must include an async aka function')
+      error.code = 'INVALID_CONFIG'
+      throw error
+    }
+    const { aka, ...nativeOptions } = options
+    const inner = await nativeCall(() => native.NodeVowifiSession.connect(nativeOptions, aka))
+    return new VowifiSession(inner)
+  }
+
+  get carrierProfileId() {
+    return this.#native.carrierProfileId
+  }
+
+  status() {
+    return this.#native.status()
+  }
+
+  nextEvent() {
+    return nativeCall(() => this.#native.nextEvent())
+  }
+
+  sendSms(message) {
+    return nativeCall(() => this.#native.sendSms(message))
+  }
+
+  shutdown() {
+    return nativeCall(() => this.#native.shutdown())
+  }
+}
+
+function resolveCarrierProfile(options) {
+  try {
+    return native.resolveCarrierProfile(options)
+  } catch (error) {
+    throw normalizeError(error)
+  }
+}
+
+function initLogging(filter) {
+  try {
+    return native.initLogging(filter)
+  } catch (error) {
+    throw normalizeError(error)
+  }
+}
+
+module.exports = { VowifiSession, initLogging, resolveCarrierProfile }

package/native.d.ts

@@ -0,0 +1,120 @@
+/* auto-generated by NAPI-RS */
+/* eslint-disable */
+export declare class NodeVowifiSession {
+  static connect(options: JsConnectOptions, aka: AkaCallback): Promise<NodeVowifiSession>
+  get carrierProfileId(): string
+  status(): JsSessionState
+  nextEvent(): Promise<JsVowifiEvent | null>
+  sendSms(input: JsSmsSendOptions): Promise<JsSmsSendResult>
+  shutdown(): Promise<void>
+}
+
+export declare function initLogging(filter?: string | undefined | null): boolean
+
+export interface JsAkaRequest {
+  rand: Buffer
+  autn: Buffer
+}
+
+export interface JsAkaResult {
+  kind: string
+  res?: Buffer
+  ck?: Buffer
+  ik?: Buffer
+  kc?: Buffer
+  auts?: Buffer
+  sw1?: number
+  sw2?: number
+}
+
+export interface JsConnectOptions {
+  subscription: JsSubscriptionIdentity
+  carrierProfile?: string
+  carrierOverrides?: Array<any>
+  explicitEpdgHostnames?: Array<string>
+  egress?: JsNetworkEgress
+  operational?: JsOperationalConfig
+}
+
+export interface JsNetworkEgress {
+  kind: string
+  localAddress?: string
+  proxy?: string
+  username?: string
+  password?: string
+}
+
+export interface JsOperationalConfig {
+  ioTimeoutMs?: number
+  ikeInitialTimeoutMs?: number
+  ikeAttempts?: number
+  registrationTimeoutMs?: number
+  refreshAtPercent?: number
+  recoveryAttempts?: number
+  recoveryInitialDelayMs?: number
+  recoveryMaxDelayMs?: number
+}
+
+export interface JsResolveCarrierProfileOptions {
+  subscription: JsSubscriptionIdentity
+  carrierProfile?: string
+  carrierOverrides?: Array<any>
+}
+
+export interface JsResolvedCarrierProfile {
+  profile: any
+  source: string
+  matchedBy: Array<string>
+}
+
+export interface JsSessionState {
+  kind: string
+  message?: string
+}
+
+export interface JsSmsContent {
+  kind: string
+  text?: string
+  data?: Buffer
+}
+
+export interface JsSmsMessage {
+  sender: string
+  protocolIdentifier: number
+  dataCodingScheme: number
+  serviceCentreTimestamp: Buffer
+  content: JsSmsContent
+}
+
+export interface JsSmsSendOptions {
+  recipient: string
+  text: string
+  smsc?: string
+}
+
+export interface JsSmsSendResult {
+  kind: string
+  parts: number
+  statuses: Array<number>
+}
+
+export interface JsSubscriptionIdentity {
+  imsi: string
+  mcc: string
+  mnc: string
+  imei?: string
+  imeisv?: string
+  spn?: string
+  gid1?: string
+  gid2?: string
+  iccid?: string
+}
+
+export interface JsVowifiEvent {
+  kind: string
+  expiresSeconds?: number
+  securityReplaced?: boolean
+  message?: JsSmsMessage
+}
+
+export declare function resolveCarrierProfile(options: JsResolveCarrierProfileOptions): JsResolvedCarrierProfile

package/native.js

@@ -0,0 +1,705 @@
+// prettier-ignore
+/* eslint-disable */
+// @ts-nocheck
+/* auto-generated by NAPI-RS */
+
+const { readFileSync } = require('fs')
+let nativeBinding = null
+const loadErrors = []
+
+const isMusl = () => {
+  let musl = false
+  if (process.platform === 'linux') {
+    musl = isMuslFromFilesystem()
+    if (musl === null) {
+      musl = isMuslFromReport()
+    }
+    if (musl === null) {
+      musl = isMuslFromChildProcess()
+    }
+  }
+  return musl
+}
+
+const isFileMusl = (f) => f.includes('libc.musl-') || f.includes('ld-musl-')
+
+const isMuslFromFilesystem = () => {
+  try {
+    return readFileSync('/usr/bin/ldd', 'utf-8').includes('musl')
+  } catch {
+    return null
+  }
+}
+
+const isMuslFromReport = () => {
+  let report = null
+  if (process.report && typeof process.report.getReport === 'function') {
+    process.report.excludeNetwork = true
+    report = process.report.getReport()
+  }
+  if (!report) {
+    return null
+  }
+  if (report.header && report.header.glibcVersionRuntime) {
+    return false
+  }
+  if (Array.isArray(report.sharedObjects)) {
+    if (report.sharedObjects.some(isFileMusl)) {
+      return true
+    }
+  }
+  return false
+}
+
+const isMuslFromChildProcess = () => {
+  try {
+    return require('child_process').execSync('ldd --version', { encoding: 'utf8' }).includes('musl')
+  } catch (e) {
+    // If we reach this case, we don't know if the system is musl or not, so is better to just fallback to false
+    return false
+  }
+}
+
+function requireNative() {
+  if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) {
+    try {
+      return require(process.env.NAPI_RS_NATIVE_LIBRARY_PATH);
+    } catch (err) {
+      loadErrors.push(err)
+    }
+  } else if (process.platform === 'android') {
+    if (process.arch === 'arm64') {
+      try {
+        return require('./vowifi-node.android-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@vowifi-rs/vowifi-android-arm64')
+        const bindingPackageVersion = require('@vowifi-rs/vowifi-android-arm64/package.json').version
+        if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm') {
+      try {
+        return require('./vowifi-node.android-arm-eabi.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@vowifi-rs/vowifi-android-arm-eabi')
+        const bindingPackageVersion = require('@vowifi-rs/vowifi-android-arm-eabi/package.json').version
+        if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Android ${process.arch}`))
+    }
+  } else if (process.platform === 'win32') {
+    if (process.arch === 'x64') {
+      if ((process.config && process.config.variables && process.config.variables.shlib_suffix === 'dll.a') || (process.config && process.config.variables && process.config.variables.node_target_type === 'shared_library')) {
+        try {
+        return require('./vowifi-node.win32-x64-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@vowifi-rs/vowifi-win32-x64-gnu')
+        const bindingPackageVersion = require('@vowifi-rs/vowifi-win32-x64-gnu/package.json').version
+        if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      } else {
+        try {
+        return require('./vowifi-node.win32-x64-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@vowifi-rs/vowifi-win32-x64-msvc')
+        const bindingPackageVersion = require('@vowifi-rs/vowifi-win32-x64-msvc/package.json').version
+        if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      }
+    } else if (process.arch === 'ia32') {
+      try {
+        return require('./vowifi-node.win32-ia32-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@vowifi-rs/vowifi-win32-ia32-msvc')
+        const bindingPackageVersion = require('@vowifi-rs/vowifi-win32-ia32-msvc/package.json').version
+        if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./vowifi-node.win32-arm64-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@vowifi-rs/vowifi-win32-arm64-msvc')
+        const bindingPackageVersion = require('@vowifi-rs/vowifi-win32-arm64-msvc/package.json').version
+        if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Windows: ${process.arch}`))
+    }
+  } else if (process.platform === 'darwin') {
+    try {
+      return require('./vowifi-node.darwin-universal.node')
+    } catch (e) {
+      loadErrors.push(e)
+    }
+    try {
+      const binding = require('@vowifi-rs/vowifi-darwin-universal')
+      const bindingPackageVersion = require('@vowifi-rs/vowifi-darwin-universal/package.json').version
+      if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+        throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+      }
+      return binding
+    } catch (e) {
+      loadErrors.push(e)
+    }
+    if (process.arch === 'x64') {
+      try {
+        return require('./vowifi-node.darwin-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@vowifi-rs/vowifi-darwin-x64')
+        const bindingPackageVersion = require('@vowifi-rs/vowifi-darwin-x64/package.json').version
+        if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./vowifi-node.darwin-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@vowifi-rs/vowifi-darwin-arm64')
+        const bindingPackageVersion = require('@vowifi-rs/vowifi-darwin-arm64/package.json').version
+        if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on macOS: ${process.arch}`))
+    }
+  } else if (process.platform === 'freebsd') {
+    if (process.arch === 'x64') {
+      try {
+        return require('./vowifi-node.freebsd-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@vowifi-rs/vowifi-freebsd-x64')
+        const bindingPackageVersion = require('@vowifi-rs/vowifi-freebsd-x64/package.json').version
+        if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./vowifi-node.freebsd-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@vowifi-rs/vowifi-freebsd-arm64')
+        const bindingPackageVersion = require('@vowifi-rs/vowifi-freebsd-arm64/package.json').version
+        if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on FreeBSD: ${process.arch}`))
+    }
+  } else if (process.platform === 'linux') {
+    if (process.arch === 'x64') {
+      if (isMusl()) {
+        try {
+          return require('./vowifi-node.linux-x64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@vowifi-rs/vowifi-linux-x64-musl')
+          const bindingPackageVersion = require('@vowifi-rs/vowifi-linux-x64-musl/package.json').version
+          if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./vowifi-node.linux-x64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@vowifi-rs/vowifi-linux-x64-gnu')
+          const bindingPackageVersion = require('@vowifi-rs/vowifi-linux-x64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'arm64') {
+      if (isMusl()) {
+        try {
+          return require('./vowifi-node.linux-arm64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@vowifi-rs/vowifi-linux-arm64-musl')
+          const bindingPackageVersion = require('@vowifi-rs/vowifi-linux-arm64-musl/package.json').version
+          if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./vowifi-node.linux-arm64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@vowifi-rs/vowifi-linux-arm64-gnu')
+          const bindingPackageVersion = require('@vowifi-rs/vowifi-linux-arm64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'arm') {
+      if (isMusl()) {
+        try {
+          return require('./vowifi-node.linux-arm-musleabihf.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@vowifi-rs/vowifi-linux-arm-musleabihf')
+          const bindingPackageVersion = require('@vowifi-rs/vowifi-linux-arm-musleabihf/package.json').version
+          if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./vowifi-node.linux-arm-gnueabihf.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@vowifi-rs/vowifi-linux-arm-gnueabihf')
+          const bindingPackageVersion = require('@vowifi-rs/vowifi-linux-arm-gnueabihf/package.json').version
+          if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'loong64') {
+      if (isMusl()) {
+        try {
+          return require('./vowifi-node.linux-loong64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@vowifi-rs/vowifi-linux-loong64-musl')
+          const bindingPackageVersion = require('@vowifi-rs/vowifi-linux-loong64-musl/package.json').version
+          if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./vowifi-node.linux-loong64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@vowifi-rs/vowifi-linux-loong64-gnu')
+          const bindingPackageVersion = require('@vowifi-rs/vowifi-linux-loong64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'riscv64') {
+      if (isMusl()) {
+        try {
+          return require('./vowifi-node.linux-riscv64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@vowifi-rs/vowifi-linux-riscv64-musl')
+          const bindingPackageVersion = require('@vowifi-rs/vowifi-linux-riscv64-musl/package.json').version
+          if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./vowifi-node.linux-riscv64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@vowifi-rs/vowifi-linux-riscv64-gnu')
+          const bindingPackageVersion = require('@vowifi-rs/vowifi-linux-riscv64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'ppc64') {
+      try {
+        return require('./vowifi-node.linux-ppc64-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@vowifi-rs/vowifi-linux-ppc64-gnu')
+        const bindingPackageVersion = require('@vowifi-rs/vowifi-linux-ppc64-gnu/package.json').version
+        if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 's390x') {
+      try {
+        return require('./vowifi-node.linux-s390x-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@vowifi-rs/vowifi-linux-s390x-gnu')
+        const bindingPackageVersion = require('@vowifi-rs/vowifi-linux-s390x-gnu/package.json').version
+        if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Linux: ${process.arch}`))
+    }
+  } else if (process.platform === 'openharmony') {
+    if (process.arch === 'arm64') {
+      try {
+        return require('./vowifi-node.openharmony-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@vowifi-rs/vowifi-openharmony-arm64')
+        const bindingPackageVersion = require('@vowifi-rs/vowifi-openharmony-arm64/package.json').version
+        if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'x64') {
+      try {
+        return require('./vowifi-node.openharmony-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@vowifi-rs/vowifi-openharmony-x64')
+        const bindingPackageVersion = require('@vowifi-rs/vowifi-openharmony-x64/package.json').version
+        if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm') {
+      try {
+        return require('./vowifi-node.openharmony-arm.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@vowifi-rs/vowifi-openharmony-arm')
+        const bindingPackageVersion = require('@vowifi-rs/vowifi-openharmony-arm/package.json').version
+        if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on OpenHarmony: ${process.arch}`))
+    }
+  } else {
+    loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`))
+  }
+}
+
+function createLoadErrorChain(errors) {
+  return errors.reduce((previous, current) => {
+    let message
+    try {
+      message =
+        current && typeof current.message === 'string'
+          ? current.message
+          : String(current)
+    } catch {
+      message = 'Unknown error'
+    }
+    const error = new Error(message)
+    error.cause = previous
+    return error
+  }, null)
+}
+
+// NAPI_RS_FORCE_WASI is a tri-state flag:
+//   unset / any other value → native binding preferred, WASI is only a fallback
+//   'true'                   → prefer WASI, but retain native as a lazy fallback
+//   'error'                  → require WASI without initializing a native fallback
+// Treating any non-empty string as truthy (the historical behavior) meant
+// NAPI_RS_FORCE_WASI=false, NAPI_RS_FORCE_WASI=0, etc. inadvertently triggered
+// the WASI path, causing ENOENT for packages shipped without a .wasi.cjs file.
+//
+// NAPI_RS_WASI_FLAVOR selects one exact generated flavor and implies strict
+// WASI loading. It never crosses into another flavor or falls back to native.
+const __napiWasiFlavors = ["wasm32-wasi"]
+const __napiWasiFlavor = process.env.NAPI_RS_WASI_FLAVOR
+const __napiWasiFlavorRequested =
+  typeof __napiWasiFlavor === 'string' && __napiWasiFlavor.length > 0
+if (
+  __napiWasiFlavorRequested &&
+  __napiWasiFlavors.indexOf(__napiWasiFlavor) === -1
+) {
+  throw new Error(
+    'Unsupported WASI flavor "' +
+      __napiWasiFlavor +
+      '". Available flavors: ' +
+      __napiWasiFlavors.join(', '),
+  )
+}
+const forceWasiError = process.env.NAPI_RS_FORCE_WASI === 'error'
+const forceWasi =
+  process.env.NAPI_RS_FORCE_WASI === 'true' ||
+  forceWasiError ||
+  __napiWasiFlavorRequested
+
+if (!forceWasi) {
+  nativeBinding = requireNative()
+}
+
+if (!nativeBinding || forceWasi) {
+  let wasiBinding = null
+  let wasiBindingLoaded = false
+  const wasiBindingErrors = []
+  const __napiWasiResolveCandidate = (specifier, isPackage, localArtifacts) => {
+    try {
+      require.resolve(specifier)
+    } catch (resolveError) {
+      if (!resolveError || resolveError.code !== 'MODULE_NOT_FOUND') {
+        throw resolveError
+      }
+      if (isPackage) {
+        try {
+          require.resolve(specifier + '/package.json')
+        } catch (packageError) {
+          if (packageError && packageError.code === 'MODULE_NOT_FOUND') {
+            return resolveError
+          }
+          // An exports restriction proves the package exists even when its
+          // package.json is not public. Preserve the root resolution failure.
+          throw resolveError
+        }
+        // The package exists but its main/export target is broken.
+        throw resolveError
+      }
+      return resolveError
+    }
+    if (localArtifacts) {
+      let artifactError = null
+      for (let i = 0; i < localArtifacts.length; i++) {
+        try {
+          require.resolve(localArtifacts[i])
+          return null
+        } catch (resolveError) {
+          if (!resolveError || resolveError.code !== 'MODULE_NOT_FOUND') {
+            throw resolveError
+          }
+          artifactError = resolveError
+        }
+      }
+      return artifactError
+    }
+    return null
+  }
+  if (!wasiBindingLoaded && (!__napiWasiFlavorRequested || __napiWasiFlavor === "wasm32-wasi")) {
+    let candidateError = null
+    let candidateFailed = false
+    try {
+      candidateError = __napiWasiResolveCandidate('./vowifi-node.wasi.cjs', false, ["./vowifi-node.wasm32-wasi.debug.wasm","./vowifi-node.wasm32-wasi.wasm"])
+      candidateFailed = candidateError !== null
+      if (!candidateFailed) {
+        wasiBinding = require('./vowifi-node.wasi.cjs')
+        nativeBinding = wasiBinding
+        wasiBindingLoaded = true
+      }
+    } catch (err) {
+      candidateError = err
+      candidateFailed = true
+    }
+    if (candidateFailed) {
+      wasiBindingErrors.push(candidateError)
+      loadErrors.push(candidateError)
+    }
+  }
+  if (!wasiBindingLoaded && (!__napiWasiFlavorRequested || __napiWasiFlavor === "wasm32-wasi")) {
+    let candidateError = null
+    let candidateFailed = false
+    try {
+      candidateError = __napiWasiResolveCandidate('@vowifi-rs/vowifi-wasm32-wasi', true, undefined)
+      candidateFailed = candidateError !== null
+      if (!candidateFailed) {
+        if (process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          const bindingPackageVersion = require('@vowifi-rs/vowifi-wasm32-wasi/package.json').version
+          if (bindingPackageVersion !== '0.1.0') {
+            throw new Error(`WASI binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+        }
+        wasiBinding = require('@vowifi-rs/vowifi-wasm32-wasi')
+        nativeBinding = wasiBinding
+        wasiBindingLoaded = true
+      }
+    } catch (err) {
+      candidateError = err
+      candidateFailed = true
+    }
+    if (candidateFailed) {
+      wasiBindingErrors.push(candidateError)
+      loadErrors.push(candidateError)
+    }
+  }
+  if (
+    !wasiBindingLoaded &&
+    forceWasi &&
+    !forceWasiError &&
+    !__napiWasiFlavorRequested
+  ) {
+    nativeBinding = requireNative()
+  }
+  if ((forceWasiError || __napiWasiFlavorRequested) && !wasiBindingLoaded) {
+    const error = new Error(
+      __napiWasiFlavorRequested
+        ? 'WASI binding for flavor "' + __napiWasiFlavor + '" not found'
+        : 'WASI binding not found and NAPI_RS_FORCE_WASI is set to error',
+    )
+    error.cause = createLoadErrorChain(wasiBindingErrors)
+    throw error
+  }
+}
+
+if (!nativeBinding) {
+  if (loadErrors.length > 0) {
+    const error = new Error(
+      `Cannot find native binding. ` +
+        `npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). ` +
+        'Please try `npm i` again after removing both package-lock.json and node_modules directory.',
+    )
+    // assign instead of the `new Error(message, { cause })` options form,
+    // which Node < 16.9 silently ignores
+    error.cause = createLoadErrorChain(loadErrors)
+    throw error
+  }
+  throw new Error(`Failed to load native binding`)
+}
+
+module.exports = nativeBinding
+module.exports.NodeVowifiSession = nativeBinding.NodeVowifiSession
+module.exports.initLogging = nativeBinding.initLogging
+module.exports.resolveCarrierProfile = nativeBinding.resolveCarrierProfile

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@vowifi-rs/vowifi",
+  "version": "0.1.6",
+  "description": "Hardware-independent VoWiFi SMS session for Node.js",
+  "license": "MIT OR Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fullstackoverflow/vowifi-rs.git",
+    "directory": "packages/vowifi-node"
+  },
+  "bugs": {
+    "url": "https://github.com/fullstackoverflow/vowifi-rs/issues"
+  },
+  "homepage": "https://github.com/fullstackoverflow/vowifi-rs#readme",
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "index.js",
+  "types": "index.d.ts",
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "native.js",
+    "native.d.ts",
+    "*.node"
+  ],
+  "scripts": {
+    "build": "napi build --platform --js native.js --dts native.d.ts",
+    "build:release": "napi build --platform --release --js native.js --dts native.d.ts",
+    "prepublishOnly": "napi prepublish -t npm --no-gh-release",
+    "test": "node --test test/*.test.js"
+  },
+  "devDependencies": {
+    "@napi-rs/cli": "^3.4.1",
+    "serialport": "^13.0.0"
+  },
+  "napi": {
+    "binaryName": "vowifi-node",
+    "targets": [
+      "x86_64-pc-windows-msvc",
+      "x86_64-unknown-linux-gnu",
+      "aarch64-unknown-linux-gnu"
+    ]
+  },
+  "optionalDependencies": {
+    "@vowifi-rs/vowifi-win32-x64-msvc": "0.1.6",
+    "@vowifi-rs/vowifi-linux-x64-gnu": "0.1.6",
+    "@vowifi-rs/vowifi-linux-arm64-gnu": "0.1.6"
+  }
+}