faceliveness 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,176 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS

package/README.md

@@ -1,3 +1,145 @@
-# Temporary Holding Version
+# faceliveness
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+On-device face liveness checks for Node.js. The user is asked to do a few random actions
+(blink, turn left, turn right, open mouth) in front of the camera, and the check passes only
+if they do them in order. Face detection and landmarks run inside the package (MediaPipe's
+face models on a Rust core): no native dependencies to install and no cloud service.
+
+```bash
+npm install faceliveness
+```
+
+Node.js 22+, prebuilt for Linux (x64, arm64), macOS (Intel, Apple Silicon) and Windows x64.
+Fully typed.
+
+## Quick start
+
+```ts
+import { Engine } from 'faceliveness'
+
+const engine = Engine.random(3) // e.g. ['turn_left', 'blink', 'open_mouth']
+
+// For each camera frame (raw RGB bytes, e.g. from ffmpeg or a decoded WebRTC frame):
+const result = await engine.processAsync(frame, { width: 640, height: 480, timestampMs })
+
+if (result.done) {
+  console.log('liveness:', result.status, result.failReason ?? '')
+} else {
+  console.log('please:', result.currentChallenge)
+}
+```
+
+`processAsync` runs on Node's worker pool so your server stays responsive; await each call
+before sending the next frame. `process` is the synchronous version.
+
+## API
+
+### `new Engine(challenges, options?)` / `Engine.random(count, options?)`
+
+One liveness attempt. Challenges are `'blink' | 'turn_left' | 'turn_right' | 'open_mouth'`.
+`Engine.random` picks them in an unpredictable order (from OS randomness), which is what you
+want in production so attempts can't be pre-recorded.
+
+Options: `totalTimeoutMs` (30000), `stepTimeoutMs` (10000), `faceLostMs` (1000),
+`minRealScore` (fail a completed session whose mean `realScore` is below it; off by default,
+calibrate first) and `seed` (a `bigint`, for tests only).
+
+### `engine.process(frame, options)` / `engine.processAsync(frame, options)`
+
+- `frame`: `Buffer` or `Uint8Array` of pixels.
+- `options`: `{ width, height, timestampMs, format?, stride?, rotation?, mirrored? }`
+  - `format`: `'rgb'` (default), `'bgr'`, `'rgba'`, `'bgra'` or `'nv21'`
+  - `rotation`: clockwise degrees (0/90/180/270) that turn the frame upright
+  - `mirrored`: `true` for selfie-preview frames, so "left" still means the user's left
+
+### `FrameResult`
+
+| Field | |
+|---|---|
+| `status` | `'in_progress'`, `'passed'` or `'failed'` |
+| `done` | `true` once passed or failed (it won't change after that) |
+| `currentChallenge`, `remaining` | what to ask the user for now, and how many are left |
+| `failReason` | `'timeout'`, `'step_timeout'`, `'face_lost'`, `'multiple_faces'` or `'spoof_suspected'` |
+| `actions` | actions recognised in this frame |
+| `faceCount`, `faces` | faces in view and their boxes |
+| `signals` | `ear` (eye openness), `mouth` (mouth openness), `yaw` (head turn) |
+| `landmarks` | 478 face-mesh points `[x, y]` of the main face |
+| `realScore` | passive anti-spoofing: 0-1 probability the face is real, not a photo or screen (measured on every 3rd frame with a face, otherwise empty) |
+
+### `new Session(challenges, options?)` and `session.update(timestampMs, { faceCount?, ear?, mouth?, yaw? })`
+
+The same challenge logic without image processing, for when you already compute face
+measurements yourself (for example with MediaPipe in the browser).
+
+## Server-side tickets and receipts
+
+A result computed on the user's device can't be trusted. Run the engine on your server and let
+other services check a signed receipt:
+
+```ts
+import { Engine, SigningKey, verifyReceipt } from 'faceliveness'
+
+const key = SigningKey.generate() // once; store key.toBytes() as a secret
+const ticket = key.issueTicket({ count: 3 }) // signed JWT: random challenges, 2 min expiry
+
+const engine = Engine.fromTicket(ticket, key.publicKey)
+// ... await engine.processAsync(frame, ...) for each frame the client streams, until done ...
+const receipt = engine.receipt(key) // signed JWT with the outcome and a frame hash
+
+// Any other service, with only the public key:
+const r = verifyReceipt(receipt, key.publicKey)
+if (r.passed && !alreadyUsed(r.nonce)) {
+  // accept each nonce once
+}
+```
+
+Tickets and receipts are standard Ed25519 (`EdDSA`) JWTs, so any JWT library can verify them.
+
+## Face record for matching
+
+Each session keeps its best face: the frame that is most frontal, eyes open, mouth closed,
+sharp, well lit and large enough, aligned to the standard 112x112 template most
+face-recognition models expect (ArcFace, SFace, MobileFaceNet...). Pass `captureSize` in the
+options for another size.
+
+```ts
+const c = engine.capture() // FaceCapture | null
+c.png // aligned face as a PNG Buffer: store/send these exact bytes
+c.quality // 0-1; below ~0.3 matching will be unreliable
+c.rgb // raw RGB pixels, c.size x c.size x 3
+```
+
+The signed receipt records `faceSha256` (the PNG's hash) and `faceQuality`, so liveness and the
+face record are one signed fact. In your face-matching service, accept a face only like this:
+
+```ts
+const r = verifyFaceRecord(receipt, publicKey, facePng)
+// throws unless: genuine and unexpired receipt, session passed, and facePng is the exact image
+// the receipt vouches for. Then also reject a nonce you've seen before.
+```
+
+This stops someone from passing liveness with their own face and then submitting a photo of
+someone else for matching.
+
+## Security notes
+
+- Challenge-response stops printed photos (they can't blink, and tilting one doesn't count as a
+  head turn) and makes pre-recorded video unlikely to match. It does not stop a live deepfake
+  or an injected virtual camera.
+- `realScore` is uncalibrated for your cameras, so it is only reported by default. Record
+  genuine and attack videos and run `tools/calibrate_spoof.py` before setting `minRealScore`.
+- Full details: [threat model](https://github.com/wiseman-umanah/Face-Liveness/blob/master/docs/threat-model.md).
+
+## Develop
+
+```bash
+pnpm install
+pnpm build   # native addon (faceliveness.<platform>.node) + index.d.ts
+pnpm test
+pnpm bench
+```
+
+## License
+
+Apache-2.0. Bundles MediaPipe face models (Apache-2.0); see
+[models/README.md](https://github.com/wiseman-umanah/Face-Liveness/blob/master/crates/liveness-core/models/README.md).

package/index.d.ts

@@ -0,0 +1,225 @@
+/* auto-generated by NAPI-RS; edit src/lib.rs or types-header.d.ts instead */
+/* eslint-disable */
+
+export type Challenge = 'blink' | 'turn_left' | 'turn_right' | 'open_mouth'
+export type PixelFormat = 'rgb' | 'bgr' | 'rgba' | 'bgra' | 'nv21'
+export type LivenessStatus = 'in_progress' | 'passed' | 'failed'
+export type FailReason = 'timeout' | 'step_timeout' | 'face_lost' | 'multiple_faces' | 'spoof_suspected'
+/**
+ * Frames in, liveness verdict out: face detection, landmarks and the challenge flow.
+ * One engine is one liveness attempt; create a new one per attempt.
+ */
+export declare class Engine {
+  constructor(challenges: Challenge[], options?: SessionOptions | undefined | null)
+  /** `count` challenges in random order. */
+  static random(count: number, options?: SessionOptions | undefined | null): Engine
+  /**
+   * A session for a ticket from `SigningKey.issueTicket`. Throws if the ticket is forged,
+   * signed by another key, or expired. Every frame is hashed into the receipt.
+   */
+  static fromTicket(token: string, publicKey: Uint8Array, options?: SessionOptions | undefined | null): Engine
+  /**
+   * Signed receipt (JWT) for a finished ticketed session, for other services to check with
+   * `verifyReceipt`. Throws if the session isn't finished or the ticket has expired.
+   */
+  receipt(signingKey: SigningKey, options?: ReceiptOptions | undefined | null): string
+  /**
+   * The best face of the session so far, aligned for face matching, or null if no single
+   * face was seen. Send `png` with the receipt to your matching service, which checks both
+   * with `verifyFaceRecord`.
+   */
+  capture(): FaceCapture | null
+  get challenges(): Challenge[]
+  /** Processes one frame on the calling thread (blocks for the inference time). */
+  process(frame: Uint8Array, options: FrameOptions): FrameResult
+  /**
+   * Processes one frame on Node's worker pool, keeping the event loop free.
+   * Await each call before sending the next frame.
+   */
+  processAsync(frame: Uint8Array, options: FrameOptions): Promise<FrameResult>
+}
+
+/** Liveness decisions from measurements you compute yourself (no image processing). */
+export declare class Session {
+  constructor(challenges: Challenge[], options?: SessionOptions | undefined | null)
+  static random(count: number, options?: SessionOptions | undefined | null): Session
+  get challenges(): Challenge[]
+  /** One frame: how many faces are visible, and the main face's measurements if known. */
+  update(timestampMs: number, observation?: Observation | undefined | null): FrameResult
+}
+
+/** Ed25519 key for issuing tickets and signing receipts. Keep it on your server. */
+export declare class SigningKey {
+  /** A new random key. */
+  static generate(): SigningKey
+  /** Loads a key saved with `toBytes()` (32 bytes). */
+  static fromBytes(secret: Uint8Array): SigningKey
+  /** The 32-byte secret: store it like a password. */
+  toBytes(): Buffer
+  /** The 32-byte public key, for verifying tickets and receipts. */
+  get publicKey(): Buffer
+  /** A signed ticket (JWT). */
+  issueTicket(options?: TicketOptions | undefined | null): string
+}
+
+/** A detected face in upright pixel coordinates. */
+export interface FaceBox {
+  x: number
+  y: number
+  width: number
+  height: number
+  score: number
+}
+
+/** The best face of a liveness session, aligned for face matching. */
+export interface FaceCapture {
+  /** The aligned face as PNG: store and send these exact bytes. */
+  png: Buffer
+  /** The same image as raw RGB bytes (size * size * 3). */
+  rgb: Buffer
+  size: number
+  /** 0-1 suitability for matching (frontal, eyes open, mouth closed, sharp, well lit). */
+  quality: number
+  timestampMs: number
+  /** Hex SHA-256 of `png`, as recorded in the receipt. */
+  sha256: string
+}
+
+export interface FrameOptions {
+  width: number
+  height: number
+  /** Capture time in milliseconds; drives every timeout. */
+  timestampMs: number
+  /** Default 'rgb' (3 bytes per pixel). */
+  format?: PixelFormat
+  /** Bytes per row; defaults to width x bytes per pixel. */
+  stride?: number
+  /** Clockwise degrees (0, 90, 180, 270) that turn the frame upright. */
+  rotation?: number
+  /** True for selfie-style mirrored frames. */
+  mirrored?: boolean
+}
+
+export interface FrameResult {
+  status: LivenessStatus
+  /** True once passed or failed; later frames won't change the outcome. */
+  done: boolean
+  /** What the user should do now, while in progress. */
+  currentChallenge?: Challenge
+  /** Challenges left including the current one, while in progress. */
+  remaining: number
+  failReason?: FailReason
+  /** Actions recognised in this frame. */
+  actions: Challenge[]
+  faceCount: number
+  signals?: Signals
+  /** Empty for `Session.update`. */
+  faces: Array<FaceBox>
+  /** 478 face-mesh landmarks [x, y] of the primary face, in upright pixels. */
+  landmarks?: Array<[number, number]>
+  /**
+   * Passive anti-spoofing: probability (0-1) that the face is real rather than a photo or
+   * screen. Measured on every 3rd frame with a face (absent otherwise); uncalibrated for
+   * your cameras.
+   */
+  realScore?: number
+}
+
+export interface Observation {
+  /** Faces in view (default 1). */
+  faceCount?: number
+  ear?: number
+  mouth?: number
+  yaw?: number
+}
+
+/** A verified liveness receipt. */
+export interface Receipt {
+  /** The ticket's nonce: accept each nonce only once. */
+  nonce: string
+  challenges: Challenge[]
+  passed: boolean
+  failReason?: FailReason
+  frames: number
+  framesSha256: string
+  realScore?: number
+  /** Hex SHA-256 of the session's face record PNG, if a face was captured. */
+  faceSha256?: string
+  faceQuality?: number
+  issuedAt: number
+  expiresAt: number
+}
+
+export interface ReceiptOptions {
+  /** How long the receipt stays valid (default 300). */
+  ttlSecs?: number
+  /** Current Unix time in seconds (default: the system clock). */
+  now?: number
+}
+
+export interface SessionOptions {
+  /** Fail if the whole check takes longer than this (default 30000). */
+  totalTimeoutMs?: number
+  /** Fail if one challenge takes longer than this (default 10000). */
+  stepTimeoutMs?: number
+  /** Fail if the face is out of view longer than this (default 1000). */
+  faceLostMs?: number
+  /**
+   * If set, a session that completes its challenges still fails with 'spoof_suspected'
+   * when the mean anti-spoofing score is below it. Off by default: calibrate on your own
+   * cameras first (see `FrameResult.realScore`).
+   */
+  minRealScore?: number
+  /** For `Engine.fromTicket`: current Unix time in seconds (default: the system clock). */
+  now?: number
+  /** Side of the face record crop, `engine.capture()` (default 112; 32-512). */
+  captureSize?: number
+  /**
+   * Only for `random`: fixes the challenge order. Leave unset in production so the
+   * order comes from the OS and can't be predicted (and pre-recorded).
+   */
+  seed?: bigint
+}
+
+export interface Signals {
+  /** Eye aspect ratio: ~0.25-0.35 open, drops sharply during a blink. */
+  ear: number
+  /** Inner-lip height / width: ~0.05 closed, >0.4 wide open. */
+  mouth: number
+  /** Nose position between the face edges: ~0.5 facing the camera. */
+  yaw: number
+}
+
+/** A verified challenge ticket. */
+export interface Ticket {
+  nonce: string
+  challenges: Challenge[]
+  issuedAt: number
+  expiresAt: number
+}
+
+export interface TicketOptions {
+  /** Challenges to ask for; default: `count` random ones. */
+  challenges?: Challenge[]
+  /** Number of random challenges when `challenges` is not given (default 3). */
+  count?: number
+  /** How long the ticket stays valid (default 120). */
+  ttlSecs?: number
+  /** Current Unix time in seconds (default: the system clock). */
+  now?: number
+}
+
+/**
+ * For the face-matching service: checks the receipt (signature, expiry), that the session
+ * passed, and that `facePng` is exactly the face record it vouches for; throws otherwise.
+ * Accept each nonce only once.
+ */
+export declare function verifyFaceRecord(token: string, publicKey: Uint8Array, facePng: Uint8Array, now?: number | undefined | null): Receipt
+
+/** Checks a receipt's signature and expiry; throws if invalid. `now` is Unix seconds. */
+export declare function verifyReceipt(token: string, publicKey: Uint8Array, now?: number | undefined | null): Receipt
+
+/** Checks a ticket's signature and expiry; throws if invalid. `now` is Unix seconds. */
+export declare function verifyTicket(token: string, publicKey: Uint8Array, now?: number | undefined | null): Ticket
+
+export declare function version(): string

package/index.js

@@ -0,0 +1,709 @@
+// 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('./faceliveness.android-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('faceliveness-android-arm64')
+        const bindingPackageVersion = require('faceliveness-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('./faceliveness.android-arm-eabi.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('faceliveness-android-arm-eabi')
+        const bindingPackageVersion = require('faceliveness-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('./faceliveness.win32-x64-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('faceliveness-win32-x64-gnu')
+        const bindingPackageVersion = require('faceliveness-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('./faceliveness.win32-x64-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('faceliveness-win32-x64-msvc')
+        const bindingPackageVersion = require('faceliveness-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('./faceliveness.win32-ia32-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('faceliveness-win32-ia32-msvc')
+        const bindingPackageVersion = require('faceliveness-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('./faceliveness.win32-arm64-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('faceliveness-win32-arm64-msvc')
+        const bindingPackageVersion = require('faceliveness-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('./faceliveness.darwin-universal.node')
+    } catch (e) {
+      loadErrors.push(e)
+    }
+    try {
+      const binding = require('faceliveness-darwin-universal')
+      const bindingPackageVersion = require('faceliveness-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('./faceliveness.darwin-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('faceliveness-darwin-x64')
+        const bindingPackageVersion = require('faceliveness-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('./faceliveness.darwin-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('faceliveness-darwin-arm64')
+        const bindingPackageVersion = require('faceliveness-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('./faceliveness.freebsd-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('faceliveness-freebsd-x64')
+        const bindingPackageVersion = require('faceliveness-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('./faceliveness.freebsd-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('faceliveness-freebsd-arm64')
+        const bindingPackageVersion = require('faceliveness-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('./faceliveness.linux-x64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('faceliveness-linux-x64-musl')
+          const bindingPackageVersion = require('faceliveness-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('./faceliveness.linux-x64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('faceliveness-linux-x64-gnu')
+          const bindingPackageVersion = require('faceliveness-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('./faceliveness.linux-arm64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('faceliveness-linux-arm64-musl')
+          const bindingPackageVersion = require('faceliveness-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('./faceliveness.linux-arm64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('faceliveness-linux-arm64-gnu')
+          const bindingPackageVersion = require('faceliveness-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('./faceliveness.linux-arm-musleabihf.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('faceliveness-linux-arm-musleabihf')
+          const bindingPackageVersion = require('faceliveness-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('./faceliveness.linux-arm-gnueabihf.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('faceliveness-linux-arm-gnueabihf')
+          const bindingPackageVersion = require('faceliveness-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('./faceliveness.linux-loong64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('faceliveness-linux-loong64-musl')
+          const bindingPackageVersion = require('faceliveness-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('./faceliveness.linux-loong64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('faceliveness-linux-loong64-gnu')
+          const bindingPackageVersion = require('faceliveness-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('./faceliveness.linux-riscv64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('faceliveness-linux-riscv64-musl')
+          const bindingPackageVersion = require('faceliveness-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('./faceliveness.linux-riscv64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('faceliveness-linux-riscv64-gnu')
+          const bindingPackageVersion = require('faceliveness-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('./faceliveness.linux-ppc64-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('faceliveness-linux-ppc64-gnu')
+        const bindingPackageVersion = require('faceliveness-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('./faceliveness.linux-s390x-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('faceliveness-linux-s390x-gnu')
+        const bindingPackageVersion = require('faceliveness-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('./faceliveness.openharmony-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('faceliveness-openharmony-arm64')
+        const bindingPackageVersion = require('faceliveness-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('./faceliveness.openharmony-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('faceliveness-openharmony-x64')
+        const bindingPackageVersion = require('faceliveness-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('./faceliveness.openharmony-arm.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('faceliveness-openharmony-arm')
+        const bindingPackageVersion = require('faceliveness-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('./faceliveness.wasi.cjs', false, ["./faceliveness.wasm32-wasi.debug.wasm","./faceliveness.wasm32-wasi.wasm"])
+      candidateFailed = candidateError !== null
+      if (!candidateFailed) {
+        wasiBinding = require('./faceliveness.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('faceliveness-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('faceliveness-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('faceliveness-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.Engine = nativeBinding.Engine
+module.exports.Session = nativeBinding.Session
+module.exports.SigningKey = nativeBinding.SigningKey
+module.exports.verifyFaceRecord = nativeBinding.verifyFaceRecord
+module.exports.verifyReceipt = nativeBinding.verifyReceipt
+module.exports.verifyTicket = nativeBinding.verifyTicket
+module.exports.version = nativeBinding.version

package/package.json

@@ -1,6 +1,105 @@
 {
   "name": "faceliveness",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "On-device face liveness checks (blink, head turn, mouth open) powered by a Rust core",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wiseman-umanah/Face-Liveness.git",
+    "directory": "crates/liveness-node"
+  },
+  "license": "Apache-2.0",
+  "keywords": [
+    "face",
+    "liveness",
+    "anti-spoofing",
+    "biometrics",
+    "kyc",
+    "napi-rs",
+    "rust"
+  ],
+  "files": [
+    "index.d.ts",
+    "index.js"
+  ],
+  "napi": {
+    "binaryName": "faceliveness",
+    "targets": [
+      "x86_64-unknown-linux-gnu",
+      "aarch64-unknown-linux-gnu",
+      "x86_64-apple-darwin",
+      "aarch64-apple-darwin",
+      "x86_64-pc-windows-msvc"
+    ],
+    "dtsHeaderFile": "types-header.d.ts"
+  },
+  "engines": {
+    "node": ">= 22.14.0 < 23 || >= 23.6.0"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "scripts": {
+    "artifacts": "napi artifacts",
+    "bench": "node --import @oxc-node/core/register benchmark/bench.ts",
+    "build": "napi build --platform --release",
+    "build:debug": "napi build --platform",
+    "format": "run-p format:oxfmt format:rs",
+    "format:oxfmt": "oxfmt",
+    "format:rs": "cargo fmt",
+    "lint": "oxlint",
+    "prepublishOnly": "napi prepublish -t npm",
+    "test": "ava",
+    "version": "napi version"
+  },
+  "devDependencies": {
+    "@emnapi/core": "^2.0.0-alpha.4",
+    "@emnapi/runtime": "^2.0.0-alpha.4",
+    "@napi-rs/cli": "^3.8.6",
+    "@napi-rs/wasm-runtime": "^1.2.3",
+    "@oxc-node/core": "^0.1.0",
+    "ava": "^8.0.1",
+    "chalk": "^6.0.0",
+    "emnapi": "^2.0.0-alpha.4",
+    "husky": "^9.1.7",
+    "lint-staged": "^17.3.0",
+    "npm-run-all2": "^9.0.3",
+    "oxfmt": "^0.74.0",
+    "oxlint": "^1.79.0",
+    "prettier": "^3.9.6",
+    "tinybench": "^6.1.3",
+    "typescript": "^7.0.2"
+  },
+  "lint-staged": {
+    "*.@(js|ts|tsx)": [
+      "oxlint --fix"
+    ],
+    "*.@(js|ts|tsx|yml|yaml|md|json|toml)": [
+      "oxfmt --write"
+    ]
+  },
+  "ava": {
+    "extensions": [
+      "ts"
+    ],
+    "timeout": "2m",
+    "workerThreads": false,
+    "environmentVariables": {
+      "TS_NODE_PROJECT": "./tsconfig.json"
+    },
+    "nodeArguments": [
+      "--import",
+      "@oxc-node/core/register"
+    ]
+  },
+  "packageManager": "pnpm@12.15.0",
+  "optionalDependencies": {
+    "faceliveness-linux-x64-gnu": "0.1.0",
+    "faceliveness-linux-arm64-gnu": "0.1.0",
+    "faceliveness-darwin-x64": "0.1.0",
+    "faceliveness-darwin-arm64": "0.1.0",
+    "faceliveness-win32-x64-msvc": "0.1.0"
+  }
 }