@intentproof/sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,783 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BoundedQueueExporter: () => BoundedQueueExporter,
+  HttpExporter: () => HttpExporter,
+  IntentProofClient: () => IntentProofClient,
+  MemoryExporter: () => MemoryExporter,
+  VERSION: () => VERSION,
+  assertCorrelationId: () => assertCorrelationId,
+  assertWrapOptionsShape: () => assertWrapOptionsShape,
+  client: () => client,
+  createIntentProofClient: () => createIntentProofClient,
+  getCorrelationId: () => getCorrelationId,
+  getIntentProofClient: () => getIntentProofClient,
+  runWithCorrelationId: () => runWithCorrelationId,
+  snapshot: () => snapshot
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_async_hooks = require("async_hooks");
+var import_crypto = require("crypto");
+
+// src/exporters/memory.ts
+var MemoryExporter = class {
+  maxEvents;
+  events = [];
+  constructor(options = {}) {
+    const cap = options.maxEvents ?? 1e3;
+    if (!Number.isFinite(cap) || cap < 1) {
+      throw new TypeError('MemoryExporter: "maxEvents" must be a finite number >= 1');
+    }
+    this.maxEvents = Math.trunc(cap);
+  }
+  export(event) {
+    this.events.push(event);
+    const overflow = this.events.length - this.maxEvents;
+    if (overflow > 0) this.events.splice(0, overflow);
+  }
+  /** Mutable snapshot for inspection — newest last. */
+  getEvents() {
+    return this.events;
+  }
+  clear() {
+    this.events.length = 0;
+  }
+  flush() {
+    return Promise.resolve();
+  }
+};
+
+// src/runtime.ts
+function describeValueType(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+}
+function isPromiseLike(x) {
+  return x !== null && typeof x === "object" && typeof x.then === "function";
+}
+
+// src/snapshot.ts
+var DEFAULT_MAX_DEPTH = 6;
+var DEFAULT_MAX_KEYS = 50;
+function snapshotLimit(n, fallback) {
+  if (n === void 0) return fallback;
+  if (!Number.isFinite(n)) return fallback;
+  const i = Math.trunc(n);
+  return i < 0 ? fallback : i;
+}
+function snapshotStringLimit(n) {
+  if (n === void 0) return void 0;
+  if (!Number.isFinite(n)) return void 0;
+  const i = Math.trunc(n);
+  return i < 0 ? void 0 : i;
+}
+function normalizeRedactSet(redactKeys) {
+  if (!redactKeys?.length) return void 0;
+  const set = new Set(
+    redactKeys.filter((k) => typeof k === "string" && k.length > 0).map((k) => k.toLowerCase())
+  );
+  return set.size > 0 ? set : void 0;
+}
+function shouldRedactKey(key, redact) {
+  if (!redact) return false;
+  return redact.has(key.toLowerCase());
+}
+function truncateString(s, maxLen) {
+  if (maxLen === void 0 || s.length <= maxLen) return s;
+  return `${s.slice(0, maxLen)}\u2026[truncated ${s.length - maxLen} chars]`;
+}
+function snapshot(value, options = {}) {
+  const maxDepth = snapshotLimit(options.maxDepth, DEFAULT_MAX_DEPTH);
+  const maxKeys = snapshotLimit(options.maxKeys, DEFAULT_MAX_KEYS);
+  const maxStringLength = snapshotStringLimit(options.maxStringLength);
+  const redact = normalizeRedactSet(options.redactKeys);
+  const seen = /* @__PURE__ */ new WeakSet();
+  function walk(v, depth) {
+    if (v === null || v === void 0) return v;
+    const t = typeof v;
+    if (t === "string" || t === "number" || t === "boolean") {
+      if (t === "string") return truncateString(v, maxStringLength);
+      return v;
+    }
+    if (t === "bigint") return v.toString();
+    if (t === "symbol") return v.toString();
+    if (t === "function") {
+      const fn = v;
+      return `[Function ${fn.name || "anonymous"}]`;
+    }
+    if (v instanceof Date) return v.toISOString();
+    if (Array.isArray(v)) {
+      if (depth >= maxDepth) return "[Array]";
+      return v.slice(0, maxKeys).map((item) => walk(item, depth + 1));
+    }
+    if (t === "object") {
+      const o = v;
+      if (seen.has(o)) return "[Circular]";
+      seen.add(o);
+      if (depth >= maxDepth) return "[Object]";
+      const out = {};
+      const keys = Object.keys(o);
+      let n = 0;
+      for (const k of keys) {
+        if (n >= maxKeys) {
+          out["\u2026"] = `${keys.length - maxKeys} more keys`;
+          break;
+        }
+        try {
+          if (shouldRedactKey(k, redact)) {
+            out[k] = "[REDACTED]";
+          } else {
+            out[k] = walk(o[k], depth + 1);
+          }
+        } catch {
+          out[k] = "[Unserializable]";
+        }
+        n += 1;
+      }
+      return out;
+    }
+  }
+  try {
+    return walk(value, 0);
+  } catch {
+    return "[SnapshotError]";
+  }
+}
+
+// src/client.ts
+var correlationStore = new import_async_hooks.AsyncLocalStorage();
+function assertCorrelationId(id) {
+  if (typeof id !== "string") {
+    throw new TypeError(
+      `IntentProofClient: "correlationId" must be a string, got ${describeValueType(id)}`
+    );
+  }
+  if (id.trim().length === 0) {
+    throw new TypeError(
+      `IntentProofClient: "correlationId" must be a non-empty string (trimmed length is 0)`
+    );
+  }
+}
+function getCorrelationId() {
+  return correlationStore.getStore();
+}
+function runWithCorrelationId(correlationId, fn) {
+  if (typeof fn !== "function") {
+    throw new TypeError(
+      "IntentProofClient: expected runWithCorrelationId(correlationId, fn)"
+    );
+  }
+  assertCorrelationId(correlationId);
+  return correlationStore.run(correlationId, fn);
+}
+function defaultOnExporterError(error, _event) {
+  console.error("[intentproof] exporter error", error);
+}
+function toErrorSnapshot(e, includeStack) {
+  if (e instanceof Error) {
+    return includeStack ? { name: e.name, message: e.message, stack: e.stack } : { name: e.name, message: e.message };
+  }
+  return { name: "Error", message: String(e) };
+}
+function assertExporterAtIndex(ex, index) {
+  if (ex == null || typeof ex !== "object" || typeof ex.export !== "function") {
+    throw new TypeError(
+      `IntentProofClient: exporters[${index}] must be an object with an export() method`
+    );
+  }
+}
+function assertAttributesRecord(label, value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new TypeError(
+      `IntentProofClient: ${label} must be a plain object, got ${describeValueType(value)}`
+    );
+  }
+  const o = value;
+  for (const key of Object.keys(o)) {
+    const v = o[key];
+    const t = typeof v;
+    if (t !== "string" && t !== "number" && t !== "boolean") {
+      throw new TypeError(
+        `IntentProofClient: ${label}[${JSON.stringify(key)}] must be a string, number, or boolean, got ${describeValueType(v)}`
+      );
+    }
+  }
+}
+function assertWrapOptionsShape(options) {
+  if (typeof options.intent !== "string") {
+    throw new TypeError(
+      `IntentProofClient: "intent" must be a string, got ${describeValueType(options.intent)}`
+    );
+  }
+  if (options.intent.trim().length === 0) {
+    throw new TypeError(
+      `IntentProofClient: "intent" must be a non-empty string (trimmed length is 0)`
+    );
+  }
+  if (typeof options.action !== "string") {
+    throw new TypeError(
+      `IntentProofClient: "action" must be a string, got ${describeValueType(options.action)}`
+    );
+  }
+  if (options.action.trim().length === 0) {
+    throw new TypeError(
+      `IntentProofClient: "action" must be a non-empty string (trimmed length is 0)`
+    );
+  }
+  if (options.correlationId !== void 0 && typeof options.correlationId !== "string") {
+    throw new TypeError(
+      `IntentProofClient: "correlationId" must be a string when provided, got ${describeValueType(options.correlationId)}`
+    );
+  }
+  if (options.correlationId !== void 0 && options.correlationId.trim().length === 0) {
+    throw new TypeError(
+      `IntentProofClient: "correlationId" must be a non-empty string when provided (trimmed length is 0)`
+    );
+  }
+  if (options.attributes !== void 0) {
+    assertAttributesRecord("WrapOptions.attributes", options.attributes);
+  }
+  if (options.includeErrorStack !== void 0) {
+    if (typeof options.includeErrorStack !== "boolean") {
+      throw new TypeError(
+        `IntentProofClient: "includeErrorStack" must be a boolean when provided, got ${describeValueType(options.includeErrorStack)}`
+      );
+    }
+  }
+}
+var IntentProofClient = class {
+  exporters = [new MemoryExporter()];
+  onExporterError = defaultOnExporterError;
+  defaultAttributes = {};
+  includeErrorStack = true;
+  constructor(config = {}) {
+    this.configure(config);
+  }
+  configure(config) {
+    if (config.exporters !== void 0) {
+      for (let i = 0; i < config.exporters.length; i++) {
+        assertExporterAtIndex(config.exporters[i], i);
+      }
+      this.exporters = [...config.exporters];
+    }
+    if (config.onExporterError !== void 0) {
+      if (typeof config.onExporterError !== "function") {
+        throw new TypeError(
+          `IntentProofClient: onExporterError must be a function, got ${describeValueType(config.onExporterError)}`
+        );
+      }
+      this.onExporterError = config.onExporterError;
+    }
+    if (config.defaultAttributes !== void 0) {
+      assertAttributesRecord("defaultAttributes", config.defaultAttributes);
+      this.defaultAttributes = config.defaultAttributes;
+    }
+    if (config.includeErrorStack !== void 0) {
+      if (typeof config.includeErrorStack !== "boolean") {
+        throw new TypeError(
+          `IntentProofClient: includeErrorStack must be a boolean when provided, got ${describeValueType(config.includeErrorStack)}`
+        );
+      }
+      this.includeErrorStack = config.includeErrorStack;
+    }
+  }
+  /**
+   * Await optional {@link Exporter.flush} on each exporter (parallel).
+   * Used for graceful shutdown or tests.
+   */
+  flush() {
+    return Promise.all(
+      this.exporters.map(
+        (ex) => typeof ex.flush === "function" ? Promise.resolve(ex.flush()) : Promise.resolve()
+      )
+    ).then(() => {
+    });
+  }
+  /**
+   * {@link Exporter.shutdown} when present, otherwise {@link Exporter.flush}.
+   */
+  shutdown() {
+    return Promise.all(
+      this.exporters.map((ex) => {
+        if (typeof ex.shutdown === "function") {
+          return Promise.resolve(ex.shutdown());
+        }
+        if (typeof ex.flush === "function") {
+          return Promise.resolve(ex.flush());
+        }
+        return Promise.resolve();
+      })
+    ).then(() => {
+    });
+  }
+  /** Read active correlation id (AsyncLocalStorage). */
+  getCorrelationId() {
+    return getCorrelationId();
+  }
+  withCorrelation(correlationIdOrFn, maybeFn) {
+    if (typeof correlationIdOrFn === "function") {
+      return runWithCorrelationId((0, import_crypto.randomUUID)(), correlationIdOrFn);
+    }
+    if (typeof correlationIdOrFn !== "string") {
+      throw new TypeError(
+        "IntentProofClient: withCorrelation: correlation id must be a string"
+      );
+    }
+    if (typeof maybeFn !== "function") {
+      throw new TypeError(
+        "IntentProofClient: expected withCorrelation(fn) or withCorrelation(correlationId, fn)"
+      );
+    }
+    const fn = maybeFn;
+    const id = correlationIdOrFn;
+    if (id.trim().length === 0) {
+      return runWithCorrelationId((0, import_crypto.randomUUID)(), fn);
+    }
+    return runWithCorrelationId(id, fn);
+  }
+  /**
+   * Wrap a function to emit one `ExecutionEvent` per invocation (sync or async).
+   */
+  wrap(options, fn) {
+    assertWrapOptionsShape(options);
+    if (typeof fn !== "function") {
+      throw new TypeError(
+        `IntentProofClient: wrap() second argument must be a function, got ${describeValueType(fn)}`
+      );
+    }
+    const self = this;
+    const wrapped = function(...args) {
+      const correlationId = options.correlationId ?? getCorrelationId() ?? void 0;
+      const startedAt = /* @__PURE__ */ new Date();
+      const serOpts = {
+        maxDepth: options.maxDepth,
+        maxKeys: options.maxKeys,
+        redactKeys: options.redactKeys,
+        maxStringLength: options.maxStringLength
+      };
+      let inputs;
+      if (options.captureInput) {
+        try {
+          inputs = options.captureInput(args);
+        } catch {
+          inputs = snapshot(args, serOpts);
+        }
+      } else {
+        inputs = snapshot(args, serOpts);
+      }
+      const base = {
+        id: (0, import_crypto.randomUUID)(),
+        correlationId,
+        intent: options.intent,
+        action: options.action,
+        inputs,
+        startedAt: startedAt.toISOString(),
+        attributes: mergeAttrs(self.defaultAttributes, options.attributes)
+      };
+      try {
+        const out = fn.apply(this, args);
+        if (isPromiseLike(out)) {
+          return self.handleAsync(out, base, options, serOpts, startedAt);
+        }
+        self.emitComplete(
+          base,
+          "ok",
+          out,
+          void 0,
+          options,
+          serOpts,
+          startedAt,
+          self.includeErrorStack
+        );
+        return out;
+      } catch (e) {
+        self.emitComplete(
+          base,
+          "error",
+          void 0,
+          e,
+          options,
+          serOpts,
+          startedAt,
+          self.includeErrorStack
+        );
+        throw e;
+      }
+    };
+    Object.defineProperty(wrapped, "name", {
+      value: `intentproof(${fn.name || "anonymous"})`,
+      configurable: true
+    });
+    return wrapped;
+  }
+  handleAsync(p, base, options, serOpts, startedAt) {
+    const includeStack = this.includeErrorStack;
+    return Promise.resolve(p).then(
+      (value) => {
+        this.emitComplete(
+          base,
+          "ok",
+          value,
+          void 0,
+          options,
+          serOpts,
+          startedAt,
+          includeStack
+        );
+        return value;
+      },
+      (err) => {
+        this.emitComplete(
+          base,
+          "error",
+          void 0,
+          err,
+          options,
+          serOpts,
+          startedAt,
+          includeStack
+        );
+        throw err;
+      }
+    );
+  }
+  emitComplete(base, status, result, error, options, serOpts, startedAt, defaultIncludeErrorStack) {
+    const completedAt = /* @__PURE__ */ new Date();
+    const durationMs = completedAt.getTime() - startedAt.getTime();
+    let output;
+    let errSnap;
+    const includeStack = options.includeErrorStack ?? defaultIncludeErrorStack;
+    if (status === "ok") {
+      try {
+        output = options.captureOutput ? options.captureOutput(result) : snapshot(result, serOpts);
+      } catch {
+        output = snapshot(result, serOpts);
+      }
+    } else {
+      errSnap = toErrorSnapshot(error, includeStack);
+      if (options.captureError) {
+        try {
+          output = options.captureError(error);
+        } catch {
+          output = void 0;
+        }
+      }
+    }
+    const event = status === "ok" ? {
+      ...base,
+      status,
+      completedAt: completedAt.toISOString(),
+      durationMs,
+      output
+    } : {
+      ...base,
+      status,
+      completedAt: completedAt.toISOString(),
+      durationMs,
+      error: errSnap,
+      ...output !== void 0 ? { output } : {}
+    };
+    this.dispatch(event);
+  }
+  dispatch(event) {
+    for (const ex of this.exporters) {
+      try {
+        const r = ex.export(event);
+        if (isPromiseLike(r)) {
+          void r.catch((e) => this.onExporterError(e, event));
+        }
+      } catch (e) {
+        this.onExporterError(e, event);
+      }
+    }
+  }
+};
+function mergeAttrs(a, b) {
+  if (!b || Object.keys(b).length === 0) {
+    return Object.keys(a).length ? { ...a } : void 0;
+  }
+  return { ...a, ...b };
+}
+var defaultClient = null;
+function getIntentProofClient() {
+  if (!defaultClient) defaultClient = new IntentProofClient();
+  return defaultClient;
+}
+
+// src/exporters/http.ts
+var HTTP_EXPORTER_FALLBACK_BODY = '{"intentproof":"1","eventSerializeFailed":true}';
+function safeJsonEnvelope(event) {
+  try {
+    return JSON.stringify({ intentproof: "1", event });
+  } catch {
+    try {
+      return JSON.stringify({
+        intentproof: "1",
+        eventPartial: {
+          id: event.id,
+          action: event.action,
+          intent: event.intent,
+          status: event.status,
+          correlationId: event.correlationId,
+          startedAt: event.startedAt,
+          completedAt: event.completedAt,
+          durationMs: event.durationMs
+        },
+        note: "full event not JSON-serializable"
+      });
+    } catch {
+      return HTTP_EXPORTER_FALLBACK_BODY;
+    }
+  }
+}
+var HttpExporter = class {
+  url;
+  method;
+  headers;
+  body;
+  awaitEach;
+  timeoutMs;
+  onError;
+  inFlight = /* @__PURE__ */ new Set();
+  closed = false;
+  constructor(options) {
+    if (typeof options.url !== "string") {
+      throw new TypeError(
+        `HttpExporter: "url" must be a non-empty string, got ${describeValueType(options.url)}`
+      );
+    }
+    if (options.url.trim().length === 0) {
+      throw new TypeError(
+        'HttpExporter: "url" must be a non-empty string (trimmed length is 0)'
+      );
+    }
+    this.url = options.url;
+    this.method = (options.method ?? "POST").trim() || "POST";
+    const rawHeaders = options.headers;
+    const extraHeaders = rawHeaders !== void 0 && rawHeaders !== null && typeof rawHeaders === "object" && !Array.isArray(rawHeaders) ? rawHeaders : {};
+    this.headers = {
+      "content-type": "application/json",
+      ...extraHeaders
+    };
+    this.body = options.body ?? ((event) => safeJsonEnvelope(event));
+    this.awaitEach = options.awaitEach ?? false;
+    if (options.timeoutMs !== void 0) {
+      const t = options.timeoutMs;
+      if (!Number.isFinite(t) || t <= 0) {
+        throw new TypeError(
+          'HttpExporter: "timeoutMs" must be a finite number > 0 when set'
+        );
+      }
+      this.timeoutMs = Math.trunc(t);
+    } else {
+      this.timeoutMs = void 0;
+    }
+    this.onError = options.onError;
+  }
+  track(p) {
+    this.inFlight.add(p);
+    void p.finally(() => this.inFlight.delete(p));
+  }
+  export(event) {
+    if (this.closed) {
+      this.onError?.(new Error("HttpExporter has been shut down"), event);
+      return;
+    }
+    let payload;
+    try {
+      payload = this.body(event);
+    } catch (e) {
+      this.onError?.(e, event);
+      payload = safeJsonEnvelope(event);
+    }
+    const run = async () => {
+      try {
+        const res = await fetch(this.url, {
+          method: this.method,
+          headers: this.headers,
+          body: payload,
+          credentials: "omit",
+          signal: this.timeoutMs !== void 0 ? AbortSignal.timeout(this.timeoutMs) : void 0
+        });
+        if (!res.ok) {
+          const err = new Error(`HTTP ${res.status}: ${res.statusText}`);
+          this.onError?.(err, event);
+        }
+      } catch (e) {
+        this.onError?.(e, event);
+      }
+    };
+    const p = run();
+    this.track(p);
+    if (this.awaitEach) return p;
+    void p;
+  }
+  /** Waits until every started request has settled (success or failure). */
+  flush() {
+    if (this.inFlight.size === 0) return Promise.resolve();
+    return Promise.all([...this.inFlight]).then(() => {
+    });
+  }
+  /** Stops accepting new events and waits for in-flight requests to finish. */
+  async shutdown() {
+    this.closed = true;
+    await this.flush();
+  }
+};
+
+// src/exporters/queue.ts
+var BoundedQueueExporter = class {
+  inner;
+  maxConcurrent;
+  maxQueue;
+  strategy;
+  onDrop;
+  onInnerError;
+  queue = [];
+  active = 0;
+  /** When false, {@link export} drops events with reason `shutdown`; queued work still drains. */
+  accepting = true;
+  idleResolvers = [];
+  constructor(options) {
+    const inner = options.exporter;
+    if (inner == null || typeof inner !== "object" || typeof inner.export !== "function") {
+      throw new TypeError(
+        'BoundedQueueExporter: "exporter" must be an object with an export() method'
+      );
+    }
+    this.inner = inner;
+    const rawMc = options.maxConcurrent ?? 4;
+    this.maxConcurrent = !Number.isFinite(rawMc) ? 4 : Math.max(1, Math.trunc(rawMc));
+    const rawQ = options.maxQueue ?? 1e3;
+    if (!Number.isFinite(rawQ)) {
+      this.maxQueue = 1e3;
+    } else {
+      const q = Math.trunc(rawQ);
+      if (q === 0) {
+        this.maxQueue = 0;
+      } else if (q < 0) {
+        this.maxQueue = 1e3;
+      } else {
+        this.maxQueue = q;
+      }
+    }
+    const strategy = options.strategy ?? "drop-newest";
+    if (strategy !== "drop-newest" && strategy !== "drop-oldest") {
+      throw new TypeError(
+        'BoundedQueueExporter: "strategy" must be "drop-newest" or "drop-oldest"'
+      );
+    }
+    this.strategy = strategy;
+    this.onDrop = options.onDrop;
+    this.onInnerError = options.onInnerError;
+  }
+  export(event) {
+    if (!this.accepting) {
+      this.onDrop?.(event, "shutdown");
+      return;
+    }
+    const cap = this.maxQueue <= 0 ? Number.POSITIVE_INFINITY : this.maxQueue;
+    if (this.queue.length >= cap) {
+      if (this.strategy === "drop-oldest") {
+        const dropped = this.queue.shift();
+        if (dropped) this.onDrop?.(dropped, "queue-overflow-drop-oldest");
+        this.queue.push(event);
+      } else {
+        this.onDrop?.(event, "queue-overflow-drop-newest");
+      }
+      this.pump();
+      return;
+    }
+    this.queue.push(event);
+    this.pump();
+  }
+  pump() {
+    while (this.active < this.maxConcurrent && this.queue.length > 0) {
+      const next = this.queue.shift();
+      this.active++;
+      void this.runInner(next).finally(() => {
+        this.active--;
+        this.pump();
+        this.resolveIdleWaitersIfNeeded();
+      });
+    }
+  }
+  async runInner(event) {
+    try {
+      const r = this.inner.export(event);
+      if (isPromiseLike(r)) await r;
+    } catch (e) {
+      this.onInnerError?.(e, event);
+    }
+  }
+  resolveIdleWaitersIfNeeded() {
+    if (this.queue.length === 0 && this.active === 0) {
+      const waiters = this.idleResolvers;
+      this.idleResolvers = [];
+      for (const r of waiters) r();
+    }
+  }
+  /** Resolves when the queue is empty and no inner export is in flight. */
+  flush() {
+    if (this.queue.length === 0 && this.active === 0) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      this.idleResolvers.push(resolve);
+    });
+  }
+  /**
+   * Stops accepting new events; does **not** drop items already in the queue—
+   * {@link flush} waits until queued and in-flight work finishes.
+   */
+  async shutdown() {
+    this.accepting = false;
+    await this.flush();
+  }
+};
+
+// src/index.ts
+var VERSION = "0.1.0";
+var client = getIntentProofClient();
+function createIntentProofClient(config) {
+  return new IntentProofClient(config);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BoundedQueueExporter,
+  HttpExporter,
+  IntentProofClient,
+  MemoryExporter,
+  VERSION,
+  assertCorrelationId,
+  assertWrapOptionsShape,
+  client,
+  createIntentProofClient,
+  getCorrelationId,
+  getIntentProofClient,
+  runWithCorrelationId,
+  snapshot
+});
+//# sourceMappingURL=index.cjs.map