@rdapify/pro 0.2.0

package/LICENSE

@@ -0,0 +1,35 @@
+RDAPify Pro — Commercial License Agreement
+
+Copyright (c) 2025 RDAPify Authors. All rights reserved.
+
+This software is licensed, not sold. By using this software, you agree
+to the following terms:
+
+1. GRANT OF LICENSE
+   A valid license key is required to use this software. Each license key
+   is granted to a single organization and covers the number of developers
+   specified in the purchased plan.
+
+2. PERMITTED USE
+   - Use in commercial and internal applications
+   - Use by the number of developers covered by your license
+   - Deployment to unlimited production environments
+
+3. RESTRICTIONS
+   - You may NOT redistribute, sublicense, or share the source code
+   - You may NOT reverse engineer, decompile, or disassemble the software
+   - You may NOT share, transfer, or publish your license key
+   - You may NOT remove or alter any proprietary notices
+
+4. SUBSCRIPTION
+   This license is valid only during the active subscription period.
+   Upon expiration or cancellation, you must cease using the software.
+
+5. WARRANTY DISCLAIMER
+   THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND.
+
+6. LIMITATION OF LIABILITY
+   IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DAMAGES ARISING
+   FROM THE USE OF THIS SOFTWARE.
+
+For licensing inquiries: licensing@rdapify.dev

package/README.md

@@ -0,0 +1,176 @@
+# @rdapify/pro
+
+Commercial extension for [rdapify](https://github.com/rdapify/RDAPify) that adds continuous monitoring, change detection, historical tracking, analytics, and integrations on top of the open-source RDAP client.
+
+`@rdapify/pro` is a **plugin** — it attaches to an existing `RDAPClient` instance via the `.use()` interface and does not modify or replace any core behaviour. All open-source features (SSRF protection, caching, PII redaction, middleware) remain fully operational.
+
+## Requirements
+
+| Dependency | Version |
+|------------|---------|
+| `rdapify` (peer) | `>= 0.2.0` |
+| Node.js | `>= 18` |
+| License key | Required — [rdapify.dev/pricing](https://rdapify.dev/pricing) |
+
+## Installation
+
+```bash
+npm install rdapify @rdapify/pro
+```
+
+## Quick start
+
+```typescript
+import { RDAPClient } from 'rdapify';
+import { ProPlugin } from '@rdapify/pro';
+
+const client = new RDAPClient();
+client.use(ProPlugin({ licenseKey: process.env.RDAPIFY_LICENSE_KEY! }));
+```
+
+Once activated, six new capabilities are available on the client instance: `monitor`, `detect`, `report`, `history`, `webhooks`, and `export`.
+
+---
+
+## Modules
+
+### Bulk monitoring
+
+Monitor thousands of domains or IP addresses on a recurring schedule. The monitor runs queries at a configurable interval, compares successive snapshots, and fires callbacks when changes are detected.
+
+```typescript
+client.monitor.start(['example.com', 'example.org'], {
+  interval: '6h',       // check every 6 hours
+  concurrency: 10,      // max parallel RDAP queries
+  onChange(event) {
+    // event.domain    — the target that changed
+    // event.type      — 'created' | 'updated' | 'expired' | 'transferred' | 'deleted'
+    // event.changes   — list of changed field paths
+    // event.previous  — previous RDAP snapshot
+    // event.current   — current RDAP snapshot
+    console.log(`${event.domain}: ${event.type}`, event.changes);
+  },
+});
+
+// Stop monitoring
+client.monitor.stop();
+```
+
+### Change detection
+
+Compare two RDAP response snapshots and extract a structured diff. Useful for on-demand comparisons without continuous monitoring.
+
+Detected change types:
+
+| Type | Description |
+|------|-------------|
+| `nameserver_changed` | Nameserver list differs |
+| `status_changed` | Domain/IP status flags changed |
+| `registrar_changed` | Sponsoring registrar changed |
+| `expiry_changed` | Expiration date moved |
+| `contact_changed` | Registrant/admin/tech contact changed |
+| `dnssec_changed` | DNSSEC delegation signer data changed |
+
+```typescript
+const previous = await client.domain('example.com');
+// ... time passes ...
+const current = await client.domain('example.com');
+
+const changes = client.detect.diff(previous, current);
+// → [{ changeType: 'expiry_changed', field: 'events.expiration',
+//       previousValue: '2025-03-01', currentValue: '2026-03-01' }]
+```
+
+### Historical tracking
+
+Record RDAP snapshots over time and query the history for a specific target.
+
+```typescript
+// Record a snapshot (typically called from monitor.onChange)
+client.history.record('example.com', 'domain', currentResponse);
+
+// Query stored history
+const entries = client.history.query({
+  target: 'example.com',
+  from: new Date('2026-01-01'),
+  to: new Date('2026-03-21'),
+  limit: 50,
+});
+```
+
+### Analytics and reporting
+
+Generate summary, detailed, or trend-based reports from collected query data.
+
+```typescript
+const report = client.report.generate({
+  format: 'trends',       // 'summary' | 'detailed' | 'trends'
+  from: new Date('2026-01-01'),
+  to: new Date('2026-03-21'),
+});
+
+console.log(report.totalQueries, report.data);
+```
+
+### Webhook integrations
+
+Push change notifications to Slack, Discord, Microsoft Teams, or any HTTP endpoint.
+
+```typescript
+client.webhooks.register({
+  provider: 'slack',      // 'slack' | 'discord' | 'teams' | 'custom'
+  url: process.env.SLACK_WEBHOOK_URL!,
+  events: ['status_changed', 'expiry_changed'],
+});
+
+// Notifications are sent automatically when monitor detects changes.
+// Manual dispatch:
+await client.webhooks.notify({ domain: 'example.com', type: 'expiry_changed' });
+```
+
+### Data export
+
+Export query results or historical snapshots to JSON or CSV.
+
+```typescript
+const csv = client.export.export(entries, {
+  format: 'csv',
+  fields: ['target', 'capturedAt', 'snapshot.registrar.name'],
+});
+```
+
+---
+
+## License key format
+
+Keys follow the pattern `RDAP-{plan}-{payload}-{signature}` and support offline validation (the payload is a signed, base64-encoded JSON). Online validation is available as an opt-in:
+
+```typescript
+client.use(ProPlugin({
+  licenseKey: 'RDAP-PRO-...',
+  onlineValidation: true,       // default: false
+}));
+```
+
+Plans: **pro** and **enterprise**. Enterprise keys unlock higher concurrency limits and priority support.
+
+## Architecture
+
+```
+@rdapify/pro
+├── plugin.ts           ProPlugin factory — validates license, attaches modules
+├── license/            Offline + online license validation
+├── monitoring/         BulkMonitor, ChangeDetector
+├── analytics/          Reporter (summary / detailed / trends)
+├── history/            HistoryTracker (in-memory snapshot storage)
+└── integrations/       WebhookManager, Exporter (json / csv)
+```
+
+Only `plugin.ts` touches `rdapify` internals. All other modules are self-contained and communicate through the plugin's `install()` hook.
+
+## License
+
+Proprietary. A commercial license is required for production use.
+
+See [LICENSE](LICENSE) for full terms.
+Purchase at [rdapify.dev/pricing](https://rdapify.dev/pricing).

package/index.d.ts

@@ -0,0 +1,245 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/* auto-generated by NAPI-RS */
+
+export interface ReportOptions {
+  /** "summary" | "detailed" | "trends". Default: "summary". */
+  format?: string
+  /** ISO-8601 — include only entries captured on or after this timestamp. */
+  from?: string
+  /** ISO-8601 — include only entries captured on or before this timestamp. */
+  to?: string
+}
+export interface TopEntry {
+  target: string
+  count: number
+}
+export interface ReportOutput {
+  generatedAt: string
+  format: string
+  totalQueries: number
+  registrars: Record<string, number>
+  statusCounts: Record<string, number>
+  queryTypes: Record<string, number>
+  topDomains: Array<TopEntry>
+  errorRate: number
+}
+export interface HistoryEntry {
+  target: string
+  queryType: string
+  /** JSON-serialised RDAP snapshot string. */
+  snapshot: string
+  /** ISO-8601 timestamp string. */
+  capturedAt: string
+}
+export interface HistoryQuery {
+  target: string
+  /** Filter: only entries captured on or after this ISO-8601 timestamp. */
+  from?: string
+  /** Filter: only entries captured on or before this ISO-8601 timestamp. */
+  to?: string
+  /** Return at most this many entries (most recent first). */
+  limit?: number
+}
+export interface WebhookConfig {
+  /** "slack" | "discord" | "teams" | "custom" */
+  provider: string
+  url: string
+  /** If set, only fire for these event types. */
+  events?: Array<string>
+  /** Custom HTTP headers added to the webhook request. */
+  headers?: Record<string, string>
+}
+export interface LicenseInfo {
+  valid: boolean
+  /** Present when `valid` is false. */
+  reason?: string
+  /** "pro" | "enterprise" | "trial" */
+  plan?: string
+  organization?: string
+  /** Unix timestamp in milliseconds (pass to `new Date(n)` in JS). */
+  expiresAt?: number
+  maxDevelopers?: number
+}
+export interface ChangeEvent {
+  target: string
+  /**
+   * "nameserver_changed" | "status_changed" | "registrar_changed" |
+   * "expiry_changed" | "dnssec_changed"
+   */
+  changeType: string
+  field: string
+  /** JSON-serialised previous value. */
+  previousValue: string
+  /** JSON-serialised current value. */
+  currentValue: string
+  /** ISO-8601 timestamp string. */
+  detectedAt: string
+}
+export interface MonitorEvent {
+  domain: string
+  /** "created" | "updated" | "expired" | "transferred" | "deleted" */
+  eventType: string
+  timestamp: string
+  changes: Array<string>
+}
+/** Options passed to `proPlugin()`. */
+export interface ProPluginOptions {
+  /** License key — required. Get one at https://rdapify.dev/pricing */
+  licenseKey: string
+  /** Enable online license validation (default: false). */
+  onlineValidation?: boolean
+}
+/**
+ * Validated plugin descriptor returned by `proPlugin()`.
+ * The JS wrapper calls `install(client)` on this object.
+ */
+export interface ProPluginDescriptor {
+  name: string
+  version: string
+  license: LicenseInfo
+}
+/**
+ * Validate the license key and return a plugin descriptor.
+ *
+ * Throws if the key is missing or invalid.
+ * The JS wrapper (`index.js`) attaches Pro modules to the client.
+ */
+export declare function proPlugin(options: ProPluginOptions): Promise<ProPluginDescriptor>
+/** Generates analytics reports from RDAP query data. */
+export declare class Reporter {
+  constructor()
+  /**
+   * Generate a report from a slice of RDAP response objects.
+   *
+   * `data` — each element must be a JSON string
+   * (e.g. `history.query(...).map(e => e.snapshot)`).
+   */
+  generate(data: Array<string>, options?: ReportOptions | undefined | null): ReportOutput
+}
+/**
+ * Tracks historical RDAP data for domains/IPs over time.
+ * Thread-safe: the inner `Vec` is guarded by a `Mutex` so that the JS
+ * `afterQuery` hook and explicit `record()` calls don't race.
+ */
+export declare class HistoryTracker {
+  constructor()
+  /**
+   * Record a new RDAP snapshot for `target`.
+   * `data` must be a JSON string (e.g. `JSON.stringify(rdapResponse)`).
+   */
+  record(target: string, queryType: string, data: string): void
+  /** Query history for a specific target, with optional date range and limit. */
+  query(options: HistoryQuery): Array<HistoryEntry>
+  /** Return the most recent snapshot for `target`, or `null` if none. */
+  latest(target: string): HistoryEntry | null
+  /** Total number of stored entries. */
+  count(): number
+  /** Remove all stored entries. */
+  clear(): void
+}
+/** Exports RDAP query results in JSON or CSV format. */
+export declare class Exporter {
+  constructor()
+  /**
+   * Export `data` as a pretty-printed JSON string.
+   *
+   * `data` — each element must be a JSON string
+   * (e.g. `history.query(...).map(e => e.snapshot)`).
+   */
+  exportJson(data: Array<string>): string
+  /**
+   * Export `data` as CSV.
+   *
+   * `data` — each element must be a JSON string.
+   * `fields` — column names to include. If omitted, all top-level string/number
+   * keys from the first record are used.
+   */
+  exportCsv(data: Array<string>, fields?: Array<string> | undefined | null): string
+}
+/**
+ * Manages webhook integrations for change-event notifications.
+ * HTTP is handled by a `reqwest` async client; failures are silently ignored
+ * so one bad webhook cannot block the others.
+ */
+export declare class WebhookManager {
+  constructor()
+  register(config: WebhookConfig): void
+  remove(url: string): void
+  getWebhooks(): Array<WebhookConfig>
+  /**
+   * Send `event` to all registered webhooks concurrently.
+   * `event` must be a JSON string (e.g. `JSON.stringify(changeEvent)`).
+   * Returns the number of webhooks notified (regardless of HTTP status).
+   */
+  notify(event: string): Promise<number>
+}
+/**
+ * License key format: `RDAP-{PLAN}-{base64url-payload}-{signature}`
+ *
+ * The payload is a base64url-encoded JSON object:
+ *   `{ org: string, exp: number (ms), maxDev?: number }`
+ *
+ * The signature segment is reserved for server-side cryptographic verification.
+ * Use `validate_online()` for full verification and revocation checks.
+ */
+export declare class LicenseValidator {
+  constructor()
+  /**
+   * Validate a license key offline.
+   * Decodes the embedded payload and checks expiry and plan.
+   * Does **not** verify the cryptographic signature.
+   */
+  static validate(key: string): LicenseInfo
+  /**
+   * Validate a license key online via the rdapify.dev license API.
+   * Falls back to offline validation if the API is unreachable.
+   */
+  static validateOnline(key: string): Promise<LicenseInfo>
+}
+/**
+ * Bulk domain/IP monitor.
+ *
+ * The Rust side manages targets, snapshots, and change detection.
+ * The JS wrapper (`index.js`) drives scheduling via `setInterval` and
+ * supplies RDAP query results by calling `process_results()`.
+ */
+export declare class BulkMonitor {
+  /**
+   * Create a new BulkMonitor.
+   *
+   * `interval` — polling interval string, e.g. `"30m"`, `"1h"`, `"6h"`, `"24h"`.
+   * `concurrency` — max parallel queries per poll cycle (default 10).
+   */
+  constructor(targets: Array<string>, interval?: string | undefined | null, concurrency?: number | undefined | null)
+  /**
+   * Process a batch of RDAP results received from the JS side.
+   *
+   * `results` — map of `{ target → JSON string of rdapResponse }`.
+   * Runs change detection against stored snapshots, updates them, and
+   * returns monitor events.
+   *
+   * Called by the JS wrapper on each poll cycle.
+   */
+  processResults(results: Record<string, string>): Array<MonitorEvent>
+  getTargets(): Array<string>
+  getIntervalMs(): number
+  getConcurrency(): number
+  addTargets(targets: Array<string>): void
+  removeTargets(targets: Array<string>): void
+  clearSnapshots(): void
+}
+/** Detects specific changes in RDAP records by comparing snapshots. */
+export declare class ChangeDetector {
+  constructor(targets: Array<string>)
+  /**
+   * Compare two RDAP response snapshots and return detected changes.
+   *
+   * Both `previous` and `current` must be JSON strings
+   * (e.g. `JSON.stringify(rdapResponse)`).
+   * Checks: nameservers, status flags, registrar name, expiry date, DNSSEC.
+   */
+  diff(previous: string, current: string): Array<ChangeEvent>
+  getTargets(): Array<string>
+}

package/index.js

@@ -0,0 +1,322 @@
+/* tslint:disable */
+/* eslint-disable */
+/* prettier-ignore */
+
+/* auto-generated by NAPI-RS */
+
+const { existsSync, readFileSync } = require('fs')
+const { join } = require('path')
+
+const { platform, arch } = process
+
+let nativeBinding = null
+let localFileExisted = false
+let loadError = null
+
+function isMusl() {
+  // For Node 10
+  if (!process.report || typeof process.report.getReport !== 'function') {
+    try {
+      const lddPath = require('child_process').execSync('which ldd').toString().trim()
+      return readFileSync(lddPath, 'utf8').includes('musl')
+    } catch (e) {
+      return true
+    }
+  } else {
+    const { glibcVersionRuntime } = process.report.getReport().header
+    return !glibcVersionRuntime
+  }
+}
+
+switch (platform) {
+  case 'android':
+    switch (arch) {
+      case 'arm64':
+        localFileExisted = existsSync(join(__dirname, 'rdapify-pro.android-arm64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rdapify-pro.android-arm64.node')
+          } else {
+            nativeBinding = require('@rdapify/pro-android-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm':
+        localFileExisted = existsSync(join(__dirname, 'rdapify-pro.android-arm-eabi.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rdapify-pro.android-arm-eabi.node')
+          } else {
+            nativeBinding = require('@rdapify/pro-android-arm-eabi')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Android ${arch}`)
+    }
+    break
+  case 'win32':
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(
+          join(__dirname, 'rdapify-pro.win32-x64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rdapify-pro.win32-x64-msvc.node')
+          } else {
+            nativeBinding = require('@rdapify/pro-win32-x64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'ia32':
+        localFileExisted = existsSync(
+          join(__dirname, 'rdapify-pro.win32-ia32-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rdapify-pro.win32-ia32-msvc.node')
+          } else {
+            nativeBinding = require('@rdapify/pro-win32-ia32-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'rdapify-pro.win32-arm64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rdapify-pro.win32-arm64-msvc.node')
+          } else {
+            nativeBinding = require('@rdapify/pro-win32-arm64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Windows: ${arch}`)
+    }
+    break
+  case 'darwin':
+    localFileExisted = existsSync(join(__dirname, 'rdapify-pro.darwin-universal.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./rdapify-pro.darwin-universal.node')
+      } else {
+        nativeBinding = require('@rdapify/pro-darwin-universal')
+      }
+      break
+    } catch {}
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(join(__dirname, 'rdapify-pro.darwin-x64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rdapify-pro.darwin-x64.node')
+          } else {
+            nativeBinding = require('@rdapify/pro-darwin-x64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'rdapify-pro.darwin-arm64.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rdapify-pro.darwin-arm64.node')
+          } else {
+            nativeBinding = require('@rdapify/pro-darwin-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on macOS: ${arch}`)
+    }
+    break
+  case 'freebsd':
+    if (arch !== 'x64') {
+      throw new Error(`Unsupported architecture on FreeBSD: ${arch}`)
+    }
+    localFileExisted = existsSync(join(__dirname, 'rdapify-pro.freebsd-x64.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./rdapify-pro.freebsd-x64.node')
+      } else {
+        nativeBinding = require('@rdapify/pro-freebsd-x64')
+      }
+    } catch (e) {
+      loadError = e
+    }
+    break
+  case 'linux':
+    switch (arch) {
+      case 'x64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'rdapify-pro.linux-x64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./rdapify-pro.linux-x64-musl.node')
+            } else {
+              nativeBinding = require('@rdapify/pro-linux-x64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'rdapify-pro.linux-x64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./rdapify-pro.linux-x64-gnu.node')
+            } else {
+              nativeBinding = require('@rdapify/pro-linux-x64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'rdapify-pro.linux-arm64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./rdapify-pro.linux-arm64-musl.node')
+            } else {
+              nativeBinding = require('@rdapify/pro-linux-arm64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'rdapify-pro.linux-arm64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./rdapify-pro.linux-arm64-gnu.node')
+            } else {
+              nativeBinding = require('@rdapify/pro-linux-arm64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'rdapify-pro.linux-arm-musleabihf.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./rdapify-pro.linux-arm-musleabihf.node')
+            } else {
+              nativeBinding = require('@rdapify/pro-linux-arm-musleabihf')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'rdapify-pro.linux-arm-gnueabihf.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./rdapify-pro.linux-arm-gnueabihf.node')
+            } else {
+              nativeBinding = require('@rdapify/pro-linux-arm-gnueabihf')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'riscv64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'rdapify-pro.linux-riscv64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./rdapify-pro.linux-riscv64-musl.node')
+            } else {
+              nativeBinding = require('@rdapify/pro-linux-riscv64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'rdapify-pro.linux-riscv64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./rdapify-pro.linux-riscv64-gnu.node')
+            } else {
+              nativeBinding = require('@rdapify/pro-linux-riscv64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 's390x':
+        localFileExisted = existsSync(
+          join(__dirname, 'rdapify-pro.linux-s390x-gnu.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rdapify-pro.linux-s390x-gnu.node')
+          } else {
+            nativeBinding = require('@rdapify/pro-linux-s390x-gnu')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Linux: ${arch}`)
+    }
+    break
+  default:
+    throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`)
+}
+
+if (!nativeBinding) {
+  if (loadError) {
+    throw loadError
+  }
+  throw new Error(`Failed to load native binding`)
+}
+
+const { Reporter, HistoryTracker, Exporter, WebhookManager, LicenseValidator, BulkMonitor, ChangeDetector, proPlugin } = nativeBinding
+
+module.exports.Reporter = Reporter
+module.exports.HistoryTracker = HistoryTracker
+module.exports.Exporter = Exporter
+module.exports.WebhookManager = WebhookManager
+module.exports.LicenseValidator = LicenseValidator
+module.exports.BulkMonitor = BulkMonitor
+module.exports.ChangeDetector = ChangeDetector
+module.exports.proPlugin = proPlugin

package/package.json

@@ -0,0 +1,98 @@
+{
+  "name": "@rdapify/pro",
+  "version": "0.2.0",
+  "description": "Premium Rust-native features for RDAPify — Bulk Monitoring, Change Detection, Analytics & more",
+  "main": "wrapper.js",
+  "types": "index.d.ts",
+  "napi": {
+    "name": "rdapify-pro",
+    "triples": {
+      "defaults": true,
+      "additional": [
+        "aarch64-apple-darwin",
+        "aarch64-unknown-linux-gnu",
+        "aarch64-unknown-linux-musl",
+        "x86_64-unknown-linux-musl"
+      ]
+    }
+  },
+  "scripts": {
+    "build": "napi build --platform --release",
+    "build:debug": "napi build --platform",
+    "artifacts": "napi artifacts",
+    "prepublishOnly": "napi prepublish -t npm",
+    "universal": "napi universal",
+    "version": "napi version",
+    "test": "jest --runInBand",
+    "clean": "rm -rf *.node target/"
+  },
+  "jest": {
+    "preset": "ts-jest",
+    "testEnvironment": "node",
+    "testMatch": [
+      "**/tests/**/*.test.ts"
+    ],
+    "moduleFileExtensions": [
+      "ts",
+      "js",
+      "json"
+    ],
+    "transform": {
+      "^.+\\.ts$": [
+        "ts-jest",
+        {
+          "tsconfig": {
+            "strict": false
+          }
+        }
+      ]
+    }
+  },
+  "peerDependencies": {
+    "rdapify": ">=0.1.9"
+  },
+  "devDependencies": {
+    "@napi-rs/cli": "^2.18.0",
+    "rdapify": "file:../rdapify",
+    "jest": "^29.7.0",
+    "@types/jest": "^29.5.0",
+    "ts-jest": "^29.2.0",
+    "typescript": "^5.7.0",
+    "@types/node": "^22.0.0"
+  },
+  "optionalDependencies": {
+    "@rdapify/pro-win32-x64-msvc": "0.2.0",
+    "@rdapify/pro-darwin-x64": "0.2.0",
+    "@rdapify/pro-linux-x64-gnu": "0.2.0",
+    "@rdapify/pro-darwin-arm64": "0.2.0",
+    "@rdapify/pro-linux-arm64-gnu": "0.2.0",
+    "@rdapify/pro-linux-arm64-musl": "0.2.0",
+    "@rdapify/pro-linux-x64-musl": "0.2.0"
+  },
+  "files": [
+    "index.js",
+    "wrapper.js",
+    "index.d.ts",
+    "rdapify-pro.node",
+    "LICENSE",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rdapify/RDAPify-Pro.git"
+  },
+  "keywords": [
+    "rdap",
+    "rdapify",
+    "rust",
+    "native",
+    "monitoring",
+    "domain",
+    "whois",
+    "analytics"
+  ]
+}

package/wrapper.js

@@ -0,0 +1,90 @@
+'use strict';
+
+const native = require('./index.js');
+
+const {
+  Reporter,
+  HistoryTracker,
+  Exporter,
+  WebhookManager,
+  LicenseValidator,
+  BulkMonitor,
+  ChangeDetector,
+  proPlugin,
+} = native;
+
+module.exports.Reporter = Reporter;
+module.exports.HistoryTracker = HistoryTracker;
+module.exports.Exporter = Exporter;
+module.exports.WebhookManager = WebhookManager;
+module.exports.LicenseValidator = LicenseValidator;
+module.exports.BulkMonitor = BulkMonitor;
+module.exports.ChangeDetector = ChangeDetector;
+module.exports.proPlugin = proPlugin;
+
+/**
+ * ProPlugin — synchronous factory that validates a license key offline and
+ * returns a plugin descriptor with an `install(client)` method.
+ *
+ * @param {object} options
+ * @param {string} options.licenseKey
+ * @param {boolean} [options.onlineValidation=false]
+ */
+function ProPlugin(options) {
+  if (!options || !options.licenseKey) {
+    throw new Error(
+      '[@rdapify/pro] License key required. Get one at https://rdapify.dev/pricing'
+    );
+  }
+
+  const license = LicenseValidator.validate(options.licenseKey);
+  if (!license.valid) {
+    throw new Error(
+      `[@rdapify/pro] Invalid or expired license key. Reason: ${license.reason}`
+    );
+  }
+
+  return {
+    name: '@rdapify/pro',
+    version: require('./package.json').version,
+    license,
+    install(client) {
+      const history = new HistoryTracker();
+
+      client.monitor = function (targets, opts) {
+        return new BulkMonitor(
+          targets,
+          (opts && opts.interval) || undefined,
+          (opts && opts.concurrency) || undefined
+        );
+      };
+
+      client.detect = function (targets) {
+        return new ChangeDetector(targets);
+      };
+
+      client.report = function () {
+        return new Reporter();
+      };
+
+      client.history = history;
+      client.webhooks = new WebhookManager();
+      client.export = new Exporter();
+
+      if (typeof client.use === 'function') {
+        client.use({
+          afterQuery(ctx) {
+            const result = ctx.result;
+            if (result) {
+              const queryType = ctx.queryType != null ? String(ctx.queryType) : 'domain';
+              const query = ctx.query != null ? String(ctx.query) : '';
+              history.record(query, queryType, JSON.stringify(result));
+            }
+          },
+        });
+      }
+    },
+  };
+}
+
+module.exports.ProPlugin = ProPlugin;