@agentcontextdistributionprotocol/acdp 0.3.0

package/README.md

@@ -0,0 +1,84 @@
+# acdp — Node.js SDK
+
+Thin NAPI-rs binding over the [`acdp`](https://crates.io/crates/acdp)
+Rust library. Implements the producer- and consumer-side crypto for the
+Agent Context Distribution Protocol v0.1.0 (RFC-ACDP-0001/0003/0008).
+HTTP is intentionally left to the caller — pair this with `fetch` /
+`undici` for transport.
+
+## Install (development)
+
+```bash
+npm install                  # installs @napi-rs/cli
+npm run build:debug          # produces index.js + acdp.<platform>.node
+node --test tests/           # in-process unit tests, no HTTP
+```
+
+## Build a release binary
+
+```bash
+npm run build                # release mode (LTO + strip)
+```
+
+## Quickstart
+
+```javascript
+import { AcdpProducer, AcdpVerifier } from '@agentcontextdistributionprotocol/acdp';
+
+const producer = AcdpProducer.generate(
+  'did:web:agents.example.com:my-agent',
+  'did:web:agents.example.com:my-agent#key-1',
+);
+
+const raw = producer.buildPublishRequest({
+  title: 'Q1 snapshot',
+  contextType: 'data_snapshot',
+  summary: 'Quarter-end inventory',
+});
+
+// POST `raw` (the JSON string) to your registry. On retrieve:
+const body = (await response.json()).body;
+AcdpVerifier.verifyContentHash(JSON.stringify(body), body.content_hash);
+AcdpVerifier.verifySignature(
+  pubKeyB64,                  // resolved from the producer's did:web doc
+  body.signature.value,
+  body.content_hash,
+);
+```
+
+## Design rules
+
+* **JSON across the FFI boundary.** Every method accepts and returns
+  JSON strings — never a Rust type, never a JS class instance you'd
+  have to serialize before sending. The binary stays at ~500 lines of
+  glue.
+* **Crypto in Rust, HTTP in JS.** Key generation, JCS + SHA-256 hashing,
+  Ed25519 signing, and signature verification happen in the underlying
+  `acdp` crate. Transport, retries, and observability are yours.
+* **`AcdpProducer` stores a 32-byte seed.** The Rust `SigningKey` is
+  `ZeroizeOnDrop` and not `Clone`, so the binding rebuilds the signing
+  key from the seed on each call.
+* **Golden vector parity.** `golden content_hash + signature match
+  sig-001` pins the JS-side `content_hash` and `signature.value`
+  against the spec's `sig-001` fixture — the same constants the Rust
+  suite asserts. A drift on either side is a protocol break.
+
+## Layout
+
+```
+bindings/acdp-node/
+├── Cargo.toml         # standalone [workspace]; depends on `acdp` via path
+├── build.rs           # napi-build setup
+├── package.json
+├── README.md          # this file
+├── index.js           # generated by `napi build`
+├── index.d.ts         # generated by `napi build`
+├── acdp.<platform>.node  # native binary
+├── src/
+│   ├── lib.rs         # module entry — re-exports the napi classes
+│   ├── producer.rs    # AcdpProducer: build/sign publish requests
+│   ├── verifier.rs    # AcdpVerifier: content_hash + signature verify
+│   └── helpers.rs     # visibility / contextType parsers
+└── tests/
+    └── test.mjs
+```

package/index.d.ts

@@ -0,0 +1,402 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/* auto-generated by NAPI-RS */
+
+/**
+ * A verification method resolved to raw public-key bytes, in the
+ * base64 shape the host's pinned-key directory speaks.
+ */
+export interface ResolvedDidKey {
+  /** Verification-method id (full DID URL with `#fragment`). */
+  keyId: string
+  /** `ed25519` or `ecdsa-p256`. */
+  algorithm: string
+  /**
+   * Standard base64 of the raw key bytes:
+   * * ed25519 — 32 bytes
+   * * ecdsa-p256 — 65-byte SEC1 uncompressed (`0x04 || x || y`)
+   */
+  publicKeyB64: string
+}
+/**
+ * Options for `buildPublishRequest`. Field names map directly to the
+ * PublishRequest wire schema (camelCase on the JS side).
+ */
+export interface PublishOpts {
+  /** Human-readable title (1..=500 chars). */
+  title: string
+  /** Closed enum or namespaced custom (`^[a-z][a-z0-9_]*:[a-z][a-z0-9_-]*$`). */
+  contextType: string
+  /** `public` | `restricted` | `private`. Defaults to `public`. */
+  visibility?: string
+  /** Long human-readable description (≤ 5000 chars). */
+  description?: string
+  /**
+   * Producer-supplied summary for search results (≤ 1000 chars).
+   * Part of ProducerContent — included in the content_hash preimage.
+   */
+  summary?: string
+  /** Free-form tags (each: `^[A-Za-z0-9][A-Za-z0-9_.-]*$`, ≤ 100 chars). */
+  tags?: Array<string>
+  /** Subject-domain identifier (≤ 200 chars). */
+  domain?: string
+  /**
+   * Producer-specific structured metadata. MUST be a JSON-encoded
+   * object string (it is re-parsed so it lands as a JSON object,
+   * not a quoted string).
+   */
+  metadata?: string
+  /**
+   * Lineage of contexts this body was derived from (`acdp://…` ids,
+   * ≤ 1000 unique).
+   */
+  derivedFrom?: Array<string>
+  /** Audience DIDs — required (≥ 1) when `visibility = "restricted"`. */
+  audience?: Array<string>
+  /** Optional JSON Schema URI describing the metadata shape. */
+  schemaUri?: string
+  /** Contributors (DIDs, ≤ 100 unique). */
+  contributors?: Array<string>
+  /**
+   * Data references — a JSON-encoded array of `acdp-data-ref` objects.
+   * Part of ProducerContent, so it is included in the content_hash
+   * preimage.
+   */
+  dataRefs?: string
+  /**
+   * RFC 3339 timestamp after which the conclusions should no longer be
+   * relied upon. Truncated to millisecond precision.
+   */
+  expiresAt?: string
+  /**
+   * Time window the data covers — a JSON object
+   * `{"start": <rfc3339>, "end": <rfc3339>}`. Both ends truncated to
+   * millisecond precision.
+   */
+  dataPeriod?: string
+  /**
+   * Self-verifying `lin:sha256:<hex>` lineage id. v2+ supersession
+   * only — rejected on first-version publishes.
+   */
+  expectedLineageId?: string
+}
+/**
+ * Options for `buildSupersedeRequest`. Any field omitted is carried
+ * over from `previousBodyJson` unchanged (mirrors `new_version_from`).
+ */
+export interface SupersedeOpts {
+  title?: string
+  summary?: string
+  description?: string
+  tags?: Array<string>
+  domain?: string
+  metadata?: string
+  /**
+   * JSON-encoded array of `acdp-data-ref` objects (replaces the
+   * carried-over data refs when present).
+   */
+  dataRefs?: string
+  /** RFC 3339 expiry timestamp. */
+  expiresAt?: string
+  /** JSON object `{"start": <rfc3339>, "end": <rfc3339>}`. */
+  dataPeriod?: string
+  /** Self-verifying `lin:sha256:<hex>` lineage id (v2+). */
+  expectedLineageId?: string
+}
+/** Stateless did:web string helpers. All methods are static. */
+export declare class AcdpDid {
+  /**
+   * Translate a `did:web:…` DID to the HTTPS URL of its DID document
+   * per RFC-ACDP-0001 §5.11.
+   *
+   * * `did:web:example.com` → `https://example.com/.well-known/did.json`
+   * * `did:web:example.com:users:alice` → `https://example.com/users/alice/did.json`
+   *
+   * Throws with `.code === "not_did_web"` if the input is not a
+   * `did:web` DID.
+   */
+  static webToUrl(did: string): string
+  /**
+   * Strip the `#fragment` from a DID URL, returning the bare DID.
+   * Returns the input unchanged when it carries no fragment.
+   */
+  static stripFragment(didUrl: string): string
+}
+/**
+ * A parsed did:web DID document. Construct with
+ * [`AcdpDidDocument::parse`], then resolve a signing key with
+ * [`AcdpDidDocument::key_for_algorithm`].
+ */
+export declare class AcdpDidDocument {
+  /**
+   * Parse a DID document and assert its `id` equals `expectedDid`.
+   *
+   * `expectedDid` is the bare DID being resolved (no fragment). The
+   * `id`-match check (RFC-ACDP-0001 §9.1) stops a misconfigured or
+   * hostile server from substituting another DID's keys.
+   *
+   * Throws `.code === "parse_failed"` on malformed JSON / missing
+   * `id`, or `.code === "id_mismatch"` when `id` ≠ `expectedDid`.
+   */
+  static parse(jsonStr: string, expectedDid: string): AcdpDidDocument
+  /** The DID this document describes. */
+  get id(): string
+  /**
+   * Resolve a verification method to raw public-key bytes, enforcing
+   * the full consumer-side gate:
+   *
+   * 1. the method `requestedKeyId` (matched by `#fragment`, exact —
+   *    no loose suffix) must exist, else `.code === "key_not_found"`;
+   * 2. it must be authorized in `assertionMethod`, else
+   *    `.code === "key_not_authorized"`;
+   * 3. any algorithm the method declares (via `type`, JWK params, or
+   *    multibase multicodec prefix) must equal `requestedAlg`, else
+   *    `.code === "alg_mismatch"` (downgrade defense, RFC-ACDP-0008
+   *    §3.9);
+   * 4. the key bytes must decode for `requestedAlg`, else
+   *    `.code === "malformed_key"`.
+   *
+   * `requestedAlg` is `"ed25519"` or `"ecdsa-p256"`
+   * (`.code === "unsupported_algorithm"` otherwise). `requestedKeyId`
+   * is the full DID URL from the signature's `key_id`.
+   */
+  keyForAlgorithm(requestedKeyId: string, requestedAlg: string): ResolvedDidKey
+}
+/** RFC 8785 canonicalization utilities. All methods are static. */
+export declare class AcdpCanonicalizer {
+  /**
+   * Canonicalize a JSON document to its RFC 8785 (JCS) form.
+   *
+   * * `jsonStr` — any JSON document as a string.
+   *
+   * Returns the canonical UTF-8 JSON string (sorted object keys, no
+   * whitespace, `-0.0` normalized to `0`, ECMAScript number
+   * formatting). Throws on malformed JSON, or if the document nests
+   * past the canonicalizer's recursion ceiling.
+   */
+  static canonicalize(jsonStr: string): string
+  /**
+   * SHA-256 over the canonical (JCS) form of a JSON document, returned
+   * as the ACDP envelope `"sha256:<64-lowercase-hex>"`.
+   *
+   * This is the hashing primitive behind `content_hash` /
+   * `data_ref.content_hash`. It hashes the document *as given* — it
+   * does NOT strip the RFC-ACDP-0001 §5.7 exclusion set, so to
+   * recompute a body's `content_hash` the caller passes the already
+   * producer-controlled object (or uses `AcdpVerifier.verifyContentHash`).
+   */
+  static contentHash(jsonStr: string): string
+}
+/**
+ * An ACDP producer: an Ed25519 signing key and its did:web identity.
+ *
+ * All methods return wire-ready JSON strings the caller sends via its
+ * own HTTP client. No HTTP calls are made inside this class.
+ */
+export declare class AcdpProducer {
+  /** Generate a producer with a fresh random Ed25519 key (OsRng). */
+  static generate(agentDid: string, keyId: string): AcdpProducer
+  /** Construct from a 32-byte Ed25519 seed (deterministic). */
+  static fromSeed(seed: Buffer, agentDid: string, keyId: string): AcdpProducer
+  /** The producer's DID (`did:web:…`). */
+  get agentDid(): string
+  /** The producer's signing-key DID URL (`did:web:…#key-1`). */
+  get keyId(): string
+  /**
+   * Raw Ed25519 public key as standard base64 (44 chars with padding).
+   * Use this to populate a did:web verification method.
+   */
+  get publicKeyB64(): string
+  /**
+   * The raw 32-byte seed, for storage in a key vault. Returns a
+   * fresh `Buffer` each call — JS owns the bytes.
+   */
+  seedBytes(): Buffer
+  /**
+   * Build and sign a first-version PublishRequest. Returns the
+   * wire JSON string.
+   */
+  buildPublishRequest(opts: PublishOpts): string
+  /**
+   * Build and sign a supersession PublishRequest from a previous
+   * version's `Body` JSON. Version is propagated automatically
+   * (`previous.version + 1`) and `lineage_id` is carried forward.
+   */
+  buildSupersedeRequest(previousBodyJson: string, opts: SupersedeOpts): string
+  /**
+   * Sign a registry auth-challenge `signingInput` string. Returns
+   * the base64-encoded Ed25519 signature (88 chars with padding).
+   * Used by the ACDP registry's bearer-token flow.
+   */
+  signChallenge(signingInput: string): string
+}
+/**
+ * An ACDP producer signing with ECDSA-P256 (`ecdsa-p256`) instead of
+ * the Ed25519 baseline.
+ *
+ * Mirrors [`AcdpProducer`] exactly — same JSON-in/JSON-out surface and
+ * the same `PublishOpts` / `SupersedeOpts` shapes — but emits
+ * `signature.algorithm = "ecdsa-p256"` and the IEEE 1363 `r‖s` wire
+ * form. Use this when the producer's `did:web` verification method
+ * declares a P-256 key. The DID document MUST declare the P-256
+ * algorithm so consumers don't reject the signature on
+ * algorithm-downgrade grounds (RFC-ACDP-0008 §3.9); use
+ * [`AcdpP256Producer::did_verification_method`] to mint that entry.
+ */
+export declare class AcdpP256Producer {
+  /** Generate a producer with a fresh random P-256 key (OsRng). */
+  static generate(agentDid: string, keyId: string): AcdpP256Producer
+  /**
+   * Construct from a 32-byte P-256 private scalar (deterministic).
+   * Throws if the bytes are not exactly 32 or are not a valid scalar.
+   */
+  static fromSeed(seed: Buffer, agentDid: string, keyId: string): AcdpP256Producer
+  /** The producer's DID (`did:web:…`). */
+  get agentDid(): string
+  /** The producer's signing-key DID URL (`did:web:…#key-1`). */
+  get keyId(): string
+  /**
+   * SEC1-uncompressed public key (`0x04 || x || y`, 65 bytes) as
+   * standard base64. Use this to populate a did:web `JsonWebKey2020`
+   * verification method.
+   */
+  get publicKeySec1B64(): string
+  /**
+   * The producer's P-256 public key as a JWK
+   * (`{"kty":"EC","crv":"P-256","x":…,"y":…}`), returned as a JSON
+   * object string. Drop this straight into a did:web `JsonWebKey2020`
+   * verification method's `publicKeyJwk`.
+   */
+  get publicKeyJwk(): string
+  /**
+   * A complete `verificationMethod` entry (JSON object string) for a
+   * did:web DID document, of type `JsonWebKey2020`.
+   *
+   * * `methodId` — the full DID URL for this key (e.g.
+   *   `"did:web:agents.example.com:alice#key-1"`).
+   * * `controller` — the bare DID that owns the key (no fragment).
+   *
+   * Consumers resolve the signature algorithm from this entry, so
+   * publishing it is what keeps a P-256 signature from being rejected
+   * on algorithm-downgrade grounds (RFC-ACDP-0008 §3.9).
+   */
+  didVerificationMethod(methodId: string, controller: string): string
+  /**
+   * The raw 32-byte private scalar, for storage in a key vault.
+   * Returns a fresh `Buffer` each call — JS owns the bytes.
+   */
+  seedBytes(): Buffer
+  /**
+   * Build and sign a first-version PublishRequest. Returns the wire
+   * JSON string. Same surface as [`AcdpProducer::build_publish_request`];
+   * only the signature algorithm differs.
+   */
+  buildPublishRequest(opts: PublishOpts): string
+  /**
+   * Build and sign a supersession PublishRequest from a previous
+   * version's `Body` JSON. Same semantics as
+   * [`AcdpProducer::build_supersede_request`].
+   */
+  buildSupersedeRequest(previousBodyJson: string, opts: SupersedeOpts): string
+  /**
+   * Sign a registry auth-challenge `signingInput` string with the
+   * producer's P-256 key. Returns the base64 IEEE 1363 signature.
+   */
+  signChallenge(signingInput: string): string
+}
+/**
+ * An SSRF policy: the synchronous classification half of the Rust
+ * `SsrfPolicy`, exposed verdict-only (no DNS, no sockets).
+ */
+export declare class AcdpSsrfPolicy {
+  /**
+   * The production policy: HTTPS-only, IP literals rejected, every
+   * private / loopback / link-local / IMDS / multicast / reserved
+   * range forbidden.
+   */
+  static production(): AcdpSsrfPolicy
+  /**
+   * A test-only policy that additionally permits loopback
+   * (`127.0.0.0/8` / `::1`) so a test harness can target a local
+   * listener. Never use in production.
+   */
+  static allowTestLoopback(): AcdpSsrfPolicy
+  /**
+   * Validate a URL: scheme (HTTPS-only), IP-literal rejection, and —
+   * for literal hosts — per-IP range filtering.
+   *
+   * Resolves on success. Throws an `Error` whose `.code` is the stable
+   * reason on a policy violation.
+   */
+  checkUrl(url: string): void
+  /**
+   * Validate a single already-resolved IP address (IPv4 or IPv6
+   * string). This is the per-address predicate the host loops over
+   * after resolving DNS itself — rejecting the whole answer set if any
+   * address fails (the mixed-answer rule stays in the host).
+   *
+   * Resolves on success. Throws with `.code === "invalid_ip"` if `ip`
+   * is not a valid address, or with the stable range reason if it
+   * falls in a forbidden range.
+   */
+  checkIp(ip: string): void
+  /**
+   * Validate that a redirect target stays within the origin's fetch
+   * authority — identical scheme, host, and effective port (an
+   * explicit `:443` equals the implicit https default).
+   *
+   * Resolves on success. Throws with `.code === "cross_authority"`
+   * when the authority differs.
+   */
+  checkRedirectAuthority(fromUrl: string, toUrl: string): void
+}
+/** Consumer-side verification utilities. All methods are static. */
+export declare class AcdpVerifier {
+  /**
+   * Verify that a body's `content_hash` matches the SHA-256 over
+   * its JCS-canonicalized producer-controlled fields.
+   *
+   * * `bodyJson` — the `body` object from a `FullContext` retrieval
+   *   (or the `PublishRequest` itself — both share the §5.7 layout).
+   * * `expectedHash` — the `body.content_hash` string
+   *   (`"sha256:<64-hex>"`).
+   *
+   * Returns `true` on success; throws on mismatch or bad JSON.
+   */
+  static verifyContentHash(bodyJson: string, expectedHash: string): boolean
+  /**
+   * Verify an Ed25519 signature over a `content_hash` string.
+   *
+   * The signing input per RFC-ACDP-0001 §5.8 is the ASCII bytes of
+   * the full `"sha256:<hex>"` string — NOT the raw 32-byte digest.
+   *
+   * * `pubKeyB64` — standard base64 (padded) of the 32-byte raw
+   *   Ed25519 public key (same shape as
+   *   `AcdpProducer.publicKeyB64`).
+   * * `sigB64` — the `body.signature.value` field from the wire
+   *   format.
+   * * `contentHash` — the `body.content_hash` string.
+   *
+   * Returns `true` on success; throws on failure.
+   */
+  static verifySignature(pubKeyB64: string, sigB64: string, contentHash: string): boolean
+  /**
+   * Verify an ECDSA-P256 signature over a `content_hash` string.
+   *
+   * The counterpart to `AcdpP256Producer` signing. The signing input
+   * per RFC-ACDP-0001 §5.8 is the ASCII bytes of the full
+   * `"sha256:<hex>"` string — NOT the raw 32-byte digest. The wire
+   * signature is IEEE 1363 `r‖s` (64 bytes, base64), NOT DER.
+   *
+   * * `pubKeySec1B64` — standard base64 of the 65-byte
+   *   SEC1-uncompressed public key (`0x04 || x || y`), the same shape
+   *   as `AcdpP256Producer.publicKeySec1B64`.
+   * * `sigB64` — the `body.signature.value` field from the wire
+   *   format (88-char base64 of the 64-byte `r‖s`).
+   * * `contentHash` — the `body.content_hash` string.
+   *
+   * Returns `true` on success; throws on failure.
+   */
+  static verifySignatureP256(pubKeySec1B64: string, sigB64: string, contentHash: string): boolean
+}

package/index.js

@@ -0,0 +1,321 @@
+/* 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, 'acdp.android-arm64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./acdp.android-arm64.node')
+          } else {
+            nativeBinding = require('@agentcontextdistributionprotocol/acdp-android-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm':
+        localFileExisted = existsSync(join(__dirname, 'acdp.android-arm-eabi.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./acdp.android-arm-eabi.node')
+          } else {
+            nativeBinding = require('@agentcontextdistributionprotocol/acdp-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, 'acdp.win32-x64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./acdp.win32-x64-msvc.node')
+          } else {
+            nativeBinding = require('@agentcontextdistributionprotocol/acdp-win32-x64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'ia32':
+        localFileExisted = existsSync(
+          join(__dirname, 'acdp.win32-ia32-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./acdp.win32-ia32-msvc.node')
+          } else {
+            nativeBinding = require('@agentcontextdistributionprotocol/acdp-win32-ia32-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'acdp.win32-arm64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./acdp.win32-arm64-msvc.node')
+          } else {
+            nativeBinding = require('@agentcontextdistributionprotocol/acdp-win32-arm64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Windows: ${arch}`)
+    }
+    break
+  case 'darwin':
+    localFileExisted = existsSync(join(__dirname, 'acdp.darwin-universal.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./acdp.darwin-universal.node')
+      } else {
+        nativeBinding = require('@agentcontextdistributionprotocol/acdp-darwin-universal')
+      }
+      break
+    } catch {}
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(join(__dirname, 'acdp.darwin-x64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./acdp.darwin-x64.node')
+          } else {
+            nativeBinding = require('@agentcontextdistributionprotocol/acdp-darwin-x64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'acdp.darwin-arm64.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./acdp.darwin-arm64.node')
+          } else {
+            nativeBinding = require('@agentcontextdistributionprotocol/acdp-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, 'acdp.freebsd-x64.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./acdp.freebsd-x64.node')
+      } else {
+        nativeBinding = require('@agentcontextdistributionprotocol/acdp-freebsd-x64')
+      }
+    } catch (e) {
+      loadError = e
+    }
+    break
+  case 'linux':
+    switch (arch) {
+      case 'x64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'acdp.linux-x64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./acdp.linux-x64-musl.node')
+            } else {
+              nativeBinding = require('@agentcontextdistributionprotocol/acdp-linux-x64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'acdp.linux-x64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./acdp.linux-x64-gnu.node')
+            } else {
+              nativeBinding = require('@agentcontextdistributionprotocol/acdp-linux-x64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'acdp.linux-arm64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./acdp.linux-arm64-musl.node')
+            } else {
+              nativeBinding = require('@agentcontextdistributionprotocol/acdp-linux-arm64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'acdp.linux-arm64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./acdp.linux-arm64-gnu.node')
+            } else {
+              nativeBinding = require('@agentcontextdistributionprotocol/acdp-linux-arm64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'acdp.linux-arm-musleabihf.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./acdp.linux-arm-musleabihf.node')
+            } else {
+              nativeBinding = require('@agentcontextdistributionprotocol/acdp-linux-arm-musleabihf')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'acdp.linux-arm-gnueabihf.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./acdp.linux-arm-gnueabihf.node')
+            } else {
+              nativeBinding = require('@agentcontextdistributionprotocol/acdp-linux-arm-gnueabihf')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'riscv64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'acdp.linux-riscv64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./acdp.linux-riscv64-musl.node')
+            } else {
+              nativeBinding = require('@agentcontextdistributionprotocol/acdp-linux-riscv64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'acdp.linux-riscv64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./acdp.linux-riscv64-gnu.node')
+            } else {
+              nativeBinding = require('@agentcontextdistributionprotocol/acdp-linux-riscv64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 's390x':
+        localFileExisted = existsSync(
+          join(__dirname, 'acdp.linux-s390x-gnu.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./acdp.linux-s390x-gnu.node')
+          } else {
+            nativeBinding = require('@agentcontextdistributionprotocol/acdp-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 { AcdpDid, AcdpDidDocument, AcdpCanonicalizer, AcdpProducer, AcdpP256Producer, AcdpSsrfPolicy, AcdpVerifier } = nativeBinding
+
+module.exports.AcdpDid = AcdpDid
+module.exports.AcdpDidDocument = AcdpDidDocument
+module.exports.AcdpCanonicalizer = AcdpCanonicalizer
+module.exports.AcdpProducer = AcdpProducer
+module.exports.AcdpP256Producer = AcdpP256Producer
+module.exports.AcdpSsrfPolicy = AcdpSsrfPolicy
+module.exports.AcdpVerifier = AcdpVerifier

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@agentcontextdistributionprotocol/acdp",
+  "version": "0.3.0",
+  "description": "Agent Context Distribution Protocol — Node.js SDK",
+  "license": "MIT OR Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/agentcontextdistributionprotocol/acdp-rs.git",
+    "directory": "bindings/acdp-node"
+  },
+  "homepage": "https://github.com/agentcontextdistributionprotocol/acdp-rs/tree/main/bindings/acdp-node",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "type": "commonjs",
+  "files": [
+    "index.js",
+    "index.d.ts"
+  ],
+  "napi": {
+    "name": "acdp",
+    "triples": {
+      "defaults": false,
+      "additional": [
+        "x86_64-apple-darwin",
+        "aarch64-apple-darwin",
+        "x86_64-unknown-linux-gnu",
+        "aarch64-unknown-linux-gnu"
+      ]
+    }
+  },
+  "scripts": {
+    "build": "napi build --platform --release",
+    "build:debug": "napi build --platform",
+    "artifacts": "napi artifacts",
+    "prepublishOnly": "napi prepublish -t npm",
+    "version": "napi version",
+    "test": "node --test tests/*.mjs"
+  },
+  "devDependencies": {
+    "@napi-rs/cli": "^2.18.0"
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "optionalDependencies": {
+    "@agentcontextdistributionprotocol/acdp-darwin-x64": "0.3.0",
+    "@agentcontextdistributionprotocol/acdp-darwin-arm64": "0.3.0",
+    "@agentcontextdistributionprotocol/acdp-linux-x64-gnu": "0.3.0",
+    "@agentcontextdistributionprotocol/acdp-linux-arm64-gnu": "0.3.0"
+  }
+}