asherah 3.0.16 → 4.0.0-beta.10

package/README.md

@@ -1,179 +1,42 @@
-# asherah-node
+# asherah
 
-Asherah envelope encryption and key rotation library
+Node.js bindings for the Asherah envelope encryption and key rotation library.
 
-This is a wrapper of the Asherah Go implementation using the Cobhan FFI library
+Prebuilt native binaries are published to npm for Linux (x64/arm64, glibc and
+musl), macOS (x64/arm64), and Windows (x64/arm64). The correct binary is
+selected automatically at install time.
 
-*NOTE:* Due to limitations around the type of libraries Go creates and the type of libraries musl libc supports, you MUST use a glibc based Linux distribution with asherah-node, such as Debian, Ubuntu, AlmaLinux, etc.  Alpine Linux with musl libc will not work.  For technical details, see below.
+## Features
 
-Example code: 
+- Synchronous and asynchronous encrypt/decrypt APIs
+- Compatible with Go, Python, Ruby, Java, and .NET Asherah implementations
+- SQLite, MySQL, PostgreSQL, and DynamoDB metastore support
+- AWS KMS and static key management
 
-### TypeScript
+## Installation
 
-```typescript
-import { AsherahConfig, decrypt, encrypt, setup, shutdown } from 'asherah'
-
-const config: AsherahConfig = {
-    KMS: 'aws',
-    Metastore: 'memory',
-    ServiceName: 'TestService',
-    ProductID: 'TestProduct',
-    Verbose: true,
-    EnableSessionCaching: true,
-    ExpireAfter: null,
-    CheckInterval: null,
-    ConnectionString: null,
-    ReplicaReadConsistency: null,
-    DynamoDBEndpoint: null,
-    DynamoDBRegion: null,
-    DynamoDBTableName: null,
-    SessionCacheMaxSize: null,
-    SessionCacheDuration: null,
-    RegionMap: {"us-west-2": "arn:aws:kms:us-west-2:XXXXXXXXX:key/XXXXXXXXXX"},
-    PreferredRegion: null,
-    EnableRegionSuffix: null,
-    DisableZeroCopy: null
-  };
-
-setup(config)
-
-const input = 'mysecretdata'
-
-console.log("Input: " + input)
-
-const data = Buffer.from(input, 'utf8');
-
-const encrypted = encrypt('partition', data);
-
-const decrypted = decrypt('partition', encrypted);
-
-const output = decrypted.toString('utf8');
-
-console.log("Output: " + output)
-
-shutdown()
+```bash
+npm install asherah
 ```
 
-### JavaScript
-
-```javascript
-
-const asherah = require('asherah')
-
-const config = {
-    KMS: 'aws',
-    Metastore: 'memory',
-    ServiceName: 'TestService',
-    ProductID: 'TestProduct',
-    Verbose: true,
-    EnableSessionCaching: true,
-    ExpireAfter: null,
-    CheckInterval: null,
-    ConnectionString: null,
-    ReplicaReadConsistency: null,
-    DynamoDBEndpoint: null,
-    DynamoDBRegion: null,
-    DynamoDBTableName: null,
-    SessionCacheMaxSize: null,
-    SessionCacheDuration: null,
-    RegionMap: {"us-west-2": "arn:aws:kms:us-west-2:XXXXXXXXX:key/XXXXXXXXXX"},
-    PreferredRegion: null,
-    EnableRegionSuffix: null,
-    DisableZeroCopy: null
-  };
-
-asherah.setup(config)
-
-const input = 'mysecretdata'
-
-console.log("Input: " + input)
-
-const data = Buffer.from(input, 'utf8');
-
-const encrypted = asherah.encrypt('partition', data);
-
-const decrypted = asherah.decrypt('partition', encrypted);
-
-const output = decrypted.toString('utf8');
-
-console.log("Output: " + output)
-
-asherah.shutdown()
-```
-
-### Environment Variables and AWS
-
-If you're experiencing issues with AWS credentials, you can forcibly set the environment variables prior to calling setup in such a way as to ensure they're set for the Go runtime:
-
-```javascript
+## Quick start
 
+```js
 const asherah = require('asherah');
-const fs = require('fs');
-
-const config = {
-    KMS: 'aws',
-    Metastore: 'memory',
-    ServiceName: 'TestService',
-    ProductID: 'TestProduct',
-    Verbose: true,
-    EnableSessionCaching: true,
-    ExpireAfter: null,
-    CheckInterval: null,
-    ConnectionString: null,
-    ReplicaReadConsistency: null,
-    DynamoDBEndpoint: null,
-    DynamoDBRegion: null,
-    DynamoDBTableName: null,
-    SessionCacheMaxSize: null,
-    SessionCacheDuration: null,
-    RegionMap: {"us-west-2": "arn:aws:kms:us-west-2:XXXXXXXXX:key/XXXXXXXXXX"},
-    PreferredRegion: null,
-    EnableRegionSuffix: null,
-    DisableZeroCopy: null
-  };
-
-// Read the AWS environment variables from the JSON file
-// DO NOT HARDCODE YOUR AWS CREDENTIALS
-const awsEnvPath = './awsEnv.json';
-const awsEnvData = fs.readFileSync(awsEnvPath, 'utf8');
-const awsEnv = JSON.stringify(awsEnvData);
-
-// Set the environment variables using the setenv function
-asherah.setenv(awsEnv);
-
-asherah.setup(config)
 
-const input = 'mysecretdata'
-
-console.log("Input: " + input)
-
-const data = Buffer.from(input, 'utf8');
-
-const encrypted = asherah.encrypt('partition', data);
+asherah.setup({
+  kms: 'static',
+  metastore: 'memory',
+  serviceName: 'myservice',
+  productId: 'myproduct',
+});
 
+const encrypted = asherah.encrypt('partition', Buffer.from('hello world'));
 const decrypted = asherah.decrypt('partition', encrypted);
 
-const output = decrypted.toString('utf8');
-
-console.log("Output: " + output)
-
-asherah.shutdown()
+asherah.shutdown();
 ```
 
-The `awsEnv.json` file would look like this (spelling errors intentional):
-
-```json
-{
-  "AXS_ACCESS_KEY_XD": "sample_access_key_xd",
-  "AXS_SXCRET_ACCXSS_KEY": "sample_sxcret_accxss_kxy",
-  "AXS_SXSSION_TXKEN": "sample_sxssion_txken"
-}
-```
-
-### Go and Alpine / musl libc
-
-The Golang compiler when creating shared libraries (.so) uses a Thread Local Storage model of init-exec.  This model is inheriently incompatible with loading libraries at runtime with dlopen(), unless your libc reserves some space for dlopen()'ed libraries which is something of a hack.  The most common libc, glibc does in fact reserve space for dlopen()'ed libraries that use init-exec model.  The libc provided with Alpine is musl libc, and it does not participate in this hack / workaround of reserving space.  Most compilers generate libraries with a Thread Local Storage model of global-dynamic which does not require this workaround, and the authors of musl libc do not feel that workaround should exist.
-
-## Updating npm packages
+## License
 
-To update packages, run `npm run update`. This command uses [npm-check-updates](https://github.com/raineorshine/npm-check-updates) to bring all npm packages to their latest version. This command also runs `npm install` and `npm audit fix` for you.
+Licensed under the Apache License, Version 2.0.

package/index.d.ts

@@ -0,0 +1,102 @@
+/// <reference types="node" />
+
+export type AsherahConfig = {
+  serviceName: string;
+  productId: string;
+  expireAfter?: number | null;
+  checkInterval?: number | null;
+  metastore: 'memory' | 'rdbms' | 'dynamodb';
+  connectionString?: string | null;
+  replicaReadConsistency?: string | null;
+  dynamoDBEndpoint?: string | null;
+  dynamoDBRegion?: string | null;
+  dynamoDBTableName?: string | null;
+  sessionCacheMaxSize?: number | null;
+  sessionCacheDuration?: number | null;
+  kms?: 'aws' | 'static' | null;
+  regionMap?: Record<string, string> | null;
+  preferredRegion?: string | null;
+  enableRegionSuffix?: boolean | null;
+  enableSessionCaching?: boolean | null;
+  verbose?: boolean | null;
+  sqlMetastoreDBType?: string | null;
+  disableZeroCopy?: boolean | null;
+  nullDataCheck?: boolean | null;
+  enableCanaries?: boolean | null;
+};
+
+/** Canonical godaddy/asherah-node PascalCase config format */
+export type AsherahConfigCompat = {
+  readonly ServiceName: string;
+  readonly ProductID: string;
+  readonly ExpireAfter?: number | null;
+  readonly CheckInterval?: number | null;
+  readonly Metastore: 'memory' | 'rdbms' | 'dynamodb' | 'test-debug-memory';
+  readonly ConnectionString?: string | null;
+  readonly DynamoDBEndpoint?: string | null;
+  readonly DynamoDBRegion?: string | null;
+  readonly DynamoDBTableName?: string | null;
+  readonly SessionCacheMaxSize?: number | null;
+  readonly SessionCacheDuration?: number | null;
+  readonly KMS?: 'aws' | 'static' | 'test-debug-static' | null;
+  readonly RegionMap?: Record<string, string> | null;
+  readonly PreferredRegion?: string | null;
+  readonly EnableRegionSuffix?: boolean | null;
+  readonly EnableSessionCaching?: boolean | null;
+  readonly Verbose?: boolean | null;
+  readonly SQLMetastoreDBType?: string | null;
+  readonly ReplicaReadConsistency?: 'eventual' | 'global' | 'session' | null;
+  readonly DisableZeroCopy?: boolean | null;
+  readonly NullDataCheck?: boolean | null;
+  readonly EnableCanaries?: boolean | null;
+};
+
+/** Canonical godaddy/asherah-node log hook callback: (level: number, message: string) => void */
+export type LogHookCallback = (level: number, message: string) => void;
+
+export declare function setup(config: AsherahConfig | AsherahConfigCompat): void;
+export declare function setupAsync(config: AsherahConfig | AsherahConfigCompat): Promise<void>;
+export declare function shutdown(): void;
+export declare function shutdownAsync(): Promise<void>;
+export declare function getSetupStatus(): boolean;
+export declare function setenv(env: string): void;
+
+export declare function encrypt(partitionId: string, data: Buffer): string;
+export declare function encryptAsync(partitionId: string, data: Buffer): Promise<string>;
+export declare function decrypt(partitionId: string, dataRowRecordJson: string): Buffer;
+export declare function decryptAsync(partitionId: string, dataRowRecordJson: string): Promise<Buffer>;
+
+export declare function encryptString(partitionId: string, data: string): string;
+export declare function encryptStringAsync(partitionId: string, data: string): Promise<string>;
+export declare function decryptString(partitionId: string, dataRowRecordJson: string): string;
+export declare function decryptStringAsync(partitionId: string, dataRowRecordJson: string): Promise<string>;
+
+export declare function setMaxStackAllocItemSize(n: number): void;
+export declare function setSafetyPaddingOverhead(n: number): void;
+
+export type LogEvent = {
+  level: 'trace' | 'debug' | 'info' | 'warn' | 'error';
+  message: string;
+  target: string;
+};
+
+export type MetricsEvent =
+  | { type: 'encrypt' | 'decrypt' | 'store' | 'load'; durationNs: number }
+  | { type: 'cache_hit' | 'cache_miss'; name: string };
+
+export declare function setLogHook(hook: ((event: LogEvent) => void) | LogHookCallback | null): void;
+export declare function setMetricsHook(hook: ((event: MetricsEvent) => void) | null): void;
+
+// Canonical godaddy/asherah-node snake_case aliases
+export declare function setup_async(config: AsherahConfig | AsherahConfigCompat): Promise<void>;
+export declare function shutdown_async(): Promise<void>;
+export declare function encrypt_async(partitionId: string, data: Buffer): Promise<string>;
+export declare function encrypt_string(partitionId: string, data: string): string;
+export declare function encrypt_string_async(partitionId: string, data: string): Promise<string>;
+export declare function decrypt_async(partitionId: string, dataRowRecordJson: string): Promise<Buffer>;
+export declare function decrypt_string(partitionId: string, dataRowRecordJson: string): string;
+export declare function decrypt_string_async(partitionId: string, dataRowRecordJson: string): Promise<string>;
+export declare function set_max_stack_alloc_item_size(n: number): void;
+export declare function set_safety_padding_overhead(n: number): void;
+export declare function set_log_hook(hook: ((event: LogEvent) => void) | LogHookCallback | null): void;
+export declare function get_setup_status(): boolean;

package/npm/index.js

@@ -0,0 +1,230 @@
+const path = require('path');
+const os = require('os');
+
+// Detect musl libc (Alpine Linux, etc.)
+function isMusl() {
+  if (os.platform() !== 'linux') return false;
+  try {
+    // Node 18+: process.report.getReport() exposes glibc version
+    const report = process.report.getReport();
+    const header = typeof report === 'string' ? JSON.parse(report).header : report.header;
+    return !header.glibcVersionRuntime;
+  } catch {
+    // Fallback: check for musl dynamic linker
+    try {
+      return require('fs').readdirSync('/lib').some(f => f.startsWith('ld-musl-'));
+    } catch {
+      return false;
+    }
+  }
+}
+
+// Determine current platform
+function getPlatform() {
+  const type = os.platform();
+  const arch = os.arch();
+
+  if (type === 'darwin') {
+    if (arch === 'x64') return 'darwin-x64';
+    if (arch === 'arm64') return 'darwin-arm64';
+  }
+  if (type === 'linux') {
+    const libc = isMusl() ? 'musl' : 'gnu';
+    if (arch === 'x64') return `linux-x64-${libc}`;
+    if (arch === 'arm64') return `linux-arm64-${libc}`;
+  }
+  if (type === 'win32') {
+    if (arch === 'x64') return 'win32-x64-msvc';
+    if (arch === 'arm64') return 'win32-arm64-msvc';
+  }
+
+  throw new Error(`Unsupported platform: ${type}-${arch}`);
+}
+
+const platform = getPlatform();
+
+// Map platform to npm package name (win32 needed a different name to avoid npm spam filter)
+const PLATFORM_PACKAGES = {
+  'darwin-arm64': 'asherah-darwin-arm64',
+  'darwin-x64': 'asherah-darwin-x64',
+  'linux-x64-gnu': 'asherah-linux-x64-gnu',
+  'linux-arm64-gnu': 'asherah-linux-arm64-gnu',
+  'linux-x64-musl': 'asherah-linux-x64-musl',
+  'linux-arm64-musl': 'asherah-linux-arm64-musl',
+  'win32-x64-msvc': 'asherah-windows-x64',
+  'win32-arm64-msvc': 'asherah-windows-arm64',
+};
+const packageName = PLATFORM_PACKAGES[platform] || `asherah-${platform}`;
+
+// Try to load the native module:
+// 1. Installed platform package (optionalDependency) — normal npm install
+// 2. Bundled in platform subdirectory — development / CI builds
+// 3. Legacy single-binary fallback
+let native = null;
+let lastErr = null;
+
+const attempts = [
+  // Platform package installed as optionalDependency (e.g., asherah-darwin-arm64)
+  packageName,
+  // Bundled in platform subdirectory (development builds)
+  path.join(__dirname, platform, `index.${platform}.node`),
+  // Fallback to old single-binary locations
+  path.join(__dirname, 'asherah.node'),
+  path.join(__dirname, '..', 'index.node'),
+];
+
+for (const candidate of attempts) {
+  try {
+    native = require(candidate);
+    native.__binary = candidate;
+    break;
+  } catch (err) {
+    lastErr = err;
+    if (
+      err.code !== 'MODULE_NOT_FOUND' &&
+      err.code !== 'ERR_MODULE_NOT_FOUND' &&
+      err.code !== 'ERR_DLOPEN_FAILED'
+    ) {
+      throw err;
+    }
+  }
+}
+
+if (!native) {
+  const detail = lastErr ? `: ${lastErr.message || String(lastErr)}` : '';
+  throw new Error(
+    `Failed to load Asherah native addon for ${platform}. ` +
+    `Ensure the platform package '${packageName}' is installed${detail}`
+  );
+}
+
+// --- Canonical godaddy/asherah-node compatibility layer ---
+
+// PascalCase → camelCase config field mapping
+const CONFIG_MAP = {
+  ServiceName: 'serviceName',
+  ProductID: 'productId',
+  ExpireAfter: 'expireAfter',
+  CheckInterval: 'checkInterval',
+  Metastore: 'metastore',
+  ConnectionString: 'connectionString',
+  DynamoDBEndpoint: 'dynamoDBEndpoint',
+  DynamoDBRegion: 'dynamoDBRegion',
+  DynamoDBTableName: 'dynamoDBTableName',
+  SessionCacheMaxSize: 'sessionCacheMaxSize',
+  SessionCacheDuration: 'sessionCacheDuration',
+  KMS: 'kms',
+  RegionMap: 'regionMap',
+  PreferredRegion: 'preferredRegion',
+  EnableRegionSuffix: 'enableRegionSuffix',
+  EnableSessionCaching: 'enableSessionCaching',
+  Verbose: 'verbose',
+  SQLMetastoreDBType: 'sqlMetastoreDBType',
+  ReplicaReadConsistency: 'replicaReadConsistency',
+  DisableZeroCopy: 'disableZeroCopy',
+  NullDataCheck: 'nullDataCheck',
+  EnableCanaries: 'enableCanaries',
+};
+
+// Legacy/debug metastore aliases (match Go behavior)
+const METASTORE_ALIASES = {
+  'test-debug-memory': 'memory',
+  'test-debug-sqlite': 'sqlite',
+  'test-debug-static': 'static',
+};
+
+// Legacy/debug KMS aliases
+const KMS_ALIASES = {
+  'test-debug-static': 'static',
+};
+
+function normalizeConfig(config) {
+  // Detect PascalCase format by checking for ServiceName (capital S)
+  if (!config || typeof config !== 'object' || !('ServiceName' in config)) {
+    return config;
+  }
+
+  const out = {};
+  for (const [key, value] of Object.entries(config)) {
+    const mapped = CONFIG_MAP[key];
+    if (mapped === undefined) {
+      // Unknown field — pass through as-is (may be a camelCase field mixed in)
+      out[key] = value;
+    } else if (mapped !== null) {
+      out[mapped] = value;
+    }
+    // mapped === null means ignored (Go-specific)
+  }
+
+  // Normalize metastore aliases
+  if (typeof out.metastore === 'string') {
+    const lower = out.metastore.toLowerCase();
+    out.metastore = METASTORE_ALIASES[lower] || lower;
+  }
+
+  // Normalize KMS aliases
+  if (typeof out.kms === 'string') {
+    const lower = out.kms.toLowerCase();
+    out.kms = KMS_ALIASES[lower] || lower;
+  }
+
+  return out;
+}
+
+// Log level mapping: Rust level string → zerolog numeric (used by Go asherah)
+const LEVEL_TO_NUMBER = {
+  trace: -1,
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+};
+
+// Wrap setup to normalize config
+function setup(config) {
+  return native.setup(normalizeConfig(config));
+}
+
+function setupAsync(config) {
+  return native.setupAsync(normalizeConfig(config));
+}
+
+// set_log_hook: accept canonical (level, message) callback or native (event) callback
+function set_log_hook(callback) {
+  if (callback == null) {
+    return native.setLogHook(null);
+  }
+  // Canonical callback: (level: number, message: string) => void (arity 2)
+  // Native callback: (event: {level, message, target}) => void (arity 1)
+  if (callback.length >= 2) {
+    return native.setLogHook(function (event) {
+      const numLevel =
+        LEVEL_TO_NUMBER[event.level] !== undefined
+          ? LEVEL_TO_NUMBER[event.level]
+          : 1;
+      callback(numLevel, event.message);
+    });
+  }
+  return native.setLogHook(callback);
+}
+
+// Export everything from native addon
+Object.assign(module.exports, native);
+
+// Override setup/setupAsync with normalizing versions
+module.exports.setup = setup;
+module.exports.setupAsync = setupAsync;
+
+// snake_case aliases for canonical API compatibility
+module.exports.setup_async = setupAsync;
+module.exports.shutdown_async = native.shutdownAsync;
+module.exports.encrypt_async = native.encryptAsync;
+module.exports.encrypt_string = native.encryptString;
+module.exports.encrypt_string_async = native.encryptStringAsync;
+module.exports.decrypt_async = native.decryptAsync;
+module.exports.decrypt_string = native.decryptString;
+module.exports.decrypt_string_async = native.decryptStringAsync;
+module.exports.set_max_stack_alloc_item_size = native.setMaxStackAllocItemSize;
+module.exports.set_safety_padding_overhead = native.setSafetyPaddingOverhead;
+module.exports.set_log_hook = set_log_hook;
+module.exports.get_setup_status = native.getSetupStatus;

package/package.json

@@ -1,87 +1,49 @@
 {
   "name": "asherah",
-  "version": "3.0.16",
+  "version": "4.0.0-beta.10",
+  "private": false,
   "description": "Asherah envelope encryption and key rotation library",
-  "main": "./dist/asherah.node",
-  "types": "./dist/asherah.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/asherah.d.ts",
-      "require": "./dist/asherah.node",
-      "import": "./dist/asherah.node",
-      "default": "./dist/asherah.node"
-    }
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/godaddy/asherah-node.git"
+  "main": "npm/index.js",
+  "types": "index.d.ts",
+  "files": [
+    "npm/index.js",
+    "index.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "napi": {
+    "binaryName": "index",
+    "targets": [
+      "x86_64-apple-darwin",
+      "aarch64-apple-darwin",
+      "x86_64-unknown-linux-gnu",
+      "aarch64-unknown-linux-gnu",
+      "x86_64-unknown-linux-musl",
+      "aarch64-unknown-linux-musl",
+      "x86_64-pc-windows-msvc",
+      "aarch64-pc-windows-msvc"
+    ]
   },
   "scripts": {
-    "preinstall": "scripts/download-libraries.sh",
-    "load": "node --max-old-space-size=500 scripts/dumpster-fire-memory.js",
-    "install": "scripts/build.sh",
-    "test:mocha-debug": "lldb -o run -- node node_modules/mocha/bin/mocha --inspect-brk",
-    "test:mocha": "mocha",
-    "test": "nyc npm run test:mocha",
-    "test:bun": "bun test/bun-test.js",
-    "debug": "nyc npm run test:mocha-debug",
-    "posttest": "npm run lint && npm run test:bun",
-    "lint": "eslint src/**.ts --fix",
-    "update": "npx npm-check-updates --target latest -u -x mocha && npm i && npm audit fix"
+    "build": "napi build",
+    "build:release": "napi build --release",
+    "test": "node test/roundtrip.js",
+    "test:bun": "bun test/roundtrip.js"
   },
-  "keywords": [],
-  "author": "Jeremiah Gowdy <jeremiah@gowdy.me>",
-  "license": "MIT",
-  "files": [
-    "binding.gyp",
-    "src/asherah_async_worker.h",
-    "src/asherah.cc",
-    "src/cobhan_buffer_napi.h",
-    "src/cobhan_buffer.h",
-    "src/hints.h",
-    "src/logging.h",
-    "src/logging_napi.cc",
-    "src/logging_napi.h",
-    "src/logging_stderr.cc",
-    "src/logging_stderr.h",
-    "src/napi_utils.h",
-    "src/scoped_allocate.h",
-    "src/asherah.d.ts",
-    "scripts/download-libraries.sh",
-    "scripts/build.sh",
-    "SHA256SUMS",
-    "SHA256SUMS-darwin",
-    ".asherah-version"
-  ],
   "devDependencies": {
-    "@cucumber/cucumber": "^11.2.0",
-    "@eslint/eslintrc": "^3.2.0",
-    "@eslint/js": "^9.20.0",
-    "@types/chai": "^5.0.1",
-    "@types/mocha": "^10.0.10",
-    "@types/node": "^22.13.1",
-    "@typescript-eslint/eslint-plugin": "^8.24.0",
-    "@typescript-eslint/parser": "^8.24.0",
-    "chai": "^5.1.2",
-    "eslint": "^9.20.1",
-    "globals": "^15.15.0",
-    "microtime": "^3.1.1",
-    "mocha": "^10.0.0",
-    "node-api-headers": "^1.5.0",
-    "nyc": "^17.1.0",
-    "tsx": "^4.21.0",
-    "typescript": "^5.7.3",
-    "winston": "^3.17.0"
+    "@napi-rs/cli": "^2.18.0"
   },
-  "mocha": {
-    "extension": [
-      "ts"
-    ],
-    "recursive": true,
-    "spec": "test/**/*.spec.ts",
-    "require": "tsx"
+  "engines": {
+    "node": ">= 18"
   },
-  "dependencies": {
-    "node-addon-api": "^8.3.0"
+  "optionalDependencies": {
+    "asherah-darwin-arm64": "4.0.0-beta.10",
+    "asherah-darwin-x64": "4.0.0-beta.10",
+    "asherah-linux-x64-gnu": "4.0.0-beta.10",
+    "asherah-linux-arm64-gnu": "4.0.0-beta.10",
+    "asherah-linux-x64-musl": "4.0.0-beta.10",
+    "asherah-linux-arm64-musl": "4.0.0-beta.10",
+    "asherah-windows-x64": "4.0.0-beta.10",
+    "asherah-windows-arm64": "4.0.0-beta.10"
   }
 }

package/.asherah-version

@@ -1 +0,0 @@
-ASHERAH_VERSION=v0.5.0

package/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2022 GoDaddy Operating Company, LLC.
-
-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.