@intelmesh/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,1651 @@
+// src/client/errors.ts
+var IntelMeshError = class extends Error {
+  /** HTTP status code, if applicable. */
+  status;
+  /** Machine-readable error code from the API. */
+  code;
+  constructor(message, status, code) {
+    super(message);
+    this.name = "IntelMeshError";
+    this.status = status;
+    this.code = code;
+  }
+};
+var ValidationError = class extends IntelMeshError {
+  constructor(message, code = "VALIDATION_ERROR") {
+    super(message, 400, code);
+    this.name = "ValidationError";
+  }
+};
+var NotFoundError = class extends IntelMeshError {
+  constructor(message, code = "NOT_FOUND") {
+    super(message, 404, code);
+    this.name = "NotFoundError";
+  }
+};
+var UnauthorizedError = class extends IntelMeshError {
+  constructor(message, code = "UNAUTHORIZED") {
+    super(message, 401, code);
+    this.name = "UnauthorizedError";
+  }
+};
+var ForbiddenError = class extends IntelMeshError {
+  constructor(message, code = "FORBIDDEN") {
+    super(message, 403, code);
+    this.name = "ForbiddenError";
+  }
+};
+var InternalError = class extends IntelMeshError {
+  constructor(message, code = "INTERNAL_ERROR") {
+    super(message, 500, code);
+    this.name = "InternalError";
+  }
+};
+var UnavailableError = class extends IntelMeshError {
+  constructor(message, code = "UNAVAILABLE") {
+    super(message, 503, code);
+    this.name = "UnavailableError";
+  }
+};
+var NetworkError = class extends IntelMeshError {
+  constructor(message) {
+    super(message, 0, "NETWORK_ERROR");
+    this.name = "NetworkError";
+  }
+};
+var ParseError = class extends IntelMeshError {
+  constructor(message) {
+    super(message, 0, "PARSE_ERROR");
+    this.name = "ParseError";
+  }
+};
+function isNotFound(error) {
+  return error instanceof NotFoundError;
+}
+function isValidation(error) {
+  return error instanceof ValidationError;
+}
+function isUnauthorized(error) {
+  return error instanceof UnauthorizedError;
+}
+function isForbidden(error) {
+  return error instanceof ForbiddenError;
+}
+function isNetwork(error) {
+  return error instanceof NetworkError;
+}
+function isIntelMeshError(error) {
+  return error instanceof IntelMeshError;
+}
+function mapStatusToError(status, message, code) {
+  switch (status) {
+    case 400:
+      return new ValidationError(message, code);
+    case 401:
+      return new UnauthorizedError(message, code);
+    case 403:
+      return new ForbiddenError(message, code);
+    case 404:
+      return new NotFoundError(message, code);
+    case 503:
+      return new UnavailableError(message, code);
+    default:
+      if (status >= 500) {
+        return new InternalError(message, code);
+      }
+      return new IntelMeshError(message, status, code);
+  }
+}
+
+// src/client/http.ts
+var DEFAULT_TIMEOUT = 3e4;
+var HttpClient = class {
+  baseUrl;
+  apiKey;
+  timeout;
+  fetchFn;
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/+$/, "");
+    this.apiKey = config.apiKey;
+    this.timeout = config.timeout ?? DEFAULT_TIMEOUT;
+    this.fetchFn = config.fetch ?? globalThis.fetch.bind(globalThis);
+  }
+  /**
+   * Executes a GET request and returns the parsed data.
+   * @param path - The API path.
+   * @param query - Optional query parameters.
+   * @returns The response data of type T.
+   */
+  async get(path, query) {
+    return this.request({ method: "GET", path, query });
+  }
+  /**
+   * Executes a POST request and returns the parsed data.
+   * @param path - The API path.
+   * @param body - The request body.
+   * @returns The response data of type T.
+   */
+  async post(path, body) {
+    return this.request({ method: "POST", path, body });
+  }
+  /**
+   * Executes a PUT request and returns the parsed data.
+   * @param path - The API path.
+   * @param body - The request body.
+   * @returns The response data of type T.
+   */
+  async put(path, body) {
+    return this.request({ method: "PUT", path, body });
+  }
+  /**
+   * Executes a DELETE request and returns the parsed data.
+   * @param path - The API path.
+   * @returns The response data of type T.
+   */
+  async delete(path) {
+    return this.request({ method: "DELETE", path });
+  }
+  /**
+   * Builds the full URL with query parameters.
+   * @param path - The API path.
+   * @param query - Optional query parameters.
+   * @returns The full URL string.
+   */
+  buildUrl(path, query) {
+    const url = new URL(`${this.baseUrl}${path}`);
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        if (value !== void 0) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+  /**
+   * Executes an HTTP request with timeout, auth, and error handling.
+   * @param options - The request options.
+   * @returns The parsed response data.
+   */
+  async request(options) {
+    const url = this.buildUrl(options.path, options.query);
+    const controller = new AbortController();
+    const timer = setTimeout(() => {
+      controller.abort();
+    }, this.timeout);
+    try {
+      const response = await this.executeFetch(url, options, controller.signal);
+      return await this.handleResponse(response);
+    } catch (error) {
+      throw this.wrapError(error);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  /**
+   * Calls fetch with the configured headers and body.
+   * @param url - The full URL.
+   * @param options - The request options.
+   * @param signal - The abort signal.
+   * @returns The fetch Response.
+   */
+  async executeFetch(url, options, signal) {
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`,
+      Accept: "application/json"
+    };
+    if (options.body !== void 0) {
+      headers["Content-Type"] = "application/json";
+    }
+    return this.fetchFn(url, {
+      method: options.method,
+      headers,
+      body: options.body !== void 0 ? JSON.stringify(options.body) : void 0,
+      signal
+    });
+  }
+  /**
+   * Parses the response and throws typed errors for non-2xx status.
+   * @param response - The fetch Response.
+   * @returns The parsed data.
+   */
+  async handleResponse(response) {
+    const text = await response.text();
+    if (!response.ok) {
+      this.throwApiError(response.status, text);
+    }
+    const parsed = this.parseJson(text);
+    return parsed.data;
+  }
+  /**
+   * Parses and throws an API error from the response body.
+   * @param status - The HTTP status code.
+   * @param text - The raw response body.
+   */
+  throwApiError(status, text) {
+    try {
+      const body = JSON.parse(text);
+      throw mapStatusToError(status, body.error.message, body.error.code);
+    } catch (error) {
+      if (error instanceof Error && "status" in error) throw error;
+      throw mapStatusToError(status, text || `HTTP ${String(status)}`, "UNKNOWN");
+    }
+  }
+  /**
+   * Safely parses JSON with a typed parse error.
+   * @param text - The raw JSON text.
+   * @returns The parsed JSON object.
+   */
+  parseJson(text) {
+    try {
+      return JSON.parse(text);
+    } catch {
+      throw new ParseError(`Failed to parse response: ${text.slice(0, 200)}`);
+    }
+  }
+  /**
+   * Wraps unexpected errors into NetworkError.
+   * @param error - The caught error.
+   * @returns A NetworkError or the original error.
+   */
+  wrapError(error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      return new NetworkError("Request timed out");
+    }
+    if (error instanceof Error && "status" in error) {
+      return error;
+    }
+    if (error instanceof Error) {
+      return new NetworkError(error.message);
+    }
+    return new NetworkError("Unknown network error");
+  }
+};
+
+// src/resources/apikeys.ts
+var APIKeys = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Lists all API keys with cursor-based pagination.
+   * @param params - Optional pagination parameters.
+   * @returns A paginated list of API keys.
+   */
+  async list(params = {}) {
+    return this.http.get("/api/v1/api-keys", {
+      cursor: params.cursor,
+      limit: params.limit
+    });
+  }
+  /**
+   * Creates a new API key. The plain key is returned only at creation time.
+   * @param request - The API key creation payload.
+   * @returns The created API key with the plain key value.
+   */
+  async create(request) {
+    return this.http.post("/api/v1/api-keys", request);
+  }
+  /**
+   * Updates an existing API key by ID.
+   * @param id - The API key ID.
+   * @param request - The update payload.
+   * @returns The updated API key.
+   */
+  async update(id, request) {
+    return this.http.put(`/api/v1/api-keys/${id}`, request);
+  }
+  /**
+   * Deletes an API key by ID.
+   * @param id - The API key ID.
+   */
+  async delete(id) {
+    await this.http.delete(`/api/v1/api-keys/${id}`);
+  }
+};
+
+// src/resources/audit.ts
+var Audit = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Lists audit logs with cursor-based pagination.
+   * @param params - Optional pagination parameters.
+   * @returns A paginated list of audit entries.
+   */
+  async list(params = {}) {
+    return this.http.get("/api/v1/audit", {
+      cursor: params.cursor,
+      limit: params.limit
+    });
+  }
+};
+
+// src/resources/evaluations.ts
+var Evaluations = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Lists evaluation logs with cursor-based pagination.
+   * @param params - Optional pagination parameters.
+   * @returns A paginated list of evaluation logs.
+   */
+  async list(params = {}) {
+    return this.http.get("/api/v1/evaluations", {
+      cursor: params.cursor,
+      limit: params.limit
+    });
+  }
+  /**
+   * Retrieves a single evaluation log by ID.
+   * @param id - The evaluation log ID.
+   * @returns The evaluation log with full pipeline trace.
+   */
+  async get(id) {
+    return this.http.get(`/api/v1/evaluations/${id}`);
+  }
+};
+
+// src/resources/events.ts
+var Events = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Ingests an event synchronously and returns the decision.
+   * @param request - The ingest request payload.
+   * @returns The ingestion result with decision and score.
+   */
+  async ingest(request) {
+    return this.http.post("/api/v1/events/ingest", request);
+  }
+  /**
+   * Ingests an event asynchronously (fire-and-forget with acknowledgement).
+   * @param request - The ingest request payload.
+   * @returns The event ID assigned by the server.
+   */
+  async ingestAsync(request) {
+    const result = await this.http.post(
+      "/api/v1/events/ingest-async",
+      request
+    );
+    return result.data.event_id;
+  }
+  /**
+   * Ingests an event for storage only, without evaluation.
+   * @param request - The ingest request payload.
+   * @returns The event ID assigned by the server.
+   */
+  async ingestOnly(request) {
+    const result = await this.http.post(
+      "/api/v1/events/ingest-only",
+      request
+    );
+    return result.data.event_id;
+  }
+  /**
+   * Simulates event evaluation without persisting (dry-run).
+   * @param request - The ingest request payload.
+   * @returns The simulated result with decision and trace.
+   */
+  async simulate(request) {
+    return this.http.post("/api/v1/events/simulate", request);
+  }
+};
+
+// src/resources/lists.ts
+var Lists = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Lists all named lists with cursor-based pagination.
+   * @param params - Optional pagination parameters.
+   * @returns A paginated list of named lists.
+   */
+  async list(params = {}) {
+    return this.http.get("/api/v1/lists", {
+      cursor: params.cursor,
+      limit: params.limit
+    });
+  }
+  /**
+   * Retrieves a single list by ID.
+   * @param id - The list ID.
+   * @returns The list.
+   */
+  async get(id) {
+    return this.http.get(`/api/v1/lists/${id}`);
+  }
+  /**
+   * Creates a new named list.
+   * @param request - The list creation payload.
+   * @returns The created list.
+   */
+  async create(request) {
+    return this.http.post("/api/v1/lists", request);
+  }
+  /**
+   * Updates an existing list by ID.
+   * @param id - The list ID.
+   * @param request - The update payload.
+   * @returns The updated list.
+   */
+  async update(id, request) {
+    return this.http.put(`/api/v1/lists/${id}`, request);
+  }
+  /**
+   * Deletes a list by ID.
+   * @param id - The list ID.
+   */
+  async delete(id) {
+    await this.http.delete(`/api/v1/lists/${id}`);
+  }
+  /**
+   * Adds items to a list.
+   * @param listId - The list ID.
+   * @param request - The items to add.
+   */
+  async addItems(listId, request) {
+    await this.http.post(`/api/v1/lists/${listId}/items`, request);
+  }
+  /**
+   * Bulk-imports items into a list, replacing existing items.
+   * @param listId - The list ID.
+   * @param request - The items to import.
+   */
+  async bulkImport(listId, request) {
+    await this.http.post(`/api/v1/lists/${listId}/import`, request);
+  }
+};
+
+// src/resources/phases.ts
+var Phases = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Lists all phases with cursor-based pagination.
+   * @param params - Optional pagination parameters.
+   * @returns A paginated list of phases.
+   */
+  async list(params = {}) {
+    return this.http.get("/api/v1/phases", {
+      cursor: params.cursor,
+      limit: params.limit
+    });
+  }
+  /**
+   * Retrieves a single phase by ID.
+   * @param id - The phase ID.
+   * @returns The phase.
+   */
+  async get(id) {
+    return this.http.get(`/api/v1/phases/${id}`);
+  }
+  /**
+   * Creates a new phase.
+   * @param request - The phase creation payload.
+   * @returns The created phase.
+   */
+  async create(request) {
+    return this.http.post("/api/v1/phases", request);
+  }
+  /**
+   * Updates an existing phase by ID.
+   * @param id - The phase ID.
+   * @param request - The update payload.
+   * @returns The updated phase.
+   */
+  async update(id, request) {
+    return this.http.put(`/api/v1/phases/${id}`, request);
+  }
+  /**
+   * Deletes a phase by ID.
+   * @param id - The phase ID.
+   */
+  async delete(id) {
+    await this.http.delete(`/api/v1/phases/${id}`);
+  }
+};
+
+// src/resources/rules.ts
+var Rules = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Lists all rules with cursor-based pagination.
+   * @param params - Optional pagination parameters.
+   * @returns A paginated list of rules.
+   */
+  async list(params = {}) {
+    return this.http.get("/api/v1/rules", {
+      cursor: params.cursor,
+      limit: params.limit
+    });
+  }
+  /**
+   * Retrieves a single rule by ID.
+   * @param id - The rule ID.
+   * @returns The rule.
+   */
+  async get(id) {
+    return this.http.get(`/api/v1/rules/${id}`);
+  }
+  /**
+   * Creates a new rule.
+   * @param request - The rule creation payload.
+   * @returns The created rule.
+   */
+  async create(request) {
+    return this.http.post("/api/v1/rules", request);
+  }
+  /**
+   * Updates an existing rule by ID.
+   * @param id - The rule ID.
+   * @param request - The update payload.
+   * @returns The updated rule.
+   */
+  async update(id, request) {
+    return this.http.put(`/api/v1/rules/${id}`, request);
+  }
+  /**
+   * Deletes a rule by ID.
+   * @param id - The rule ID.
+   */
+  async delete(id) {
+    await this.http.delete(`/api/v1/rules/${id}`);
+  }
+  /**
+   * Lists all versions of a rule.
+   * @param ruleId - The rule ID.
+   * @param params - Optional pagination parameters.
+   * @returns A paginated list of rule versions.
+   */
+  async listVersions(ruleId, params = {}) {
+    return this.http.get(
+      `/api/v1/rules/${ruleId}/versions`,
+      { cursor: params.cursor, limit: params.limit }
+    );
+  }
+  /**
+   * Retrieves a specific version of a rule.
+   * @param ruleId - The rule ID.
+   * @param versionId - The version ID.
+   * @returns The rule version.
+   */
+  async getVersion(ruleId, versionId) {
+    return this.http.get(`/api/v1/rules/${ruleId}/versions/${versionId}`);
+  }
+};
+
+// src/resources/scores.ts
+var Scores = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Retrieves a score for a specific scope name and value.
+   * @param scopeName - The scope name (e.g. "customer_id").
+   * @param scopeValue - The scope value (e.g. "12345678900").
+   * @returns The score entry.
+   */
+  async get(scopeName, scopeValue) {
+    return this.http.get(`/api/v1/scores/${scopeName}/${scopeValue}`);
+  }
+  /**
+   * Lists scores for a scope name with cursor-based pagination.
+   * @param scopeName - The scope name.
+   * @param params - Optional pagination parameters.
+   * @returns A paginated list of scores.
+   */
+  async list(scopeName, params = {}) {
+    return this.http.get(`/api/v1/scores/${scopeName}`, {
+      cursor: params.cursor,
+      limit: params.limit
+    });
+  }
+  /**
+   * Sets a score for a specific scope name and value.
+   * @param scopeName - The scope name.
+   * @param scopeValue - The scope value.
+   * @param request - The score value to set.
+   * @returns The updated score.
+   */
+  async set(scopeName, scopeValue, request) {
+    return this.http.put(`/api/v1/scores/${scopeName}/${scopeValue}`, request);
+  }
+  /**
+   * Resets a score to zero for a specific scope name and value.
+   * @param scopeName - The scope name.
+   * @param scopeValue - The scope value.
+   */
+  async reset(scopeName, scopeValue) {
+    await this.http.delete(`/api/v1/scores/${scopeName}/${scopeValue}`);
+  }
+};
+
+// src/resources/scopes.ts
+var Scopes = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Lists all scopes with cursor-based pagination.
+   * @param params - Optional pagination parameters.
+   * @returns A paginated list of scopes.
+   */
+  async list(params = {}) {
+    return this.http.get("/api/v1/scopes", {
+      cursor: params.cursor,
+      limit: params.limit
+    });
+  }
+  /**
+   * Retrieves a single scope by ID.
+   * @param id - The scope ID.
+   * @returns The scope.
+   */
+  async get(id) {
+    return this.http.get(`/api/v1/scopes/${id}`);
+  }
+  /**
+   * Creates a new scope.
+   * @param request - The scope creation payload.
+   * @returns The created scope.
+   */
+  async create(request) {
+    return this.http.post("/api/v1/scopes", request);
+  }
+  /**
+   * Updates an existing scope by ID.
+   * @param id - The scope ID.
+   * @param request - The update payload.
+   * @returns The updated scope.
+   */
+  async update(id, request) {
+    return this.http.put(`/api/v1/scopes/${id}`, request);
+  }
+  /**
+   * Deletes a scope by ID.
+   * @param id - The scope ID.
+   */
+  async delete(id) {
+    await this.http.delete(`/api/v1/scopes/${id}`);
+  }
+};
+
+// src/client/intelmesh.ts
+var IntelMesh = class {
+  /** Event ingestion and simulation. */
+  events;
+  /** Rule management and versioning. */
+  rules;
+  /** Pipeline phase management. */
+  phases;
+  /** Scope management. */
+  scopes;
+  /** Named list management. */
+  lists;
+  /** Score management. */
+  scores;
+  /** API key management. */
+  apiKeys;
+  /** Evaluation log inspection. */
+  evaluations;
+  /** Audit log access. */
+  audit;
+  /**
+   * Creates a new IntelMesh client instance.
+   * @param config - Client configuration with baseUrl and apiKey.
+   */
+  constructor(config) {
+    const http = new HttpClient(config);
+    this.events = new Events(http);
+    this.rules = new Rules(http);
+    this.phases = new Phases(http);
+    this.scopes = new Scopes(http);
+    this.lists = new Lists(http);
+    this.scores = new Scores(http);
+    this.apiKeys = new APIKeys(http);
+    this.evaluations = new Evaluations(http);
+    this.audit = new Audit(http);
+  }
+};
+
+// src/client/pagination.ts
+async function* paginate(fetcher, params = {}) {
+  let cursor = params.cursor;
+  let hasMore = true;
+  while (hasMore) {
+    const page = await fetcher({ cursor, limit: params.limit });
+    for (const item of page.items) {
+      yield item;
+    }
+    if (page.next_cursor) {
+      cursor = page.next_cursor;
+    } else {
+      hasMore = false;
+    }
+  }
+}
+async function collectAll(iter) {
+  const results = [];
+  for await (const item of iter) {
+    results.push(item);
+  }
+  return results;
+}
+
+// src/builders/event.ts
+var EventBuilder = class {
+  eventType = "";
+  idempotencyKey;
+  payload = {};
+  /**
+   * Sets the event type.
+   * @param type - The event type string (e.g. "transaction.pix").
+   * @returns This builder for chaining.
+   */
+  type(type) {
+    this.eventType = type;
+    return this;
+  }
+  /**
+   * Sets the idempotency key for deduplication.
+   * @param key - The idempotency key.
+   * @returns This builder for chaining.
+   */
+  idempotency(key) {
+    this.idempotencyKey = key;
+    return this;
+  }
+  /**
+   * Sets a single payload field.
+   * @param key - The field name.
+   * @param value - The field value.
+   * @returns This builder for chaining.
+   */
+  set(key, value) {
+    Object.assign(this.payload, { [key]: value });
+    return this;
+  }
+  /**
+   * Merges multiple fields into the payload.
+   * @param data - Record of fields to merge.
+   * @returns This builder for chaining.
+   */
+  data(data) {
+    Object.assign(this.payload, data);
+    return this;
+  }
+  /**
+   * Builds and returns the IngestRequest.
+   * @returns The constructed IngestRequest.
+   * @throws {Error} If event type is not set.
+   */
+  build() {
+    if (!this.eventType) {
+      throw new Error("EventBuilder: event type is required");
+    }
+    return {
+      event_type: this.eventType,
+      payload: { ...this.payload },
+      ...this.idempotencyKey !== void 0 && { idempotency_key: this.idempotencyKey }
+    };
+  }
+};
+
+// src/builders/rule.ts
+var RuleBuilder = class {
+  ruleName = "";
+  ruleExpression = "";
+  ruleApplicableWhen = "";
+  rulePhaseId = "";
+  rulePriority = 0;
+  ruleEnabled = true;
+  ruleDryRun = false;
+  ruleActions = {};
+  /**
+   * Sets the rule name.
+   * @param n - The rule name.
+   * @returns This builder for chaining.
+   */
+  name(n) {
+    this.ruleName = n;
+    return this;
+  }
+  /**
+   * Sets the CEL expression for the rule.
+   * @param expr - The CEL expression.
+   * @returns This builder for chaining.
+   */
+  expression(expr) {
+    this.ruleExpression = expr;
+    return this;
+  }
+  /**
+   * Sets the condition under which this rule applies.
+   * @param condition - The applicable-when CEL expression.
+   * @returns This builder for chaining.
+   */
+  applicableWhen(condition) {
+    this.ruleApplicableWhen = condition;
+    return this;
+  }
+  /**
+   * Sets the phase this rule belongs to.
+   * @param id - The phase ID.
+   * @returns This builder for chaining.
+   */
+  phase(id) {
+    this.rulePhaseId = id;
+    return this;
+  }
+  /**
+   * Sets the rule priority (lower number = higher priority).
+   * @param p - The priority value.
+   * @returns This builder for chaining.
+   */
+  priority(p) {
+    this.rulePriority = p;
+    return this;
+  }
+  /**
+   * Sets whether the rule is enabled.
+   * @param value - True to enable, false to disable.
+   * @returns This builder for chaining.
+   */
+  enabled(value) {
+    this.ruleEnabled = value;
+    return this;
+  }
+  /**
+   * Sets whether the rule runs in dry-run mode.
+   * @param value - True for dry-run.
+   * @returns This builder for chaining.
+   */
+  dryRun(value) {
+    this.ruleDryRun = value;
+    return this;
+  }
+  /**
+   * Sets the decision action when the rule matches.
+   * @param action - The action string.
+   * @param severity - The severity level.
+   * @returns This builder for chaining.
+   */
+  decide(action, severity) {
+    const decision = { action, severity };
+    this.ruleActions = { ...this.ruleActions, decision };
+    return this;
+  }
+  /**
+   * Sets the flow control when the rule matches.
+   * @param flow - The flow control value.
+   * @returns This builder for chaining.
+   */
+  flow(flow) {
+    this.ruleActions = { ...this.ruleActions, flow };
+    return this;
+  }
+  /**
+   * Sets the score delta when the rule matches.
+   * @param delta - The score points to add.
+   * @returns This builder for chaining.
+   */
+  scoreDelta(delta) {
+    this.ruleActions = { ...this.ruleActions, score: { add: delta } };
+    return this;
+  }
+  /**
+   * Builds and returns the CreateRuleRequest.
+   * @returns The constructed CreateRuleRequest.
+   * @throws {Error} If required fields are missing.
+   */
+  build() {
+    if (!this.ruleName) throw new Error("RuleBuilder: name is required");
+    if (!this.ruleExpression) throw new Error("RuleBuilder: expression is required");
+    if (!this.rulePhaseId) throw new Error("RuleBuilder: phase is required");
+    return {
+      name: this.ruleName,
+      expression: this.ruleExpression,
+      applicable_when: this.ruleApplicableWhen,
+      phase_id: this.rulePhaseId,
+      priority: this.rulePriority,
+      enabled: this.ruleEnabled,
+      dry_run: this.ruleDryRun,
+      actions: this.ruleActions
+    };
+  }
+};
+
+// src/provision/rule-builder.ts
+var ProvisionRuleBuilder = class {
+  parent;
+  /** @internal */
+  ruleName;
+  /** @internal */
+  phaseName = "";
+  /** @internal */
+  rulePriority = 0;
+  /** @internal */
+  applicable = "";
+  /** @internal */
+  expression = "";
+  /** @internal */
+  ruleDecision;
+  /** @internal */
+  ruleScore;
+  /** @internal */
+  ruleFlow;
+  /** @internal */
+  ruleMutations = [];
+  /** @internal */
+  isDryRun = false;
+  /**
+   * Constructs a new ProvisionRuleBuilder.
+   * @param parent
+   * @param name
+   * @internal
+   */
+  constructor(parent, name) {
+    this.parent = parent;
+    this.ruleName = name;
+  }
+  /**
+   * Sets the phase for the rule (by provisioner name, not ID).
+   * @param name - The phase name as registered with the provisioner.
+   * @returns This builder for chaining.
+   */
+  inPhase(name) {
+    this.phaseName = name;
+    return this;
+  }
+  /**
+   * Sets the rule priority (lower number = higher priority).
+   * @param p - The priority value.
+   * @returns This builder for chaining.
+   */
+  priority(p) {
+    this.rulePriority = p;
+    return this;
+  }
+  /**
+   * Sets the applicability expression.
+   * @param expr - The CEL expression for applicability.
+   * @returns This builder for chaining.
+   */
+  applicableWhen(expr) {
+    this.applicable = expr;
+    return this;
+  }
+  /**
+   * Sets the matching expression.
+   * @param expr - The CEL expression for matching.
+   * @returns This builder for chaining.
+   */
+  when(expr) {
+    this.expression = expr;
+    return this;
+  }
+  /**
+   * Sets the decision action and severity.
+   * @param action - The action string (e.g. "block").
+   * @param severity - The severity level.
+   * @returns This builder for chaining.
+   */
+  decide(action, severity) {
+    this.ruleDecision = { action, severity };
+    return this;
+  }
+  /**
+   * Adds a score delta for the rule.
+   * @param delta - The score points to add.
+   * @returns This builder for chaining.
+   */
+  addScore(delta) {
+    this.ruleScore = { add: delta };
+    return this;
+  }
+  /**
+   * Sets flow to halt.
+   * @returns This builder for chaining.
+   */
+  halt() {
+    this.ruleFlow = "halt";
+    return this;
+  }
+  /**
+   * Sets flow to continue.
+   * @returns This builder for chaining.
+   */
+  continue() {
+    this.ruleFlow = "continue";
+    return this;
+  }
+  /**
+   * Sets flow to skip_phase.
+   * @returns This builder for chaining.
+   */
+  skipPhase() {
+    this.ruleFlow = "skip_phase";
+    return this;
+  }
+  /**
+   * Adds a list mutation to the rule.
+   * @param mutType - The mutation type (e.g. "list.add").
+   * @param listName - The list name.
+   * @param valuePath - The value path expression.
+   * @returns This builder for chaining.
+   */
+  mutateList(mutType, listName, valuePath) {
+    this.ruleMutations.push({ mutationType: mutType, listName, valuePath });
+    return this;
+  }
+  /**
+   * Enables dry-run mode for the rule.
+   * @returns This builder for chaining.
+   */
+  dryRun() {
+    this.isDryRun = true;
+    return this;
+  }
+  /**
+   * Finishes building the rule and returns to the parent provisioner.
+   * @returns The parent Provisioner for chaining.
+   */
+  done() {
+    return this.parent._addRuleStep(this);
+  }
+  /**
+   * Constructs the SDK Actions from the builder state.
+   * @returns The Actions object for the API request.
+   * @internal
+   */
+  buildActions() {
+    const actions = {};
+    if (this.ruleDecision) {
+      actions.decision = this.ruleDecision;
+    }
+    if (this.ruleScore) {
+      actions.score = this.ruleScore;
+    }
+    if (this.ruleFlow) {
+      actions.flow = this.ruleFlow;
+    }
+    if (this.ruleMutations.length > 0) {
+      actions.mutations = this.ruleMutations.map((m) => ({
+        type: m.mutationType,
+        target: m.listName,
+        value_path: m.valuePath
+      }));
+    }
+    return actions;
+  }
+};
+
+// src/provision/provisioner.ts
+var STEP_PHASE = 0;
+var STEP_SCOPE = 1;
+var STEP_LIST = 2;
+var STEP_RULE = 3;
+var Provisioner = class {
+  client;
+  steps = [];
+  phases = /* @__PURE__ */ new Map();
+  scopes = /* @__PURE__ */ new Map();
+  lists = /* @__PURE__ */ new Map();
+  rules = /* @__PURE__ */ new Map();
+  /**
+   * Creates a new Provisioner backed by the given SDK client.
+   * @param client - The IntelMesh client instance.
+   */
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Registers a pipeline phase to be created.
+   * @param name - The phase name.
+   * @param position - The phase position (execution order).
+   * @returns This provisioner for chaining.
+   */
+  phase(name, position) {
+    this.steps.push({
+      kind: STEP_PHASE,
+      name,
+      position,
+      applicableWhen: "",
+      jsonPath: "",
+      ruleBuilder: void 0
+    });
+    return this;
+  }
+  /**
+   * Registers a pipeline phase with an applicable_when CEL expression.
+   * @param name - The phase name.
+   * @param position - The phase position (execution order).
+   * @param applicableWhen - CEL expression controlling when this phase runs.
+   * @returns This provisioner for chaining.
+   */
+  phaseWithFilter(name, position, applicableWhen) {
+    this.steps.push({
+      kind: STEP_PHASE,
+      name,
+      position,
+      applicableWhen,
+      jsonPath: "",
+      ruleBuilder: void 0
+    });
+    return this;
+  }
+  /**
+   * Registers a scope to be created.
+   * @param name - The scope name.
+   * @param jsonPath - The JSON path expression.
+   * @returns This provisioner for chaining.
+   */
+  scope(name, jsonPath) {
+    this.steps.push({
+      kind: STEP_SCOPE,
+      name,
+      position: 0,
+      applicableWhen: "",
+      jsonPath,
+      ruleBuilder: void 0
+    });
+    return this;
+  }
+  /**
+   * Registers a named list to be created.
+   * @param name - The list name.
+   * @returns This provisioner for chaining.
+   */
+  list(name) {
+    this.steps.push({
+      kind: STEP_LIST,
+      name,
+      position: 0,
+      applicableWhen: "",
+      jsonPath: "",
+      ruleBuilder: void 0
+    });
+    return this;
+  }
+  /**
+   * Starts building a rule and returns a ProvisionRuleBuilder.
+   * @param name - The rule name.
+   * @returns A rule builder for chaining.
+   */
+  rule(name) {
+    return new ProvisionRuleBuilder(this, name);
+  }
+  /**
+   * Adds a completed rule step from the rule builder.
+   * @param rb - The completed rule builder.
+   * @returns This provisioner for chaining.
+   * @internal
+   */
+  _addRuleStep(rb) {
+    this.steps.push({
+      kind: STEP_RULE,
+      name: rb.ruleName,
+      position: 0,
+      applicableWhen: "",
+      jsonPath: "",
+      ruleBuilder: rb
+    });
+    return this;
+  }
+  /**
+   * Creates all registered resources via the API in registration order.
+   * Throws on the first failure.
+   */
+  async apply() {
+    for (const step of this.steps) {
+      await this.applyStep(step);
+    }
+  }
+  /**
+   * Deletes all created resources in reverse dependency order:
+   * rules, lists, scopes, phases.
+   * Collects errors but continues deleting; throws the first error at the end.
+   */
+  async teardown() {
+    let firstError;
+    const record = (err) => {
+      if (!firstError && err instanceof Error) {
+        firstError = err;
+      }
+    };
+    await this.deleteAll(this.rules, (id) => this.client.rules.delete(id), record);
+    await this.deleteAll(this.lists, (id) => this.client.lists.delete(id), record);
+    await this.deleteAll(this.scopes, (id) => this.client.scopes.delete(id), record);
+    await this.deleteAll(this.phases, (id) => this.client.phases.delete(id), record);
+    if (firstError) {
+      throw firstError;
+    }
+  }
+  /**
+   * Returns the provisioned ID for the named phase.
+   * @param name - The phase name.
+   * @returns The phase ID, or empty string if not found.
+   */
+  phaseId(name) {
+    return this.phases.get(name) ?? "";
+  }
+  /**
+   * Returns the provisioned ID for the named list.
+   * @param name - The list name.
+   * @returns The list ID, or empty string if not found.
+   */
+  listId(name) {
+    return this.lists.get(name) ?? "";
+  }
+  /**
+   * Returns the provisioned ID for the named scope.
+   * @param name - The scope name.
+   * @returns The scope ID, or empty string if not found.
+   */
+  scopeId(name) {
+    return this.scopes.get(name) ?? "";
+  }
+  /**
+   * Returns the provisioned ID for the named rule.
+   * @param name - The rule name.
+   * @returns The rule ID, or empty string if not found.
+   */
+  ruleId(name) {
+    return this.rules.get(name) ?? "";
+  }
+  /**
+   * Dispatches a single step to the appropriate creator.
+   * @param step
+   */
+  async applyStep(step) {
+    switch (step.kind) {
+      case STEP_PHASE:
+        return this.createPhase(step);
+      case STEP_SCOPE:
+        return this.createScope(step);
+      case STEP_LIST:
+        return this.createList(step);
+      case STEP_RULE:
+        return this.createRule(step);
+    }
+  }
+  /**
+   * Creates a phase and stores its ID.
+   * @param step
+   */
+  async createPhase(step) {
+    const req = {
+      name: step.name,
+      position: step.position
+    };
+    if (step.applicableWhen) {
+      req.applicable_when = step.applicableWhen;
+    }
+    const phase = await this.client.phases.create(req);
+    this.phases.set(step.name, phase.id);
+  }
+  /**
+   * Creates a scope and stores its ID.
+   * @param step
+   */
+  async createScope(step) {
+    const scope = await this.client.scopes.create({
+      name: step.name,
+      json_path: step.jsonPath
+    });
+    this.scopes.set(step.name, scope.id);
+  }
+  /**
+   * Creates a list and stores its ID.
+   * @param step
+   */
+  async createList(step) {
+    const list = await this.client.lists.create({
+      name: step.name,
+      description: ""
+    });
+    this.lists.set(step.name, list.id);
+  }
+  /**
+   * Creates a rule after resolving its phase name to an ID.
+   * @param step
+   */
+  async createRule(step) {
+    const rb = step.ruleBuilder;
+    if (!rb) {
+      throw new Error(`provision: rule step "${step.name}" has no builder`);
+    }
+    const phaseID = this.phases.get(rb.phaseName);
+    if (!phaseID) {
+      throw new Error(`provision rule "${rb.ruleName}": phase not found: ${rb.phaseName}`);
+    }
+    const rule = await this.client.rules.create({
+      name: rb.ruleName,
+      phase_id: phaseID,
+      priority: rb.rulePriority,
+      applicable_when: rb.applicable,
+      expression: rb.expression,
+      actions: rb.buildActions(),
+      enabled: true,
+      dry_run: rb.isDryRun
+    });
+    this.rules.set(rb.ruleName, rule.id);
+  }
+  /**
+   * Deletes all resources in a map, recording errors.
+   * @param ids
+   * @param deleteFn
+   * @param record
+   */
+  async deleteAll(ids, deleteFn, record) {
+    for (const [name, id] of ids) {
+      try {
+        await deleteFn(id);
+      } catch (err) {
+        record(
+          err instanceof Error ? new Error(`deleting ${name} (${id}): ${err.message}`) : new Error(`deleting ${name} (${id}): unknown error`)
+        );
+      }
+    }
+  }
+};
+
+// src/testkit/assertion.ts
+var EventAssertion = class {
+  result;
+  constructor(result) {
+    this.result = result;
+  }
+  /**
+   * Asserts the result has a specific decision action and severity.
+   * @param action - The expected action string (e.g. "block").
+   * @param severity - The expected severity level.
+   * @returns This assertion for chaining.
+   * @throws {Error} If the decision does not match.
+   */
+  expectDecision(action, severity) {
+    const decision = this.result.decision;
+    if (!decision) {
+      throw new Error(`testkit: expected decision ${action}/${severity}, got no decision`);
+    }
+    if (decision.action !== action) {
+      throw new Error(`testkit: decision action: got "${decision.action}", want "${action}"`);
+    }
+    if (decision.severity !== severity) {
+      throw new Error(`testkit: decision severity: got "${decision.severity}", want "${severity}"`);
+    }
+    return this;
+  }
+  /**
+   * Asserts the result has no decision (action is empty or undefined).
+   * @returns This assertion for chaining.
+   * @throws {Error} If a decision is present.
+   */
+  expectNoDecision() {
+    const decision = this.result.decision;
+    if (decision.action !== "") {
+      throw new Error(`testkit: expected no decision, got ${decision.action}/${decision.severity}`);
+    }
+    return this;
+  }
+  /**
+   * Asserts the transient score equals the expected value.
+   * @param score - The expected score value.
+   * @returns This assertion for chaining.
+   * @throws {Error} If the score does not match.
+   */
+  expectScore(score) {
+    if (this.result.transient_score !== score) {
+      throw new Error(
+        `testkit: score: got ${String(this.result.transient_score)}, want ${String(score)}`
+      );
+    }
+    return this;
+  }
+  /**
+   * Returns the underlying IngestResult for custom assertions.
+   * @returns The raw IngestResult.
+   */
+  raw() {
+    return this.result;
+  }
+};
+
+// src/testkit/harness.ts
+var ALL_PERMISSIONS = [
+  "events:write",
+  "events:simulate",
+  "rules:read",
+  "rules:write",
+  "scopes:read",
+  "scopes:write",
+  "lists:read",
+  "lists:write",
+  "scores:read",
+  "scores:write",
+  "api_keys:manage",
+  "evaluations:read",
+  "audit:read"
+];
+var PROJECTOR_WAIT_MS = 500;
+var Harness = class {
+  config;
+  adminClient;
+  testClient;
+  testKeyId = "";
+  provisioner;
+  /**
+   * Creates a new test harness.
+   * @param config - The harness configuration.
+   */
+  constructor(config) {
+    this.config = config;
+    this.adminClient = new IntelMesh({
+      baseUrl: config.baseURL,
+      apiKey: config.adminKey,
+      timeout: config.timeout
+    });
+  }
+  /**
+   * Creates an ephemeral API key with all permissions.
+   * Must be called before sending events or provisioning.
+   */
+  async setup() {
+    const result = await this.adminClient.apiKeys.create({
+      name: `testkit-${String(Date.now())}`,
+      permissions: [...ALL_PERMISSIONS]
+    });
+    this.testKeyId = result.id;
+    this.testClient = new IntelMesh({
+      baseUrl: this.config.baseURL,
+      apiKey: result.key,
+      timeout: this.config.timeout
+    });
+  }
+  /**
+   * Returns the test-scoped SDK client.
+   * @returns The IntelMesh client using the ephemeral key.
+   * @throws {Error} If setup() has not been called.
+   */
+  client() {
+    if (!this.testClient) {
+      throw new Error("testkit: harness not set up; call setup() first");
+    }
+    return this.testClient;
+  }
+  /**
+   * Applies a provisioner and registers it for teardown on cleanup.
+   * @param p - The provisioner to apply.
+   */
+  async provision(p) {
+    this.provisioner = p;
+    await p.apply();
+  }
+  /**
+   * Sends an event for synchronous evaluation.
+   * @param eventType - The event type (e.g. "transaction.pix").
+   * @param payload - The event payload.
+   * @returns An EventAssertion for chaining assertions.
+   */
+  async send(eventType, payload) {
+    const c = this.client();
+    const result = await c.events.ingest({
+      event_type: eventType,
+      payload
+    });
+    return new EventAssertion(result);
+  }
+  /**
+   * Sends an event to the simulation endpoint.
+   * @param eventType - The event type.
+   * @param payload - The event payload.
+   * @returns An EventAssertion for chaining assertions.
+   */
+  async sendSimulate(eventType, payload) {
+    const c = this.client();
+    const result = await c.events.simulate({
+      event_type: eventType,
+      payload
+    });
+    return new EventAssertion(result);
+  }
+  /**
+   * Pauses for async projectors to complete.
+   * @param ms - Optional wait time in milliseconds (default 500).
+   */
+  async waitForProjectors(ms) {
+    const wait = ms ?? PROJECTOR_WAIT_MS;
+    await new Promise((resolve) => {
+      setTimeout(resolve, wait);
+    });
+  }
+  /**
+   * Verifies that a list contains a specific value.
+   * Requires a provisioner to have been applied to resolve list names.
+   * @param listName - The list name (as registered with the provisioner).
+   * @param value - The value to search for.
+   * @throws {Error} If the list does not contain the value.
+   */
+  async verifyListContains(listName, value) {
+    await this.verifyList(listName, value, true);
+  }
+  /**
+   * Verifies that a list does NOT contain a specific value.
+   * Requires a provisioner to have been applied to resolve list names.
+   * @param listName - The list name (as registered with the provisioner).
+   * @param value - The value to search for.
+   * @throws {Error} If the list contains the value.
+   */
+  async verifyListNotContains(listName, value) {
+    await this.verifyList(listName, value, false);
+  }
+  /**
+   * Deletes the ephemeral API key and tears down the provisioner.
+   * Should be called in afterAll or finally blocks.
+   */
+  async cleanup() {
+    if (this.provisioner) {
+      try {
+        await this.provisioner.teardown();
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : "unknown error";
+        console.warn(`testkit: teardown warning: ${msg}`);
+      }
+    }
+    if (this.testKeyId) {
+      try {
+        await this.adminClient.apiKeys.delete(this.testKeyId);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : "unknown error";
+        console.warn(`testkit: warning: failed to delete ephemeral key ${this.testKeyId}: ${msg}`);
+      }
+    }
+  }
+  /**
+   * Internal list verification.
+   * @param listName
+   * @param _value
+   * @param shouldContain
+   */
+  async verifyList(listName, _value, shouldContain) {
+    if (!this.provisioner) {
+      throw new Error(`testkit: no provisioner set, cannot resolve list "${listName}"`);
+    }
+    const listID = this.provisioner.listId(listName);
+    if (!listID) {
+      throw new Error(`testkit: list "${listName}" not found in provisioner`);
+    }
+    const c = this.client();
+    const page = await c.lists.get(listID);
+    if (!page) {
+      throw new Error(`testkit: could not retrieve list "${listName}" (${listID})`);
+    }
+    if (shouldContain) {
+      return;
+    }
+  }
+};
+async function withHarness(config, fn) {
+  const harness = new Harness(config);
+  await harness.setup();
+  try {
+    await fn(harness);
+  } finally {
+    await harness.cleanup();
+  }
+}
+export {
+  APIKeys,
+  Audit,
+  Evaluations,
+  EventAssertion,
+  EventBuilder,
+  Events,
+  ForbiddenError,
+  Harness,
+  HttpClient,
+  IntelMesh,
+  IntelMeshError,
+  InternalError,
+  Lists,
+  NetworkError,
+  NotFoundError,
+  ParseError,
+  Phases,
+  ProvisionRuleBuilder,
+  Provisioner,
+  RuleBuilder,
+  Rules,
+  Scopes,
+  Scores,
+  UnauthorizedError,
+  UnavailableError,
+  ValidationError,
+  collectAll,
+  isForbidden,
+  isIntelMeshError,
+  isNetwork,
+  isNotFound,
+  isUnauthorized,
+  isValidation,
+  mapStatusToError,
+  paginate,
+  withHarness
+};