@intentproof/sdk 0.1.4 → 0.2.0

package/dist/index.js

@@ -1,1119 +1,22 @@
-// src/client.ts
-import { AsyncLocalStorage } from "async_hooks";
-import { randomUUID } from "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));
-    }
-    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/validators.ts
-import { Ajv2020 } from "ajv/dist/2020.js";
-import * as AjvFormats from "ajv-formats";
-
-// src/generated/embed/execution-event.v1.ts
-var execution_event_v1_default = {
-  $comment: "Normative IntentProof source tree: https://github.com/IntentProof/intentproof-spec/tree/main/schema \u2014 $id is a logical URI; see README.",
-  $defs: {
-    ExecutionError: {
-      additionalProperties: false,
-      properties: {
-        cause: {
-          $ref: "#/$defs/ExecutionError",
-          description: "Optional chained cause; MUST conform to ExecutionError when present."
-        },
-        code: { description: "Optional stable machine-readable code.", type: "string" },
-        message: {
-          description: "Human-readable error message (may be empty string if the runtime provides none).",
-          type: "string"
-        },
-        name: {
-          description: "Exception or error type name (e.g. Error, TypeError).",
-          minLength: 1,
-          type: "string"
-        },
-        stack: {
-          description: "Optional stringified stack trace; null when stacks are suppressed.",
-          type: ["string", "null"]
-        }
-      },
-      required: ["name", "message"],
-      type: "object"
-    },
-    JsonValue: {
-      anyOf: [
-        { type: "null" },
-        { type: "boolean" },
-        { type: "number" },
-        { type: "string" },
-        { items: { $ref: "#/$defs/JsonValue" }, type: "array" },
-        { additionalProperties: { $ref: "#/$defs/JsonValue" }, type: "object" }
-      ],
-      description: "Any JSON-serializable value per semantics/serialization_rules.md."
-    }
-  },
-  $id: "https://intentproof.dev/schema/execution_event.v1.schema.json",
-  $schema: "https://json-schema.org/draft/2020-12/schema",
-  additionalProperties: false,
-  allOf: [
-    {
-      if: { properties: { status: { const: "ok" } }, required: ["status"] },
-      then: { not: { required: ["error"] }, required: ["output"] }
-    },
-    {
-      if: { properties: { status: { const: "error" } }, required: ["status"] },
-      then: { required: ["error"] }
-    }
-  ],
-  properties: {
-    action: {
-      description: "Stable identifier for the concrete operation. Many systems use hierarchical dotted names (e.g. vendor.resource.operation); REST paths, RPC names, or other conventions are allowed. The schema does not constrain the format.",
-      minLength: 1,
-      type: "string"
-    },
-    attributes: {
-      additionalProperties: { type: ["string", "number", "boolean", "null"] },
-      description: "Flat primitive key/value metadata attached to the event.",
-      propertyNames: { pattern: "^[A-Za-z0-9_.:-]{1,256}$" },
-      type: "object"
-    },
-    completedAt: {
-      description: "RFC 3339 / ISO 8601 instant when execution completed.",
-      format: "date-time",
-      type: "string"
-    },
-    correlationId: {
-      description: "Optional cross-cutting identifier for distributed tracing. MUST be trimmed and non-empty when present.",
-      minLength: 1,
-      type: "string"
-    },
-    durationMs: {
-      description: "Wall-clock duration in milliseconds between startedAt and completedAt.",
-      minimum: 0,
-      type: "number"
-    },
-    error: {
-      $ref: "#/$defs/ExecutionError",
-      description: "Structured error when status is error."
-    },
-    id: {
-      description: "Stable unique identifier for this execution record.",
-      minLength: 1,
-      type: "string"
-    },
-    inputs: {
-      additionalProperties: true,
-      description: "Captured call inputs. Values MUST be JSON-serializable (see semantics/serialization_rules.md).",
-      type: "object"
-    },
-    intent: {
-      description: "Natural-language description of what the user or caller was trying to achieve (often a full sentence or question). No fixed grammar; SHOULD stay human-readable in logs and UIs.",
-      minLength: 1,
-      type: "string"
-    },
-    output: {
-      $ref: "#/$defs/JsonValue",
-      description: "Captured return value when status is ok, or optional captured value when captureError allows output on failure."
-    },
-    startedAt: {
-      description: "RFC 3339 / ISO 8601 instant when execution started.",
-      format: "date-time",
-      type: "string"
-    },
-    status: {
-      description: "Terminal execution status.",
-      enum: ["ok", "error"],
-      type: "string"
-    }
-  },
-  required: [
-    "id",
-    "intent",
-    "action",
-    "status",
-    "inputs",
-    "startedAt",
-    "completedAt",
-    "durationMs"
-  ],
-  title: "IntentProof ExecutionEvent v1",
-  type: "object"
-};
-
-// src/generated/embed/intentproof-config.v1.ts
-var intentproof_config_v1_default = {
-  $comment: "Normative IntentProof source tree: https://github.com/IntentProof/intentproof-spec/tree/main/schema \u2014 $id is a logical URI; see README.",
-  $defs: {
-    WrapOptionsV1: {
-      $comment: "Normative IntentProof source tree: https://github.com/IntentProof/intentproof-spec/tree/main/schema \u2014 $id is a logical URI; see README.",
-      $id: "https://intentproof.dev/schema/wrap_options.v1.schema.json",
-      $schema: "https://json-schema.org/draft/2020-12/schema",
-      additionalProperties: false,
-      properties: {
-        action: {
-          description: "Default operation identifier (often dotted like vendor.service.method); SDKs MAY derive from the callable when omitted.",
-          minLength: 1,
-          type: "string"
-        },
-        attributes: {
-          additionalProperties: { type: ["string", "number", "boolean", "null"] },
-          description: "Static attributes merged into each emitted ExecutionEvent.attributes.",
-          type: "object"
-        },
-        captureError: {
-          default: true,
-          description: "When true, failures MUST populate error; when false with captureOutput semantics, see semantics/wrap_behavior.md.",
-          type: "boolean"
-        },
-        captureInputs: {
-          default: true,
-          description: "When false, inputs MUST be serialized as an empty object {}.",
-          type: "boolean"
-        },
-        captureOutput: {
-          default: true,
-          description: "When false and status is ok, output MUST be null.",
-          type: "boolean"
-        },
-        captureStack: {
-          default: true,
-          description: "When false, error.stack MUST be null on emitted events.",
-          type: "boolean"
-        },
-        exporterTimeoutMs: {
-          description: "Maximum time an exporter hook may block the wrap boundary; 0 means SDK default.",
-          minimum: 0,
-          type: "number"
-        },
-        intent: {
-          description: "Default natural-language intent for wrapped executions when the call site does not override it.",
-          minLength: 1,
-          type: "string"
-        },
-        propagateCorrelation: {
-          default: true,
-          description: "When true, nested wraps inherit the active correlationId.",
-          type: "boolean"
-        }
-      },
-      title: "IntentProof WrapOptions v1",
-      type: "object"
-    }
-  },
-  $id: "https://intentproof.dev/schema/intentproof_config.v1.schema.json",
-  $schema: "https://json-schema.org/draft/2020-12/schema",
-  additionalProperties: false,
-  properties: {
-    correlation: {
-      additionalProperties: false,
-      properties: {
-        generateOnMissing: {
-          default: true,
-          description: "When true, SDK generates a UUID when no correlation is active.",
-          type: "boolean"
-        },
-        headerName: {
-          default: "x-intentproof-correlation-id",
-          description: "HTTP header used for inbound correlation extraction when applicable.",
-          type: "string"
-        }
-      },
-      type: "object"
-    },
-    defaultWrapOptions: { $ref: "#/$defs/WrapOptionsV1" },
-    exporters: {
-      description: "Ordered list of exporter identifiers or inline hooks (SDK-defined encoding).",
-      items: {
-        additionalProperties: true,
-        properties: {
-          endpoint: {
-            description: "Required for http exporters when used.",
-            format: "uri",
-            type: "string"
-          },
-          failOpen: {
-            default: true,
-            description: "When true, exporter failures MUST NOT change user-visible outcomes.",
-            type: "boolean"
-          },
-          headers: {
-            additionalProperties: { type: "string" },
-            description: "Optional HTTP headers for http exporters.",
-            type: "object"
-          },
-          type: {
-            description: "Exporter kind; custom MUST include implementation-specific fields.",
-            enum: ["console", "http", "otel", "custom"],
-            type: "string"
-          }
-        },
-        required: ["type"],
-        type: "object"
-      },
-      type: "array"
-    },
-    serialization: {
-      additionalProperties: false,
-      properties: {
-        maxDepth: {
-          default: 32,
-          description: "Maximum object graph depth for input/output capture.",
-          minimum: 1,
-          type: "integer"
-        },
-        maxStringLength: {
-          default: 65536,
-          description: "Maximum serialized string length for any single field.",
-          minimum: 1,
-          type: "integer"
-        },
-        redactKeys: {
-          description: "Case-insensitive key names to replace with [REDACTED] in captured objects.",
-          items: { type: "string" },
-          type: "array"
-        }
-      },
-      type: "object"
-    },
-    version: {
-      const: 1,
-      description: "Config document version; MUST be 1 for this schema.",
-      type: "integer"
-    }
-  },
-  title: "IntentProof Runtime Config v1",
-  type: "object"
-};
-
-// src/generated/embed/wrap-options.v1.ts
-var wrap_options_v1_default = {
-  $comment: "Normative IntentProof source tree: https://github.com/IntentProof/intentproof-spec/tree/main/schema \u2014 $id is a logical URI; see README.",
-  $id: "https://intentproof.dev/schema/wrap_options.v1.schema.json",
-  $schema: "https://json-schema.org/draft/2020-12/schema",
-  additionalProperties: false,
-  properties: {
-    action: {
-      description: "Default operation identifier (often dotted like vendor.service.method); SDKs MAY derive from the callable when omitted.",
-      minLength: 1,
-      type: "string"
-    },
-    attributes: {
-      additionalProperties: { type: ["string", "number", "boolean", "null"] },
-      description: "Static attributes merged into each emitted ExecutionEvent.attributes.",
-      type: "object"
-    },
-    captureError: {
-      default: true,
-      description: "When true, failures MUST populate error; when false with captureOutput semantics, see semantics/wrap_behavior.md.",
-      type: "boolean"
-    },
-    captureInputs: {
-      default: true,
-      description: "When false, inputs MUST be serialized as an empty object {}.",
-      type: "boolean"
-    },
-    captureOutput: {
-      default: true,
-      description: "When false and status is ok, output MUST be null.",
-      type: "boolean"
-    },
-    captureStack: {
-      default: true,
-      description: "When false, error.stack MUST be null on emitted events.",
-      type: "boolean"
-    },
-    exporterTimeoutMs: {
-      description: "Maximum time an exporter hook may block the wrap boundary; 0 means SDK default.",
-      minimum: 0,
-      type: "number"
-    },
-    intent: {
-      description: "Default natural-language intent for wrapped executions when the call site does not override it.",
-      minLength: 1,
-      type: "string"
-    },
-    propagateCorrelation: {
-      default: true,
-      description: "When true, nested wraps inherit the active correlationId.",
-      type: "boolean"
-    }
-  },
-  title: "IntentProof WrapOptions v1",
-  type: "object"
-};
-
-// src/validators.ts
-var ajv = new Ajv2020({
-  allErrors: true,
-  strict: false
-});
-var addFormats = AjvFormats.default;
-addFormats(ajv);
-var validateExecutionEvent = ajv.compile(
-  execution_event_v1_default
-);
-var validateWrapOptions = ajv.compile(
-  wrap_options_v1_default
-);
-var validateIntentProofConfig = ajv.compile(
-  intentproof_config_v1_default
-);
-function errorsText(v) {
-  return ajv.errorsText(v.errors, { separator: "; " });
-}
-function assertValidExecutionEventWire(data) {
-  if (!validateExecutionEvent(data)) {
-    throw new TypeError(
-      `ExecutionEvent wire JSON failed schema validation: ${errorsText(validateExecutionEvent)}`
-    );
-  }
-}
-
-// src/client.ts
-var correlationStore = new AsyncLocalStorage();
-function normalizeInputsForExecutionEvent(inputs) {
-  if (inputs !== null && typeof inputs === "object" && !Array.isArray(inputs)) {
-    return inputs;
-  }
-  return { args: inputs };
-}
-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) {
-  const message = error instanceof Error ? error.message : String(error);
-  console.error("[intentproof] exporter error", message);
-}
-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(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(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: randomUUID(),
-        correlationId,
-        intent: options.intent,
-        action: options.action,
-        inputs: normalizeInputsForExecutionEvent(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) {
-    assertValidExecutionEventWire(JSON.parse(JSON.stringify(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();
-        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.4";
-var client = getIntentProofClient();
-function createIntentProofClient(config) {
-  return new IntentProofClient(config);
-}
-export {
-  BoundedQueueExporter,
-  HttpExporter,
-  IntentProofClient,
-  MemoryExporter,
-  VERSION,
-  assertCorrelationId,
-  assertValidExecutionEventWire,
-  assertWrapOptionsShape,
-  client,
-  createIntentProofClient,
-  getCorrelationId,
-  getIntentProofClient,
-  runWithCorrelationId,
-  snapshot,
-  validateExecutionEvent,
-  validateIntentProofConfig,
-  validateWrapOptions
-};
-//# sourceMappingURL=index.js.map
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SENTINEL_PREV_HASH = exports.verifyEventSignature = exports.signEvent = exports.loadPrivateKey = exports.eventContentHash = exports.canonicalizeEvent = exports.wrap = exports.runWithCorrelationId = exports.pushSubjectMapping = exports.SDK_VERSION = exports.getTenantId = exports.getPublicKey = exports.getOutbox = exports.getInstanceId = exports.flush = exports.configure = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "configure", { enumerable: true, get: function () { return client_1.configure; } });
+Object.defineProperty(exports, "flush", { enumerable: true, get: function () { return client_1.flush; } });
+Object.defineProperty(exports, "getInstanceId", { enumerable: true, get: function () { return client_1.getInstanceId; } });
+Object.defineProperty(exports, "getOutbox", { enumerable: true, get: function () { return client_1.getOutbox; } });
+Object.defineProperty(exports, "getPublicKey", { enumerable: true, get: function () { return client_1.getPublicKey; } });
+Object.defineProperty(exports, "getTenantId", { enumerable: true, get: function () { return client_1.getTenantId; } });
+Object.defineProperty(exports, "SDK_VERSION", { enumerable: true, get: function () { return client_1.SDK_VERSION; } });
+var instrumentation_1 = require("./instrumentation");
+Object.defineProperty(exports, "pushSubjectMapping", { enumerable: true, get: function () { return instrumentation_1.pushSubjectMapping; } });
+Object.defineProperty(exports, "runWithCorrelationId", { enumerable: true, get: function () { return instrumentation_1.runWithCorrelationId; } });
+Object.defineProperty(exports, "wrap", { enumerable: true, get: function () { return instrumentation_1.wrap; } });
+var signing_1 = require("./signing");
+Object.defineProperty(exports, "canonicalizeEvent", { enumerable: true, get: function () { return signing_1.canonicalizeEvent; } });
+Object.defineProperty(exports, "eventContentHash", { enumerable: true, get: function () { return signing_1.eventContentHash; } });
+Object.defineProperty(exports, "loadPrivateKey", { enumerable: true, get: function () { return signing_1.loadPrivateKey; } });
+Object.defineProperty(exports, "signEvent", { enumerable: true, get: function () { return signing_1.signEvent; } });
+Object.defineProperty(exports, "verifyEventSignature", { enumerable: true, get: function () { return signing_1.verifyEventSignature; } });
+Object.defineProperty(exports, "SENTINEL_PREV_HASH", { enumerable: true, get: function () { return signing_1.SENTINEL_PREV_HASH; } });