kloakd-sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,843 @@
+// src/errors.ts
+var KloakdError = class extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.name = "KloakdError";
+    this.statusCode = statusCode;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var AuthenticationError = class extends KloakdError {
+  constructor(message) {
+    super(message, 401);
+    this.name = "AuthenticationError";
+  }
+};
+var NotEntitledError = class extends KloakdError {
+  constructor(message, module, upgradeUrl = "https://app.kloakd.dev/billing") {
+    super(message, 403);
+    this.name = "NotEntitledError";
+    this.module = module;
+    this.upgradeUrl = upgradeUrl;
+  }
+};
+var RateLimitError = class extends KloakdError {
+  constructor(message, retryAfter, resetAt = "") {
+    super(message, 429);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+    this.resetAt = resetAt;
+  }
+};
+var UpstreamError = class extends KloakdError {
+  constructor(message) {
+    super(message, 502);
+    this.name = "UpstreamError";
+  }
+};
+var ApiError = class extends KloakdError {
+  constructor(message, statusCode) {
+    super(message, statusCode);
+    this.name = "ApiError";
+  }
+};
+function raiseForStatus(statusCode, body) {
+  if (statusCode < 400) return;
+  const detail = body["detail"] ?? body["message"] ?? `HTTP ${statusCode}`;
+  if (statusCode === 401) {
+    throw new AuthenticationError(`Invalid or expired API key: ${detail}`);
+  }
+  if (statusCode === 403) {
+    throw new NotEntitledError(
+      `Not entitled to this module: ${detail}`,
+      body["module"] ?? "unknown",
+      body["upgrade_url"] ?? "https://app.kloakd.dev/billing"
+    );
+  }
+  if (statusCode === 429) {
+    throw new RateLimitError(
+      `Rate limit exceeded: ${detail}`,
+      Number(body["retry_after"] ?? 60),
+      body["reset_at"] ?? ""
+    );
+  }
+  if (statusCode === 502) {
+    throw new UpstreamError(`Upstream fetch failed: ${detail}`);
+  }
+  throw new ApiError(`KLOAKD API error ${statusCode}: ${detail}`, statusCode);
+}
+
+// src/_http.ts
+var SDK_VERSION = "0.1.0";
+var RETRYABLE = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+function sdkHeader() {
+  return `typescript/${SDK_VERSION}`;
+}
+function backoff(attempt, retryAfter) {
+  if (retryAfter != null && retryAfter > 0) return retryAfter * 1e3;
+  return Math.min(1e3 * Math.pow(2, attempt), 6e4);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var HttpTransport = class {
+  constructor(opts) {
+    this._apiKey = opts.apiKey;
+    this._organizationId = opts.organizationId;
+    this._baseUrl = opts.baseUrl.replace(/\/$/, "");
+    this._timeout = opts.timeout;
+    this._maxRetries = opts.maxRetries;
+    this._fetch = opts.fetchImpl ?? globalThis.fetch.bind(globalThis);
+  }
+  authHeaders() {
+    return {
+      Authorization: `Bearer ${this._apiKey}`,
+      "X-Kloakd-Organization": this._organizationId,
+      "X-Kloakd-SDK": sdkHeader(),
+      "Content-Type": "application/json"
+    };
+  }
+  orgPrefix() {
+    return `/api/v1/organizations/${this._organizationId}`;
+  }
+  url(path) {
+    return `${this._baseUrl}${this.orgPrefix()}/${path.replace(/^\//, "")}`;
+  }
+  async request(method, path, body, params) {
+    let fullUrl = this.url(path);
+    if (params && Object.keys(params).length > 0) {
+      fullUrl += "?" + new URLSearchParams(params).toString();
+    }
+    const headers = this.authHeaders();
+    const init = {
+      method,
+      headers,
+      signal: AbortSignal.timeout(this._timeout * 1e3)
+    };
+    if (body !== void 0) {
+      init.body = JSON.stringify(body);
+    }
+    let lastError;
+    for (let attempt = 0; attempt <= this._maxRetries; attempt++) {
+      const resp = await this._fetch(fullUrl, init);
+      const json = resp.headers.get("content-type")?.includes("application/json") ? await resp.json() : {};
+      try {
+        raiseForStatus(resp.status, json);
+        return json;
+      } catch (err) {
+        if (!(err instanceof KloakdError)) throw err;
+        if (!RETRYABLE.has(err.statusCode)) throw err;
+        lastError = err;
+        if (attempt < this._maxRetries) {
+          const retryAfter = err.statusCode === 429 ? Number(resp.headers.get("retry-after") ?? json["retry_after"] ?? 60) : void 0;
+          await sleep(backoff(attempt, retryAfter));
+        }
+      }
+    }
+    throw lastError;
+  }
+  async get(path, params) {
+    return this.request("GET", path, void 0, params);
+  }
+  async post(path, body) {
+    return this.request("POST", path, body);
+  }
+  async delete(path) {
+    await this.request("DELETE", path);
+  }
+  /**
+   * Open an SSE stream and return an AsyncIterable over raw `data:` payloads.
+   * Caller is responsible for parsing each chunk.
+   */
+  async *stream(path, body) {
+    const headers = { ...this.authHeaders(), Accept: "text/event-stream" };
+    const resp = await this._fetch(this.url(path), {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(0)
+      // no timeout on streams
+    });
+    raiseForStatus(resp.status, {});
+    if (!resp.body) return;
+    const reader = resp.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed.startsWith("data:")) continue;
+          const dataStr = trimmed.slice(5).trim();
+          if (!dataStr) continue;
+          try {
+            yield JSON.parse(dataStr);
+          } catch {
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  /**
+   * SSE stream that also surfaces `event:` field alongside `data:`.
+   * Used by Parlyr.chatStream().
+   */
+  async *streamWithEvents(path, body) {
+    const headers = { ...this.authHeaders(), Accept: "text/event-stream" };
+    const resp = await this._fetch(this.url(path), {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(0)
+    });
+    raiseForStatus(resp.status, {});
+    if (!resp.body) return;
+    const reader = resp.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let currentEvent = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (trimmed.startsWith("event:")) {
+            currentEvent = trimmed.slice(6).trim();
+          } else if (trimmed.startsWith("data:")) {
+            const dataStr = trimmed.slice(5).trim();
+            if (!dataStr) continue;
+            try {
+              yield { event: currentEvent, data: JSON.parse(dataStr) };
+            } catch {
+            }
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+};
+
+// src/modules/evadr.ts
+function parseFetch(raw, url) {
+  const result = {
+    success: Boolean(raw["success"]),
+    url: raw["url"] ?? url,
+    statusCode: Number(raw["status_code"] ?? 0),
+    tierUsed: Number(raw["tier_used"] ?? 1),
+    html: raw["html"] ?? null,
+    vendorDetected: raw["vendor_detected"] ?? null,
+    antiBotBypassed: Boolean(raw["anti_bot_bypassed"]),
+    artifactId: raw["artifact_id"] ?? null,
+    error: raw["error"] ?? null
+  };
+  return { ...result, get ok() {
+    return result.success && result.error === null;
+  } };
+}
+var EvadrNamespace = class {
+  constructor(_t) {
+    this._t = _t;
+  }
+  async fetch(url, opts = {}) {
+    const body = { url };
+    if (opts.forceBrowser) body["force_browser"] = true;
+    if (opts.useProxy) body["use_proxy"] = true;
+    if (opts.sessionArtifactId) body["session_artifact_id"] = opts.sessionArtifactId;
+    const raw = await this._t.post("evadr/fetch", body);
+    return parseFetch(raw, url);
+  }
+  async fetchAsync(url, opts = {}) {
+    const body = { url, async: true };
+    if (opts.forceBrowser) body["force_browser"] = true;
+    if (opts.useProxy) body["use_proxy"] = true;
+    if (opts.webhookUrl) body["webhook_url"] = opts.webhookUrl;
+    const raw = await this._t.post("evadr/fetch", body);
+    return String(raw["job_id"]);
+  }
+  async *fetchStream(url, opts = {}) {
+    const body = { url };
+    if (opts.forceBrowser) body["force_browser"] = true;
+    for await (const data of this._t.stream("evadr/fetch/stream", body)) {
+      yield {
+        type: String(data["type"] ?? ""),
+        tier: data["tier"] != null ? Number(data["tier"]) : null,
+        vendor: data["vendor"] ?? null,
+        metadata: data["metadata"] ?? {}
+      };
+    }
+  }
+  async analyze(url, opts = {}) {
+    const raw = await this._t.post("evadr/analyze", {
+      url,
+      status_code: opts.statusCode ?? 200,
+      headers: opts.headers ?? {},
+      body_snippet: opts.bodySnippet ?? null
+    });
+    return {
+      blocked: Boolean(raw["blocked"]),
+      vendor: raw["vendor"] ?? null,
+      confidence: Number(raw["confidence"] ?? 0),
+      recommendedActions: raw["recommended_actions"] ?? []
+    };
+  }
+  async storeProxy(name, proxyUrl) {
+    await this._t.post("evadr/proxies", { name, proxy_url: proxyUrl });
+  }
+};
+
+// src/modules/fetchyr.ts
+var FetchyrNamespace = class {
+  constructor(_t) {
+    this._t = _t;
+  }
+  async login(url, usernameSelector, passwordSelector, username, password, opts = {}) {
+    const body = {
+      url,
+      username_selector: usernameSelector,
+      password_selector: passwordSelector,
+      username,
+      password
+    };
+    if (opts.submitSelector) body["submit_selector"] = opts.submitSelector;
+    if (opts.successUrlContains) body["success_url_contains"] = opts.successUrlContains;
+    const raw = await this._t.post("fetchyr/login", body);
+    const result = {
+      success: Boolean(raw["success"]),
+      sessionId: raw["session_id"] ?? "",
+      url: raw["url"] ?? url,
+      artifactId: raw["artifact_id"] ?? null,
+      screenshotUrl: raw["screenshot_url"] ?? null,
+      error: raw["error"] ?? null
+    };
+    return { ...result, get ok() {
+      return result.success && result.error === null;
+    } };
+  }
+  async fetch(url, sessionArtifactId, opts = {}) {
+    const body = { url, session_artifact_id: sessionArtifactId };
+    if (opts.waitForSelector) body["wait_for_selector"] = opts.waitForSelector;
+    if (opts.extractHtml !== void 0) body["extract_html"] = opts.extractHtml;
+    const raw = await this._t.post("fetchyr/fetch", body);
+    const result = {
+      success: Boolean(raw["success"]),
+      url: raw["url"] ?? url,
+      statusCode: Number(raw["status_code"] ?? 0),
+      html: raw["html"] ?? null,
+      artifactId: raw["artifact_id"] ?? null,
+      sessionArtifactId,
+      error: raw["error"] ?? null
+    };
+    return { ...result, get ok() {
+      return result.success && result.error === null;
+    } };
+  }
+  async getSession(artifactId) {
+    return this._t.get(`fetchyr/sessions/${artifactId}`);
+  }
+  async invalidateSession(artifactId) {
+    await this._t.delete(`fetchyr/sessions/${artifactId}`);
+  }
+  async createWorkflow(name, steps, url) {
+    const body = { name, steps };
+    if (url) body["url"] = url;
+    const raw = await this._t.post("fetchyr/workflows", body);
+    const result = {
+      workflowId: raw["workflow_id"] ?? "",
+      name: raw["name"] ?? name,
+      steps: raw["steps"] ?? steps,
+      url: raw["url"] ?? null,
+      createdAt: raw["created_at"] ?? "",
+      error: raw["error"] ?? null
+    };
+    return { ...result, get ok() {
+      return result.error === null;
+    } };
+  }
+  async executeWorkflow(workflowId) {
+    const raw = await this._t.post(`fetchyr/workflows/${workflowId}/execute`, {});
+    return parseExecution(raw);
+  }
+  async getExecution(workflowId, executionId) {
+    const raw = await this._t.get(`fetchyr/workflows/${workflowId}/executions/${executionId}`);
+    return parseExecution(raw);
+  }
+  async detectForms(url, opts = {}) {
+    const body = { url };
+    if (opts.sessionArtifactId) body["session_artifact_id"] = opts.sessionArtifactId;
+    const raw = await this._t.post("fetchyr/detect-forms", body);
+    return {
+      forms: raw["forms"] ?? [],
+      totalForms: Number(raw["total_forms"] ?? 0),
+      error: raw["error"] ?? null
+    };
+  }
+  async detectMfa(url, opts = {}) {
+    const body = { url };
+    if (opts.sessionArtifactId) body["session_artifact_id"] = opts.sessionArtifactId;
+    const raw = await this._t.post("fetchyr/detect-mfa", body);
+    return {
+      mfaDetected: Boolean(raw["mfa_detected"]),
+      challengeId: raw["challenge_id"] ?? null,
+      mfaType: raw["mfa_type"] ?? null,
+      error: raw["error"] ?? null
+    };
+  }
+  async submitMfa(challengeId, code) {
+    const raw = await this._t.post("fetchyr/submit-mfa", { challenge_id: challengeId, code });
+    return {
+      success: Boolean(raw["success"]),
+      sessionArtifactId: raw["session_artifact_id"] ?? null,
+      error: raw["error"] ?? null
+    };
+  }
+  async checkDuplicates(records, opts = {}) {
+    const body = { records };
+    if (opts.domain) body["domain"] = opts.domain;
+    const raw = await this._t.post("fetchyr/deduplicate", body);
+    const result = {
+      uniqueRecords: raw["unique_records"] ?? [],
+      duplicateCount: Number(raw["duplicate_count"] ?? 0),
+      totalInput: Number(raw["total_input"] ?? records.length),
+      error: raw["error"] ?? null
+    };
+    return { ...result, get ok() {
+      return result.error === null;
+    } };
+  }
+};
+function parseExecution(raw) {
+  const result = {
+    executionId: raw["execution_id"] ?? "",
+    workflowId: raw["workflow_id"] ?? "",
+    status: raw["status"] ?? "unknown",
+    startedAt: raw["started_at"] ?? null,
+    completedAt: raw["completed_at"] ?? null,
+    records: raw["records"] ?? [],
+    error: raw["error"] ?? null
+  };
+  return { ...result, get ok() {
+    return result.status === "completed" && result.error === null;
+  } };
+}
+
+// src/modules/kolektr.ts
+function parseExtraction(raw, url) {
+  const result = {
+    success: Boolean(raw["success"]),
+    url: raw["url"] ?? url,
+    method: raw["method"] ?? "unknown",
+    records: raw["records"] ?? [],
+    totalRecords: Number(raw["total_records"] ?? 0),
+    pagesScraped: Number(raw["pages_scraped"] ?? 0),
+    artifactId: raw["artifact_id"] ?? null,
+    jobId: raw["job_id"] ?? null,
+    error: raw["error"] ?? null,
+    hasMore: Boolean(raw["has_more"]),
+    total: Number(raw["total"] ?? 0)
+  };
+  return { ...result, get ok() {
+    return result.success && result.error === null;
+  } };
+}
+var KolektrNamespace = class {
+  constructor(_t) {
+    this._t = _t;
+  }
+  async page(url, opts = {}) {
+    const body = {
+      url,
+      limit: opts.limit ?? 100,
+      offset: opts.offset ?? 0
+    };
+    if (opts.schema) body["schema"] = opts.schema;
+    if (opts.fetchArtifactId) body["fetch_artifact_id"] = opts.fetchArtifactId;
+    if (opts.sessionArtifactId) body["session_artifact_id"] = opts.sessionArtifactId;
+    if (opts.apiMapArtifactId) body["api_map_artifact_id"] = opts.apiMapArtifactId;
+    if (opts.options) body["options"] = opts.options;
+    const raw = await this._t.post("kolektr/extract", body);
+    return parseExtraction(raw, url);
+  }
+  async pageAll(url, opts = {}) {
+    const all = [];
+    let offset = 0;
+    while (true) {
+      const result = await this.page(url, { ...opts, limit: 100, offset });
+      all.push(...result.records);
+      if (!result.hasMore) break;
+      offset += result.records.length;
+    }
+    return all;
+  }
+  async extractHtml(html, url, opts = {}) {
+    const body = { html, url };
+    if (opts.schema) body["schema"] = opts.schema;
+    const raw = await this._t.post("kolektr/extract/html", body);
+    return parseExtraction(raw, url);
+  }
+};
+
+// src/modules/nexus.ts
+var NexusNamespace = class {
+  constructor(_t) {
+    this._t = _t;
+  }
+  async analyze(url, opts = {}) {
+    const body = { url };
+    if (opts.html) body["html"] = opts.html;
+    if (opts.constraints) body["constraints"] = opts.constraints;
+    const raw = await this._t.post("nexus/analyze", body);
+    const result = {
+      perceptionId: raw["perception_id"] ?? "",
+      strategy: raw["strategy"] ?? {},
+      pageType: raw["page_type"] ?? "unknown",
+      complexityLevel: raw["complexity_level"] ?? "unknown",
+      artifactId: raw["artifact_id"] ?? null,
+      durationMs: Number(raw["duration_ms"] ?? 0),
+      error: raw["error"] ?? null
+    };
+    return { ...result, get ok() {
+      return result.error === null;
+    } };
+  }
+  async synthesize(perceptionId, opts = {}) {
+    const body = { perception_id: perceptionId };
+    if (opts.strategy) body["strategy"] = opts.strategy;
+    if (opts.timeout) body["timeout"] = opts.timeout;
+    const raw = await this._t.post("nexus/synthesize", body);
+    const result = {
+      strategyId: raw["strategy_id"] ?? "",
+      strategyName: raw["strategy_name"] ?? "",
+      generatedCode: raw["generated_code"] ?? "",
+      artifactId: raw["artifact_id"] ?? null,
+      synthesisTimeMs: Number(raw["synthesis_time_ms"] ?? 0),
+      error: raw["error"] ?? null
+    };
+    return { ...result, get ok() {
+      return result.error === null;
+    } };
+  }
+  async verify(strategyId) {
+    const raw = await this._t.post("nexus/verify", { strategy_id: strategyId });
+    const result = {
+      verificationResultId: raw["verification_result_id"] ?? "",
+      isSafe: Boolean(raw["is_safe"]),
+      riskScore: Number(raw["risk_score"] ?? 0),
+      safetyScore: Number(raw["safety_score"] ?? 0),
+      violations: raw["violations"] ?? [],
+      durationMs: Number(raw["duration_ms"] ?? 0),
+      error: raw["error"] ?? null
+    };
+    return { ...result, get ok() {
+      return result.isSafe && result.error === null;
+    } };
+  }
+  async execute(strategyId, url) {
+    const raw = await this._t.post("nexus/execute", { strategy_id: strategyId, url });
+    const result = {
+      executionResultId: raw["execution_result_id"] ?? "",
+      success: Boolean(raw["success"]),
+      records: raw["data"] ?? [],
+      artifactId: raw["artifact_id"] ?? null,
+      durationMs: Number(raw["duration_ms"] ?? 0),
+      error: raw["error"] ?? null
+    };
+    return { ...result, get ok() {
+      return result.success && result.error === null;
+    } };
+  }
+  async knowledge(executionResultId, opts = {}) {
+    const raw = await this._t.post("nexus/knowledge", {
+      execution_result_id: executionResultId,
+      limit: opts.limit ?? 100,
+      offset: opts.offset ?? 0
+    });
+    const result = {
+      learnedConcepts: raw["learned_concepts"] ?? [],
+      learnedPatterns: raw["learned_patterns"] ?? [],
+      durationMs: Number(raw["duration_ms"] ?? 0),
+      error: raw["error"] ?? null,
+      hasMore: Boolean(raw["has_more"]),
+      total: Number(raw["total"] ?? 0)
+    };
+    return { ...result, get ok() {
+      return result.error === null;
+    } };
+  }
+};
+
+// src/modules/parlyr.ts
+var ParlyrNamespace = class {
+  constructor(_t) {
+    this._t = _t;
+  }
+  async parse(message, opts = {}) {
+    const body = { message };
+    if (opts.sessionId) body["session_id"] = opts.sessionId;
+    const raw = await this._t.post("parlyr/parse", body);
+    const result = {
+      intent: raw["intent"] ?? "unknown",
+      confidence: Number(raw["confidence"] ?? 0),
+      tier: Number(raw["tier"] ?? 0),
+      source: raw["source"] ?? "",
+      entities: raw["entities"] ?? {},
+      requiresAction: Boolean(raw["requires_action"]),
+      clarificationNeeded: raw["clarification_needed"] ?? null,
+      reasoning: raw["reasoning"] ?? null,
+      detectedUrl: raw["detected_url"] ?? null
+    };
+    return { ...result, get ok() {
+      return !result.requiresAction;
+    } };
+  }
+  /**
+   * Send one chat turn and collect all SSE events into a ChatTurn.
+   * Blocks until the `done` event is received.
+   */
+  async chat(sessionId, message) {
+    let intentData = {};
+    let responseText = "";
+    for await (const { event, data } of this._t.streamWithEvents("parlyr/chat", {
+      session_id: sessionId,
+      message
+    })) {
+      if (event === "intent") intentData = data;
+      else if (event === "response") responseText = data["content"] ?? "";
+    }
+    return {
+      sessionId,
+      intent: intentData["intent"] ?? "unknown",
+      confidence: Number(intentData["confidence"] ?? 0),
+      tier: Number(intentData["tier"] ?? 0),
+      response: responseText,
+      entities: intentData["entities"] ?? {},
+      requiresAction: Boolean(intentData["requires_action"]),
+      clarificationNeeded: intentData["clarification_needed"] ?? null
+    };
+  }
+  /**
+   * Async iterable SSE stream for one chat turn.
+   *
+   * @example
+   * ```typescript
+   * for await (const event of client.parlyr.chatStream('sess-1', 'Scrape linkedin.com')) {
+   *   console.log(event.event, event.data);
+   * }
+   * ```
+   */
+  async *chatStream(sessionId, message) {
+    for await (const { event, data } of this._t.streamWithEvents("parlyr/chat", {
+      session_id: sessionId,
+      message
+    })) {
+      yield { event, data };
+    }
+  }
+  async deleteSession(sessionId) {
+    await this._t.delete(`parlyr/chat/${sessionId}`);
+  }
+};
+
+// src/modules/skanyr.ts
+function parseEndpoint(e) {
+  return {
+    url: String(e["url"] ?? ""),
+    method: String(e["method"] ?? "GET"),
+    apiType: String(e["api_type"] ?? "rest"),
+    confidence: Number(e["confidence"] ?? 0),
+    parameters: e["parameters"] ?? {}
+  };
+}
+function parseDiscover(raw, url) {
+  const endpoints = (raw["endpoints"] ?? []).map(parseEndpoint);
+  const result = {
+    success: Boolean(raw["success"]),
+    discoveryId: raw["discovery_id"] ?? "",
+    url: raw["url"] ?? url,
+    totalEndpoints: Number(raw["total_endpoints"] ?? 0),
+    endpoints,
+    artifactId: raw["artifact_id"] ?? null,
+    error: raw["error"] ?? null,
+    hasMore: Boolean(raw["has_more"]),
+    total: Number(raw["total"] ?? 0)
+  };
+  return { ...result, get ok() {
+    return result.success && result.error === null;
+  } };
+}
+var SkanyrNamespace = class {
+  constructor(_t) {
+    this._t = _t;
+  }
+  async discover(url, opts = {}) {
+    const body = {
+      url,
+      max_requests: opts.maxRequests ?? 200,
+      limit: opts.limit ?? 100,
+      offset: opts.offset ?? 0
+    };
+    if (opts.siteHierarchyArtifactId) body["site_hierarchy_artifact_id"] = opts.siteHierarchyArtifactId;
+    if (opts.sessionArtifactId) body["session_artifact_id"] = opts.sessionArtifactId;
+    const raw = await this._t.post("skanyr/discover", body);
+    return parseDiscover(raw, url);
+  }
+  async discoverAll(url, opts = {}) {
+    const all = [];
+    let offset = 0;
+    while (true) {
+      const result = await this.discover(url, { ...opts, limit: 100, offset });
+      all.push(...result.endpoints);
+      if (!result.hasMore) break;
+      offset += result.endpoints.length;
+    }
+    return all;
+  }
+  async *discoverStream(url, opts = {}) {
+    const body = { url, max_requests: opts.maxRequests ?? 200 };
+    if (opts.siteHierarchyArtifactId) body["site_hierarchy_artifact_id"] = opts.siteHierarchyArtifactId;
+    for await (const data of this._t.stream("skanyr/discover/stream", body)) {
+      yield {
+        type: String(data["type"] ?? ""),
+        endpointUrl: data["endpoint_url"] ?? null,
+        apiType: data["api_type"] ?? null,
+        metadata: data["metadata"] ?? {}
+      };
+    }
+  }
+  async getApiMap(artifactId) {
+    return this._t.get(`skanyr/api-map/${artifactId}`);
+  }
+  async getJob(jobId) {
+    return this._t.get(`skanyr/jobs/${jobId}`);
+  }
+};
+
+// src/modules/webgrph.ts
+function parsePageNode(n) {
+  return {
+    url: String(n["url"] ?? ""),
+    depth: Number(n["depth"] ?? 0),
+    title: n["title"] ?? null,
+    statusCode: n["status_code"] != null ? Number(n["status_code"]) : null,
+    children: n["children"] ?? []
+  };
+}
+function parseCrawl(raw, url) {
+  const pages = (raw["pages"] ?? []).map(parsePageNode);
+  const result = {
+    success: Boolean(raw["success"]),
+    crawlId: raw["crawl_id"] ?? "",
+    url: raw["url"] ?? url,
+    totalPages: Number(raw["total_pages"] ?? 0),
+    maxDepthReached: Number(raw["max_depth_reached"] ?? 0),
+    pages,
+    artifactId: raw["artifact_id"] ?? null,
+    error: raw["error"] ?? null,
+    hasMore: Boolean(raw["has_more"]),
+    total: Number(raw["total"] ?? 0)
+  };
+  return { ...result, get ok() {
+    return result.success && result.error === null;
+  } };
+}
+var WebgrphNamespace = class {
+  constructor(_t) {
+    this._t = _t;
+  }
+  async crawl(url, opts = {}) {
+    const body = {
+      url,
+      max_depth: opts.maxDepth ?? 3,
+      max_pages: opts.maxPages ?? 100,
+      include_external_links: opts.includeExternalLinks ?? false,
+      limit: opts.limit ?? 100,
+      offset: opts.offset ?? 0
+    };
+    if (opts.sessionArtifactId) body["session_artifact_id"] = opts.sessionArtifactId;
+    const raw = await this._t.post("webgrph/crawl", body);
+    return parseCrawl(raw, url);
+  }
+  async crawlAll(url, opts = {}) {
+    const all = [];
+    let offset = 0;
+    while (true) {
+      const result = await this.crawl(url, { ...opts, limit: 100, offset });
+      all.push(...result.pages);
+      if (!result.hasMore) break;
+      offset += result.pages.length;
+    }
+    return all;
+  }
+  async *crawlStream(url, opts = {}) {
+    const body = {
+      url,
+      max_depth: opts.maxDepth ?? 3,
+      max_pages: opts.maxPages ?? 100
+    };
+    for await (const data of this._t.stream("webgrph/crawl/stream", body)) {
+      yield {
+        type: String(data["type"] ?? ""),
+        url: data["url"] ?? null,
+        depth: data["depth"] != null ? Number(data["depth"]) : null,
+        pagesFound: data["pages_found"] != null ? Number(data["pages_found"]) : null,
+        metadata: data["metadata"] ?? {}
+      };
+    }
+  }
+  async getHierarchy(artifactId) {
+    return this._t.get(`webgrph/hierarchy/${artifactId}`);
+  }
+  async getJob(jobId) {
+    return this._t.get(`webgrph/jobs/${jobId}`);
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.kloakd.dev";
+var DEFAULT_TIMEOUT = 60;
+var DEFAULT_MAX_RETRIES = 3;
+var Kloakd = class {
+  constructor(opts) {
+    if (!opts.apiKey?.trim()) throw new Error("Kloakd: apiKey is required");
+    if (!opts.organizationId?.trim()) throw new Error("Kloakd: organizationId is required");
+    this._transport = new HttpTransport({
+      apiKey: opts.apiKey,
+      organizationId: opts.organizationId,
+      baseUrl: opts.baseUrl ?? DEFAULT_BASE_URL,
+      timeout: opts.timeout ?? DEFAULT_TIMEOUT,
+      maxRetries: opts.maxRetries ?? DEFAULT_MAX_RETRIES,
+      ...opts.fetchImpl !== void 0 && { fetchImpl: opts.fetchImpl }
+    });
+    this.evadr = new EvadrNamespace(this._transport);
+    this.webgrph = new WebgrphNamespace(this._transport);
+    this.skanyr = new SkanyrNamespace(this._transport);
+    this.nexus = new NexusNamespace(this._transport);
+    this.parlyr = new ParlyrNamespace(this._transport);
+    this.fetchyr = new FetchyrNamespace(this._transport);
+    this.kolektr = new KolektrNamespace(this._transport);
+  }
+  toString() {
+    return `Kloakd(organizationId=${this._transport._organizationId}, baseUrl=${this._transport._baseUrl})`;
+  }
+};
+export {
+  ApiError,
+  AuthenticationError,
+  Kloakd,
+  KloakdError,
+  NotEntitledError,
+  RateLimitError,
+  UpstreamError
+};