@dashai/sdk 0.7.0

package/dist/index.cjs

@@ -0,0 +1,721 @@
+'use strict';
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/data/deps.ts
+var MODULE_SLUG_REGEX = /^[a-z][a-z0-9-]*[a-z0-9]$/;
+var TABLE_SLUG_REGEX = /^[a-z][a-z0-9_]*[a-z0-9]$/;
+function assertValidProviderSlug(slug) {
+  if (typeof slug !== "string" || !MODULE_SLUG_REGEX.test(slug)) {
+    throw new Error(
+      `@dashai/sdk: invalid provider slug "${slug}". Provider slugs are the dependency module's slug (kebab-case, e.g. "crm-app"); must match /^[a-z][a-z0-9-]*[a-z0-9]$/.`
+    );
+  }
+}
+function assertValidTableSlug(slug) {
+  if (typeof slug !== "string" || !TABLE_SLUG_REGEX.test(slug)) {
+    throw new Error(
+      `@dashai/sdk: invalid table slug "${slug}". Table slugs must match /^[a-z][a-z0-9_]*[a-z0-9]$/ (snake_case).`
+    );
+  }
+}
+function makeDeps(transport, providerSlug) {
+  assertValidProviderSlug(providerSlug);
+  return {
+    db(tableSlug) {
+      assertValidTableSlug(tableSlug);
+      return makeBorrowedTableClient(transport, providerSlug, tableSlug);
+    }
+  };
+}
+function makeBorrowedTableClient(transport, providerSlug, tableSlug) {
+  const root = `/deps/${providerSlug}/db/${tableSlug}`;
+  return {
+    async list(opts) {
+      const body = opts ?? {};
+      const result = await transport.request("POST", `${root}/list`, body);
+      if (Array.isArray(result)) {
+        return {
+          rows: result,
+          total: result.length,
+          limit: body.limit ?? result.length,
+          offset: body.offset ?? 0
+        };
+      }
+      return result;
+    },
+    async get(id) {
+      return transport.request("GET", `${root}/${id}`);
+    }
+  };
+}
+
+// src/data/errors.ts
+var DashwiseErrorCode = {
+  // Auth / authz
+  UNAUTHENTICATED: "UNAUTHENTICATED",
+  FORBIDDEN: "FORBIDDEN",
+  TOKEN_EXPIRED: "TOKEN_EXPIRED",
+  INSTALLATION_NOT_FOUND: "INSTALLATION_NOT_FOUND",
+  INSTALLATION_MODE_UNSUPPORTED: "INSTALLATION_MODE_UNSUPPORTED",
+  // Contract enforcement
+  CONTRACT_VIOLATION: "CONTRACT_VIOLATION",
+  FIELD_NOT_READABLE: "FIELD_NOT_READABLE",
+  FILTER_OP_UNKNOWN: "FILTER_OP_UNKNOWN",
+  OPERATION_NOT_ALLOWED: "OPERATION_NOT_ALLOWED",
+  // Cross-module dependencies (Phase 1 of the SDK query plane —
+  // see dashwise-devops-docs/plans/modules-sdk-query-v1.md).
+  // Surfaced when reading borrowed tables via `client.deps(slug)`.
+  DEPENDENCY_NOT_DECLARED: "DEPENDENCY_NOT_DECLARED",
+  TABLE_NOT_IN_CONTRACT: "TABLE_NOT_IN_CONTRACT",
+  PROVIDER_TABLE_MISSING: "PROVIDER_TABLE_MISSING",
+  OPERATION_NOT_ALLOWED_BY_PROVIDER: "OPERATION_NOT_ALLOWED_BY_PROVIDER",
+  // Query-plane joins (Phase 3 — see
+  // dashwise-devops-docs/plans/modules-sdk-query-v1-p3-execution.md).
+  // Surfaced when `.join('<slug>')` / `.leftJoin('<slug>')` can't
+  // resolve the target. Pre-declared in slice 3.1 so slice 3.2's
+  // backend translator can emit them through fromBackendEnvelope
+  // without an SDK roundtrip.
+  LINK_FIELD_NOT_FOUND: "LINK_FIELD_NOT_FOUND",
+  NOT_A_LINK_FIELD: "NOT_A_LINK_FIELD",
+  JOIN_NOT_LINKED: "JOIN_NOT_LINKED",
+  // Cross-module actions (Phase 7 slice 7.3a — see
+  // dashwise-devops-docs/plans/modules-sdk-query-v1-p7-cross-module-writes.md).
+  // Surfaced when `qb.deps.<dep>.actions.<name>(input)` (generated
+  // factory) dispatches against the new backend endpoint
+  // `POST :installationId/deps/:providerSlug/actions/:actionName`.
+  // Slice 7.2b ships the backend emitter; slice 7.3a (this slice)
+  // reserves the codes + maps them to DepActionError in the SDK.
+  ACTION_NOT_EXPOSED: "ACTION_NOT_EXPOSED",
+  ACTION_NOT_DECLARED: "ACTION_NOT_DECLARED",
+  ACTION_INPUT_INVALID: "ACTION_INPUT_INVALID",
+  ACTION_OUTPUT_INVALID: "ACTION_OUTPUT_INVALID",
+  ACTION_RATE_LIMITED: "ACTION_RATE_LIMITED",
+  ACTION_EXECUTION_FAILED: "ACTION_EXECUTION_FAILED",
+  // Data plane
+  ROW_NOT_FOUND: "ROW_NOT_FOUND",
+  TABLE_NOT_FOUND: "TABLE_NOT_FOUND",
+  VALIDATION_FAILED: "VALIDATION_FAILED",
+  ROW_LIMIT_EXCEEDED: "ROW_LIMIT_EXCEEDED",
+  STORAGE_LIMIT_EXCEEDED: "STORAGE_LIMIT_EXCEEDED",
+  // Outbound / runtime
+  OUTBOUND_NOT_ALLOWED: "OUTBOUND_NOT_ALLOWED",
+  OUTBOUND_CONCURRENCY_LIMITED: "OUTBOUND_CONCURRENCY_LIMITED",
+  // Transport
+  NETWORK_ERROR: "NETWORK_ERROR",
+  TIMEOUT: "TIMEOUT",
+  // Server
+  INTERNAL_ERROR: "INTERNAL_ERROR"
+};
+var DashwiseError = class extends Error {
+  code;
+  status;
+  retriable;
+  context;
+  /**
+   * Backend-issued trace anchor (Phase 6 slice 6.2, 2026-05-19).
+   * Mirrors the `x-request-id` response header. Populated whenever
+   * the backend's `RuntimeQueryController` (or any future endpoint
+   * that echoes the header) is the origin of this error. `null` when
+   * the failure is client-side (NetworkError / TimeoutError — the
+   * request never reached the server, so there's no server-issued
+   * ID to surface).
+   *
+   * Use this as a debugging trace anchor when filing a bug against a
+   * specific failed query — the matching row in `module_query_log`
+   * carries the full backend context (ast_hash, error_code,
+   * duration_ms, etc.).
+   */
+  requestId;
+  constructor(code, message, options = {}) {
+    super(message);
+    this.name = this.constructor.name;
+    this.code = code;
+    this.status = options.status ?? 0;
+    this.retriable = options.retriable ?? false;
+    this.context = options.context;
+    this.requestId = options.requestId ?? null;
+    if (options.cause !== void 0) {
+      this.cause = options.cause;
+    }
+  }
+};
+var NetworkError = class extends DashwiseError {
+  constructor(message, cause) {
+    super(DashwiseErrorCode.NETWORK_ERROR, message, { retriable: true, cause });
+  }
+};
+var TimeoutError = class extends DashwiseError {
+  constructor(message, timeoutMs) {
+    super(DashwiseErrorCode.TIMEOUT, message, {
+      retriable: true,
+      context: { timeout_ms: timeoutMs }
+    });
+  }
+};
+var UnauthenticatedError = class extends DashwiseError {
+  constructor(message = "Authentication required", requestId = null) {
+    super(DashwiseErrorCode.UNAUTHENTICATED, message, { status: 401, requestId });
+  }
+};
+var ForbiddenError = class extends DashwiseError {
+  constructor(message, context, requestId = null) {
+    super(DashwiseErrorCode.FORBIDDEN, message, { status: 403, context, requestId });
+  }
+};
+var RowNotFoundError = class extends DashwiseError {
+  constructor(message, context, requestId = null) {
+    super(DashwiseErrorCode.ROW_NOT_FOUND, message, { status: 404, context, requestId });
+  }
+};
+var ContractViolationError = class extends DashwiseError {
+  constructor(message, context, requestId = null) {
+    super(DashwiseErrorCode.CONTRACT_VIOLATION, message, {
+      status: 403,
+      context,
+      requestId
+    });
+  }
+};
+var ValidationError = class extends DashwiseError {
+  constructor(message, context, requestId = null) {
+    super(DashwiseErrorCode.VALIDATION_FAILED, message, {
+      status: 400,
+      context,
+      requestId
+    });
+  }
+};
+var DependencyContractError = class extends DashwiseError {
+  constructor(code, message, context, requestId = null) {
+    super(code, message, { status: 404, context, requestId });
+  }
+};
+var ProviderTableMissingError = class extends DashwiseError {
+  constructor(message, context, requestId = null) {
+    super(DashwiseErrorCode.PROVIDER_TABLE_MISSING, message, {
+      status: 404,
+      context,
+      requestId
+    });
+  }
+};
+var OperationNotAllowedByProviderError = class extends DashwiseError {
+  constructor(message, context, requestId = null) {
+    super(DashwiseErrorCode.OPERATION_NOT_ALLOWED_BY_PROVIDER, message, {
+      status: 403,
+      context,
+      requestId
+    });
+  }
+};
+var JoinError = class extends DashwiseError {
+  constructor(code, message, context, requestId = null) {
+    super(code, message, { status: 400, context, requestId });
+  }
+};
+var DepActionError = class extends DashwiseError {
+  constructor(code, message, status, context, requestId = null) {
+    super(code, message, {
+      status,
+      retriable: code === DashwiseErrorCode.ACTION_RATE_LIMITED,
+      context,
+      requestId
+    });
+  }
+};
+function fromBackendEnvelope(status, envelope, requestId = null) {
+  const code = envelope?.code ?? codeFromStatus(status);
+  const message = envelope?.message ?? `HTTP ${status}`;
+  const context = envelope?.context;
+  switch (code) {
+    case DashwiseErrorCode.UNAUTHENTICATED:
+    case DashwiseErrorCode.TOKEN_EXPIRED:
+      return new UnauthenticatedError(message, requestId);
+    case DashwiseErrorCode.FORBIDDEN:
+      return new ForbiddenError(message, context, requestId);
+    case DashwiseErrorCode.ROW_NOT_FOUND:
+      return new RowNotFoundError(message, context, requestId);
+    case DashwiseErrorCode.CONTRACT_VIOLATION:
+    case DashwiseErrorCode.FIELD_NOT_READABLE:
+    case DashwiseErrorCode.FILTER_OP_UNKNOWN:
+    case DashwiseErrorCode.OPERATION_NOT_ALLOWED:
+      return new ContractViolationError(message, context, requestId);
+    case DashwiseErrorCode.VALIDATION_FAILED:
+      return new ValidationError(message, context, requestId);
+    case DashwiseErrorCode.DEPENDENCY_NOT_DECLARED:
+    case DashwiseErrorCode.TABLE_NOT_IN_CONTRACT:
+      return new DependencyContractError(code, message, context, requestId);
+    case DashwiseErrorCode.PROVIDER_TABLE_MISSING:
+      return new ProviderTableMissingError(message, context, requestId);
+    case DashwiseErrorCode.OPERATION_NOT_ALLOWED_BY_PROVIDER:
+      return new OperationNotAllowedByProviderError(message, context, requestId);
+    case DashwiseErrorCode.LINK_FIELD_NOT_FOUND:
+    case DashwiseErrorCode.NOT_A_LINK_FIELD:
+    case DashwiseErrorCode.JOIN_NOT_LINKED:
+      return new JoinError(code, message, context, requestId);
+    case DashwiseErrorCode.ACTION_NOT_EXPOSED:
+    case DashwiseErrorCode.ACTION_NOT_DECLARED:
+      return new DepActionError(code, message, 403, context, requestId);
+    case DashwiseErrorCode.ACTION_INPUT_INVALID:
+      return new DepActionError(code, message, 400, context, requestId);
+    case DashwiseErrorCode.ACTION_OUTPUT_INVALID:
+      return new DepActionError(code, message, 500, context, requestId);
+    case DashwiseErrorCode.ACTION_RATE_LIMITED:
+      return new DepActionError(code, message, 429, context, requestId);
+    case DashwiseErrorCode.ACTION_EXECUTION_FAILED:
+      return new DepActionError(code, message, 200, context, requestId);
+    default:
+      return new DashwiseError(code, message, {
+        status,
+        retriable: envelope?.retriable ?? false,
+        context,
+        requestId
+      });
+  }
+}
+function codeFromStatus(status) {
+  if (status === 401) return DashwiseErrorCode.UNAUTHENTICATED;
+  if (status === 403) return DashwiseErrorCode.FORBIDDEN;
+  if (status === 404) return DashwiseErrorCode.ROW_NOT_FOUND;
+  if (status >= 500) return DashwiseErrorCode.INTERNAL_ERROR;
+  return "HTTP_ERROR";
+}
+
+// src/data/http.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_SLOW_QUERY_THRESHOLD_MS = 500;
+var TRAILING_SLASH = /\/+$/;
+var LEADING_SLASH = /^\/+/;
+function buildBaseUrl(baseUrl, installationId) {
+  if (!baseUrl) {
+    throw new Error("@dashai/sdk: `baseUrl` is required");
+  }
+  const trimmed = baseUrl.replace(TRAILING_SLASH, "");
+  return `${trimmed}/api/modules/${installationId}`;
+}
+function resolveFetch(custom) {
+  if (custom) return custom;
+  if (typeof globalThis.fetch !== "function") {
+    throw new Error(
+      "@dashai/sdk: no `fetch` available. On Node < 18, pass an explicit `fetch` in `createClient({...})`."
+    );
+  }
+  return globalThis.fetch.bind(globalThis);
+}
+async function readBody(res) {
+  if (res.status === 204) return void 0;
+  const contentType = res.headers.get("content-type") ?? "";
+  if (!contentType.includes("application/json")) {
+    try {
+      return await res.text();
+    } catch {
+      return null;
+    }
+  }
+  try {
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+function createHttp(config) {
+  const base = buildBaseUrl(config.baseUrl, config.installationId);
+  const doFetch = resolveFetch(config.fetch);
+  const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const staticHeaders = {
+    Accept: "application/json",
+    ...config.headers ?? {}
+  };
+  const onSlowQuery = config.onSlowQuery;
+  const slowQueryThresholdMs = config.slowQueryThresholdMs ?? DEFAULT_SLOW_QUERY_THRESHOLD_MS;
+  function maybeFireSlowQuery(info) {
+    if (!onSlowQuery) return;
+    if (info.durationMs <= slowQueryThresholdMs) return;
+    try {
+      onSlowQuery(info);
+    } catch {
+    }
+  }
+  async function request(method, path, body) {
+    const normalizedPath = `/${path.replace(LEADING_SLASH, "")}`;
+    const url = normalizedPath.startsWith("/api/") ? `${config.baseUrl.replace(/\/+$/, "")}${normalizedPath}` : `${base}${normalizedPath}`;
+    const token = config.getToken ? await config.getToken() : null;
+    const headers = { ...staticHeaders };
+    if (body !== void 0) {
+      headers["Content-Type"] = "application/json";
+    }
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const start = Date.now();
+    let res;
+    try {
+      res = await doFetch(url, {
+        method,
+        headers,
+        body: body === void 0 ? void 0 : JSON.stringify(body),
+        signal: controller.signal
+      });
+    } catch (err) {
+      clearTimeout(timer);
+      const durationMs2 = Date.now() - start;
+      if (isAbortError(err)) {
+        maybeFireSlowQuery({
+          method,
+          path: normalizedPath,
+          durationMs: durationMs2,
+          status: 0,
+          success: false,
+          requestId: null
+        });
+        throw new TimeoutError(`Request to ${method} ${normalizedPath} timed out`, timeoutMs);
+      }
+      maybeFireSlowQuery({
+        method,
+        path: normalizedPath,
+        durationMs: durationMs2,
+        status: 0,
+        success: false,
+        requestId: null
+      });
+      throw new NetworkError(
+        `Network failure on ${method} ${normalizedPath}: ${describeError(err)}`,
+        err
+      );
+    }
+    clearTimeout(timer);
+    const parsed = await readBody(res);
+    const durationMs = Date.now() - start;
+    const requestId = res.headers.get("x-request-id");
+    if (!res.ok) {
+      maybeFireSlowQuery({
+        method,
+        path: normalizedPath,
+        durationMs,
+        status: res.status,
+        success: false,
+        requestId
+      });
+      const envelope = isEnvelope(parsed) ? parsed : null;
+      throw fromBackendEnvelope(res.status, envelope, requestId);
+    }
+    maybeFireSlowQuery({
+      method,
+      path: normalizedPath,
+      durationMs,
+      status: res.status,
+      success: true,
+      requestId
+    });
+    return parsed;
+  }
+  async function streamRaw(method, path, body, signal) {
+    const normalizedPath = `/${path.replace(LEADING_SLASH, "")}`;
+    const url = `${base}${normalizedPath}`;
+    const token = config.getToken ? await config.getToken() : null;
+    const headers = { ...staticHeaders };
+    if (body !== void 0) {
+      headers["Content-Type"] = "application/json";
+    }
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+    const timeoutController = new AbortController();
+    const timer = setTimeout(() => timeoutController.abort(), timeoutMs);
+    const combinedController = new AbortController();
+    if (signal) {
+      if (signal.aborted) combinedController.abort();
+      else signal.addEventListener("abort", () => combinedController.abort(), { once: true });
+    }
+    timeoutController.signal.addEventListener(
+      "abort",
+      () => combinedController.abort(),
+      { once: true }
+    );
+    const start = Date.now();
+    let res;
+    try {
+      res = await doFetch(url, {
+        method,
+        headers,
+        body: body === void 0 ? void 0 : JSON.stringify(body),
+        signal: combinedController.signal
+      });
+    } catch (err) {
+      clearTimeout(timer);
+      const durationMs = Date.now() - start;
+      if (isAbortError(err)) {
+        maybeFireSlowQuery({
+          method,
+          path: normalizedPath,
+          durationMs,
+          status: 0,
+          success: false,
+          requestId: null
+        });
+        if (signal?.aborted) {
+          const e = new Error("Aborted by caller");
+          e.name = "AbortError";
+          throw e;
+        }
+        throw new TimeoutError(
+          `Streaming request to ${method} ${normalizedPath} timed out before headers arrived`,
+          timeoutMs
+        );
+      }
+      maybeFireSlowQuery({
+        method,
+        path: normalizedPath,
+        durationMs,
+        status: 0,
+        success: false,
+        requestId: null
+      });
+      throw new NetworkError(
+        `Network failure on ${method} ${normalizedPath}: ${describeError(err)}`,
+        err
+      );
+    }
+    clearTimeout(timer);
+    const requestId = res.headers.get("x-request-id");
+    maybeFireSlowQuery({
+      method,
+      path: normalizedPath,
+      durationMs: Date.now() - start,
+      status: res.status,
+      success: res.ok,
+      requestId
+    });
+    return res;
+  }
+  return { request, streamRaw };
+}
+function isAbortError(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  return e.name === "AbortError" || e.code === "ABORT_ERR";
+}
+function describeError(err) {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  try {
+    return JSON.stringify(err);
+  } catch {
+    return "<unknown error>";
+  }
+}
+function isEnvelope(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return typeof v.code === "string" || typeof v.message === "string";
+}
+
+// src/data/client.ts
+function createClient(config) {
+  const transport = createHttp(config);
+  return {
+    db(tableSlug) {
+      assertValidTableSlug2(tableSlug);
+      return makeTableClient(transport, tableSlug);
+    },
+    deps(providerSlug) {
+      return makeDeps(transport, providerSlug);
+    },
+    request(method, path, body) {
+      return transport.request(method, path, body);
+    },
+    streamRaw(method, path, body, signal) {
+      return transport.streamRaw(method, path, body, signal);
+    },
+    async _callAction(providerSlug, actionName, input, opts) {
+      assertValidModuleSlug(providerSlug);
+      assertValidActionName(actionName);
+      const path = `/api/modules/runtime/installations/${config.installationId}/deps/${encodeURIComponent(
+        providerSlug
+      )}/actions/${encodeURIComponent(actionName)}`;
+      const body = { input };
+      if (opts?.idempotencyKey !== void 0) {
+        body.idempotency_key = opts.idempotencyKey;
+      }
+      if (opts?.timeoutMs !== void 0) {
+        body.timeout_ms = opts.timeoutMs;
+      }
+      const envelope = await transport.request(
+        "POST",
+        path,
+        body
+      );
+      if (envelope.ok === false) {
+        const requestId = envelope.cross_module?.request_id ?? null;
+        throw fromBackendEnvelope(
+          200,
+          {
+            code: envelope.error.code,
+            message: envelope.error.message,
+            context: envelope.error.trace ? { trace: envelope.error.trace } : void 0
+          },
+          requestId
+        );
+      }
+      return envelope.result;
+    }
+  };
+}
+var ACTION_NAME_REGEX = /^[a-zA-Z_$][a-zA-Z0-9_$]{0,63}$/;
+var MODULE_SLUG_REGEX2 = /^[a-z][a-z0-9-]*[a-z0-9]$/;
+function assertValidModuleSlug(slug) {
+  if (!MODULE_SLUG_REGEX2.test(slug)) {
+    throw new Error(
+      `Invalid provider module slug "${slug}" \u2014 must be kebab-case (^[a-z][a-z0-9-]*[a-z0-9]$).`
+    );
+  }
+}
+function assertValidActionName(name) {
+  if (!ACTION_NAME_REGEX.test(name)) {
+    throw new Error(
+      `Invalid action name "${name}" \u2014 must be a JS identifier (letters/digits/underscore/$, starts non-digit, \u226464 chars).`
+    );
+  }
+}
+var TABLE_SLUG_REGEX2 = /^[a-z][a-z0-9_]*$/;
+function assertValidTableSlug2(slug) {
+  if (typeof slug !== "string" || !TABLE_SLUG_REGEX2.test(slug)) {
+    throw new Error(
+      `@dashai/sdk: invalid table slug "${slug}". Slugs must match /^[a-z][a-z0-9_]*$/.`
+    );
+  }
+}
+function makeTableClient(transport, tableSlug) {
+  const root = `/db/${tableSlug}`;
+  return {
+    async list(opts) {
+      const ast = {
+        v: 1,
+        from: { kind: "owned", slug: tableSlug }
+      };
+      if (opts?.filter !== void 0) ast.where = opts.filter;
+      if (opts?.sort !== void 0 && opts.sort.length > 0) {
+        ast.orderBy = opts.sort;
+      }
+      if (typeof opts?.limit === "number") ast.limit = opts.limit;
+      if (typeof opts?.offset === "number") ast.offset = opts.offset;
+      const result = await transport.request("POST", "/query", { ast });
+      if (Array.isArray(result)) {
+        return {
+          rows: result,
+          total: result.length,
+          limit: opts?.limit ?? result.length,
+          offset: opts?.offset ?? 0
+        };
+      }
+      return result;
+    },
+    async get(id) {
+      return transport.request("GET", `${root}/${id}`);
+    },
+    async create(body) {
+      return transport.request("POST", root, body);
+    },
+    async update(id, patch) {
+      return transport.request("PATCH", `${root}/${id}`, patch);
+    },
+    async delete(id) {
+      await transport.request("DELETE", `${root}/${id}`);
+    }
+  };
+}
+
+// src/data/dev-client.ts
+function createDevClient(overrides = {}) {
+  const fileConfig = readCliConfigFile();
+  const baseUrl = overrides.baseUrl ?? readEnv("DASHWISE_API_URL") ?? fileConfig?.apiUrl ?? null;
+  if (!baseUrl) {
+    throw new Error(
+      "@dashai/sdk: createDevClient() could not resolve a baseUrl. Pass `{ baseUrl }` explicitly, set `DASHWISE_API_URL`, or run `dashwise login` to create the CLI config file."
+    );
+  }
+  const installationId = overrides.installationId ?? readEnv("DASHWISE_INSTALLATION_ID") ?? "local";
+  const snapshotToken = readEnv("DASHWISE_API_TOKEN") ?? fileConfig?.token ?? null;
+  const resolvedGetToken = overrides.getToken ?? (() => snapshotToken);
+  return createClient({
+    ...overrides,
+    baseUrl,
+    installationId,
+    getToken: resolvedGetToken
+  });
+}
+function readEnv(key) {
+  if (typeof process === "undefined" || !process.env) return void 0;
+  const v = process.env[key];
+  return typeof v === "string" && v.length > 0 ? v : void 0;
+}
+function isNodeRuntime() {
+  if (typeof process === "undefined") return false;
+  if (!process.versions || typeof process.versions.node !== "string") {
+    return false;
+  }
+  return true;
+}
+function readCliConfigFile() {
+  if (!isNodeRuntime()) return null;
+  if (readEnv("NODE_ENV") === "production") return null;
+  try {
+    const fs = __require("fs");
+    const path = __require("path");
+    const os = __require("os");
+    const dir = resolveConfigDir(path, os);
+    const file = path.join(dir, "auth.json");
+    if (!fs.existsSync(file)) return null;
+    const raw = fs.readFileSync(file, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!isPlausibleFileShape(parsed)) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function resolveConfigDir(path, os) {
+  const xdg = readEnv("XDG_CONFIG_HOME");
+  if (xdg) return path.join(xdg, "dashwise");
+  if (os.platform() === "win32") {
+    const appdata = readEnv("APPDATA");
+    if (appdata) return path.join(appdata, "dashwise");
+  }
+  return path.join(os.homedir(), ".config", "dashwise");
+}
+function isPlausibleFileShape(v) {
+  if (!v || typeof v !== "object") return false;
+  const o = v;
+  return (o.apiUrl === void 0 || typeof o.apiUrl === "string") && (o.token === void 0 || typeof o.token === "string");
+}
+
+// src/index.ts
+var VERSION = "0.7.0" ;
+
+exports.ContractViolationError = ContractViolationError;
+exports.DashwiseError = DashwiseError;
+exports.DashwiseErrorCode = DashwiseErrorCode;
+exports.DependencyContractError = DependencyContractError;
+exports.ForbiddenError = ForbiddenError;
+exports.JoinError = JoinError;
+exports.NetworkError = NetworkError;
+exports.OperationNotAllowedByProviderError = OperationNotAllowedByProviderError;
+exports.ProviderTableMissingError = ProviderTableMissingError;
+exports.RowNotFoundError = RowNotFoundError;
+exports.TimeoutError = TimeoutError;
+exports.UnauthenticatedError = UnauthenticatedError;
+exports.VERSION = VERSION;
+exports.ValidationError = ValidationError;
+exports.createClient = createClient;
+exports.createDevClient = createDevClient;
+exports.fromBackendEnvelope = fromBackendEnvelope;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map