@rustrak/client 0.12.3 → 0.14.0

package/dist/index.js

@@ -357,6 +357,28 @@ var upsertProjectMemberSchema = z.object({
   user_id: z.number().int(),
   role: projectRoleSchema
 });
+var metricDeltaSchema = z.object({
+  current: z.number().int(),
+  /**
+   * The same window immediately before this one. Null only for all-time
+   * requests, where a `0` would render as a misleading "+100%".
+   */
+  previous: z.number().int().nullable()
+});
+var projectListStatsSchema = z.object({
+  /**
+   * Distinct issues active in each bucket, oldest first. A shape, not a
+   * total: an issue firing all day appears in every bucket it touched.
+   */
+  trend: z.array(z.number().int()),
+  events: metricDeltaSchema,
+  /** Issues first seen in the window. Drives the "getting worse" signal. */
+  new_issues: metricDeltaSchema,
+  /** Unresolved issues right now, independent of the window. */
+  open_issues: z.number().int(),
+  /** The subset of `open_issues` at `fatal` level. */
+  fatal_issues: z.number().int()
+});
 var projectSchema = z.object({
   id: z.number().int(),
   name: z.string(),
@@ -367,15 +389,31 @@ var projectSchema = z.object({
   digested_event_count: z.number().int(),
   created_at: dateTimeSchema,
   updated_at: dateTimeSchema,
-  platform: z.string().nullable()
+  platform: z.string().nullable(),
+  stats: projectListStatsSchema.optional()
 });
 var createProjectSchema = z.object({
   name: z.string().min(1),
-  slug: z.string().optional()
+  /**
+   * Slugified server-side. Supplying it means the user chose it, so a taken
+   * slug is a 409. Omitting it derives one from the name and silently
+   * de-duplicates, since nobody chose that value.
+   */
+  slug: z.string().min(1).optional(),
+  /**
+   * Validated server-side against SELECTABLE_PLATFORMS. Omitting it leaves the
+   * project eligible for platform auto-detection from its first event.
+   */
+  platform: z.string().min(1).optional()
 });
 var updateProjectSchema = z.object({
   name: z.string().min(1).optional(),
-  platform: z.string().min(1).optional()
+  platform: z.string().min(1).optional(),
+  /**
+   * Slugified server-side. Unlike on create, a taken slug is a 409 rather than
+   * being silently de-duplicated.
+   */
+  slug: z.string().min(1).optional()
 });
 var releaseHealthRowSchema = z.object({
   release: z.string(),
@@ -413,6 +451,11 @@ var chunkUploadCapabilitySchema = z.object({
   accept: z.array(z.string()),
   concurrency: z.number().int().optional()
 });
+var assembleInputSchema = z.object({
+  checksum: z.string().min(1),
+  chunks: z.array(z.string().min(1)),
+  projects: z.array(z.string().min(1)).min(1)
+});
 var assembleResponseSchema = z.object({
   state: z.string(),
   missingChunks: z.array(z.string()),
@@ -437,15 +480,15 @@ var eventTimeseriesPointSchema = z.object({
   info: z.number().int()
 });
 var eventTimeseriesSchema = z.array(eventTimeseriesPointSchema);
-var metricDeltaSchema = z.object({
+var metricDeltaSchema2 = z.object({
   current: z.number().int(),
   previous: z.number().int().nullable()
 });
 var projectStatsSummarySchema = z.object({
   /** Resolved window in hours, or `null` for all time. */
   period_hours: z.number().int().nullable(),
-  events: metricDeltaSchema,
-  new_issues: metricDeltaSchema,
+  events: metricDeltaSchema2,
+  new_issues: metricDeltaSchema2,
   /** Currently unresolved issues, independent of the window. */
   open_issues: z.number().int()
 });
@@ -595,117 +638,330 @@ var registerRequestSchema = z.object({
   password: z.string().min(1)
 });
 
-// src/errors/base.ts
-var RustrakError = class extends Error {
-  /**
-   * Whether this error is safe to retry
-   */
-  retryable;
-  /**
-   * HTTP status code if applicable
-   */
-  statusCode;
-  /**
-   * Original error cause
-   */
-  cause;
-  constructor(message, options) {
-    super(message);
-    this.name = this.constructor.name;
-    this.retryable = options?.retryable ?? false;
-    this.statusCode = options?.statusCode;
-    this.cause = options?.cause;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, this.constructor);
-    }
-  }
-};
+// src/errors.ts
+var FIELD_ERROR_CODES = [
+  "required",
+  "invalid",
+  "already_exists",
+  "too_short",
+  "too_long",
+  "custom"
+];
+var SERVER_ERROR_MESSAGE = "The server failed to handle the request.";
+var NETWORK_ERROR_MESSAGE = "The request could not reach the server.";
+var TIMEOUT_ERROR_MESSAGE = "The request timed out.";
+function isRetryable(error) {
+  return error.kind === "network" || error.kind === "server_error" || error.kind === "rate_limited";
+}
 
-// src/errors/http.ts
-var NetworkError = class extends RustrakError {
-  constructor(message, cause) {
-    super(message, { retryable: true, cause });
+// src/result.ts
+function Ok(data) {
+  return { success: true, data };
+}
+function Err(error) {
+  return { success: false, error };
+}
+function unwrap(result) {
+  if (result.success) {
+    return result.data;
   }
-};
-var AuthenticationError = class extends RustrakError {
-  constructor(message = "Authentication failed") {
-    super(message, { retryable: false, statusCode: 401 });
+  throw new Error(
+    `unwrap() called on a failed Result: ${describe(result.error)}`
+  );
+}
+function unwrapOr(result, fallback) {
+  return result.success ? result.data : fallback;
+}
+function mapResult(result, fn) {
+  return result.success ? Ok(fn(result.data)) : result;
+}
+function describe(error) {
+  if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
+    return error.message;
   }
-};
-var AuthorizationError = class extends RustrakError {
-  constructor(message = "Insufficient permissions") {
-    super(message, { retryable: false, statusCode: 403 });
+  return String(error);
+}
+var RustrakTransportFailure = class extends Error {
+  rustrakError;
+  constructor(error) {
+    super(error.message);
+    this.name = "RustrakTransportFailure";
+    this.rustrakError = error;
   }
 };
-var NotFoundError = class extends RustrakError {
-  constructor(resource) {
-    super(`Resource not found: ${resource}`, {
-      retryable: false,
-      statusCode: 404
-    });
+function isTransportFailure(value) {
+  return value instanceof RustrakTransportFailure;
+}
+function readErrorMessage(error, status) {
+  const fallback = `HTTP ${status} error`;
+  const body = error.data;
+  if (body && typeof body === "object") {
+    const nested = typeof body.error === "object" ? body.error?.message : body.error;
+    return nested || body.message || fallback;
   }
-};
-var RateLimitError = class extends RustrakError {
-  /**
-   * Number of seconds to wait before retrying (from Retry-After header)
-   */
-  retryAfter;
-  constructor(message = "Rate limit exceeded", retryAfter) {
-    super(message, { retryable: true, statusCode: 429 });
-    if (retryAfter !== void 0) {
-      this.retryAfter = typeof retryAfter === "string" ? parseInt(retryAfter, 10) : retryAfter;
+  return fallback;
+}
+var KNOWN_FIELD_ERROR_CODES = new Set(FIELD_ERROR_CODES);
+function isFieldErrorCode(value) {
+  return typeof value === "string" && KNOWN_FIELD_ERROR_CODES.has(value);
+}
+var warnedFieldErrorCodes = /* @__PURE__ */ new Set();
+function warnUnknownFieldErrorCode(code, field) {
+  if (warnedFieldErrorCodes.has(code)) return;
+  warnedFieldErrorCodes.add(code);
+  console.warn(
+    `[@rustrak/client] Dropped a field error with an unrecognised code "${code}" (field "${field}"). This client build does not know that code, so the affected inputs degrade to a form-level error. The server is most likely newer than @rustrak/client; upgrade the client to match the server version.`
+  );
+}
+function readFieldErrors(error) {
+  const body = error.data;
+  const raw = body && typeof body === "object" ? body.error?.fields : void 0;
+  if (!Array.isArray(raw)) {
+    return void 0;
+  }
+  const fields = [];
+  for (const entry of raw) {
+    if (typeof entry !== "object" || entry === null) continue;
+    const { field, code, message } = entry;
+    if (typeof field !== "string") continue;
+    if (!isFieldErrorCode(code)) {
+      if (typeof code === "string") warnUnknownFieldErrorCode(code, field);
+      continue;
     }
+    fields.push(
+      code === "custom" && typeof message === "string" ? { field, code, message } : { field, code }
+    );
   }
-};
-var ServerError = class extends RustrakError {
-  constructor(message, statusCode = 500) {
-    super(message, { retryable: true, statusCode });
+  return fields.length > 0 ? fields : void 0;
+}
+function readRetryAfter(response) {
+  const header = response.headers.get("Retry-After")?.trim();
+  if (!header) {
+    return void 0;
   }
-};
-var BadRequestError = class extends RustrakError {
-  constructor(message) {
-    super(message, { retryable: false, statusCode: 400 });
+  if (/^\d+$/.test(header)) {
+    return Number.parseInt(header, 10);
   }
-};
-
-// src/errors/validation.ts
-var ValidationError = class extends RustrakError {
-  /**
-   * Zod validation errors
-   */
-  validationErrors;
-  constructor(message, validationErrors) {
-    super(message, { retryable: false });
-    this.validationErrors = validationErrors;
+  if (/^[+-]\d+$/.test(header)) {
+    return void 0;
   }
-  /**
-   * Get a formatted string of validation errors
-   */
-  getValidationDetails() {
-    if (!this.validationErrors) {
-      return this.message;
+  const date = Date.parse(header);
+  if (Number.isNaN(date)) {
+    return void 0;
+  }
+  return Math.max(0, Math.ceil((date - Date.now()) / 1e3));
+}
+function annotate(base, fields) {
+  return fields === void 0 ? base : { ...base, fields };
+}
+function transformHttpError(error) {
+  const { response } = error;
+  const status = response.status;
+  if (status >= 500) {
+    return { kind: "server_error", status, message: SERVER_ERROR_MESSAGE };
+  }
+  const message = readErrorMessage(error, status);
+  const fields = readFieldErrors(error);
+  switch (status) {
+    case 400:
+      return annotate({ kind: "validation", status, message }, fields);
+    case 401:
+      return annotate({ kind: "unauthenticated", status, message }, fields);
+    case 403:
+      return annotate({ kind: "forbidden", status, message }, fields);
+    case 404:
+      return annotate({ kind: "not_found", status, message }, fields);
+    case 409:
+      return annotate({ kind: "conflict", status, message }, fields);
+    case 410:
+      return annotate({ kind: "gone", status, message }, fields);
+    case 413:
+      return annotate({ kind: "payload_too_large", status, message }, fields);
+    case 429: {
+      const retryAfter = readRetryAfter(response);
+      return annotate(
+        retryAfter === void 0 ? { kind: "rate_limited", status, message } : { kind: "rate_limited", status, message, retryAfter },
+        fields
+      );
     }
-    const errors = this.validationErrors.issues.map((err) => `${err.path.map(String).join(".")}: ${err.message}`).join(", ");
-    return `${this.message} - ${errors}`;
+    default:
+      return annotate({ kind: "client_error", status, message }, fields);
   }
-};
+}
+function createKyInstance(config) {
+  const headers = {
+    // `Accept` is set here rather than relied on from ky. The `.json()`
+    // shortcut sets it before the request is issued, and `BaseResource` no
+    // longer uses that shortcut: it awaits the `Response` and parses the body
+    // itself, so without this every one of the 86 methods would send `*/*` and
+    // any content-negotiating hop could answer with HTML.
+    Accept: "application/json",
+    "Content-Type": "application/json",
+    ...config.headers
+  };
+  if (config.token) {
+    headers.Authorization = `Bearer ${config.token}`;
+  }
+  return ky.create({
+    prefix: config.baseUrl,
+    timeout: config.timeout ?? 3e4,
+    credentials: "include",
+    retry: {
+      limit: config.maxRetries ?? 2,
+      statusCodes: [408, 500, 502, 503, 504],
+      methods: ["get", "post", "put", "patch", "delete"]
+    },
+    headers,
+    hooks: {
+      beforeError: [
+        ({ error }) => {
+          if (error.name === "TimeoutError") {
+            throw new RustrakTransportFailure({
+              kind: "network",
+              message: TIMEOUT_ERROR_MESSAGE,
+              reason: "timeout"
+            });
+          }
+          if (isHTTPError(error)) {
+            throw new RustrakTransportFailure(transformHttpError(error));
+          }
+          throw new RustrakTransportFailure({
+            kind: "network",
+            message: NETWORK_ERROR_MESSAGE,
+            reason: "unreachable"
+          });
+        }
+      ]
+    }
+  });
+}
 
 // src/resources/base.ts
+var TRANSPORT_TYPE_ERROR = /terminated|aborted|socket|network|closed|reset|fetch failed/i;
+function isProgrammingError(error) {
+  if (!(error instanceof Error)) {
+    return true;
+  }
+  if (error instanceof ReferenceError || error instanceof RangeError) {
+    return true;
+  }
+  if (error instanceof TypeError) {
+    return error.cause === void 0 && !TRANSPORT_TYPE_ERROR.test(error.message);
+  }
+  return false;
+}
+function classifyBodyFailure(error) {
+  if (error instanceof SyntaxError) {
+    return {
+      kind: "invalid_response",
+      message: "The server returned a body that is not valid JSON."
+    };
+  }
+  if (isProgrammingError(error)) {
+    return "rethrow";
+  }
+  return {
+    kind: "network",
+    message: NETWORK_ERROR_MESSAGE,
+    reason: error instanceof Error && error.name === "TimeoutError" ? "timeout" : "unreachable"
+  };
+}
+function discardBody(response) {
+  try {
+    void response.body?.cancel().catch(() => {
+    });
+  } catch {
+  }
+}
 var BaseResource = class {
   http;
   constructor(http) {
     this.http = http;
   }
   /**
-   * Validate API response against Zod schema
-   * @throws {ValidationError} if validation fails
+   * Validate an API response against its Zod schema.
+   *
+   * Failure is `invalid_response`: "our own response schema did not match",
+   * never "the user's input was rejected". No Zod issues are attached: they
+   * embed the offending response data.
    */
   validate(data, schema) {
     const result = schema.safeParse(data);
     if (!result.success) {
-      throw new ValidationError("API response validation failed", result.error);
+      return Err({
+        kind: "invalid_response",
+        message: "The server response did not match the expected schema."
+      });
     }
-    return result.data;
+    return Ok(result.data);
+  }
+  /**
+   * Validate caller-supplied input before it reaches the network.
+   *
+   * Failure is `invalid_request` and has no `status`: nothing was sent.
+   */
+  validateInput(input, schema) {
+    const result = schema.safeParse(input);
+    if (!result.success) {
+      return Err({
+        kind: "invalid_request",
+        message: "The request input did not match the expected schema."
+      });
+    }
+    return Ok(result.data);
+  }
+  /**
+   * The boundary. Runs `send`, converts a transport failure into an `Err`, and
+   * hands the `Response` to `read`.
+   *
+   * Anything thrown that is not the internal carrier is a programming error and
+   * is rethrown.
+   */
+  async requestResponse(send, read) {
+    let response;
+    try {
+      response = await send();
+    } catch (error) {
+      if (isTransportFailure(error)) {
+        return Err(error.rustrakError);
+      }
+      throw error;
+    }
+    return read(response);
+  }
+  /**
+   * Read a JSON body, mapping a failed read onto the right `kind`.
+   *
+   * Shared with `AuthResource`, which needs the `Set-Cookie` headers off the
+   * raw `Response` and so cannot go through {@link BaseResource.request}.
+   */
+  async readJson(response) {
+    try {
+      return Ok(await response.json());
+    } catch (error) {
+      const failure = classifyBodyFailure(error);
+      if (failure === "rethrow") {
+        throw error;
+      }
+      return Err(failure);
+    }
+  }
+  /** Send a request and validate its JSON body against `schema`. */
+  async request(send, schema) {
+    return this.requestResponse(send, async (response) => {
+      const body = await this.readJson(response);
+      if (!body.success) {
+        return body;
+      }
+      return this.validate(body.data, schema);
+    });
+  }
+  /** Send a request whose response body carries no contract (204, or ignored). */
+  async requestVoid(send) {
+    return this.requestResponse(send, async (response) => {
+      discardBody(response);
+      return Ok(void 0);
+    });
   }
 };
 
@@ -735,46 +991,56 @@ var AgentsResource = class extends BaseResource {
    * Time-bucketed count of agent-run spans (`gen_ai.operation.type:agent`).
    */
   async getRuns(projectId, options) {
-    const data = await this.http.get(`api/projects/${projectId}/agents/runs`, {
-      searchParams: timeseriesSearchParams(options)
-    }).json();
-    return this.validate(data, z.array(agentTimeseriesPointSchema));
+    return this.request(
+      () => this.http.get(`api/projects/${projectId}/agents/runs`, {
+        searchParams: timeseriesSearchParams(options)
+      }),
+      z.array(agentTimeseriesPointSchema)
+    );
   }
   /**
    * Time-bucketed avg/p95 duration for `agent`/`ai_client` spans.
    */
   async getDuration(projectId, options) {
-    const data = await this.http.get(`api/projects/${projectId}/agents/duration`, {
-      searchParams: timeseriesSearchParams(options)
-    }).json();
-    return this.validate(data, z.array(agentDurationPointSchema));
+    return this.request(
+      () => this.http.get(`api/projects/${projectId}/agents/duration`, {
+        searchParams: timeseriesSearchParams(options)
+      }),
+      z.array(agentDurationPointSchema)
+    );
   }
   /**
    * Top models by LLM call count (`gen_ai.operation.type:ai_client`).
    */
   async getModelsByCalls(projectId, options) {
-    const data = await this.http.get(`api/projects/${projectId}/agents/models/calls`, {
-      searchParams: breakdownSearchParams(options)
-    }).json();
-    return this.validate(data, z.array(genAiBreakdownRowSchema));
+    return this.request(
+      () => this.http.get(`api/projects/${projectId}/agents/models/calls`, {
+        searchParams: breakdownSearchParams(options)
+      }),
+      z.array(genAiBreakdownRowSchema)
+    );
   }
   /**
    * Top models by total tokens used (`gen_ai.operation.type:ai_client`).
    */
   async getModelsByTokens(projectId, options) {
-    const data = await this.http.get(`api/projects/${projectId}/agents/models/tokens`, {
-      searchParams: breakdownSearchParams(options)
-    }).json();
-    return this.validate(data, z.array(genAiBreakdownRowSchema));
+    return this.request(
+      () => this.http.get(`api/projects/${projectId}/agents/models/tokens`, {
+        searchParams: breakdownSearchParams(options)
+      }),
+      z.array(genAiBreakdownRowSchema)
+    );
   }
   /**
    * Top tools by call count (`gen_ai.operation.type:tool`).
    */
   async getTools(projectId, options) {
-    const data = await this.http.get(`api/projects/${projectId}/agents/tools`, {
-      searchParams: breakdownSearchParams(options)
-    }).json();
-    return this.validate(data, z.array(genAiBreakdownRowSchema));
+    return this.request(
+      () => this.http.get(`api/projects/${projectId}/agents/tools`, {
+        searchParams: breakdownSearchParams(options)
+      }),
+      z.array(genAiBreakdownRowSchema)
+    );
   }
   /**
    * Paginated per-trace_id aggregate (duration, tokens, tool usage) across
@@ -788,9 +1054,10 @@ var AgentsResource = class extends BaseResource {
     if (options?.per_page) {
       searchParams.per_page = String(options.per_page);
     }
-    const data = await this.http.get(`api/projects/${projectId}/agents/traces`, { searchParams }).json();
-    return this.validate(
-      data,
+    return this.request(
+      () => this.http.get(`api/projects/${projectId}/agents/traces`, {
+        searchParams
+      }),
       offsetPaginatedResponseSchema(agentTraceSummarySchema)
     );
   }
@@ -800,52 +1067,83 @@ var AlertIntegrationsResource = class extends BaseResource {
    * List all alert integrations
    */
   async list() {
-    const data = await this.http.get("api/integrations").json();
-    return this.validate(data, z.array(alertIntegrationSchema));
+    return this.request(
+      () => this.http.get("api/integrations"),
+      z.array(alertIntegrationSchema)
+    );
   }
   /**
    * Get a single alert integration by ID
    */
   async get(id) {
-    const data = await this.http.get(`api/integrations/${id}`).json();
-    return this.validate(data, alertIntegrationSchema);
+    return this.request(
+      () => this.http.get(`api/integrations/${id}`),
+      alertIntegrationSchema
+    );
   }
   /**
    * Create a new alert integration
    */
   async create(input) {
-    const validatedInput = this.validate(input, createAlertIntegrationSchema);
-    const data = await this.http.post("api/integrations", { json: validatedInput }).json();
-    return this.validate(data, alertIntegrationSchema);
+    const validatedInput = this.validateInput(
+      input,
+      createAlertIntegrationSchema
+    );
+    if (!validatedInput.success) {
+      return validatedInput;
+    }
+    return this.request(
+      () => this.http.post("api/integrations", { json: validatedInput.data }),
+      alertIntegrationSchema
+    );
   }
   /**
    * Update an existing alert integration
    */
   async update(id, input) {
-    const validatedInput = this.validate(input, updateAlertIntegrationSchema);
-    const data = await this.http.patch(`api/integrations/${id}`, { json: validatedInput }).json();
-    return this.validate(data, alertIntegrationSchema);
+    const validatedInput = this.validateInput(
+      input,
+      updateAlertIntegrationSchema
+    );
+    if (!validatedInput.success) {
+      return validatedInput;
+    }
+    return this.request(
+      () => this.http.patch(`api/integrations/${id}`, {
+        json: validatedInput.data
+      }),
+      alertIntegrationSchema
+    );
   }
   /**
    * Delete an alert integration
    */
   async delete(id) {
-    await this.http.delete(`api/integrations/${id}`);
+    return this.requestVoid(() => this.http.delete(`api/integrations/${id}`));
   }
   /**
    * Send a test notification to verify integration configuration.
    * For Slack bot_token integrations, routingOverride must include `channel`.
    */
   async test(id, routingOverride) {
-    const body = routingOverride !== void 0 ? this.validate(
-      { routing_override: routingOverride },
-      testIntegrationBodySchema
-    ) : void 0;
-    const data = await this.http.post(
-      `api/integrations/${id}/test`,
-      body !== void 0 ? { json: body } : void 0
-    ).json();
-    return this.validate(data, testChannelResponseSchema);
+    let body;
+    if (routingOverride !== void 0) {
+      const validatedInput = this.validateInput(
+        { routing_override: routingOverride },
+        testIntegrationBodySchema
+      );
+      if (!validatedInput.success) {
+        return validatedInput;
+      }
+      body = validatedInput.data;
+    }
+    return this.request(
+      () => this.http.post(
+        `api/integrations/${id}/test`,
+        body !== void 0 ? { json: body } : void 0
+      ),
+      testChannelResponseSchema
+    );
   }
 };
 var AlertRulesResource = class extends BaseResource {
@@ -853,39 +1151,57 @@ var AlertRulesResource = class extends BaseResource {
    * List all alert rules for a project
    */
   async list(projectId) {
-    const data = await this.http.get(`api/projects/${projectId}/alert-rules`).json();
-    return this.validate(data, z.array(alertRuleSchema));
+    return this.request(
+      () => this.http.get(`api/projects/${projectId}/alert-rules`),
+      z.array(alertRuleSchema)
+    );
   }
   /**
    * Get a single alert rule by ID
    */
   async get(projectId, ruleId) {
-    const data = await this.http.get(`api/projects/${projectId}/alert-rules/${ruleId}`).json();
-    return this.validate(data, alertRuleSchema);
+    return this.request(
+      () => this.http.get(`api/projects/${projectId}/alert-rules/${ruleId}`),
+      alertRuleSchema
+    );
   }
   /**
    * Create a new alert rule for a project
    */
   async create(projectId, input) {
-    const validatedInput = this.validate(input, createAlertRuleSchema);
-    const data = await this.http.post(`api/projects/${projectId}/alert-rules`, { json: validatedInput }).json();
-    return this.validate(data, alertRuleSchema);
+    const validatedInput = this.validateInput(input, createAlertRuleSchema);
+    if (!validatedInput.success) {
+      return validatedInput;
+    }
+    return this.request(
+      () => this.http.post(`api/projects/${projectId}/alert-rules`, {
+        json: validatedInput.data
+      }),
+      alertRuleSchema
+    );
   }
   /**
    * Update an existing alert rule
    */
   async update(projectId, ruleId, input) {
-    const validatedInput = this.validate(input, updateAlertRuleSchema);
-    const data = await this.http.patch(`api/projects/${projectId}/alert-rules/${ruleId}`, {
-      json: validatedInput
-    }).json();
-    return this.validate(data, alertRuleSchema);
+    const validatedInput = this.validateInput(input, updateAlertRuleSchema);
+    if (!validatedInput.success) {
+      return validatedInput;
+    }
+    return this.request(
+      () => this.http.patch(`api/projects/${projectId}/alert-rules/${ruleId}`, {
+        json: validatedInput.data
+      }),
+      alertRuleSchema
+    );
   }
   /**
    * Delete an alert rule
    */
   async delete(projectId, ruleId) {
-    await this.http.delete(`api/projects/${projectId}/alert-rules/${ruleId}`);
+    return this.requestVoid(
+      () => this.http.delete(`api/projects/${projectId}/alert-rules/${ruleId}`)
+    );
   }
   /**
    * List alert history for a project
@@ -897,12 +1213,18 @@ var AlertRulesResource = class extends BaseResource {
     }
     const query = searchParams.toString();
     const url = query ? `api/projects/${projectId}/alert-history?${query}` : `api/projects/${projectId}/alert-history`;
-    const data = await this.http.get(url).json();
-    return this.validate(data, z.array(alertHistorySchema));
+    return this.request(() => this.http.get(url), z.array(alertHistorySchema));
   }
 };
 
 // src/resources/auth.ts
+function readSetCookie(response) {
+  if (typeof response.headers.getSetCookie === "function") {
+    return response.headers.getSetCookie();
+  }
+  const folded = response.headers.get("set-cookie");
+  return folded === null ? [] : [folded];
+}
 var AuthResource = class extends BaseResource {
   /**
    * Register a new user account
@@ -911,17 +1233,17 @@ var AuthResource = class extends BaseResource {
    * @returns LoginResult with user information and session cookies
    */
   async register(credentials) {
-    const validatedInput = this.validate(credentials, registerRequestSchema);
-    const response = await this.http.post("auth/register", {
-      json: validatedInput
-    });
-    const cookies = response.headers.getSetCookie();
-    const data = await response.json();
-    const authResponse = this.validate(data, authResponseSchema);
-    return {
-      user: authResponse.user,
-      cookies
-    };
+    const validatedInput = this.validateInput(
+      credentials,
+      registerRequestSchema
+    );
+    if (!validatedInput.success) {
+      return validatedInput;
+    }
+    return this.requestResponse(
+      () => this.http.post("auth/register", { json: validatedInput.data }),
+      (response) => this.readLoginResult(response)
+    );
   }
   /**
    * Login with email and password
@@ -930,17 +1252,14 @@ var AuthResource = class extends BaseResource {
    * @returns LoginResult with user information and session cookies
    */
   async login(credentials) {
-    const validatedInput = this.validate(credentials, loginRequestSchema);
-    const response = await this.http.post("auth/login", {
-      json: validatedInput
-    });
-    const cookies = response.headers.getSetCookie();
-    const data = await response.json();
-    const authResponse = this.validate(data, authResponseSchema);
-    return {
-      user: authResponse.user,
-      cookies
-    };
+    const validatedInput = this.validateInput(credentials, loginRequestSchema);
+    if (!validatedInput.success) {
+      return validatedInput;
+    }
+    return this.requestResponse(
+      () => this.http.post("auth/login", { json: validatedInput.data }),
+      (response) => this.readLoginResult(response)
+    );
   }
   /**
    * Logout the current user
@@ -948,17 +1267,28 @@ var AuthResource = class extends BaseResource {
    * @returns Array of Set-Cookie headers (typically clearing cookies)
    */
   async logout() {
-    const response = await this.http.post("auth/logout");
-    return response.headers.getSetCookie();
+    return this.requestResponse(
+      () => this.http.post("auth/logout"),
+      async (response) => {
+        const cookies = readSetCookie(response);
+        discardBody(response);
+        return Ok(cookies);
+      }
+    );
   }
   /**
    * Get current authenticated user
    * Requires a valid session cookie
-   * @returns User information
+   *
+   * No session is `{success: false, kind: 'unauthenticated'}`, not a `null`
+   * user: it is the literal reading of the server's 401. Callers must send the
+   * visitor to login on `unauthenticated` **only**. Treating `network` or
+   * `server_error` the same way turns a flaky connection into a login loop.
+   *
+   * @returns The current user, or `unauthenticated` when there is no session
    */
   async getCurrentUser() {
-    const data = await this.http.get("auth/me").json();
-    return this.validate(data, userSchema);
+    return this.request(() => this.http.get("auth/me"), userSchema);
   }
   /**
    * Get the details of a pending invitation by its token (public endpoint)
@@ -967,8 +1297,10 @@ var AuthResource = class extends BaseResource {
    * @returns Invitation info (email, role, status, expiry)
    */
   async getInvitation(token) {
-    const data = await this.http.get(`auth/invitation/${token}`).json();
-    return this.validate(data, invitationInfoSchema);
+    return this.request(
+      () => this.http.get(`auth/invitation/${token}`),
+      invitationInfoSchema
+    );
   }
   /**
    * Accept a pending invitation, creating the user account and logging in
@@ -976,17 +1308,33 @@ var AuthResource = class extends BaseResource {
    * @returns LoginResult with user information and session cookies
    */
   async acceptInvitation(input) {
-    const validatedInput = this.validate(input, acceptInvitationSchema);
-    const response = await this.http.post("auth/accept-invitation", {
-      json: validatedInput
-    });
-    const cookies = response.headers.getSetCookie();
-    const data = await response.json();
-    const authResponse = this.validate(data, authResponseSchema);
-    return {
-      user: authResponse.user,
-      cookies
-    };
+    const validatedInput = this.validateInput(input, acceptInvitationSchema);
+    if (!validatedInput.success) {
+      return validatedInput;
+    }
+    return this.requestResponse(
+      () => this.http.post("auth/accept-invitation", {
+        json: validatedInput.data
+      }),
+      (response) => this.readLoginResult(response)
+    );
+  }
+  /**
+   * The three session-establishing endpoints share a body and need the
+   * `Set-Cookie` headers off the raw `Response`, which is why they go through
+   * `requestResponse` rather than the plain JSON path.
+   */
+  async readLoginResult(response) {
+    const cookies = readSetCookie(response);
+    const body = await this.readJson(response);
+    if (!body.success) {
+      return body;
+    }
+    const authResponse = this.validate(body.data, authResponseSchema);
+    if (!authResponse.success) {
+      return authResponse;
+    }
+    return Ok({ user: authResponse.data.user, cookies });
   }
 };
 
@@ -1003,17 +1351,23 @@ var EventsResource = class extends BaseResource {
     if (options?.cursor) {
       searchParams.cursor = options.cursor;
     }
-    const data = await this.http.get(`api/projects/${projectId}/issues/${issueId}/events`, {
-      searchParams
-    }).json();
-    return this.validate(data, paginatedResponseSchema(eventSchema));
+    return this.request(
+      () => this.http.get(`api/projects/${projectId}/issues/${issueId}/events`, {
+        searchParams
+      }),
+      paginatedResponseSchema(eventSchema)
+    );
   }
   /**
    * Get a single event by ID with full details
    */
   async get(projectId, issueId, eventId) {
-    const data = await this.http.get(`api/projects/${projectId}/issues/${issueId}/events/${eventId}`).json();
-    return this.validate(data, eventDetailSchema);
+    return this.request(
+      () => this.http.get(
+        `api/projects/${projectId}/issues/${issueId}/events/${eventId}`
+      ),
+      eventDetailSchema
+    );
   }
 };
 var serverVersionSchema = z.object({
@@ -1023,8 +1377,10 @@ var serverVersionSchema = z.object({
 // src/resources/health.ts
 var HealthResource = class extends BaseResource {
   async getVersion() {
-    const data = await this.http.get("health/version").json();
-    return this.validate(data, serverVersionSchema);
+    return this.request(
+      () => this.http.get("health/version"),
+      serverVersionSchema
+    );
   }
 };
 
@@ -1035,23 +1391,30 @@ var InvitationsResource = class extends BaseResource {
    * @param input - Email and global role for the invited user
    */
   async create(input) {
-    const validatedInput = this.validate(input, createInvitationSchema);
-    const data = await this.http.post("api/invitations", { json: validatedInput }).json();
-    return this.validate(data, invitationSchema);
+    const validatedInput = this.validateInput(input, createInvitationSchema);
+    if (!validatedInput.success) {
+      return validatedInput;
+    }
+    return this.request(
+      () => this.http.post("api/invitations", { json: validatedInput.data }),
+      invitationSchema
+    );
   }
   /**
    * List all invitations
    */
   async list() {
-    const data = await this.http.get("api/invitations").json();
-    return this.validate(data, invitationSchema.array());
+    return this.request(
+      () => this.http.get("api/invitations"),
+      invitationSchema.array()
+    );
   }
   /**
    * Revoke a pending invitation
    * @param token - Invitation token to revoke
    */
   async revoke(token) {
-    await this.http.delete(`api/invitations/${token}`);
+    return this.requestVoid(() => this.http.delete(`api/invitations/${token}`));
   }
 };
 var IssuesResource = class extends BaseResource {
@@ -1078,25 +1441,34 @@ var IssuesResource = class extends BaseResource {
     if (options?.q) {
       searchParams.q = options.q;
     }
-    const data = await this.http.get(`api/projects/${projectId}/issues`, { searchParams }).json();
-    return this.validate(data, offsetPaginatedResponseSchema(issueSchema));
+    return this.request(
+      () => this.http.get(`api/projects/${projectId}/issues`, { searchParams }),
+      offsetPaginatedResponseSchema(issueSchema)
+    );
   }
   /**
    * Get a single issue by ID
    */
   async get(projectId, issueId) {
-    const data = await this.http.get(`api/projects/${projectId}/issues/${issueId}`).json();
-    return this.validate(data, issueSchema);
+    return this.request(
+      () => this.http.get(`api/projects/${projectId}/issues/${issueId}`),
+      issueSchema
+    );
   }
   /**
    * Update issue state (status, substatus, priority, assignment, …)
    */
   async updateState(projectId, issueId, input) {
-    const validatedInput = this.validate(input, updateIssueStateSchema);
-    const data = await this.http.patch(`api/projects/${projectId}/issues/${issueId}`, {
-      json: validatedInput
-    }).json();
-    return this.validate(data, issueSchema);
+    const validatedInput = this.validateInput(input, updateIssueStateSchema);
+    if (!validatedInput.success) {
+      return validatedInput;
+    }
+    return this.request(
+      () => this.http.patch(`api/projects/${projectId}/issues/${issueId}`, {
+        json: validatedInput.data
+      }),
+      issueSchema
+    );
   }
   /**
    * Resolve an issue in the next release (suppresses regression until a deploy).
@@ -1110,115 +1482,163 @@ var IssuesResource = class extends BaseResource {
    * Delete an issue
    */
   async delete(projectId, issueId) {
-    await this.http.delete(`api/projects/${projectId}/issues/${issueId}`);
+    return this.requestVoid(
+      () => this.http.delete(`api/projects/${projectId}/issues/${issueId}`)
+    );
   }
   /**
    * Bulk-mutate issues (status and/or priority).
    */
   async bulkUpdate(projectId, input) {
-    const validatedInput = this.validate(input, bulkUpdateIssuesSchema);
-    const data = await this.http.put(`api/projects/${projectId}/issues`, { json: validatedInput }).json();
-    return this.validate(data, z.object({ updated: z.number().int() }));
+    const validatedInput = this.validateInput(input, bulkUpdateIssuesSchema);
+    if (!validatedInput.success) {
+      return validatedInput;
+    }
+    return this.request(
+      () => this.http.put(`api/projects/${projectId}/issues`, {
+        json: validatedInput.data
+      }),
+      z.object({ updated: z.number().int() })
+    );
   }
   /**
    * Bulk-delete issues.
    */
   async bulkDelete(projectId, input) {
-    const validatedInput = this.validate(input, bulkDeleteIssuesSchema);
-    const data = await this.http.delete(`api/projects/${projectId}/issues`, { json: validatedInput }).json();
-    return this.validate(data, z.object({ deleted: z.number().int() }));
+    const validatedInput = this.validateInput(input, bulkDeleteIssuesSchema);
+    if (!validatedInput.success) {
+      return validatedInput;
+    }
+    return this.request(
+      () => this.http.delete(`api/projects/${projectId}/issues`, {
+        json: validatedInput.data
+      }),
+      z.object({ deleted: z.number().int() })
+    );
   }
   /**
    * List the grouping hashes that map to an issue.
    */
   async getHashes(projectId, issueId) {
-    const data = await this.http.get(`api/projects/${projectId}/issues/${issueId}/hashes`).json();
-    return this.validate(data, z.array(issueHashSchema));
+    return this.request(
+      () => this.http.get(`api/projects/${projectId}/issues/${issueId}/hashes`),
+      z.array(issueHashSchema)
+    );
   }
   /**
    * List the distinct values (with counts) for a tag key across the issue.
    * Returns a bare list, one entry per value (Sentry-compatible shape).
    */
   async getTagValues(projectId, issueId, key) {
-    const data = await this.http.get(
-      `api/projects/${projectId}/issues/${issueId}/tags/${encodeURIComponent(key)}`
-    ).json();
-    return this.validate(data, z.array(issueTagValueSchema));
+    return this.request(
+      () => this.http.get(
+        `api/projects/${projectId}/issues/${issueId}/tags/${encodeURIComponent(key)}`
+      ),
+      z.array(issueTagValueSchema)
+    );
   }
   /**
    * Fetch per-issue aggregates (unique user count + top tags).
    */
   async getAggregates(projectId, issueId) {
-    const data = await this.http.get(`api/projects/${projectId}/issues/${issueId}/aggregates`).json();
-    return this.validate(data, issueAggregatesSchema);
+    return this.request(
+      () => this.http.get(`api/projects/${projectId}/issues/${issueId}/aggregates`),
+      issueAggregatesSchema
+    );
   }
   /**
    * Fetch a zero-filled event-count timeseries (24h or 30d).
    */
   async getStats(projectId, issueId, window = "24h") {
-    const data = await this.http.get(`api/projects/${projectId}/issues/${issueId}/stats`, {
-      searchParams: { window }
-    }).json();
-    return this.validate(data, issueStatsSchema);
+    return this.request(
+      () => this.http.get(`api/projects/${projectId}/issues/${issueId}/stats`, {
+        searchParams: { window }
+      }),
+      issueStatsSchema
+    );
   }
   /**
    * List an issue's activity log (status changes, comments/notes, …).
    */
   async getActivity(projectId, issueId) {
-    const data = await this.http.get(`api/projects/${projectId}/issues/${issueId}/activity`).json();
-    return this.validate(data, z.array(activityEntrySchema));
+    return this.request(
+      () => this.http.get(`api/projects/${projectId}/issues/${issueId}/activity`),
+      z.array(activityEntrySchema)
+    );
   }
   /**
    * Add a comment (note) to an issue.
    */
   async addComment(projectId, issueId, input) {
-    const validatedInput = this.validate(input, createCommentSchema);
-    const data = await this.http.post(`api/projects/${projectId}/issues/${issueId}/comments`, {
-      json: validatedInput
-    }).json();
-    return this.validate(data, activityEntrySchema);
+    const validatedInput = this.validateInput(input, createCommentSchema);
+    if (!validatedInput.success) {
+      return validatedInput;
+    }
+    return this.request(
+      () => this.http.post(`api/projects/${projectId}/issues/${issueId}/comments`, {
+        json: validatedInput.data
+      }),
+      activityEntrySchema
+    );
   }
   /**
    * Set or clear the current user's bookmark on an issue.
    */
   async setBookmark(projectId, issueId, enabled) {
-    const data = await this.http.put(`api/projects/${projectId}/issues/${issueId}/bookmark`, {
-      json: { enabled }
-    }).json();
-    return this.validate(data, z.object({ is_bookmarked: z.boolean() }));
+    return this.request(
+      () => this.http.put(`api/projects/${projectId}/issues/${issueId}/bookmark`, {
+        json: { enabled }
+      }),
+      z.object({ is_bookmarked: z.boolean() })
+    );
   }
   /**
    * Set or clear the current user's subscription to an issue.
    */
   async setSubscription(projectId, issueId, enabled) {
-    const data = await this.http.put(`api/projects/${projectId}/issues/${issueId}/subscription`, {
-      json: { enabled }
-    }).json();
-    return this.validate(data, z.object({ is_subscribed: z.boolean() }));
+    return this.request(
+      () => this.http.put(
+        `api/projects/${projectId}/issues/${issueId}/subscription`,
+        { json: { enabled } }
+      ),
+      z.object({ is_subscribed: z.boolean() })
+    );
   }
   /**
    * Mark the issue as seen by the current user.
    */
   async markSeen(projectId, issueId) {
-    const data = await this.http.post(`api/projects/${projectId}/issues/${issueId}/seen`).json();
-    return this.validate(data, z.object({ has_seen: z.boolean() }));
+    return this.request(
+      () => this.http.post(`api/projects/${projectId}/issues/${issueId}/seen`),
+      z.object({ has_seen: z.boolean() })
+    );
   }
   /**
    * List user feedback reports for an issue.
    */
   async listUserReports(projectId, issueId) {
-    const data = await this.http.get(`api/projects/${projectId}/issues/${issueId}/user-reports`).json();
-    return this.validate(data, z.array(userReportSchema));
+    return this.request(
+      () => this.http.get(
+        `api/projects/${projectId}/issues/${issueId}/user-reports`
+      ),
+      z.array(userReportSchema)
+    );
   }
   /**
    * Attach a user feedback report to an issue.
    */
   async createUserReport(projectId, issueId, input) {
-    const validatedInput = this.validate(input, createUserReportSchema);
-    const data = await this.http.post(`api/projects/${projectId}/issues/${issueId}/user-reports`, {
-      json: validatedInput
-    }).json();
-    return this.validate(data, userReportSchema);
+    const validatedInput = this.validateInput(input, createUserReportSchema);
+    if (!validatedInput.success) {
+      return validatedInput;
+    }
+    return this.request(
+      () => this.http.post(
+        `api/projects/${projectId}/issues/${issueId}/user-reports`,
+        { json: validatedInput.data }
+      ),
+      userReportSchema
+    );
   }
 };
 
@@ -1242,8 +1662,10 @@ var LogsResource = class extends BaseResource {
     if (options?.trace_id) {
       searchParams.trace_id = options.trace_id;
     }
-    const data = await this.http.get(`api/projects/${projectId}/logs`, { searchParams }).json();
-    return this.validate(data, offsetPaginatedResponseSchema(logSchema));
+    return this.request(
+      () => this.http.get(`api/projects/${projectId}/logs`, { searchParams }),
+      offsetPaginatedResponseSchema(logSchema)
+    );
   }
 };
 
@@ -1254,8 +1676,10 @@ var MembersResource = class extends BaseResource {
    * @param projectId - ID of the project
    */
   async list(projectId) {
-    const data = await this.http.get(`api/projects/${projectId}/members`).json();
-    return this.validate(data, projectMemberSchema.array());
+    return this.request(
+      () => this.http.get(`api/projects/${projectId}/members`),
+      projectMemberSchema.array()
+    );
   }
   /**
    * Add or update a project member
@@ -1263,10 +1687,15 @@ var MembersResource = class extends BaseResource {
    * @param input - User ID and per-project role
    */
   async upsert(projectId, input) {
-    const validatedInput = this.validate(input, upsertProjectMemberSchema);
-    await this.http.put(`api/projects/${projectId}/members`, {
-      json: validatedInput
-    });
+    const validatedInput = this.validateInput(input, upsertProjectMemberSchema);
+    if (!validatedInput.success) {
+      return validatedInput;
+    }
+    return this.requestVoid(
+      () => this.http.put(`api/projects/${projectId}/members`, {
+        json: validatedInput.data
+      })
+    );
   }
   /**
    * Remove a member from a project
@@ -1274,7 +1703,9 @@ var MembersResource = class extends BaseResource {
    * @param userId - ID of the user to remove
    */
   async remove(projectId, userId) {
-    await this.http.delete(`api/projects/${projectId}/members/${userId}`);
+    return this.requestVoid(
+      () => this.http.delete(`api/projects/${projectId}/members/${userId}`)
+    );
   }
 };
 
@@ -1294,39 +1725,56 @@ var ProjectsResource = class extends BaseResource {
     if (options?.order) {
       searchParams.set("order", options.order);
     }
+    if (options?.stats_period) {
+      searchParams.set("stats_period", options.stats_period);
+    }
     const query = searchParams.toString();
     const url = query ? `api/projects?${query}` : "api/projects";
-    const data = await this.http.get(url).json();
-    return this.validate(data, offsetPaginatedResponseSchema(projectSchema));
+    return this.request(
+      () => this.http.get(url),
+      offsetPaginatedResponseSchema(projectSchema)
+    );
   }
   /**
    * Get a single project by ID
    */
   async get(id) {
-    const data = await this.http.get(`api/projects/${id}`).json();
-    return this.validate(data, projectSchema);
+    return this.request(
+      () => this.http.get(`api/projects/${id}`),
+      projectSchema
+    );
   }
   /**
    * Create a new project
    */
   async create(input) {
-    const validatedInput = this.validate(input, createProjectSchema);
-    const data = await this.http.post("api/projects", { json: validatedInput }).json();
-    return this.validate(data, projectSchema);
+    const validatedInput = this.validateInput(input, createProjectSchema);
+    if (!validatedInput.success) {
+      return validatedInput;
+    }
+    return this.request(
+      () => this.http.post("api/projects", { json: validatedInput.data }),
+      projectSchema
+    );
   }
   /**
    * Update an existing project
    */
   async update(id, input) {
-    const validatedInput = this.validate(input, updateProjectSchema);
-    const data = await this.http.patch(`api/projects/${id}`, { json: validatedInput }).json();
-    return this.validate(data, projectSchema);
+    const validatedInput = this.validateInput(input, updateProjectSchema);
+    if (!validatedInput.success) {
+      return validatedInput;
+    }
+    return this.request(
+      () => this.http.patch(`api/projects/${id}`, { json: validatedInput.data }),
+      projectSchema
+    );
   }
   /**
    * Delete a project
    */
   async delete(id) {
-    await this.http.delete(`api/projects/${id}`);
+    return this.requestVoid(() => this.http.delete(`api/projects/${id}`));
   }
 };
 var ReleasesResource = class extends BaseResource {
@@ -1342,11 +1790,13 @@ var ReleasesResource = class extends BaseResource {
     if (limit !== void 0) {
       searchParams.limit = limit.toString();
     }
-    const data = await this.http.get(
-      `api/projects/${projectId}/releases/${encodeURIComponent(release)}/new-issues`,
-      { searchParams }
-    ).json();
-    return this.validate(data, z.array(issueSchema));
+    return this.request(
+      () => this.http.get(
+        `api/projects/${projectId}/releases/${encodeURIComponent(release)}/new-issues`,
+        { searchParams }
+      ),
+      z.array(issueSchema)
+    );
   }
 };
 
@@ -1372,9 +1822,10 @@ var SessionsResource = class extends BaseResource {
     if (options?.per_page) {
       searchParams.per_page = String(options.per_page);
     }
-    const data = await this.http.get(`api/projects/${projectId}/sessions/stats`, { searchParams }).json();
-    return this.validate(
-      data,
+    return this.request(
+      () => this.http.get(`api/projects/${projectId}/sessions/stats`, {
+        searchParams
+      }),
       offsetPaginatedResponseSchema(releaseHealthRowSchema)
     );
   }
@@ -1388,8 +1839,12 @@ var SessionsResource = class extends BaseResource {
     if (period) {
       searchParams.period = period;
     }
-    const data = await this.http.get(`api/projects/${projectId}/sessions/summary`, { searchParams }).json();
-    return this.validate(data, sessionSummarySchema);
+    return this.request(
+      () => this.http.get(`api/projects/${projectId}/sessions/summary`, {
+        searchParams
+      }),
+      sessionSummarySchema
+    );
   }
   /**
    * Get a time-bucketed session trend for a project, aggregated across all
@@ -1406,8 +1861,12 @@ var SessionsResource = class extends BaseResource {
     if (interval !== void 0) {
       searchParams.interval = interval.toString();
     }
-    const data = await this.http.get(`api/projects/${projectId}/sessions/timeseries`, { searchParams }).json();
-    return this.validate(data, sessionTimeseriesSchema);
+    return this.request(
+      () => this.http.get(`api/projects/${projectId}/sessions/timeseries`, {
+        searchParams
+      }),
+      sessionTimeseriesSchema
+    );
   }
 };
 
@@ -1418,8 +1877,10 @@ var SourceMapsResource = class extends BaseResource {
    * Returns the upload URL, chunk size limits, and accepted artifact types.
    */
   async getChunkUploadCapability(orgSlug) {
-    const data = await this.http.get(`api/0/organizations/${orgSlug}/chunk-upload/`).json();
-    return this.validate(data, chunkUploadCapabilitySchema);
+    return this.request(
+      () => this.http.get(`api/0/organizations/${orgSlug}/chunk-upload/`),
+      chunkUploadCapabilitySchema
+    );
   }
   /**
    * Upload chunks as multipart/form-data, batching by `chunksPerRequest` (default 64).
@@ -1428,7 +1889,10 @@ var SourceMapsResource = class extends BaseResource {
    */
   async uploadChunks(orgSlug, chunks, chunksPerRequest = 64) {
     if (!Number.isInteger(chunksPerRequest) || chunksPerRequest <= 0) {
-      throw new Error("chunksPerRequest must be a positive integer");
+      return Err({
+        kind: "invalid_request",
+        message: "chunksPerRequest must be a positive integer."
+      });
     }
     for (let i = 0; i < chunks.length; i += chunksPerRequest) {
       const batch = chunks.slice(i, i + chunksPerRequest);
@@ -1436,10 +1900,16 @@ var SourceMapsResource = class extends BaseResource {
       for (const chunk of batch) {
         form.append(chunk.hash, chunk.data);
       }
-      await this.http.post(`api/0/organizations/${orgSlug}/chunk-upload/`, {
-        body: form
-      });
+      const uploaded = await this.requestVoid(
+        () => this.http.post(`api/0/organizations/${orgSlug}/chunk-upload/`, {
+          body: form
+        })
+      );
+      if (!uploaded.success) {
+        return uploaded;
+      }
     }
+    return Ok(void 0);
   }
   /**
    * Trigger assembly of a previously uploaded artifact bundle.
@@ -1449,17 +1919,28 @@ var SourceMapsResource = class extends BaseResource {
    *          still needs uploading via `uploadChunks`.
    */
   async assembleBundle(orgSlug, input) {
-    const data = await this.http.post(`api/0/organizations/${orgSlug}/artifactbundle/assemble/`, {
-      json: input
-    }).json();
-    return this.validate(data, assembleResponseSchema);
+    const validatedInput = this.validateInput(input, assembleInputSchema);
+    if (!validatedInput.success) {
+      return validatedInput;
+    }
+    return this.request(
+      () => this.http.post(
+        `api/0/organizations/${orgSlug}/artifactbundle/assemble/`,
+        { json: validatedInput.data }
+      ),
+      assembleResponseSchema
+    );
   }
   /**
    * List all source map files uploaded for a project.
    */
   async list(orgSlug, projectSlug) {
-    const data = await this.http.get(`api/0/projects/${orgSlug}/${projectSlug}/files/source-maps/`).json();
-    return this.validate(data, listSourceMapsResponseSchema);
+    return this.request(
+      () => this.http.get(
+        `api/0/projects/${orgSlug}/${projectSlug}/files/source-maps/`
+      ),
+      listSourceMapsResponseSchema
+    );
   }
 };
 
@@ -1489,8 +1970,10 @@ var SpansResource = class extends BaseResource {
     if (options?.operation_type) {
       searchParams.operation_type = options.operation_type;
     }
-    const data = await this.http.get(`api/projects/${projectId}/spans`, { searchParams }).json();
-    return this.validate(data, offsetPaginatedResponseSchema(spanSchema));
+    return this.request(
+      () => this.http.get(`api/projects/${projectId}/spans`, { searchParams }),
+      offsetPaginatedResponseSchema(spanSchema)
+    );
   }
 };
 
@@ -1515,8 +1998,12 @@ var StatsResource = class extends BaseResource {
     if (interval !== void 0) {
       searchParams.interval = interval.toString();
     }
-    const data = await this.http.get(`api/projects/${projectId}/events/stats`, { searchParams }).json();
-    return this.validate(data, eventTimeseriesSchema);
+    return this.request(
+      () => this.http.get(`api/projects/${projectId}/events/stats`, {
+        searchParams
+      }),
+      eventTimeseriesSchema
+    );
   }
   /**
    * Get project-wide counters for a window, each paired with the same counter
@@ -1531,8 +2018,12 @@ var StatsResource = class extends BaseResource {
     if (period) {
       searchParams.period = period;
     }
-    const data = await this.http.get(`api/projects/${projectId}/stats/summary`, { searchParams }).json();
-    return this.validate(data, projectStatsSummarySchema);
+    return this.request(
+      () => this.http.get(`api/projects/${projectId}/stats/summary`, {
+        searchParams
+      }),
+      projectStatsSummarySchema
+    );
   }
 };
 var StorageResource = class extends BaseResource {
@@ -1541,42 +2032,60 @@ var StorageResource = class extends BaseResource {
    * whole-DB size, and exact source-map weight.
    */
   async getSummary() {
-    const data = await this.http.get("api/storage/summary").json();
-    return this.validate(data, storageSummarySchema);
+    return this.request(
+      () => this.http.get("api/storage/summary"),
+      storageSummarySchema
+    );
   }
   /**
    * Get the per-project storage breakdown (one row per project, including
    * empty ones).
    */
   async getProjects() {
-    const data = await this.http.get("api/storage/projects").json();
-    return this.validate(data, z.array(projectStorageSchema));
+    return this.request(
+      () => this.http.get("api/storage/projects"),
+      z.array(projectStorageSchema)
+    );
   }
   /**
    * Dry-run: count the rows a cleanup would remove. Mutates nothing — use it to
    * confirm impact before {@link executeCleanup}.
    */
   async previewCleanup(options) {
-    const json = cleanupOptionsSchema.parse(options);
-    const data = await this.http.post("api/storage/cleanup/preview", { json }).json();
-    return this.validate(data, cleanupCountsSchema);
+    const validatedInput = this.validateInput(options, cleanupOptionsSchema);
+    if (!validatedInput.success) {
+      return validatedInput;
+    }
+    return this.request(
+      () => this.http.post("api/storage/cleanup/preview", {
+        json: validatedInput.data
+      }),
+      cleanupCountsSchema
+    );
   }
   /**
    * Execute a cleanup: delete data older than `older_than_days` (optionally
    * scoped to one project) and remove any issue left with zero events.
    */
   async executeCleanup(options) {
-    const json = cleanupOptionsSchema.parse(options);
-    const data = await this.http.post("api/storage/cleanup", { json }).json();
-    return this.validate(data, cleanupCountsSchema);
+    const validatedInput = this.validateInput(options, cleanupOptionsSchema);
+    if (!validatedInput.success) {
+      return validatedInput;
+    }
+    return this.request(
+      () => this.http.post("api/storage/cleanup", { json: validatedInput.data }),
+      cleanupCountsSchema
+    );
   }
   /**
    * Dry-run for {@link gcSourceMaps}: count the orphaned source-map files and
    * bytes a GC would reclaim. Mutates nothing.
    */
   async previewGcSourceMaps() {
-    const data = await this.http.post("api/storage/source-maps/gc/preview").json();
-    return this.validate(data, sourceMapGcResultSchema);
+    return this.request(
+      () => this.http.post("api/storage/source-maps/gc/preview"),
+      sourceMapGcResultSchema
+    );
   }
   /**
    * Garbage-collect orphaned source maps: files no longer referenced by any
@@ -1584,8 +2093,10 @@ var StorageResource = class extends BaseResource {
    * referenced files.
    */
   async gcSourceMaps() {
-    const data = await this.http.post("api/storage/source-maps/gc").json();
-    return this.validate(data, sourceMapGcResultSchema);
+    return this.request(
+      () => this.http.post("api/storage/source-maps/gc"),
+      sourceMapGcResultSchema
+    );
   }
 };
 
@@ -1595,8 +2106,10 @@ var TeamResource = class extends BaseResource {
    * List all team members (users)
    */
   async list() {
-    const data = await this.http.get("api/team").json();
-    return this.validate(data, teamMemberSchema.array());
+    return this.request(
+      () => this.http.get("api/team"),
+      teamMemberSchema.array()
+    );
   }
   /**
    * Change a user's global role
@@ -1604,15 +2117,20 @@ var TeamResource = class extends BaseResource {
    * @param role - New global role to assign
    */
   async updateRole(userId, role) {
-    const body = this.validate({ role }, updateUserRoleSchema);
-    await this.http.patch(`api/team/${userId}/role`, { json: body });
+    const body = this.validateInput({ role }, updateUserRoleSchema);
+    if (!body.success) {
+      return body;
+    }
+    return this.requestVoid(
+      () => this.http.patch(`api/team/${userId}/role`, { json: body.data })
+    );
   }
   /**
    * Permanently remove a user from the instance.
    * @param userId - ID of the user to delete
    */
   async remove(userId) {
-    await this.http.delete(`api/team/${userId}`);
+    return this.requestVoid(() => this.http.delete(`api/team/${userId}`));
   }
 };
 
@@ -1622,8 +2140,10 @@ var TokensResource = class extends BaseResource {
    * List all auth tokens (masked)
    */
   async list() {
-    const data = await this.http.get("api/tokens").json();
-    return this.validate(data, authTokenSchema.array());
+    return this.request(
+      () => this.http.get("api/tokens"),
+      authTokenSchema.array()
+    );
   }
   /**
    * Get a single auth token by ID (full token value).
@@ -1632,23 +2152,30 @@ var TokensResource = class extends BaseResource {
    * complete token for GET /api/tokens/{id}.
    */
   async get(id) {
-    const data = await this.http.get(`api/tokens/${id}`).json();
-    return this.validate(data, authTokenCreatedSchema);
+    return this.request(
+      () => this.http.get(`api/tokens/${id}`),
+      authTokenCreatedSchema
+    );
   }
   /**
    * Create a new auth token
    * Note: The full token is only returned once during creation
    */
   async create(input) {
-    const validatedInput = this.validate(input, createAuthTokenSchema);
-    const data = await this.http.post("api/tokens", { json: validatedInput }).json();
-    return this.validate(data, authTokenCreatedSchema);
+    const validatedInput = this.validateInput(input, createAuthTokenSchema);
+    if (!validatedInput.success) {
+      return validatedInput;
+    }
+    return this.request(
+      () => this.http.post("api/tokens", { json: validatedInput.data }),
+      authTokenCreatedSchema
+    );
   }
   /**
    * Delete an auth token
    */
   async delete(id) {
-    await this.http.delete(`api/tokens/${id}`);
+    return this.requestVoid(() => this.http.delete(`api/tokens/${id}`));
   }
 };
 var TransactionsResource = class extends BaseResource {
@@ -1678,11 +2205,10 @@ var TransactionsResource = class extends BaseResource {
     if (options?.release) {
       searchParams.release = options.release;
     }
-    const data = await this.http.get(`api/projects/${projectId}/transactions`, {
-      searchParams
-    }).json();
-    return this.validate(
-      data,
+    return this.request(
+      () => this.http.get(`api/projects/${projectId}/transactions`, {
+        searchParams
+      }),
       offsetPaginatedResponseSchema(transactionSchema)
     );
   }
@@ -1690,8 +2216,12 @@ var TransactionsResource = class extends BaseResource {
    * Get the indexed spans extracted from a transaction, in waterfall order.
    */
   async getSpans(projectId, transactionId) {
-    const data = await this.http.get(`api/projects/${projectId}/transactions/${transactionId}/spans`).json();
-    return this.validate(data, z.array(spanSchema));
+    return this.request(
+      () => this.http.get(
+        `api/projects/${projectId}/transactions/${transactionId}/spans`
+      ),
+      z.array(spanSchema)
+    );
   }
   /**
    * Get aggregate performance stats (count, p50/p95/p99 latency, failure rate)
@@ -1706,99 +2236,43 @@ var TransactionsResource = class extends BaseResource {
     if (options?.per_page) {
       searchParams.per_page = String(options.per_page);
     }
-    const data = await this.http.get(`api/projects/${projectId}/transactions/stats`, { searchParams }).json();
-    return this.validate(
-      data,
+    return this.request(
+      () => this.http.get(`api/projects/${projectId}/transactions/stats`, {
+        searchParams
+      }),
       offsetPaginatedResponseSchema(transactionStatsSchema)
     );
   }
   /**
    * Get aggregate stats for a single (transaction name, op) group — a direct
-   * lookup that works regardless of how many groups the project has. Throws
-   * NotFoundError when the group has no transactions.
+   * lookup that works regardless of how many groups the project has. Reports
+   * `not_found` when the group has no transactions.
    */
   async getStatForGroup(projectId, name, op) {
     const searchParams = { name };
     if (op) {
       searchParams.op = op;
     }
-    const data = await this.http.get(`api/projects/${projectId}/transactions/stats/group`, {
-      searchParams
-    }).json();
-    return this.validate(data, transactionStatsSchema);
+    return this.request(
+      () => this.http.get(`api/projects/${projectId}/transactions/stats/group`, {
+        searchParams
+      }),
+      transactionStatsSchema
+    );
   }
   /**
    * Get a single transaction by ID with its full Sentry payload (spans,
    * contexts.trace, measurements, tags) for the performance detail view.
    */
   async get(projectId, transactionId) {
-    const data = await this.http.get(`api/projects/${projectId}/transactions/${transactionId}`).json();
-    return this.validate(data, transactionDetailSchema);
+    return this.request(
+      () => this.http.get(
+        `api/projects/${projectId}/transactions/${transactionId}`
+      ),
+      transactionDetailSchema
+    );
   }
 };
-function transformHttpError(error) {
-  const { response } = error;
-  const status = response.status;
-  let errorMessage = `HTTP ${status} error`;
-  const body = error.data;
-  if (body) {
-    errorMessage = body.error || body.message || errorMessage;
-  }
-  switch (status) {
-    case 400:
-      return new BadRequestError(errorMessage);
-    case 401:
-      return new AuthenticationError(errorMessage);
-    case 403:
-      return new AuthorizationError(errorMessage);
-    case 404:
-      return new NotFoundError(errorMessage);
-    case 429: {
-      const retryAfter = response.headers.get("Retry-After");
-      return new RateLimitError(errorMessage, retryAfter ?? void 0);
-    }
-    case 500:
-    case 502:
-    case 503:
-    case 504:
-      return new ServerError(errorMessage, status);
-    default:
-      return new RustrakError(errorMessage, { statusCode: status });
-  }
-}
-function createKyInstance(config) {
-  const headers = {
-    "Content-Type": "application/json",
-    ...config.headers
-  };
-  if (config.token) {
-    headers.Authorization = `Bearer ${config.token}`;
-  }
-  return ky.create({
-    prefix: config.baseUrl,
-    timeout: config.timeout ?? 3e4,
-    credentials: "include",
-    retry: {
-      limit: config.maxRetries ?? 2,
-      statusCodes: [408, 500, 502, 503, 504],
-      methods: ["get", "post", "put", "patch", "delete"]
-    },
-    headers,
-    hooks: {
-      beforeError: [
-        ({ error }) => {
-          if (error.name === "TimeoutError") {
-            throw new NetworkError("Request timed out", error);
-          }
-          if (isHTTPError(error)) {
-            throw transformHttpError(error);
-          }
-          throw new NetworkError(error.message, error);
-        }
-      ]
-    }
-  });
-}
 
 // src/client.ts
 var RustrakClient = class {
@@ -1913,6 +2387,6 @@ var RustrakClient = class {
   }
 };
 
-export { AuthenticationError, AuthorizationError, BadRequestError, NetworkError, NotFoundError, RateLimitError, RustrakClient, RustrakError, ServerError, ValidationError };
+export { Err, FIELD_ERROR_CODES, NETWORK_ERROR_MESSAGE, Ok, RustrakClient, SERVER_ERROR_MESSAGE, TIMEOUT_ERROR_MESSAGE, isRetryable, mapResult, unwrap, unwrapOr };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map