@rustrak/client 0.18.1 → 0.19.0

package/dist/client.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.cjs","names":["Rustrak","createClient","createConfig","createFetch","Ok","isTransportFailure","Err","transformHttpError","ZodError"],"sources":["../src/client.ts"],"sourcesContent":["import { ZodError } from 'zod';\nimport type { ClientConfig } from './config.js';\nimport type { RustrakError } from './errors.js';\nimport { createClient, createConfig } from './generated/client/index.js';\nimport { Rustrak } from './generated/sdk.gen.js';\nimport { Err, Ok, type Result } from './result.js';\nimport {\n  createFetch,\n  isTransportFailure,\n  transformHttpError,\n} from './utils/http.js';\n\n/** What a caller may pass: the request's own parts, never client plumbing. */\ntype RequestKeys = 'path' | 'query' | 'body' | 'headers' | 'signal';\n\ntype Call<F> = F extends (options: infer O) => infer R\n  ? (\n      ...args: {} extends Pick<O, Extract<keyof O, RequestKeys>>\n        ? [options?: Pick<O, Extract<keyof O, RequestKeys>>]\n        : [options: Pick<O, Extract<keyof O, RequestKeys>>]\n    ) => Promise<Result<Data<Awaited<R>>, RustrakError>>\n  : never;\n\n/** The success half of the generated `{ data, error }` union. */\ntype Data<R> =\n  Extract<R, { error: undefined }> extends { data: infer D } ? D : never;\n\ntype Resource<T> = { readonly [M in keyof T]: Call<T[M]> };\n\n/**\n * Every operation in `openapi.json`, grouped by tag:\n * `client.issues.list({ path: { project_id } })`.\n *\n * Generated in `src/generated/`; this file only changes what a call returns.\n */\nexport type RustrakClient = {\n  readonly [R in keyof Rustrak]: Resource<Rustrak[R]>;\n};\n\n/**\n * Main Rustrak API client. Every method returns a `Result`; nothing throws for\n * an expected failure.\n *\n * @example\n * ```typescript\n * const client = new RustrakClient({\n *   baseUrl: 'http://localhost:8080',\n *   token: 'your-api-token',\n * });\n *\n * const issues = await client.issues.list({ path: { project_id: 1 } });\n * if (issues.success) console.log(issues.data.items);\n * ```\n */\nexport const RustrakClient = class {\n  constructor(config: ClientConfig) {\n    // biome-ignore lint/correctness/noConstructorReturn: the instance is the generated SDK with every method wrapped\n    return Object.setPrototypeOf(createApi(config), new.target.prototype);\n  }\n} as unknown as new (\n  config: ClientConfig,\n) => RustrakClient;\n\nfunction createApi(config: ClientConfig): RustrakClient {\n  const sdk = new Rustrak({\n    client: createClient(\n      createConfig({\n        baseUrl: config.baseUrl,\n        credentials: 'include',\n        fetch: createFetch(config),\n        // Every 2xx in the spec is JSON or empty. `auto` would hand back an\n        // HTML page or a stream as a success without validating it.\n        parseAs: 'json',\n        headers: {\n          // Without it a content-negotiating hop can answer with HTML.\n          Accept: 'application/json',\n          ...config.headers,\n          ...(config.token && { Authorization: `Bearer ${config.token}` }),\n        },\n      }),\n    ),\n  });\n\n  const api: Record<string, Record<string, unknown>> = {};\n  for (const name of Object.getOwnPropertyNames(Rustrak.prototype)) {\n    if (name === 'constructor') continue;\n    const resource = sdk[name as keyof Rustrak] as unknown as Record<\n      string,\n      (options: object) => Promise<Outcome>\n    >;\n    const methods: Record<string, unknown> = {};\n    for (const method of Object.getOwnPropertyNames(\n      Object.getPrototypeOf(resource),\n    )) {\n      if (method === 'constructor') continue;\n      methods[method] = async (options: { headers?: unknown } = {}) =>\n        toResult(\n          await resource[method]!({\n            ...options,\n            // A JSON write spreads these into an object, which keeps nothing\n            // of a `Headers` or an array of pairs.\n            headers:\n              options.headers instanceof Headers ||\n              Array.isArray(options.headers)\n                ? Object.fromEntries(new Headers(options.headers))\n                : options.headers,\n            throwOnError: false,\n          }),\n        );\n    }\n    api[name] = methods;\n  }\n  return api as unknown as RustrakClient;\n}\n\ntype Outcome = {\n  data?: unknown;\n  error?: unknown;\n  response?: Response;\n};\n\n/**\n * The boundary: the generated client's `{ data, error, response }` becomes a\n * `Result`.\n *\n * Only failures this file recognises become an `Err`. Anything else, a\n * `TypeError` from a genuine bug, is rethrown so it crashes where it can be\n * debugged instead of being laundered into `{ success: false }`.\n */\nfunction toResult({\n  data,\n  error,\n  response,\n}: Outcome): Result<unknown, RustrakError> {\n  if (error === undefined) return Ok(data);\n  if (isTransportFailure(error)) return Err(error.rustrakError);\n  if (response && !response.ok) {\n    // `error` is the parsed body, or its text when it is not JSON.\n    return Err(transformHttpError(response, error));\n  }\n  if (!response && error instanceof ZodError) {\n    return Err({\n      kind: 'invalid_request',\n      message: 'The request input did not match the expected schema.',\n    });\n  }\n  if (response && error instanceof SyntaxError) {\n    return Err({\n      kind: 'invalid_response',\n      message: 'The server returned a body that is not valid JSON.',\n    });\n  }\n  if (response && error instanceof ZodError) {\n    // No Zod issues: they embed the offending response data.\n    return Err({\n      kind: 'invalid_response',\n      message: 'The server response did not match the expected schema.',\n    });\n  }\n  throw error;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAsDA,MAAa,gBAAgB,MAAM;CACjC,YAAY,QAAsB;EAEhC,OAAO,OAAO,eAAe,UAAU,MAAM,GAAG,WAAW,SAAS;CACtE;AACF;AAIA,SAAS,UAAU,QAAqC;CACtD,MAAM,MAAM,IAAIA,gBAAAA,QAAQ,EACtB,QAAQC,mBAAAA,aACNC,kBAAAA,aAAa;EACX,SAAS,OAAO;EAChB,aAAa;EACb,OAAOC,aAAAA,YAAY,MAAM;EAGzB,SAAS;EACT,SAAS;GAEP,QAAQ;GACR,GAAG,OAAO;GACV,GAAI,OAAO,SAAS,EAAE,eAAe,UAAU,OAAO,QAAQ;EAChE;CACF,CAAC,CACH,EACF,CAAC;CAED,MAAM,MAA+C,CAAC;CACtD,KAAK,MAAM,QAAQ,OAAO,oBAAoBH,gBAAAA,QAAQ,SAAS,GAAG;EAChE,IAAI,SAAS,eAAe;EAC5B,MAAM,WAAW,IAAI;EAIrB,MAAM,UAAmC,CAAC;EAC1C,KAAK,MAAM,UAAU,OAAO,oBAC1B,OAAO,eAAe,QAAQ,CAChC,GAAG;GACD,IAAI,WAAW,eAAe;GAC9B,QAAQ,UAAU,OAAO,UAAiC,CAAC,MACzD,SACE,MAAM,SAAS,OAAO,CAAE;IACtB,GAAG;IAGH,SACE,QAAQ,mBAAmB,WAC3B,MAAM,QAAQ,QAAQ,OAAO,IACzB,OAAO,YAAY,IAAI,QAAQ,QAAQ,OAAO,CAAC,IAC/C,QAAQ;IACd,cAAc;GAChB,CAAC,CACH;EACJ;EACA,IAAI,QAAQ;CACd;CACA,OAAO;AACT;;;;;;;;;AAgBA,SAAS,SAAS,EAChB,MACA,OACA,YACyC;CACzC,IAAI,UAAU,KAAA,GAAW,OAAOI,eAAAA,GAAG,IAAI;CACvC,IAAIC,aAAAA,mBAAmB,KAAK,GAAG,OAAOC,eAAAA,IAAI,MAAM,YAAY;CAC5D,IAAI,YAAY,CAAC,SAAS,IAExB,OAAOA,eAAAA,IAAIC,aAAAA,mBAAmB,UAAU,KAAK,CAAC;CAEhD,IAAI,CAAC,YAAY,iBAAiBC,IAAAA,UAChC,OAAOF,eAAAA,IAAI;EACT,MAAM;EACN,SAAS;CACX,CAAC;CAEH,IAAI,YAAY,iBAAiB,aAC/B,OAAOA,eAAAA,IAAI;EACT,MAAM;EACN,SAAS;CACX,CAAC;CAEH,IAAI,YAAY,iBAAiBE,IAAAA,UAE/B,OAAOF,eAAAA,IAAI;EACT,MAAM;EACN,SAAS;CACX,CAAC;CAEH,MAAM;AACR"}

package/dist/client.d.cts

@@ -0,0 +1,18 @@
+import { ClientConfig } from "./config.cjs";
+import { RustrakError } from "./errors.cjs";
+import { Rustrak } from "./generated/sdk.gen.cjs";
+import { Result } from "./result.cjs";
+//#region src/client.d.ts
+type RequestKeys = 'path' | 'query' | 'body' | 'headers' | 'signal';
+type Call<F> = F extends ((options: infer O) => infer R) ? (...args: {} extends Pick<O, Extract<keyof O, RequestKeys>> ? [options?: Pick<O, Extract<keyof O, RequestKeys>>] : [options: Pick<O, Extract<keyof O, RequestKeys>>]) => Promise<Result<Data<Awaited<R>>, RustrakError>> : never;
+type Data<R> = Extract<R, {
+  error: undefined;
+}> extends {
+  data: infer D;
+} ? D : never;
+type Resource<T> = { readonly [M in keyof T]: Call<T[M]>; };
+export type RustrakClient = { readonly [R in keyof Rustrak]: Resource<Rustrak[R]>; };
+export declare const RustrakClient: new (config: ClientConfig) => RustrakClient;
+//#endregion
+export {};
+//# sourceMappingURL=client.d.cts.map

package/dist/client.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.cts","names":[],"sources":["../src/client.ts"],"mappings":";;;;;KAaK;KAEA,KAAK,KAAK,YAAW,eAAe,YAAY,SAE5C,iBAAiB,KAAK,GAAG,cAAc,GAAG,iBACxC,UAAU,KAAK,GAAG,cAAc,GAAG,kBACnC,SAAS,KAAK,GAAG,cAAc,GAAG,mBACpC,QAAQ,OAAO,KAAK,QAAQ,KAAK;KAIrC,KAAK,KACR,QAAQ;EAAK;;EAA8B,YAAY;IAAM;KAE1D,SAAS,iBAAiB,WAAW,IAAI,KAAK,EAAE;YAQzC,4BACA,WAAW,UAAU,SAAS,QAAQ;qBAkBrC,oBAMX,QAAQ,iBACL"}

package/dist/client.d.mts

@@ -0,0 +1,18 @@
+import { ClientConfig } from "./config.mjs";
+import { RustrakError } from "./errors.mjs";
+import { Rustrak } from "./generated/sdk.gen.mjs";
+import { Result } from "./result.mjs";
+//#region src/client.d.ts
+type RequestKeys = 'path' | 'query' | 'body' | 'headers' | 'signal';
+type Call<F> = F extends ((options: infer O) => infer R) ? (...args: {} extends Pick<O, Extract<keyof O, RequestKeys>> ? [options?: Pick<O, Extract<keyof O, RequestKeys>>] : [options: Pick<O, Extract<keyof O, RequestKeys>>]) => Promise<Result<Data<Awaited<R>>, RustrakError>> : never;
+type Data<R> = Extract<R, {
+  error: undefined;
+}> extends {
+  data: infer D;
+} ? D : never;
+type Resource<T> = { readonly [M in keyof T]: Call<T[M]>; };
+export type RustrakClient = { readonly [R in keyof Rustrak]: Resource<Rustrak[R]>; };
+export declare const RustrakClient: new (config: ClientConfig) => RustrakClient;
+//#endregion
+export {};
+//# sourceMappingURL=client.d.mts.map

package/dist/client.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.mts","names":[],"sources":["../src/client.ts"],"mappings":";;;;;KAaK;KAEA,KAAK,KAAK,YAAW,eAAe,YAAY,SAE5C,iBAAiB,KAAK,GAAG,cAAc,GAAG,iBACxC,UAAU,KAAK,GAAG,cAAc,GAAG,kBACnC,SAAS,KAAK,GAAG,cAAc,GAAG,mBACpC,QAAQ,OAAO,KAAK,QAAQ,KAAK;KAIrC,KAAK,KACR,QAAQ;EAAK;;EAA8B,YAAY;IAAM;KAE1D,SAAS,iBAAiB,WAAW,IAAI,KAAK,EAAE;YAQzC,4BACA,WAAW,UAAU,SAAS,QAAQ;qBAkBrC,oBAMX,QAAQ,iBACL"}

package/dist/client.mjs

@@ -0,0 +1,86 @@
+import { createConfig } from "./generated/client/utils.gen.mjs";
+import { createClient } from "./generated/client/client.gen.mjs";
+import { Rustrak } from "./generated/sdk.gen.mjs";
+import { Err, Ok } from "./result.mjs";
+import { createFetch, isTransportFailure, transformHttpError } from "./utils/http.mjs";
+import { ZodError } from "zod";
+//#region src/client.ts
+/**
+* Main Rustrak API client. Every method returns a `Result`; nothing throws for
+* an expected failure.
+*
+* @example
+* ```typescript
+* const client = new RustrakClient({
+*   baseUrl: 'http://localhost:8080',
+*   token: 'your-api-token',
+* });
+*
+* const issues = await client.issues.list({ path: { project_id: 1 } });
+* if (issues.success) console.log(issues.data.items);
+* ```
+*/
+const RustrakClient = class {
+	constructor(config) {
+		return Object.setPrototypeOf(createApi(config), new.target.prototype);
+	}
+};
+function createApi(config) {
+	const sdk = new Rustrak({ client: createClient(createConfig({
+		baseUrl: config.baseUrl,
+		credentials: "include",
+		fetch: createFetch(config),
+		parseAs: "json",
+		headers: {
+			Accept: "application/json",
+			...config.headers,
+			...config.token && { Authorization: `Bearer ${config.token}` }
+		}
+	})) });
+	const api = {};
+	for (const name of Object.getOwnPropertyNames(Rustrak.prototype)) {
+		if (name === "constructor") continue;
+		const resource = sdk[name];
+		const methods = {};
+		for (const method of Object.getOwnPropertyNames(Object.getPrototypeOf(resource))) {
+			if (method === "constructor") continue;
+			methods[method] = async (options = {}) => toResult(await resource[method]({
+				...options,
+				headers: options.headers instanceof Headers || Array.isArray(options.headers) ? Object.fromEntries(new Headers(options.headers)) : options.headers,
+				throwOnError: false
+			}));
+		}
+		api[name] = methods;
+	}
+	return api;
+}
+/**
+* The boundary: the generated client's `{ data, error, response }` becomes a
+* `Result`.
+*
+* Only failures this file recognises become an `Err`. Anything else, a
+* `TypeError` from a genuine bug, is rethrown so it crashes where it can be
+* debugged instead of being laundered into `{ success: false }`.
+*/
+function toResult({ data, error, response }) {
+	if (error === void 0) return Ok(data);
+	if (isTransportFailure(error)) return Err(error.rustrakError);
+	if (response && !response.ok) return Err(transformHttpError(response, error));
+	if (!response && error instanceof ZodError) return Err({
+		kind: "invalid_request",
+		message: "The request input did not match the expected schema."
+	});
+	if (response && error instanceof SyntaxError) return Err({
+		kind: "invalid_response",
+		message: "The server returned a body that is not valid JSON."
+	});
+	if (response && error instanceof ZodError) return Err({
+		kind: "invalid_response",
+		message: "The server response did not match the expected schema."
+	});
+	throw error;
+}
+//#endregion
+export { RustrakClient };
+
+//# sourceMappingURL=client.mjs.map

package/dist/client.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.mjs","names":[],"sources":["../src/client.ts"],"sourcesContent":["import { ZodError } from 'zod';\nimport type { ClientConfig } from './config.js';\nimport type { RustrakError } from './errors.js';\nimport { createClient, createConfig } from './generated/client/index.js';\nimport { Rustrak } from './generated/sdk.gen.js';\nimport { Err, Ok, type Result } from './result.js';\nimport {\n  createFetch,\n  isTransportFailure,\n  transformHttpError,\n} from './utils/http.js';\n\n/** What a caller may pass: the request's own parts, never client plumbing. */\ntype RequestKeys = 'path' | 'query' | 'body' | 'headers' | 'signal';\n\ntype Call<F> = F extends (options: infer O) => infer R\n  ? (\n      ...args: {} extends Pick<O, Extract<keyof O, RequestKeys>>\n        ? [options?: Pick<O, Extract<keyof O, RequestKeys>>]\n        : [options: Pick<O, Extract<keyof O, RequestKeys>>]\n    ) => Promise<Result<Data<Awaited<R>>, RustrakError>>\n  : never;\n\n/** The success half of the generated `{ data, error }` union. */\ntype Data<R> =\n  Extract<R, { error: undefined }> extends { data: infer D } ? D : never;\n\ntype Resource<T> = { readonly [M in keyof T]: Call<T[M]> };\n\n/**\n * Every operation in `openapi.json`, grouped by tag:\n * `client.issues.list({ path: { project_id } })`.\n *\n * Generated in `src/generated/`; this file only changes what a call returns.\n */\nexport type RustrakClient = {\n  readonly [R in keyof Rustrak]: Resource<Rustrak[R]>;\n};\n\n/**\n * Main Rustrak API client. Every method returns a `Result`; nothing throws for\n * an expected failure.\n *\n * @example\n * ```typescript\n * const client = new RustrakClient({\n *   baseUrl: 'http://localhost:8080',\n *   token: 'your-api-token',\n * });\n *\n * const issues = await client.issues.list({ path: { project_id: 1 } });\n * if (issues.success) console.log(issues.data.items);\n * ```\n */\nexport const RustrakClient = class {\n  constructor(config: ClientConfig) {\n    // biome-ignore lint/correctness/noConstructorReturn: the instance is the generated SDK with every method wrapped\n    return Object.setPrototypeOf(createApi(config), new.target.prototype);\n  }\n} as unknown as new (\n  config: ClientConfig,\n) => RustrakClient;\n\nfunction createApi(config: ClientConfig): RustrakClient {\n  const sdk = new Rustrak({\n    client: createClient(\n      createConfig({\n        baseUrl: config.baseUrl,\n        credentials: 'include',\n        fetch: createFetch(config),\n        // Every 2xx in the spec is JSON or empty. `auto` would hand back an\n        // HTML page or a stream as a success without validating it.\n        parseAs: 'json',\n        headers: {\n          // Without it a content-negotiating hop can answer with HTML.\n          Accept: 'application/json',\n          ...config.headers,\n          ...(config.token && { Authorization: `Bearer ${config.token}` }),\n        },\n      }),\n    ),\n  });\n\n  const api: Record<string, Record<string, unknown>> = {};\n  for (const name of Object.getOwnPropertyNames(Rustrak.prototype)) {\n    if (name === 'constructor') continue;\n    const resource = sdk[name as keyof Rustrak] as unknown as Record<\n      string,\n      (options: object) => Promise<Outcome>\n    >;\n    const methods: Record<string, unknown> = {};\n    for (const method of Object.getOwnPropertyNames(\n      Object.getPrototypeOf(resource),\n    )) {\n      if (method === 'constructor') continue;\n      methods[method] = async (options: { headers?: unknown } = {}) =>\n        toResult(\n          await resource[method]!({\n            ...options,\n            // A JSON write spreads these into an object, which keeps nothing\n            // of a `Headers` or an array of pairs.\n            headers:\n              options.headers instanceof Headers ||\n              Array.isArray(options.headers)\n                ? Object.fromEntries(new Headers(options.headers))\n                : options.headers,\n            throwOnError: false,\n          }),\n        );\n    }\n    api[name] = methods;\n  }\n  return api as unknown as RustrakClient;\n}\n\ntype Outcome = {\n  data?: unknown;\n  error?: unknown;\n  response?: Response;\n};\n\n/**\n * The boundary: the generated client's `{ data, error, response }` becomes a\n * `Result`.\n *\n * Only failures this file recognises become an `Err`. Anything else, a\n * `TypeError` from a genuine bug, is rethrown so it crashes where it can be\n * debugged instead of being laundered into `{ success: false }`.\n */\nfunction toResult({\n  data,\n  error,\n  response,\n}: Outcome): Result<unknown, RustrakError> {\n  if (error === undefined) return Ok(data);\n  if (isTransportFailure(error)) return Err(error.rustrakError);\n  if (response && !response.ok) {\n    // `error` is the parsed body, or its text when it is not JSON.\n    return Err(transformHttpError(response, error));\n  }\n  if (!response && error instanceof ZodError) {\n    return Err({\n      kind: 'invalid_request',\n      message: 'The request input did not match the expected schema.',\n    });\n  }\n  if (response && error instanceof SyntaxError) {\n    return Err({\n      kind: 'invalid_response',\n      message: 'The server returned a body that is not valid JSON.',\n    });\n  }\n  if (response && error instanceof ZodError) {\n    // No Zod issues: they embed the offending response data.\n    return Err({\n      kind: 'invalid_response',\n      message: 'The server response did not match the expected schema.',\n    });\n  }\n  throw error;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAsDA,MAAa,gBAAgB,MAAM;CACjC,YAAY,QAAsB;EAEhC,OAAO,OAAO,eAAe,UAAU,MAAM,GAAG,WAAW,SAAS;CACtE;AACF;AAIA,SAAS,UAAU,QAAqC;CACtD,MAAM,MAAM,IAAI,QAAQ,EACtB,QAAQ,aACN,aAAa;EACX,SAAS,OAAO;EAChB,aAAa;EACb,OAAO,YAAY,MAAM;EAGzB,SAAS;EACT,SAAS;GAEP,QAAQ;GACR,GAAG,OAAO;GACV,GAAI,OAAO,SAAS,EAAE,eAAe,UAAU,OAAO,QAAQ;EAChE;CACF,CAAC,CACH,EACF,CAAC;CAED,MAAM,MAA+C,CAAC;CACtD,KAAK,MAAM,QAAQ,OAAO,oBAAoB,QAAQ,SAAS,GAAG;EAChE,IAAI,SAAS,eAAe;EAC5B,MAAM,WAAW,IAAI;EAIrB,MAAM,UAAmC,CAAC;EAC1C,KAAK,MAAM,UAAU,OAAO,oBAC1B,OAAO,eAAe,QAAQ,CAChC,GAAG;GACD,IAAI,WAAW,eAAe;GAC9B,QAAQ,UAAU,OAAO,UAAiC,CAAC,MACzD,SACE,MAAM,SAAS,OAAO,CAAE;IACtB,GAAG;IAGH,SACE,QAAQ,mBAAmB,WAC3B,MAAM,QAAQ,QAAQ,OAAO,IACzB,OAAO,YAAY,IAAI,QAAQ,QAAQ,OAAO,CAAC,IAC/C,QAAQ;IACd,cAAc;GAChB,CAAC,CACH;EACJ;EACA,IAAI,QAAQ;CACd;CACA,OAAO;AACT;;;;;;;;;AAgBA,SAAS,SAAS,EAChB,MACA,OACA,YACyC;CACzC,IAAI,UAAU,KAAA,GAAW,OAAO,GAAG,IAAI;CACvC,IAAI,mBAAmB,KAAK,GAAG,OAAO,IAAI,MAAM,YAAY;CAC5D,IAAI,YAAY,CAAC,SAAS,IAExB,OAAO,IAAI,mBAAmB,UAAU,KAAK,CAAC;CAEhD,IAAI,CAAC,YAAY,iBAAiB,UAChC,OAAO,IAAI;EACT,MAAM;EACN,SAAS;CACX,CAAC;CAEH,IAAI,YAAY,iBAAiB,aAC/B,OAAO,IAAI;EACT,MAAM;EACN,SAAS;CACX,CAAC;CAEH,IAAI,YAAY,iBAAiB,UAE/B,OAAO,IAAI;EACT,MAAM;EACN,SAAS;CACX,CAAC;CAEH,MAAM;AACR"}

package/dist/config.d.cts

@@ -0,0 +1,10 @@
+//#region src/config.d.ts
+export interface ClientConfig {
+  baseUrl: string;
+  token?: string;
+  timeout?: number;
+  maxRetries?: number;
+  headers?: Record<string, string>;
+}
+//#endregion
+//# sourceMappingURL=config.d.cts.map

package/dist/config.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.cts","names":[],"sources":["../src/config.ts"],"mappings":";iBAGiB;EAKf;EAOA;EAMA;EAMA;EAKA,UAAU"}

package/dist/config.d.mts

@@ -0,0 +1,10 @@
+//#region src/config.d.ts
+export interface ClientConfig {
+  baseUrl: string;
+  token?: string;
+  timeout?: number;
+  maxRetries?: number;
+  headers?: Record<string, string>;
+}
+//#endregion
+//# sourceMappingURL=config.d.mts.map

package/dist/config.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.mts","names":[],"sources":["../src/config.ts"],"mappings":";iBAGiB;EAKf;EAOA;EAMA;EAMA;EAKA,UAAU"}

package/dist/errors.cjs

@@ -0,0 +1,52 @@
+//#region src/errors.ts
+/**
+* Every `code` a {@link FieldError} may carry, mirroring the `FieldErrorCode`
+* enum in `apps/server/src/error.rs`.
+*
+* Deliberately tiny and resource-agnostic. `tests/unit/app-error-contract.test.ts`
+* parses that Rust enum and fails if this list stops matching it, so a variant
+* added on the server cannot ship without a matching entry here.
+*
+* Exported as a value, not only a type, so a consumer can exhaustively switch
+* or validate against it at runtime.
+*/
+const FIELD_ERROR_CODES = [
+	"required",
+	"invalid",
+	"already_exists",
+	"too_short",
+	"too_long",
+	"custom"
+];
+/**
+* The fixed message every `server_error` carries. Exported so a consumer (or a
+* test) can assert that nothing server-supplied survived the 5xx redaction.
+*/
+const SERVER_ERROR_MESSAGE = "The server failed to handle the request.";
+/**
+* The fixed message a `network` error carries when the request never reached
+* the server. Fixed for the same reason as {@link SERVER_ERROR_MESSAGE}: the
+* underlying message interpolates the request URL, which is the deployment's
+* internal host and port. Read `reason` to branch, not `message`.
+*/
+const NETWORK_ERROR_MESSAGE = "The request could not reach the server.";
+/** The fixed message a `network` error carries when the client timed out. */
+const TIMEOUT_ERROR_MESSAGE = "The request timed out.";
+/**
+* Whether retrying the same call could plausibly succeed.
+*
+* `network` and `server_error` are transient by nature; `rate_limited` clears
+* once its window rolls over. Everything else is deterministic: the same
+* request will fail the same way.
+*/
+function isRetryable(error) {
+	return error.kind === "network" || error.kind === "server_error" || error.kind === "rate_limited";
+}
+//#endregion
+exports.FIELD_ERROR_CODES = FIELD_ERROR_CODES;
+exports.NETWORK_ERROR_MESSAGE = NETWORK_ERROR_MESSAGE;
+exports.SERVER_ERROR_MESSAGE = SERVER_ERROR_MESSAGE;
+exports.TIMEOUT_ERROR_MESSAGE = TIMEOUT_ERROR_MESSAGE;
+exports.isRetryable = isRetryable;
+
+//# sourceMappingURL=errors.cjs.map

package/dist/errors.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.cjs","names":[],"sources":["../src/errors.ts"],"sourcesContent":["/**\n * The one closed error union `@rustrak/client` reports.\n *\n * It mirrors `apps/server/src/error.rs` variant by variant, plus the three\n * failures that never reach the server (`invalid_request`, `network`,\n * `invalid_response`) and a catch-all so an unanticipated status is still\n * representable rather than unrepresentable.\n *\n * Every member is a plain object: no class, no prototype chain, no `Error`\n * instance. That is what lets a failed `Result` survive `structuredClone` and\n * therefore React's server/client boundary.\n *\n * `status` is `number`, never a literal union. Pinning literals would make a\n * proxy-generated 502 or a future status a type error at the call site rather\n * than a value the consumer can log.\n *\n * `fields` appears on every member that can carry an `AppError` body, because\n * `AppError::with_field` works on all eight Rust variants: a `Forbidden` or a\n * `NotFound` may name an input just as a `Conflict` does. Only the members\n * that never carry a server body at all (`server_error`, which discards it,\n * plus `invalid_request`, `network` and `invalid_response`, which never had\n * one) omit it. See {@link FieldError}.\n */\nexport type RustrakError =\n  /**\n   * 400. `AppError::Validation`: the server rejected the request.\n   *\n   * `fields` is present only when the server named the offending inputs; a\n   * consumer that ignores it behaves exactly as it did before.\n   */\n  | {\n      readonly kind: 'validation';\n      readonly status: number;\n      readonly message: string;\n      readonly fields?: readonly FieldError[];\n    }\n  /** 401. `AppError::Unauthorized`: no session, or the session expired. */\n  | {\n      readonly kind: 'unauthenticated';\n      readonly status: number;\n      readonly message: string;\n      readonly fields?: readonly FieldError[];\n    }\n  /** 403. `AppError::Forbidden`: authenticated, but not allowed. */\n  | {\n      readonly kind: 'forbidden';\n      readonly status: number;\n      readonly message: string;\n      readonly fields?: readonly FieldError[];\n    }\n  /** 404. `AppError::NotFound`. */\n  | {\n      readonly kind: 'not_found';\n      readonly status: number;\n      readonly message: string;\n      readonly fields?: readonly FieldError[];\n    }\n  /**\n   * 409. `AppError::Conflict`.\n   *\n   * Where `fields` earns its keep: uniqueness is the thing only the server can\n   * know, and a taken name or slug is a 409, not a 400.\n   */\n  | {\n      readonly kind: 'conflict';\n      readonly status: number;\n      readonly message: string;\n      readonly fields?: readonly FieldError[];\n    }\n  /** 410. Reserved for endpoints that retire a resource rather than delete it. */\n  | {\n      readonly kind: 'gone';\n      readonly status: number;\n      readonly message: string;\n      readonly fields?: readonly FieldError[];\n    }\n  /** 413. `AppError::PayloadTooLarge`: envelope ingestion only. */\n  | {\n      readonly kind: 'payload_too_large';\n      readonly status: number;\n      readonly message: string;\n      readonly fields?: readonly FieldError[];\n    }\n  /** 429. The ingest rate limiter (`routes/ingest.rs`), the one flat body. */\n  | {\n      readonly kind: 'rate_limited';\n      readonly status: number;\n      readonly message: string;\n      /** Seconds to wait, from the `Retry-After` header, when the server sent one. */\n      readonly retryAfter?: number;\n      readonly fields?: readonly FieldError[];\n    }\n  /**\n   * Any status below 500 that no other member claims. The catch-all that keeps\n   * the union closed but total.\n   *\n   * Not only 4xx: a 3xx that reached the error path (a redirect ky did not\n   * follow), a 408, an unenumerated 4xx, and an opaque `status: 0` all land\n   * here. `status` is the field to read; `kind` only says \"no dedicated\n   * handling exists for this one\".\n   */\n  | {\n      readonly kind: 'client_error';\n      readonly status: number;\n      readonly message: string;\n      readonly fields?: readonly FieldError[];\n    }\n  /**\n   * The caller's own input failed a pre-flight check. Never reached the\n   * network, so it has no status.\n   */\n  | { readonly kind: 'invalid_request'; readonly message: string }\n  /**\n   * Any 5xx. `AppError::Database` and `AppError::Internal` both land here, and\n   * so does anything a reverse proxy generates.\n   *\n   * `message` is always {@link SERVER_ERROR_MESSAGE}: the server's body is\n   * discarded at construction, inside the client, so no consumer can leak a\n   * connection string or a filesystem path into a UI. `incidentId` is the\n   * forward-compatible slot for a correlation id the server does not send yet.\n   */\n  | {\n      readonly kind: 'server_error';\n      readonly status: number;\n      readonly message: string;\n      readonly incidentId?: string;\n    }\n  /**\n   * The request never got an HTTP response: DNS, connection refused, TLS,\n   * timeout, abort. Also a connection that died while the body was still being\n   * read, which is a transport failure even though a status line arrived.\n   *\n   * `message` is always {@link NETWORK_ERROR_MESSAGE} or\n   * {@link TIMEOUT_ERROR_MESSAGE}, never the underlying error's own: fetch\n   * builds that message by interpolating the request method and URL\n   * (`Request failed due to a network error: GET http://rustrak.internal:8080/api/projects`),\n   * so echoing it prints a self-hosted deployment's internal host and port into\n   * any UI that renders `error.message`.\n   *\n   * Carries no `cause` for the same reason. `reason` is the machine-readable\n   * discriminator a caller needs instead, derived from the error's `name` and\n   * never from its message.\n   */\n  | {\n      readonly kind: 'network';\n      readonly message: string;\n      /** `timeout` when the client gave up waiting; `unreachable` otherwise. */\n      readonly reason: 'timeout' | 'unreachable';\n    }\n  /**\n   * A 2xx arrived but the body is not what the schema promises: not JSON, or\n   * JSON of the wrong shape.\n   *\n   * Carries no Zod issues: they embed the offending response data.\n   */\n  | { readonly kind: 'invalid_response'; readonly message: string };\n\n/** The `kind` discriminant, useful for exhaustive `switch` in consumers. */\nexport type RustrakErrorKind = RustrakError['kind'];\n\n/**\n * Every `code` a {@link FieldError} may carry, mirroring the `FieldErrorCode`\n * enum in `apps/server/src/error.rs`.\n *\n * Deliberately tiny and resource-agnostic. `tests/unit/app-error-contract.test.ts`\n * parses that Rust enum and fails if this list stops matching it, so a variant\n * added on the server cannot ship without a matching entry here.\n *\n * Exported as a value, not only a type, so a consumer can exhaustively switch\n * or validate against it at runtime.\n */\nexport const FIELD_ERROR_CODES = [\n  'required',\n  'invalid',\n  'already_exists',\n  'too_short',\n  'too_long',\n  'custom',\n] as const;\n\n/** The `code` of a {@link FieldError}. */\nexport type FieldErrorCode = (typeof FIELD_ERROR_CODES)[number];\n\n/**\n * One input the server rejected, named as data.\n *\n * `field` is a **dot path into the request body** (`slug`,\n * `credentials.webhook_url`), which is exactly what a form library's\n * `setError` takes.\n *\n * Select the copy shown to the user from `(field, code)` and never from\n * `message`: that is what makes it translatable. `message` is populated only\n * for `code: 'custom'`, where the code set genuinely cannot express the\n * reason, and is then rendered verbatim. The client strips a `message` that\n * arrives on any other code, so the rule holds even against a server that\n * breaks it.\n *\n * The same `(field, code)` pair can mean two things at two statuses:\n * `(role, 'invalid')` is \"not a role at all\" on a 400 and \"a real role, but\n * not acceptable right now\" on a 409. Branch on `kind` as well when the copy\n * has to differ.\n *\n * A `field` naming an input the form does not have must fall back to a\n * form-level error. Passing an unknown path to `setError` registers a\n * phantom field that nothing can ever clear.\n */\nexport type FieldError = {\n  readonly field: string;\n  readonly code: FieldErrorCode;\n  readonly message?: string;\n};\n\n/**\n * The fixed message every `server_error` carries. Exported so a consumer (or a\n * test) can assert that nothing server-supplied survived the 5xx redaction.\n */\nexport const SERVER_ERROR_MESSAGE = 'The server failed to handle the request.';\n\n/**\n * The fixed message a `network` error carries when the request never reached\n * the server. Fixed for the same reason as {@link SERVER_ERROR_MESSAGE}: the\n * underlying message interpolates the request URL, which is the deployment's\n * internal host and port. Read `reason` to branch, not `message`.\n */\nexport const NETWORK_ERROR_MESSAGE = 'The request could not reach the server.';\n\n/** The fixed message a `network` error carries when the client timed out. */\nexport const TIMEOUT_ERROR_MESSAGE = 'The request timed out.';\n\n/**\n * Whether retrying the same call could plausibly succeed.\n *\n * `network` and `server_error` are transient by nature; `rate_limited` clears\n * once its window rolls over. Everything else is deterministic: the same\n * request will fail the same way.\n */\nexport function isRetryable(error: RustrakError): boolean {\n  return (\n    error.kind === 'network' ||\n    error.kind === 'server_error' ||\n    error.kind === 'rate_limited'\n  );\n}\n"],"mappings":";;;;;;;;;;;;AA2KA,MAAa,oBAAoB;CAC/B;CACA;CACA;CACA;CACA;CACA;AACF;;;;;AAsCA,MAAa,uBAAuB;;;;;;;AAQpC,MAAa,wBAAwB;;AAGrC,MAAa,wBAAwB;;;;;;;;AASrC,SAAgB,YAAY,OAA8B;CACxD,OACE,MAAM,SAAS,aACf,MAAM,SAAS,kBACf,MAAM,SAAS;AAEnB"}

package/dist/errors.d.cts

@@ -0,0 +1,77 @@
+//#region src/errors.d.ts
+export type RustrakError = {
+  readonly kind: 'validation';
+  readonly status: number;
+  readonly message: string;
+  readonly fields?: readonly FieldError[];
+} | {
+  readonly kind: 'unauthenticated';
+  readonly status: number;
+  readonly message: string;
+  readonly fields?: readonly FieldError[];
+} | {
+  readonly kind: 'forbidden';
+  readonly status: number;
+  readonly message: string;
+  readonly fields?: readonly FieldError[];
+} | {
+  readonly kind: 'not_found';
+  readonly status: number;
+  readonly message: string;
+  readonly fields?: readonly FieldError[];
+} | {
+  readonly kind: 'conflict';
+  readonly status: number;
+  readonly message: string;
+  readonly fields?: readonly FieldError[];
+} | {
+  readonly kind: 'gone';
+  readonly status: number;
+  readonly message: string;
+  readonly fields?: readonly FieldError[];
+} | {
+  readonly kind: 'payload_too_large';
+  readonly status: number;
+  readonly message: string;
+  readonly fields?: readonly FieldError[];
+} | {
+  readonly kind: 'rate_limited';
+  readonly status: number;
+  readonly message: string;
+  readonly retryAfter?: number;
+  readonly fields?: readonly FieldError[];
+} | {
+  readonly kind: 'client_error';
+  readonly status: number;
+  readonly message: string;
+  readonly fields?: readonly FieldError[];
+} | {
+  readonly kind: 'invalid_request';
+  readonly message: string;
+} | {
+  readonly kind: 'server_error';
+  readonly status: number;
+  readonly message: string;
+  readonly incidentId?: string;
+} | {
+  readonly kind: 'network';
+  readonly message: string;
+  readonly reason: 'timeout' | 'unreachable';
+} | {
+  readonly kind: 'invalid_response';
+  readonly message: string;
+};
+export type RustrakErrorKind = RustrakError['kind'];
+export declare const FIELD_ERROR_CODES: readonly ["required", "invalid", "already_exists", "too_short", "too_long", "custom"];
+export type FieldErrorCode = (typeof FIELD_ERROR_CODES)[number];
+export type FieldError = {
+  readonly field: string;
+  readonly code: FieldErrorCode;
+  readonly message?: string;
+};
+export declare const SERVER_ERROR_MESSAGE = "The server failed to handle the request.";
+export declare const NETWORK_ERROR_MESSAGE = "The request could not reach the server.";
+export declare const TIMEOUT_ERROR_MESSAGE = "The request timed out.";
+export declare function isRetryable(error: RustrakError): boolean;
+//#endregion
+//# sourceMappingURL=errors.d.cts.map

package/dist/errors.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.cts","names":[],"sources":["../src/errors.ts"],"mappings":";YAuBY;WAQG;WACA;WACA;WACA,kBAAkB;;WAIlB;WACA;WACA;WACA,kBAAkB;;WAIlB;WACA;WACA;WACA,kBAAkB;;WAIlB;WACA;WACA;WACA,kBAAkB;;WASlB;WACA;WACA;WACA,kBAAkB;;WAIlB;WACA;WACA;WACA,kBAAkB;;WAIlB;WACA;WACA;WACA,kBAAkB;;WAIlB;WACA;WACA;WAEA;WACA,kBAAkB;;WAYlB;WACA;WACA;WACA,kBAAkB;;WAMlB;WAAkC;;WAWlC;WACA;WACA;WACA;;WAmBA;WACA;WAEA;;WAQA;WAAmC;;YAGtC,mBAAmB;qBAalB;YAUD,yBAAyB;YAyBzB;WACD;WACA,MAAM;WACN;;qBAOE;qBAQA;qBAGA;wBASG,YAAY,OAAO"}

package/dist/errors.d.mts

@@ -0,0 +1,77 @@
+//#region src/errors.d.ts
+export type RustrakError = {
+  readonly kind: 'validation';
+  readonly status: number;
+  readonly message: string;
+  readonly fields?: readonly FieldError[];
+} | {
+  readonly kind: 'unauthenticated';
+  readonly status: number;
+  readonly message: string;
+  readonly fields?: readonly FieldError[];
+} | {
+  readonly kind: 'forbidden';
+  readonly status: number;
+  readonly message: string;
+  readonly fields?: readonly FieldError[];
+} | {
+  readonly kind: 'not_found';
+  readonly status: number;
+  readonly message: string;
+  readonly fields?: readonly FieldError[];
+} | {
+  readonly kind: 'conflict';
+  readonly status: number;
+  readonly message: string;
+  readonly fields?: readonly FieldError[];
+} | {
+  readonly kind: 'gone';
+  readonly status: number;
+  readonly message: string;
+  readonly fields?: readonly FieldError[];
+} | {
+  readonly kind: 'payload_too_large';
+  readonly status: number;
+  readonly message: string;
+  readonly fields?: readonly FieldError[];
+} | {
+  readonly kind: 'rate_limited';
+  readonly status: number;
+  readonly message: string;
+  readonly retryAfter?: number;
+  readonly fields?: readonly FieldError[];
+} | {
+  readonly kind: 'client_error';
+  readonly status: number;
+  readonly message: string;
+  readonly fields?: readonly FieldError[];
+} | {
+  readonly kind: 'invalid_request';
+  readonly message: string;
+} | {
+  readonly kind: 'server_error';
+  readonly status: number;
+  readonly message: string;
+  readonly incidentId?: string;
+} | {
+  readonly kind: 'network';
+  readonly message: string;
+  readonly reason: 'timeout' | 'unreachable';
+} | {
+  readonly kind: 'invalid_response';
+  readonly message: string;
+};
+export type RustrakErrorKind = RustrakError['kind'];
+export declare const FIELD_ERROR_CODES: readonly ["required", "invalid", "already_exists", "too_short", "too_long", "custom"];
+export type FieldErrorCode = (typeof FIELD_ERROR_CODES)[number];
+export type FieldError = {
+  readonly field: string;
+  readonly code: FieldErrorCode;
+  readonly message?: string;
+};
+export declare const SERVER_ERROR_MESSAGE = "The server failed to handle the request.";
+export declare const NETWORK_ERROR_MESSAGE = "The request could not reach the server.";
+export declare const TIMEOUT_ERROR_MESSAGE = "The request timed out.";
+export declare function isRetryable(error: RustrakError): boolean;
+//#endregion
+//# sourceMappingURL=errors.d.mts.map

package/dist/errors.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.mts","names":[],"sources":["../src/errors.ts"],"mappings":";YAuBY;WAQG;WACA;WACA;WACA,kBAAkB;;WAIlB;WACA;WACA;WACA,kBAAkB;;WAIlB;WACA;WACA;WACA,kBAAkB;;WAIlB;WACA;WACA;WACA,kBAAkB;;WASlB;WACA;WACA;WACA,kBAAkB;;WAIlB;WACA;WACA;WACA,kBAAkB;;WAIlB;WACA;WACA;WACA,kBAAkB;;WAIlB;WACA;WACA;WAEA;WACA,kBAAkB;;WAYlB;WACA;WACA;WACA,kBAAkB;;WAMlB;WAAkC;;WAWlC;WACA;WACA;WACA;;WAmBA;WACA;WAEA;;WAQA;WAAmC;;YAGtC,mBAAmB;qBAalB;YAUD,yBAAyB;YAyBzB;WACD;WACA,MAAM;WACN;;qBAOE;qBAQA;qBAGA;wBASG,YAAY,OAAO"}

package/dist/errors.mjs

@@ -0,0 +1,48 @@
+//#region src/errors.ts
+/**
+* Every `code` a {@link FieldError} may carry, mirroring the `FieldErrorCode`
+* enum in `apps/server/src/error.rs`.
+*
+* Deliberately tiny and resource-agnostic. `tests/unit/app-error-contract.test.ts`
+* parses that Rust enum and fails if this list stops matching it, so a variant
+* added on the server cannot ship without a matching entry here.
+*
+* Exported as a value, not only a type, so a consumer can exhaustively switch
+* or validate against it at runtime.
+*/
+const FIELD_ERROR_CODES = [
+	"required",
+	"invalid",
+	"already_exists",
+	"too_short",
+	"too_long",
+	"custom"
+];
+/**
+* The fixed message every `server_error` carries. Exported so a consumer (or a
+* test) can assert that nothing server-supplied survived the 5xx redaction.
+*/
+const SERVER_ERROR_MESSAGE = "The server failed to handle the request.";
+/**
+* The fixed message a `network` error carries when the request never reached
+* the server. Fixed for the same reason as {@link SERVER_ERROR_MESSAGE}: the
+* underlying message interpolates the request URL, which is the deployment's
+* internal host and port. Read `reason` to branch, not `message`.
+*/
+const NETWORK_ERROR_MESSAGE = "The request could not reach the server.";
+/** The fixed message a `network` error carries when the client timed out. */
+const TIMEOUT_ERROR_MESSAGE = "The request timed out.";
+/**
+* Whether retrying the same call could plausibly succeed.
+*
+* `network` and `server_error` are transient by nature; `rate_limited` clears
+* once its window rolls over. Everything else is deterministic: the same
+* request will fail the same way.
+*/
+function isRetryable(error) {
+	return error.kind === "network" || error.kind === "server_error" || error.kind === "rate_limited";
+}
+//#endregion
+export { FIELD_ERROR_CODES, NETWORK_ERROR_MESSAGE, SERVER_ERROR_MESSAGE, TIMEOUT_ERROR_MESSAGE, isRetryable };
+
+//# sourceMappingURL=errors.mjs.map

package/dist/errors.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.mjs","names":[],"sources":["../src/errors.ts"],"sourcesContent":["/**\n * The one closed error union `@rustrak/client` reports.\n *\n * It mirrors `apps/server/src/error.rs` variant by variant, plus the three\n * failures that never reach the server (`invalid_request`, `network`,\n * `invalid_response`) and a catch-all so an unanticipated status is still\n * representable rather than unrepresentable.\n *\n * Every member is a plain object: no class, no prototype chain, no `Error`\n * instance. That is what lets a failed `Result` survive `structuredClone` and\n * therefore React's server/client boundary.\n *\n * `status` is `number`, never a literal union. Pinning literals would make a\n * proxy-generated 502 or a future status a type error at the call site rather\n * than a value the consumer can log.\n *\n * `fields` appears on every member that can carry an `AppError` body, because\n * `AppError::with_field` works on all eight Rust variants: a `Forbidden` or a\n * `NotFound` may name an input just as a `Conflict` does. Only the members\n * that never carry a server body at all (`server_error`, which discards it,\n * plus `invalid_request`, `network` and `invalid_response`, which never had\n * one) omit it. See {@link FieldError}.\n */\nexport type RustrakError =\n  /**\n   * 400. `AppError::Validation`: the server rejected the request.\n   *\n   * `fields` is present only when the server named the offending inputs; a\n   * consumer that ignores it behaves exactly as it did before.\n   */\n  | {\n      readonly kind: 'validation';\n      readonly status: number;\n      readonly message: string;\n      readonly fields?: readonly FieldError[];\n    }\n  /** 401. `AppError::Unauthorized`: no session, or the session expired. */\n  | {\n      readonly kind: 'unauthenticated';\n      readonly status: number;\n      readonly message: string;\n      readonly fields?: readonly FieldError[];\n    }\n  /** 403. `AppError::Forbidden`: authenticated, but not allowed. */\n  | {\n      readonly kind: 'forbidden';\n      readonly status: number;\n      readonly message: string;\n      readonly fields?: readonly FieldError[];\n    }\n  /** 404. `AppError::NotFound`. */\n  | {\n      readonly kind: 'not_found';\n      readonly status: number;\n      readonly message: string;\n      readonly fields?: readonly FieldError[];\n    }\n  /**\n   * 409. `AppError::Conflict`.\n   *\n   * Where `fields` earns its keep: uniqueness is the thing only the server can\n   * know, and a taken name or slug is a 409, not a 400.\n   */\n  | {\n      readonly kind: 'conflict';\n      readonly status: number;\n      readonly message: string;\n      readonly fields?: readonly FieldError[];\n    }\n  /** 410. Reserved for endpoints that retire a resource rather than delete it. */\n  | {\n      readonly kind: 'gone';\n      readonly status: number;\n      readonly message: string;\n      readonly fields?: readonly FieldError[];\n    }\n  /** 413. `AppError::PayloadTooLarge`: envelope ingestion only. */\n  | {\n      readonly kind: 'payload_too_large';\n      readonly status: number;\n      readonly message: string;\n      readonly fields?: readonly FieldError[];\n    }\n  /** 429. The ingest rate limiter (`routes/ingest.rs`), the one flat body. */\n  | {\n      readonly kind: 'rate_limited';\n      readonly status: number;\n      readonly message: string;\n      /** Seconds to wait, from the `Retry-After` header, when the server sent one. */\n      readonly retryAfter?: number;\n      readonly fields?: readonly FieldError[];\n    }\n  /**\n   * Any status below 500 that no other member claims. The catch-all that keeps\n   * the union closed but total.\n   *\n   * Not only 4xx: a 3xx that reached the error path (a redirect ky did not\n   * follow), a 408, an unenumerated 4xx, and an opaque `status: 0` all land\n   * here. `status` is the field to read; `kind` only says \"no dedicated\n   * handling exists for this one\".\n   */\n  | {\n      readonly kind: 'client_error';\n      readonly status: number;\n      readonly message: string;\n      readonly fields?: readonly FieldError[];\n    }\n  /**\n   * The caller's own input failed a pre-flight check. Never reached the\n   * network, so it has no status.\n   */\n  | { readonly kind: 'invalid_request'; readonly message: string }\n  /**\n   * Any 5xx. `AppError::Database` and `AppError::Internal` both land here, and\n   * so does anything a reverse proxy generates.\n   *\n   * `message` is always {@link SERVER_ERROR_MESSAGE}: the server's body is\n   * discarded at construction, inside the client, so no consumer can leak a\n   * connection string or a filesystem path into a UI. `incidentId` is the\n   * forward-compatible slot for a correlation id the server does not send yet.\n   */\n  | {\n      readonly kind: 'server_error';\n      readonly status: number;\n      readonly message: string;\n      readonly incidentId?: string;\n    }\n  /**\n   * The request never got an HTTP response: DNS, connection refused, TLS,\n   * timeout, abort. Also a connection that died while the body was still being\n   * read, which is a transport failure even though a status line arrived.\n   *\n   * `message` is always {@link NETWORK_ERROR_MESSAGE} or\n   * {@link TIMEOUT_ERROR_MESSAGE}, never the underlying error's own: fetch\n   * builds that message by interpolating the request method and URL\n   * (`Request failed due to a network error: GET http://rustrak.internal:8080/api/projects`),\n   * so echoing it prints a self-hosted deployment's internal host and port into\n   * any UI that renders `error.message`.\n   *\n   * Carries no `cause` for the same reason. `reason` is the machine-readable\n   * discriminator a caller needs instead, derived from the error's `name` and\n   * never from its message.\n   */\n  | {\n      readonly kind: 'network';\n      readonly message: string;\n      /** `timeout` when the client gave up waiting; `unreachable` otherwise. */\n      readonly reason: 'timeout' | 'unreachable';\n    }\n  /**\n   * A 2xx arrived but the body is not what the schema promises: not JSON, or\n   * JSON of the wrong shape.\n   *\n   * Carries no Zod issues: they embed the offending response data.\n   */\n  | { readonly kind: 'invalid_response'; readonly message: string };\n\n/** The `kind` discriminant, useful for exhaustive `switch` in consumers. */\nexport type RustrakErrorKind = RustrakError['kind'];\n\n/**\n * Every `code` a {@link FieldError} may carry, mirroring the `FieldErrorCode`\n * enum in `apps/server/src/error.rs`.\n *\n * Deliberately tiny and resource-agnostic. `tests/unit/app-error-contract.test.ts`\n * parses that Rust enum and fails if this list stops matching it, so a variant\n * added on the server cannot ship without a matching entry here.\n *\n * Exported as a value, not only a type, so a consumer can exhaustively switch\n * or validate against it at runtime.\n */\nexport const FIELD_ERROR_CODES = [\n  'required',\n  'invalid',\n  'already_exists',\n  'too_short',\n  'too_long',\n  'custom',\n] as const;\n\n/** The `code` of a {@link FieldError}. */\nexport type FieldErrorCode = (typeof FIELD_ERROR_CODES)[number];\n\n/**\n * One input the server rejected, named as data.\n *\n * `field` is a **dot path into the request body** (`slug`,\n * `credentials.webhook_url`), which is exactly what a form library's\n * `setError` takes.\n *\n * Select the copy shown to the user from `(field, code)` and never from\n * `message`: that is what makes it translatable. `message` is populated only\n * for `code: 'custom'`, where the code set genuinely cannot express the\n * reason, and is then rendered verbatim. The client strips a `message` that\n * arrives on any other code, so the rule holds even against a server that\n * breaks it.\n *\n * The same `(field, code)` pair can mean two things at two statuses:\n * `(role, 'invalid')` is \"not a role at all\" on a 400 and \"a real role, but\n * not acceptable right now\" on a 409. Branch on `kind` as well when the copy\n * has to differ.\n *\n * A `field` naming an input the form does not have must fall back to a\n * form-level error. Passing an unknown path to `setError` registers a\n * phantom field that nothing can ever clear.\n */\nexport type FieldError = {\n  readonly field: string;\n  readonly code: FieldErrorCode;\n  readonly message?: string;\n};\n\n/**\n * The fixed message every `server_error` carries. Exported so a consumer (or a\n * test) can assert that nothing server-supplied survived the 5xx redaction.\n */\nexport const SERVER_ERROR_MESSAGE = 'The server failed to handle the request.';\n\n/**\n * The fixed message a `network` error carries when the request never reached\n * the server. Fixed for the same reason as {@link SERVER_ERROR_MESSAGE}: the\n * underlying message interpolates the request URL, which is the deployment's\n * internal host and port. Read `reason` to branch, not `message`.\n */\nexport const NETWORK_ERROR_MESSAGE = 'The request could not reach the server.';\n\n/** The fixed message a `network` error carries when the client timed out. */\nexport const TIMEOUT_ERROR_MESSAGE = 'The request timed out.';\n\n/**\n * Whether retrying the same call could plausibly succeed.\n *\n * `network` and `server_error` are transient by nature; `rate_limited` clears\n * once its window rolls over. Everything else is deterministic: the same\n * request will fail the same way.\n */\nexport function isRetryable(error: RustrakError): boolean {\n  return (\n    error.kind === 'network' ||\n    error.kind === 'server_error' ||\n    error.kind === 'rate_limited'\n  );\n}\n"],"mappings":";;;;;;;;;;;;AA2KA,MAAa,oBAAoB;CAC/B;CACA;CACA;CACA;CACA;CACA;AACF;;;;;AAsCA,MAAa,uBAAuB;;;;;;;AAQpC,MAAa,wBAAwB;;AAGrC,MAAa,wBAAwB;;;;;;;;AASrC,SAAgB,YAAY,OAA8B;CACxD,OACE,MAAM,SAAS,aACf,MAAM,SAAS,kBACf,MAAM,SAAS;AAEnB"}