cojson-core-napi 0.18.22

package/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright 2025, Garden Computing, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,346 @@
+# cojson-core-napi
+
+A high-performance Node.js native addon for cryptographic operations, built with Rust and NAPI. This package provides essential cryptographic primitives for the Jazz framework, including hashing, encryption, digital signatures, and key management.
+
+## Features
+
+- **BLAKE3 Hashing**: Fast, secure cryptographic hashing with incremental support
+- **Ed25519 Digital Signatures**: High-performance elliptic curve digital signatures
+- **X25519 Key Exchange**: Secure key exchange for encrypted communications
+- **XSalsa20 Encryption**: Stream cipher encryption with optional authentication
+- **Session Management**: Transaction logging and cryptographic session handling
+- **Cross-Platform**: Pre-built binaries for multiple platforms and architectures
+
+## Jazz Framework Integration
+
+This package is a core component of the Jazz framework, providing the cryptographic foundation for:
+
+- **CoJSON**: Collaborative JSON documents with cryptographic integrity
+- **Real-time Collaboration**: Secure peer-to-peer synchronization
+- **Authentication**: Cryptographic identity and session management
+- **End-to-End Encryption**: Secure data transmission and storage
+
+The package is used throughout the Jazz ecosystem by other packages like `cojson`, `jazz-tools`, and various examples in the monorepo.
+
+## Installation
+
+### In the Jazz Monorepo
+
+If you're working within the Jazz monorepo, the package is already available as a workspace dependency:
+
+```bash
+# From the monorepo root
+pnpm install
+
+# Build the NAPI package specifically
+pnpm run build:napi
+
+# Run tests for the NAPI package
+pnpm test:napi
+```
+
+### As a Standalone Package
+
+```bash
+pnpm install cojson-core-napi
+```
+
+The package includes pre-built binaries for the following platforms:
+- macOS (x64, ARM64)
+- Linux (x64, ARM64, ARM, musl)
+
+## API Reference
+
+### Hashing Functions
+
+#### `blake3HashOnce(data: Uint8Array): Uint8Array`
+
+Hash data once using BLAKE3. Returns 32 bytes of hash output.
+
+```typescript
+import { blake3HashOnce } from 'cojson-core-napi';
+
+const data = new TextEncoder().encode("Hello, World!");
+const hash = blake3HashOnce(data);
+console.log(hash.length); // 32
+```
+
+#### `blake3HashOnceWithContext(data: Uint8Array, context: Uint8Array): Uint8Array`
+
+Hash data with a context prefix for domain separation.
+
+```typescript
+import { blake3HashOnceWithContext } from 'cojson-core-napi';
+
+const data = new TextEncoder().encode("message");
+const context = new TextEncoder().encode("domain");
+const hash = blake3HashOnceWithContext(data, context);
+```
+
+#### `Blake3Hasher`
+
+Incremental hashing for large datasets.
+
+```typescript
+import { Blake3Hasher } from 'cojson-core-napi';
+
+const hasher = new Blake3Hasher();
+hasher.update(new TextEncoder().encode("part1"));
+hasher.update(new TextEncoder().encode("part2"));
+const hash = hasher.finalize();
+```
+
+### Digital Signatures (Ed25519)
+
+#### `newEd25519SigningKey(): Uint8Array`
+
+Generate a new Ed25519 signing key.
+
+```typescript
+import { newEd25519SigningKey, ed25519VerifyingKey, ed25519Sign, ed25519Verify } from 'cojson-core-napi';
+
+const signingKey = newEd25519SigningKey();
+const verifyingKey = ed25519VerifyingKey(signingKey);
+
+const message = new TextEncoder().encode("Hello, World!");
+const signature = ed25519Sign(signingKey, message);
+const isValid = ed25519Verify(verifyingKey, message, signature);
+```
+
+#### Key Management Functions
+
+- `ed25519SigningKeyFromBytes(bytes: Uint8Array): Uint8Array` - Validate and copy signing key bytes
+- `ed25519VerifyingKeyFromBytes(bytes: Uint8Array): Uint8Array` - Validate and copy verifying key bytes
+- `ed25519SignatureFromBytes(bytes: Uint8Array): Uint8Array` - Validate and copy signature bytes
+- `ed25519SigningKeyToPublic(signingKey: Uint8Array): Uint8Array` - Derive public key from signing key
+- `ed25519SigningKeySign(signingKey: Uint8Array, message: Uint8Array): Uint8Array` - Sign with signing key
+
+### Key Exchange (X25519)
+
+#### `newX25519PrivateKey(): Uint8Array`
+
+Generate a new X25519 private key.
+
+```typescript
+import { newX25519PrivateKey, x25519PublicKey, x25519DiffieHellman } from 'cojson-core-napi';
+
+const alicePrivate = newX25519PrivateKey();
+const alicePublic = x25519PublicKey(alicePrivate);
+
+const bobPrivate = newX25519PrivateKey();
+const bobPublic = x25519PublicKey(bobPrivate);
+
+// Perform key exchange
+const aliceShared = x25519DiffieHellman(alicePrivate, bobPublic);
+const bobShared = x25519DiffieHellman(bobPrivate, alicePublic);
+// aliceShared and bobShared are identical
+```
+
+### Encryption Functions
+
+#### `encrypt(value: Uint8Array, keySecret: string, nonceMaterial: Uint8Array): Uint8Array`
+#### `decrypt(ciphertext: Uint8Array, keySecret: string, nonceMaterial: Uint8Array): Uint8Array`
+
+Encrypt/decrypt data with a key secret and nonce material.
+
+```typescript
+import { encrypt, decrypt } from 'cojson-core-napi';
+
+const keySecret = "keySecret_z11111111111111111111111111111111"; // Base58-encoded key
+const nonceMaterial = new TextEncoder().encode("nonce");
+const plaintext = new TextEncoder().encode("Secret message");
+
+const ciphertext = encrypt(plaintext, keySecret, nonceMaterial);
+const decrypted = decrypt(ciphertext, keySecret, nonceMaterial);
+```
+
+#### `encryptXsalsa20(key: Uint8Array, nonceMaterial: Uint8Array, plaintext: Uint8Array): Uint8Array`
+#### `decryptXsalsa20(key: Uint8Array, nonceMaterial: Uint8Array, ciphertext: Uint8Array): Uint8Array`
+
+XSalsa20 stream cipher encryption (without authentication).
+
+```typescript
+import { encryptXsalsa20, decryptXsalsa20 } from 'cojson-core-napi';
+
+const key = new Uint8Array(32); // 32-byte key
+const nonceMaterial = new TextEncoder().encode("nonce");
+const plaintext = new TextEncoder().encode("Message");
+
+const ciphertext = encryptXsalsa20(key, nonceMaterial, plaintext);
+const decrypted = decryptXsalsa20(key, nonceMaterial, ciphertext);
+```
+
+### Sealing/Unsealing (Authenticated Encryption)
+
+#### `seal(message: Uint8Array, senderSecret: string, recipientId: string, nonceMaterial: Uint8Array): Uint8Array`
+#### `unseal(sealedMessage: Uint8Array, recipientSecret: string, senderId: string, nonceMaterial: Uint8Array): Uint8Array`
+
+Authenticated encryption with perfect forward secrecy using X25519 + XSalsa20-Poly1305.
+
+```typescript
+import { seal, unseal, getSealerId } from 'cojson-core-napi';
+
+const senderSecret = "sealerSecret_z..."; // Base58-encoded private key
+const recipientId = "sealer_z..."; // Base58-encoded public key
+const nonceMaterial = new TextEncoder().encode("nonce");
+const message = new TextEncoder().encode("Secret message");
+
+const sealed = seal(message, senderSecret, recipientId, nonceMaterial);
+const unsealed = unseal(sealed, senderSecret, recipientId, nonceMaterial);
+```
+
+### Signing/Verification (Base58-wrapped)
+
+#### `sign(message: Uint8Array, secret: Uint8Array): string`
+#### `verify(signature: Uint8Array, message: Uint8Array, id: Uint8Array): boolean`
+
+Sign and verify messages with base58-encoded signatures and IDs.
+
+```typescript
+import { sign, verify, getSignerId } from 'cojson-core-napi';
+
+const secret = new TextEncoder().encode("signerSecret_z...");
+const message = new TextEncoder().encode("Hello, World!");
+
+const signature = sign(message, secret);
+const isValid = verify(new TextEncoder().encode(signature), message, new TextEncoder().encode("signer_z..."));
+```
+
+### Utility Functions
+
+#### `generateNonce(nonceMaterial: Uint8Array): Uint8Array`
+
+Generate a 24-byte nonce from input material using BLAKE3.
+
+```typescript
+import { generateNonce } from 'cojson-core-napi';
+
+const nonceMaterial = new TextEncoder().encode("input");
+const nonce = generateNonce(nonceMaterial);
+console.log(nonce.length); // 24
+```
+
+#### `getSealerId(secret: Uint8Array): string`
+#### `getSignerId(secret: Uint8Array): string`
+
+Derive sealer/signer IDs from secrets.
+
+```typescript
+import { getSealerId, getSignerId } from 'cojson-core-napi';
+
+const sealerSecret = new TextEncoder().encode("sealerSecret_z...");
+const sealerId = getSealerId(sealerSecret);
+console.log(sealerId); // "sealer_z..."
+
+const signerSecret = new TextEncoder().encode("signerSecret_z...");
+const signerId = getSignerId(signerSecret);
+console.log(signerId); // "signer_z..."
+```
+
+### Session Management
+
+#### `SessionLog`
+
+Manage cryptographic sessions and transactions.
+
+```typescript
+import { SessionLog } from 'cojson-core-napi';
+
+const session = new SessionLog("coId", "sessionId", "signerId");
+
+// Add a new private transaction
+const result = session.addNewPrivateTransaction(
+  '{"changes": "..."}',
+  "signerSecret_z...",
+  "keySecret_z...",
+  "keyId",
+  Date.now(),
+  "metadata"
+);
+
+// Add a new trusting transaction
+const signature = session.addNewTrustingTransaction(
+  '{"changes": "..."}',
+  "signerSecret_z...",
+  Date.now(),
+  "metadata"
+);
+
+// Decrypt transaction data
+const changes = session.decryptNextTransactionChangesJson(0, "keySecret_z...");
+const meta = session.decryptNextTransactionMetaJson(0, "keySecret_z...");
+```
+
+## Error Handling
+
+All functions throw `Error` objects with descriptive messages for invalid inputs or cryptographic failures.
+
+```typescript
+try {
+  const hash = blake3HashOnce(invalidData);
+} catch (error) {
+  console.error('Hashing failed:', error.message);
+}
+```
+
+## Performance
+
+This package is built with Rust for maximum performance:
+- BLAKE3 hashing is significantly faster than SHA-256
+- Ed25519 signatures are faster than RSA
+- X25519 key exchange is faster than RSA key exchange
+- Native code execution avoids JavaScript overhead
+
+## Platform Support
+
+The package includes pre-built binaries for:
+- **Windows**: x64, x86, ARM64
+- **macOS**: x64, ARM64 (Apple Silicon)
+- **Linux**: x64, ARM64, ARM, musl
+- **FreeBSD**: x64
+- **Android**: ARM64, ARM
+
+## Development
+
+### Within the Jazz Monorepo
+
+```bash
+# From the monorepo root - install all dependencies
+pnpm install
+
+# Build only the NAPI package
+pnpm run build:napi
+
+# Build all packages including NAPI
+pnpm run build:packages
+
+# Run tests for the NAPI package
+pnpm test:napi
+
+# Run all tests (excluding NAPI tests)
+pnpm test
+
+```
+
+### Using in Other Jazz Packages
+
+```typescript
+// In any Jazz package, import directly
+import { 
+  blake3HashOnce, 
+  newEd25519SigningKey, 
+  encrypt, 
+  decrypt 
+} from 'cojson-core-napi';
+
+// The package is available as a workspace dependency
+// No additional installation needed
+```
+
+## License
+
+MIT License - see LICENSE file for details.
+
+## Contributing
+
+Contributions are welcome! Please see the main Jazz repository for contribution guidelines.

package/index.d.ts

@@ -0,0 +1,222 @@
+/* auto-generated by NAPI-RS */
+/* eslint-disable */
+export declare class Blake3Hasher {
+  constructor()
+  update(data: Uint8Array): void
+  finalize(): Uint8Array
+  clone(): Blake3Hasher
+}
+
+export declare class SessionLog {
+  constructor(coId: string, sessionId: string, signerId?: string | undefined | null)
+  clone(): SessionLog
+  tryAdd(transactionsJson: Array<string>, newSignatureStr: string, skipVerify: boolean): void
+  addNewPrivateTransaction(changesJson: string, signerSecret: string, encryptionKey: string, keyId: string, madeAt: number, meta?: string | undefined | null): string
+  addNewTrustingTransaction(changesJson: string, signerSecret: string, madeAt: number, meta?: string | undefined | null): string
+  decryptNextTransactionChangesJson(txIndex: number, encryptionKey: string): string
+  decryptNextTransactionMetaJson(txIndex: number, encryptionKey: string): string | null
+}
+
+/**
+ * Hash data once using BLAKE3.
+ * - `data`: Raw bytes to hash
+ * Returns 32 bytes of hash output.
+ * This is the simplest way to compute a BLAKE3 hash of a single piece of data.
+ */
+export declare function blake3HashOnce(data: Uint8Array): Uint8Array
+
+/**
+ * Hash data once using BLAKE3 with a context prefix.
+ * - `data`: Raw bytes to hash
+ * - `context`: Context bytes to prefix to the data
+ * Returns 32 bytes of hash output.
+ * This is useful for domain separation - the same data hashed with different contexts will produce different outputs.
+ */
+export declare function blake3HashOnceWithContext(data: Uint8Array, context: Uint8Array): Uint8Array
+
+/**
+ * NAPI-exposed function to decrypt bytes with a key secret and nonce material.
+ * - `ciphertext`: The encrypted bytes to decrypt
+ * - `key_secret`: A base58-encoded key secret with "keySecret_z" prefix
+ * - `nonce_material`: Raw bytes used to generate the nonce (must match encryption)
+ * Returns the decrypted bytes or throws a JsError if decryption fails.
+ */
+export declare function decrypt(ciphertext: Uint8Array, keySecret: string, nonceMaterial: Uint8Array): Uint8Array
+
+/**
+ * NAPI-exposed function for XSalsa20 decryption without authentication.
+ * - `key`: 32-byte key for decryption (must match encryption key)
+ * - `nonce_material`: Raw bytes used to generate a 24-byte nonce (must match encryption)
+ * - `ciphertext`: Encrypted bytes to decrypt
+ * Returns the decrypted bytes or throws a JsError if decryption fails.
+ * Note: This function does not provide authentication. Use decrypt_xsalsa20_poly1305 for authenticated decryption.
+ */
+export declare function decryptXsalsa20(key: Uint8Array, nonceMaterial: Uint8Array, ciphertext: Uint8Array): Uint8Array
+
+/**
+ * NAPI-exposed function to sign a message using Ed25519.
+ * - `signing_key`: 32 bytes of signing key material
+ * - `message`: Raw bytes to sign
+ * Returns 64 bytes of signature material or throws JsError if signing fails.
+ */
+export declare function ed25519Sign(signingKey: Uint8Array, message: Uint8Array): Uint8Array
+
+/**
+ * NAPI-exposed function to validate and copy Ed25519 signature bytes.
+ * - `bytes`: 64 bytes of signature material to validate
+ * Returns the same 64 bytes if valid or throws JsError if invalid.
+ */
+export declare function ed25519SignatureFromBytes(bytes: Uint8Array): Uint8Array
+
+/**
+ * NAPI-exposed function to validate and copy Ed25519 signing key bytes.
+ * - `bytes`: 32 bytes of signing key material to validate
+ * Returns the same 32 bytes if valid or throws JsError if invalid.
+ */
+export declare function ed25519SigningKeyFromBytes(bytes: Uint8Array): Uint8Array
+
+/**
+ * NAPI-exposed function to sign a message with an Ed25519 signing key.
+ * - `signing_key`: 32 bytes of signing key material
+ * - `message`: Raw bytes to sign
+ * Returns 64 bytes of signature material or throws JsError if signing fails.
+ */
+export declare function ed25519SigningKeySign(signingKey: Uint8Array, message: Uint8Array): Uint8Array
+
+/**
+ * NAPI-exposed function to derive the public key from an Ed25519 signing key.
+ * - `signing_key`: 32 bytes of signing key material
+ * Returns 32 bytes of public key material or throws JsError if key is invalid.
+ */
+export declare function ed25519SigningKeyToPublic(signingKey: Uint8Array): Uint8Array
+
+/**
+ * NAPI-exposed function to verify an Ed25519 signature.
+ * - `verifying_key`: 32 bytes of verifying key material
+ * - `message`: Raw bytes that were signed
+ * - `signature`: 64 bytes of signature material
+ * Returns true if signature is valid, false otherwise, or throws JsError if verification fails.
+ */
+export declare function ed25519Verify(verifyingKey: Uint8Array, message: Uint8Array, signature: Uint8Array): boolean
+
+/**
+ * NAPI-exposed function to derive an Ed25519 verifying key from a signing key.
+ * - `signing_key`: 32 bytes of signing key material
+ * Returns 32 bytes of verifying key material or throws JsError if key is invalid.
+ */
+export declare function ed25519VerifyingKey(signingKey: Uint8Array): Uint8Array
+
+/**
+ * NAPI-exposed function to validate and copy Ed25519 verifying key bytes.
+ * - `bytes`: 32 bytes of verifying key material to validate
+ * Returns the same 32 bytes if valid or throws JsError if invalid.
+ */
+export declare function ed25519VerifyingKeyFromBytes(bytes: Uint8Array): Uint8Array
+
+/**
+ * NAPI-exposed function to encrypt bytes with a key secret and nonce material.
+ * - `value`: The raw bytes to encrypt
+ * - `key_secret`: A base58-encoded key secret with "keySecret_z" prefix
+ * - `nonce_material`: Raw bytes used to generate the nonce
+ * Returns the encrypted bytes or throws a JsError if encryption fails.
+ */
+export declare function encrypt(value: Uint8Array, keySecret: string, nonceMaterial: Uint8Array): Uint8Array
+
+/**
+ * NAPI-exposed function for XSalsa20 encryption without authentication.
+ * - `key`: 32-byte key for encryption
+ * - `nonce_material`: Raw bytes used to generate a 24-byte nonce via BLAKE3
+ * - `plaintext`: Raw bytes to encrypt
+ * Returns the encrypted bytes or throws a JsError if encryption fails.
+ * Note: This function does not provide authentication. Use encrypt_xsalsa20_poly1305 for authenticated encryption.
+ */
+export declare function encryptXsalsa20(key: Uint8Array, nonceMaterial: Uint8Array, plaintext: Uint8Array): Uint8Array
+
+/**
+ * Generate a 24-byte nonce from input material using BLAKE3.
+ * - `nonce_material`: Raw bytes to derive the nonce from
+ * Returns 24 bytes suitable for use as a nonce in cryptographic operations.
+ * This function is deterministic - the same input will produce the same nonce.
+ */
+export declare function generateNonce(nonceMaterial: Uint8Array): Uint8Array
+
+/**
+ * NAPI-exposed function to derive a sealer ID from a sealer secret.
+ * - `secret`: Raw bytes of the sealer secret
+ * Returns a base58-encoded sealer ID with "sealer_z" prefix or throws JsError if derivation fails.
+ */
+export declare function getSealerId(secret: Uint8Array): string
+
+/**
+ * NAPI-exposed function to derive a signer ID from a signing key.
+ * - `secret`: Raw Ed25519 signing key bytes
+ * Returns base58-encoded verifying key with "signer_z" prefix or throws JsError if derivation fails.
+ */
+export declare function getSignerId(secret: Uint8Array): string
+
+/**
+ * Generate a new Ed25519 signing key using secure random number generation.
+ * Returns 32 bytes of raw key material suitable for use with other Ed25519 functions.
+ */
+export declare function newEd25519SigningKey(): Uint8Array
+
+/**
+ * Generate a new X25519 private key using secure random number generation.
+ * Returns 32 bytes of raw key material suitable for use with other X25519 functions.
+ * This key can be reused for multiple Diffie-Hellman exchanges.
+ */
+export declare function newX25519PrivateKey(): Uint8Array
+
+/**
+ * NAPI-exposed function for sealing a message using X25519 + XSalsa20-Poly1305.
+ * Provides authenticated encryption with perfect forward secrecy.
+ * - `message`: Raw bytes to seal
+ * - `sender_secret`: Base58-encoded sender's private key with "sealerSecret_z" prefix
+ * - `recipient_id`: Base58-encoded recipient's public key with "sealer_z" prefix
+ * - `nonce_material`: Raw bytes used to generate the nonce
+ * Returns sealed bytes or throws JsError if sealing fails.
+ */
+export declare function seal(message: Uint8Array, senderSecret: string, recipientId: string, nonceMaterial: Uint8Array): Uint8Array
+
+/**
+ * NAPI-exposed function to sign a message using Ed25519.
+ * - `message`: Raw bytes to sign
+ * - `secret`: Raw Ed25519 signing key bytes
+ * Returns base58-encoded signature with "signature_z" prefix or throws JsError if signing fails.
+ */
+export declare function sign(message: Uint8Array, secret: Uint8Array): string
+
+/**
+ * NAPI-exposed function for unsealing a message using X25519 + XSalsa20-Poly1305.
+ * Provides authenticated decryption with perfect forward secrecy.
+ * - `sealed_message`: The sealed bytes to decrypt
+ * - `recipient_secret`: Base58-encoded recipient's private key with "sealerSecret_z" prefix
+ * - `sender_id`: Base58-encoded sender's public key with "sealer_z" prefix
+ * - `nonce_material`: Raw bytes used to generate the nonce (must match sealing)
+ * Returns unsealed bytes or throws JsError if unsealing fails.
+ */
+export declare function unseal(sealedMessage: Uint8Array, recipientSecret: string, senderId: string, nonceMaterial: Uint8Array): Uint8Array
+
+/**
+ * NAPI-exposed function to verify an Ed25519 signature.
+ * - `signature`: Raw signature bytes
+ * - `message`: Raw bytes that were signed
+ * - `id`: Raw Ed25519 verifying key bytes
+ * Returns true if signature is valid, false otherwise, or throws JsError if verification fails.
+ */
+export declare function verify(signature: Uint8Array, message: Uint8Array, id: Uint8Array): boolean
+
+/**
+ * NAPI-exposed function to perform X25519 Diffie-Hellman key exchange.
+ * - `private_key`: 32 bytes of private key material
+ * - `public_key`: 32 bytes of public key material
+ * Returns 32 bytes of shared secret material or throws JsError if key exchange fails.
+ */
+export declare function x25519DiffieHellman(privateKey: Uint8Array, publicKey: Uint8Array): Uint8Array
+
+/**
+ * NAPI-exposed function to derive an X25519 public key from a private key.
+ * - `private_key`: 32 bytes of private key material
+ * Returns 32 bytes of public key material or throws JsError if key is invalid.
+ */
+export declare function x25519PublicKey(privateKey: Uint8Array): Uint8Array

package/index.js

@@ -0,0 +1,586 @@
+// prettier-ignore
+/* eslint-disable */
+// @ts-nocheck
+/* auto-generated by NAPI-RS */
+
+const { createRequire } = require('node:module')
+require = createRequire(__filename)
+
+const { readFileSync } = require('node: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 (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('./cojson-core-napi.android-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('cojson-core-napi-android-arm64')
+        const bindingPackageVersion = require('cojson-core-napi-android-arm64/package.json').version
+        if (bindingPackageVersion !== '0.18.22' && 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.18.22 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('./cojson-core-napi.android-arm-eabi.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('cojson-core-napi-android-arm-eabi')
+        const bindingPackageVersion = require('cojson-core-napi-android-arm-eabi/package.json').version
+        if (bindingPackageVersion !== '0.18.22' && 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.18.22 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') {
+      try {
+        return require('./cojson-core-napi.win32-x64-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('cojson-core-napi-win32-x64-msvc')
+        const bindingPackageVersion = require('cojson-core-napi-win32-x64-msvc/package.json').version
+        if (bindingPackageVersion !== '0.18.22' && 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.18.22 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('./cojson-core-napi.win32-ia32-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('cojson-core-napi-win32-ia32-msvc')
+        const bindingPackageVersion = require('cojson-core-napi-win32-ia32-msvc/package.json').version
+        if (bindingPackageVersion !== '0.18.22' && 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.18.22 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('./cojson-core-napi.win32-arm64-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('cojson-core-napi-win32-arm64-msvc')
+        const bindingPackageVersion = require('cojson-core-napi-win32-arm64-msvc/package.json').version
+        if (bindingPackageVersion !== '0.18.22' && 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.18.22 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('./cojson-core-napi.darwin-universal.node')
+    } catch (e) {
+      loadErrors.push(e)
+    }
+    try {
+      const binding = require('cojson-core-napi-darwin-universal')
+      const bindingPackageVersion = require('cojson-core-napi-darwin-universal/package.json').version
+      if (bindingPackageVersion !== '0.18.22' && 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.18.22 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('./cojson-core-napi.darwin-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('cojson-core-napi-darwin-x64')
+        const bindingPackageVersion = require('cojson-core-napi-darwin-x64/package.json').version
+        if (bindingPackageVersion !== '0.18.22' && 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.18.22 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('./cojson-core-napi.darwin-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('cojson-core-napi-darwin-arm64')
+        const bindingPackageVersion = require('cojson-core-napi-darwin-arm64/package.json').version
+        if (bindingPackageVersion !== '0.18.22' && 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.18.22 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('./cojson-core-napi.freebsd-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('cojson-core-napi-freebsd-x64')
+        const bindingPackageVersion = require('cojson-core-napi-freebsd-x64/package.json').version
+        if (bindingPackageVersion !== '0.18.22' && 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.18.22 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('./cojson-core-napi.freebsd-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('cojson-core-napi-freebsd-arm64')
+        const bindingPackageVersion = require('cojson-core-napi-freebsd-arm64/package.json').version
+        if (bindingPackageVersion !== '0.18.22' && 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.18.22 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('./cojson-core-napi.linux-x64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('cojson-core-napi-linux-x64-musl')
+          const bindingPackageVersion = require('cojson-core-napi-linux-x64-musl/package.json').version
+          if (bindingPackageVersion !== '0.18.22' && 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.18.22 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./cojson-core-napi.linux-x64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('cojson-core-napi-linux-x64-gnu')
+          const bindingPackageVersion = require('cojson-core-napi-linux-x64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.18.22' && 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.18.22 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('./cojson-core-napi.linux-arm64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('cojson-core-napi-linux-arm64-musl')
+          const bindingPackageVersion = require('cojson-core-napi-linux-arm64-musl/package.json').version
+          if (bindingPackageVersion !== '0.18.22' && 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.18.22 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./cojson-core-napi.linux-arm64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('cojson-core-napi-linux-arm64-gnu')
+          const bindingPackageVersion = require('cojson-core-napi-linux-arm64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.18.22' && 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.18.22 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('./cojson-core-napi.linux-arm-musleabihf.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('cojson-core-napi-linux-arm-musleabihf')
+          const bindingPackageVersion = require('cojson-core-napi-linux-arm-musleabihf/package.json').version
+          if (bindingPackageVersion !== '0.18.22' && 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.18.22 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./cojson-core-napi.linux-arm-gnueabihf.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('cojson-core-napi-linux-arm-gnueabihf')
+          const bindingPackageVersion = require('cojson-core-napi-linux-arm-gnueabihf/package.json').version
+          if (bindingPackageVersion !== '0.18.22' && 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.18.22 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('./cojson-core-napi.linux-loong64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('cojson-core-napi-linux-loong64-musl')
+          const bindingPackageVersion = require('cojson-core-napi-linux-loong64-musl/package.json').version
+          if (bindingPackageVersion !== '0.18.22' && 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.18.22 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./cojson-core-napi.linux-loong64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('cojson-core-napi-linux-loong64-gnu')
+          const bindingPackageVersion = require('cojson-core-napi-linux-loong64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.18.22' && 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.18.22 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('./cojson-core-napi.linux-riscv64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('cojson-core-napi-linux-riscv64-musl')
+          const bindingPackageVersion = require('cojson-core-napi-linux-riscv64-musl/package.json').version
+          if (bindingPackageVersion !== '0.18.22' && 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.18.22 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./cojson-core-napi.linux-riscv64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('cojson-core-napi-linux-riscv64-gnu')
+          const bindingPackageVersion = require('cojson-core-napi-linux-riscv64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.18.22' && 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.18.22 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('./cojson-core-napi.linux-ppc64-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('cojson-core-napi-linux-ppc64-gnu')
+        const bindingPackageVersion = require('cojson-core-napi-linux-ppc64-gnu/package.json').version
+        if (bindingPackageVersion !== '0.18.22' && 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.18.22 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('./cojson-core-napi.linux-s390x-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('cojson-core-napi-linux-s390x-gnu')
+        const bindingPackageVersion = require('cojson-core-napi-linux-s390x-gnu/package.json').version
+        if (bindingPackageVersion !== '0.18.22' && 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.18.22 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('./cojson-core-napi.openharmony-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('cojson-core-napi-openharmony-arm64')
+        const bindingPackageVersion = require('cojson-core-napi-openharmony-arm64/package.json').version
+        if (bindingPackageVersion !== '0.18.22' && 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.18.22 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('./cojson-core-napi.openharmony-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('cojson-core-napi-openharmony-x64')
+        const bindingPackageVersion = require('cojson-core-napi-openharmony-x64/package.json').version
+        if (bindingPackageVersion !== '0.18.22' && 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.18.22 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('./cojson-core-napi.openharmony-arm.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('cojson-core-napi-openharmony-arm')
+        const bindingPackageVersion = require('cojson-core-napi-openharmony-arm/package.json').version
+        if (bindingPackageVersion !== '0.18.22' && 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.18.22 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}`))
+  }
+}
+
+nativeBinding = requireNative()
+
+if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
+  let wasiBinding = null
+  let wasiBindingError = null
+  try {
+    wasiBinding = require('./cojson-core-napi.wasi.cjs')
+    nativeBinding = wasiBinding
+  } catch (err) {
+    if (process.env.NAPI_RS_FORCE_WASI) {
+      wasiBindingError = err
+    }
+  }
+  if (!nativeBinding) {
+    try {
+      wasiBinding = require('cojson-core-napi-wasm32-wasi')
+      nativeBinding = wasiBinding
+    } catch (err) {
+      if (process.env.NAPI_RS_FORCE_WASI) {
+        wasiBindingError.cause = err
+        loadErrors.push(err)
+      }
+    }
+  }
+  if (process.env.NAPI_RS_FORCE_WASI === 'error' && !wasiBinding) {
+    const error = new Error('WASI binding not found and NAPI_RS_FORCE_WASI is set to error')
+    error.cause = wasiBindingError
+    throw error
+  }
+}
+
+if (!nativeBinding) {
+  if (loadErrors.length > 0) {
+    throw 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.',
+      {
+        cause: loadErrors.reduce((err, cur) => {
+          cur.cause = err
+          return cur
+        }),
+      },
+    )
+  }
+  throw new Error(`Failed to load native binding`)
+}
+
+module.exports = nativeBinding
+module.exports.Blake3Hasher = nativeBinding.Blake3Hasher
+module.exports.SessionLog = nativeBinding.SessionLog
+module.exports.blake3HashOnce = nativeBinding.blake3HashOnce
+module.exports.blake3HashOnceWithContext = nativeBinding.blake3HashOnceWithContext
+module.exports.decrypt = nativeBinding.decrypt
+module.exports.decryptXsalsa20 = nativeBinding.decryptXsalsa20
+module.exports.ed25519Sign = nativeBinding.ed25519Sign
+module.exports.ed25519SignatureFromBytes = nativeBinding.ed25519SignatureFromBytes
+module.exports.ed25519SigningKeyFromBytes = nativeBinding.ed25519SigningKeyFromBytes
+module.exports.ed25519SigningKeySign = nativeBinding.ed25519SigningKeySign
+module.exports.ed25519SigningKeyToPublic = nativeBinding.ed25519SigningKeyToPublic
+module.exports.ed25519Verify = nativeBinding.ed25519Verify
+module.exports.ed25519VerifyingKey = nativeBinding.ed25519VerifyingKey
+module.exports.ed25519VerifyingKeyFromBytes = nativeBinding.ed25519VerifyingKeyFromBytes
+module.exports.encrypt = nativeBinding.encrypt
+module.exports.encryptXsalsa20 = nativeBinding.encryptXsalsa20
+module.exports.generateNonce = nativeBinding.generateNonce
+module.exports.getSealerId = nativeBinding.getSealerId
+module.exports.getSignerId = nativeBinding.getSignerId
+module.exports.newEd25519SigningKey = nativeBinding.newEd25519SigningKey
+module.exports.newX25519PrivateKey = nativeBinding.newX25519PrivateKey
+module.exports.seal = nativeBinding.seal
+module.exports.sign = nativeBinding.sign
+module.exports.unseal = nativeBinding.unseal
+module.exports.verify = nativeBinding.verify
+module.exports.x25519DiffieHellman = nativeBinding.x25519DiffieHellman
+module.exports.x25519PublicKey = nativeBinding.x25519PublicKey

package/package.json

@@ -0,0 +1,114 @@
+{
+  "name": "cojson-core-napi",
+  "version": "0.18.22",
+  "description": "Node.js N-API bindings for the cojson-core Rust library, providing high-performance.",
+  "main": "index.js",
+  "license": "MIT",
+  "keywords": [
+    "napi-rs",
+    "NAPI",
+    "N-API",
+    "Rust",
+    "node-addon",
+    "node-addon-api"
+  ],
+  "files": [
+    "index.d.ts",
+    "index.js"
+  ],
+  "napi": {
+    "binaryName": "cojson-core-napi",
+    "packageName": "cojson-core-napi",
+    "targets": [
+      "x86_64-apple-darwin",
+      "x86_64-unknown-linux-gnu",
+      "x86_64-unknown-linux-musl",
+      "aarch64-unknown-linux-gnu",
+      "armv7-unknown-linux-gnueabihf",
+      "aarch64-apple-darwin",
+      "aarch64-unknown-linux-musl"
+    ]
+  },
+  "engines": {
+    "node": ">= 12.22.0 < 13 || >= 14.17.0 < 15 || >= 15.12.0 < 16 || >= 16.0.0"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "devDependencies": {
+    "@emnapi/core": "^1.5.0",
+    "@emnapi/runtime": "^1.5.0",
+    "@napi-rs/cli": "^3.2.0",
+    "@oxc-node/core": "^0.0.32",
+    "@scure/base": "1.2.1",
+    "@taplo/cli": "^0.7.0",
+    "@tybys/wasm-util": "^0.10.0",
+    "chalk": "^5.6.2",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.1.6",
+    "npm-run-all2": "^8.0.4",
+    "oxlint": "^1.14.0",
+    "prettier": "^3.6.2",
+    "tinybench": "^5.0.1",
+    "typescript": "^5.9.2",
+    "vitest": "3.2.4"
+  },
+  "lint-staged": {
+    "*.@(js|ts|tsx)": [
+      "oxlint --fix"
+    ],
+    "*.@(js|ts|tsx|yml|yaml|md|json)": [
+      "prettier --write"
+    ],
+    "*.toml": [
+      "taplo format"
+    ]
+  },
+  "ava": {
+    "extensions": {
+      "ts": "module"
+    },
+    "timeout": "2m",
+    "workerThreads": false,
+    "environmentVariables": {
+      "OXC_TSCONFIG_PATH": "./__test__/tsconfig.json"
+    },
+    "nodeArguments": [
+      "--import",
+      "@oxc-node/core/register"
+    ]
+  },
+  "prettier": {
+    "printWidth": 120,
+    "semi": false,
+    "trailingComma": "all",
+    "singleQuote": true,
+    "arrowParens": "always"
+  },
+  "optionalDependencies": {
+    "cojson-core-napi-darwin-x64": "0.18.22",
+    "cojson-core-napi-linux-x64-gnu": "0.18.22",
+    "cojson-core-napi-linux-x64-musl": "0.18.22",
+    "cojson-core-napi-linux-arm64-gnu": "0.18.22",
+    "cojson-core-napi-linux-arm-gnueabihf": "0.18.22",
+    "cojson-core-napi-darwin-arm64": "0.18.22",
+    "cojson-core-napi-linux-arm64-musl": "0.18.22"
+  },
+  "scripts": {
+    "artifacts": "napi artifacts",
+    "build:napi": "napi build --platform --release",
+    "build:jsBinding": "napi build --platform --release && node --import @oxc-node/core/register scripts/build.ts",
+    "build:debug": "napi build --platform",
+    "format": "run-p format:prettier format:rs format:toml",
+    "format:prettier": "prettier . -w",
+    "format:toml": "taplo format",
+    "format:rs": "cargo fmt",
+    "lint": "oxlint . && cargo fmt -- --check",
+    "generate:npm": "napi create-npm-dirs",
+    "test": "vitest --watch --project cojson-core-napi",
+    "test:ci": "vitest run --watch=false",
+    "preversion": "napi build --platform && git add .",
+    "version": "napi version"
+  }
+}