@ariestools/sdk 7.0.3

package/dist/_pkg/fetch/neutral/index.d.ts

@@ -0,0 +1,11 @@
+export type { FetchClientConfig, FetchClientRequestConfig } from './FetchClient.ts';
+export { FetchClient, FetchClientError } from './FetchClient.ts';
+export type { FetchCompressOptions } from './fetchCompress.ts';
+export { fetchCompress } from './fetchCompress.ts';
+export type { FetchErrorContext, FetchErrorJson, FetchErrorType, } from './FetchError.ts';
+export { classifyFetchError, FetchError, isFetchError, toFetchError, } from './FetchError.ts';
+export { fetchJson } from './fetchJson.ts';
+export { FetchJsonClient, fetchJsonClient } from './FetchJsonClient.ts';
+export { fetchJsonDelete, fetchJsonGet, fetchJsonPatch, fetchJsonPost, fetchJsonPut, } from './methods.ts';
+export type { FetchJsonOptions, FetchJsonResponse } from './types.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/fetch/neutral/index.mjs

@@ -0,0 +1,365 @@
+// src/FetchError.ts
+var fetchErrorMarker = "$$xylabs-fetch-error";
+var codeTypes = {
+  ENOTFOUND: "dns",
+  EAI_AGAIN: "dns",
+  ECONNREFUSED: "connection-refused",
+  ECONNRESET: "connection-reset",
+  EPIPE: "connection-reset",
+  ETIMEDOUT: "connection-timeout",
+  UND_ERR_CONNECT_TIMEOUT: "connection-timeout",
+  UND_ERR_HEADERS_TIMEOUT: "timeout",
+  UND_ERR_BODY_TIMEOUT: "timeout",
+  EHOSTUNREACH: "unreachable",
+  ENETUNREACH: "unreachable",
+  CERT_HAS_EXPIRED: "tls",
+  DEPTH_ZERO_SELF_SIGNED_CERT: "tls",
+  UNABLE_TO_VERIFY_LEAF_SIGNATURE: "tls",
+  SELF_SIGNED_CERT_IN_CHAIN: "tls",
+  ERR_TLS_CERT_ALTNAME_INVALID: "tls"
+};
+function findErrorCode(error) {
+  let current = error;
+  for (let depth = 0; depth < 8 && current instanceof Error; depth++) {
+    const code = current.code;
+    if (typeof code === "string") return code;
+    current = current.cause;
+  }
+  return void 0;
+}
+function typeFromCode(code) {
+  if (Object.hasOwn(codeTypes, code)) return codeTypes[code];
+  if (code.startsWith("CERT_") || code.startsWith("ERR_TLS_")) return "tls";
+  return void 0;
+}
+function classifyFetchError(error) {
+  if (error instanceof Error) {
+    if (error.name === "TimeoutError") return { type: "timeout" };
+    if (error.name === "AbortError") return { type: "aborted" };
+  }
+  const code = findErrorCode(error);
+  if (code !== void 0) {
+    const type = typeFromCode(code);
+    if (type !== void 0) return { type, code };
+    return { type: "unknown", code };
+  }
+  if (error instanceof TypeError && /fetch failed|failed to fetch|network/i.test(error.message)) {
+    return { type: "network" };
+  }
+  return { type: "unknown" };
+}
+var FetchError = class extends Error {
+  __fetchErrorMarker = fetchErrorMarker;
+  body;
+  code;
+  method;
+  response;
+  status;
+  statusText;
+  type;
+  url;
+  constructor(message, context = {}) {
+    super(message, { cause: context.cause });
+    this.name = "FetchError";
+    this.type = context.type ?? "unknown";
+    this.code = context.code;
+    this.url = context.url;
+    this.method = context.method;
+    this.status = context.status;
+    this.statusText = context.statusText;
+    this.response = context.response;
+    this.body = context.body;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      type: this.type,
+      code: this.code,
+      url: this.url,
+      method: this.method,
+      status: this.status,
+      statusText: this.statusText
+    };
+  }
+};
+function isFetchError(value) {
+  return value instanceof FetchError || typeof value === "object" && value !== null && value.__fetchErrorMarker === fetchErrorMarker;
+}
+function toFetchError(error, context = {}) {
+  if (isFetchError(error)) return error;
+  const { type, code } = classifyFetchError(error);
+  const message = error instanceof Error ? error.message : String(error);
+  return new FetchError(message, {
+    ...context,
+    type,
+    code,
+    cause: error
+  });
+}
+
+// src/fetchCompress.ts
+async function gzipString(body) {
+  const blob = new Blob([body]);
+  const stream = blob.stream().pipeThrough(new CompressionStream("gzip"));
+  const response = new Response(stream);
+  return response.arrayBuffer();
+}
+async function fetchCompress(url, options = {}) {
+  const { compressMinLength = 1024, ...init } = options;
+  try {
+    if (init.body !== void 0 && init.body !== null) {
+      const bodyStr = typeof init.body === "string" ? init.body : JSON.stringify(init.body);
+      if (bodyStr.length > compressMinLength) {
+        const headers = new Headers(init.headers);
+        headers.set("Content-Encoding", "gzip");
+        return await fetch(url, {
+          ...init,
+          body: await gzipString(bodyStr),
+          headers
+        });
+      }
+    }
+    return await fetch(url, init);
+  } catch (error) {
+    throw toFetchError(error, { url: url.toString(), method: init.method });
+  }
+}
+
+// src/parseJson.ts
+async function parseJsonResponse(response, context = {}) {
+  let text;
+  try {
+    text = await response.text();
+  } catch (error) {
+    throw toFetchError(error, context);
+  }
+  if (text.trim() === "") return null;
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    throw new FetchError("Failed to parse response body as JSON", {
+      type: "parse",
+      url: context.url,
+      method: context.method,
+      status: response.status,
+      statusText: response.statusText,
+      body: text,
+      cause: error
+    });
+  }
+}
+async function tryParseJson(response) {
+  try {
+    const text = await response.text();
+    if (text.trim() === "") return null;
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+// src/FetchClient.ts
+var FetchClientError = class extends FetchError {
+  config;
+  constructor(message, response, config) {
+    super(message, {
+      type: "http-status",
+      url: config.url,
+      method: config.method,
+      status: response.status,
+      statusText: response.statusText,
+      response
+    });
+    this.name = "FetchClientError";
+    this.config = config;
+  }
+};
+function buildHeaders(custom, includeContentType = false) {
+  const headers = new Headers();
+  headers.set("Accept", "application/json, text/plain, *.*");
+  if (includeContentType) {
+    headers.set("Content-Type", "application/json");
+  }
+  if (custom) {
+    const merged = new Headers(custom);
+    for (const [key, value] of merged.entries()) headers.set(key, value);
+  }
+  return headers;
+}
+function buildURL(config) {
+  const base = config.baseURL ?? "";
+  const path = config.url ?? "";
+  const url = base === "" ? new URL(path) : new URL(path, base);
+  if (config.params) {
+    for (const [key, value] of Object.entries(config.params)) {
+      url.searchParams.set(key, value);
+    }
+  }
+  return url.href;
+}
+var FetchClient = class _FetchClient {
+  defaults;
+  constructor(defaults = {}) {
+    this.defaults = defaults;
+  }
+  static create(config) {
+    return new _FetchClient(config);
+  }
+  delete(url, config) {
+    return this.request({
+      ...config,
+      url,
+      method: "DELETE"
+    });
+  }
+  get(url, config) {
+    return this.request({
+      ...config,
+      url,
+      method: "GET"
+    });
+  }
+  patch(url, data, config) {
+    return this.request({
+      ...config,
+      url,
+      data,
+      method: "PATCH"
+    });
+  }
+  post(url, data, config) {
+    return this.request({
+      ...config,
+      url,
+      data,
+      method: "POST"
+    });
+  }
+  put(url, data, config) {
+    return this.request({
+      ...config,
+      url,
+      data,
+      method: "PUT"
+    });
+  }
+  async request(config) {
+    const merged = { ...this.defaults, ...config };
+    const url = buildURL(merged);
+    const init = {
+      method: merged.method ?? "GET",
+      headers: buildHeaders(merged.headers, merged.data !== void 0),
+      compressMinLength: merged.compressMinLength,
+      signal: merged.timeout !== void 0 && merged.timeout !== 0 ? AbortSignal.timeout(merged.timeout) : merged.signal
+    };
+    if (merged.data !== void 0) {
+      init.body = JSON.stringify(merged.data);
+    }
+    const response = await fetchCompress(url, init);
+    const data = response.ok ? await parseJsonResponse(response, { url, method: merged.method }) : await tryParseJson(response);
+    const result = {
+      data,
+      headers: response.headers,
+      response,
+      status: response.status,
+      statusText: response.statusText
+    };
+    const validateStatus = merged.validateStatus === void 0 ? (s) => s >= 200 && s < 300 : merged.validateStatus;
+    if (validateStatus && !validateStatus(response.status)) {
+      throw new FetchClientError(
+        `Request failed with status ${response.status} ${response.statusText}`,
+        result,
+        { ...merged, url }
+      );
+    }
+    return result;
+  }
+};
+
+// src/fetchJson.ts
+function buildHeaders2(custom, includeContentType = false) {
+  const headers = new Headers();
+  headers.set("Accept", "application/json, text/plain, *.*");
+  if (includeContentType) {
+    headers.set("Content-Type", "application/json");
+  }
+  if (custom) {
+    const merged = new Headers(custom);
+    for (const [key, value] of merged.entries()) headers.set(key, value);
+  }
+  return headers;
+}
+async function fetchJson(url, options = {}) {
+  const { headers: customHeaders, ...rest } = options;
+  const response = await fetchCompress(url, {
+    ...rest,
+    headers: buildHeaders2(customHeaders, rest.body !== void 0 && rest.body !== null)
+  });
+  const data = response.ok ? await parseJsonResponse(response, { url, method: rest.method }) : await tryParseJson(response);
+  return {
+    data,
+    headers: response.headers,
+    response,
+    status: response.status,
+    statusText: response.statusText
+  };
+}
+
+// src/FetchJsonClient.ts
+var FetchJsonClient = class _FetchJsonClient extends FetchClient {
+  constructor(config) {
+    super(config);
+  }
+  static create(config) {
+    return new _FetchJsonClient(config);
+  }
+};
+var fetchJsonClient = new FetchJsonClient();
+
+// src/methods.ts
+function fetchJsonGet(url, options) {
+  return fetchJson(url, { ...options, method: "GET" });
+}
+function fetchJsonPost(url, data, options) {
+  return fetchJson(url, {
+    ...options,
+    body: JSON.stringify(data),
+    method: "POST"
+  });
+}
+function fetchJsonPut(url, data, options) {
+  return fetchJson(url, {
+    ...options,
+    body: JSON.stringify(data),
+    method: "PUT"
+  });
+}
+function fetchJsonPatch(url, data, options) {
+  return fetchJson(url, {
+    ...options,
+    body: JSON.stringify(data),
+    method: "PATCH"
+  });
+}
+function fetchJsonDelete(url, options) {
+  return fetchJson(url, { ...options, method: "DELETE" });
+}
+export {
+  FetchClient,
+  FetchClientError,
+  FetchError,
+  FetchJsonClient,
+  classifyFetchError,
+  fetchCompress,
+  fetchJson,
+  fetchJsonClient,
+  fetchJsonDelete,
+  fetchJsonGet,
+  fetchJsonPatch,
+  fetchJsonPost,
+  fetchJsonPut,
+  isFetchError,
+  toFetchError
+};
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/fetch/neutral/methods.d.ts

@@ -0,0 +1,12 @@
+import type { FetchJsonOptions, FetchJsonResponse } from './types.ts';
+/** JSON GET request. */
+export declare function fetchJsonGet<T>(url: string, options?: FetchJsonOptions): Promise<FetchJsonResponse<T>>;
+/** JSON POST request with a body. */
+export declare function fetchJsonPost<T>(url: string, data?: unknown, options?: FetchJsonOptions): Promise<FetchJsonResponse<T>>;
+/** JSON PUT request with a body. */
+export declare function fetchJsonPut<T>(url: string, data?: unknown, options?: FetchJsonOptions): Promise<FetchJsonResponse<T>>;
+/** JSON PATCH request with a body. */
+export declare function fetchJsonPatch<T>(url: string, data?: unknown, options?: FetchJsonOptions): Promise<FetchJsonResponse<T>>;
+/** JSON DELETE request. */
+export declare function fetchJsonDelete<T>(url: string, options?: FetchJsonOptions): Promise<FetchJsonResponse<T>>;
+//# sourceMappingURL=methods.d.ts.map

package/dist/_pkg/fetch/neutral/model.d.ts

@@ -0,0 +1,5 @@
+export type { FetchClientConfig, FetchClientRequestConfig, } from './FetchClient.ts';
+export type { FetchCompressOptions } from './fetchCompress.ts';
+export type { FetchErrorContext, FetchErrorJson, FetchErrorType, } from './FetchError.ts';
+export type * from './types.ts';
+//# sourceMappingURL=model.d.ts.map

package/dist/_pkg/fetch/neutral/model.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=model.mjs.map

package/dist/_pkg/fetch/neutral/parseJson.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Reads and JSON-parses a response body. An empty or whitespace-only body resolves to `null`
+ * (so 204/304/HEAD and other empty responses are not treated as failures). A non-empty body that
+ * cannot be parsed throws a FetchError of type `parse` carrying the raw body and status. A failure
+ * while reading the body stream (e.g. a dropped connection) is classified as a network FetchError.
+ */
+export declare function parseJsonResponse<T>(response: Response, context?: {
+    method?: string;
+    url?: string;
+}): Promise<T | null>;
+/**
+ * Best-effort JSON parse for non-success responses: returns `null` on any failure
+ * (empty body, malformed body, or read error) so the response can still be surfaced for inspection.
+ */
+export declare function tryParseJson<T>(response: Response): Promise<T | null>;
+//# sourceMappingURL=parseJson.d.ts.map

package/dist/_pkg/fetch/neutral/types.d.ts

@@ -0,0 +1,12 @@
+import type { FetchCompressOptions } from './fetchCompress.ts';
+/** Fetch request options extended with an optional gzip compression threshold. */
+export type FetchJsonOptions = FetchCompressOptions;
+/** Structured response from a fetchJson call. */
+export interface FetchJsonResponse<T> {
+    data: T | null;
+    headers: Headers;
+    response: Response;
+    status: number;
+    statusText: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/_pkg/forget/neutral/ForgetConfig.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Configuration options for fire-and-forget promises.
+ */
+export interface ForgetConfig<T = any> {
+    /** Optional name for identifying the forgotten promise in logs. */
+    name?: string;
+    /** Called when the configured timeout elapses before the promise settles. The promise keeps running. */
+    onCancel?: () => void;
+    /** Called when the promise completes, with a tuple of [result, error]. */
+    onComplete?: (result: [T | undefined, Error | undefined]) => void;
+    /** Called when an exception occurs outside the promise itself. */
+    onException?: (error: Error) => void;
+    /**
+     * Timeout in milliseconds after which `onCancel` and `timeoutHandler` run.
+     * This does not abort the promise; `activeForgets` stays elevated until it settles.
+     */
+    timeout?: number;
+}
+/** Default forget configuration with a 30-second timeout. */
+export declare const defaultForgetConfig: ForgetConfig<unknown>;
+//# sourceMappingURL=ForgetConfig.d.ts.map

package/dist/_pkg/forget/neutral/ForgetNodeConfig.d.ts

@@ -0,0 +1,13 @@
+import { type ForgetConfig } from './ForgetConfig.ts';
+/**
+ * Node.js-specific forget configuration that extends ForgetConfig with process termination options.
+ */
+export interface ForgetNodeConfig<T = any> extends ForgetConfig<T> {
+    /** Terminate the process on an exception that happens outside of the promise being forgotten. */
+    terminateOnException?: boolean;
+    /** Terminate the process if the promise times out. */
+    terminateOnTimeout?: boolean;
+}
+/** Default Node.js forget configuration with termination disabled. */
+export declare const defaultForgetNodeConfig: ForgetNodeConfig<unknown>;
+//# sourceMappingURL=ForgetNodeConfig.d.ts.map

package/dist/_pkg/forget/neutral/ForgetPromise.d.ts

@@ -0,0 +1,49 @@
+import type { Logger } from '../../logger/neutral/index.ts';
+import type { Promisable, PromiseEx } from '../../promise/neutral/index.ts';
+import { type ForgetConfig } from './ForgetConfig.ts';
+/** A function that returns a promisable value. */
+type PromisableFunction<T> = () => Promisable<T>;
+/**
+ * Manages fire-and-forget promises with tracking, timeouts, and error handling.
+ *
+ * Timeouts are observability hooks only: they invoke `onCancel` and `timeoutHandler` but do not
+ * abort or await-cleanup the underlying promise. `activeForgets` therefore counts promises that
+ * are still running (unsettled), not promises still inside their configured timeout window.
+ */
+export declare class ForgetPromise {
+    /**
+     * Number of forgotten promises still running (not yet settled).
+     * Decremented only when the underlying promise fulfills or rejects — not when a timeout fires.
+     */
+    static activeForgets: number;
+    /** Number of forgotten promises that threw exceptions. */
+    static exceptedForgets: number;
+    /** Logger instance used for error and warning output. */
+    static logger: Logger;
+    /** Whether any forgotten promises are still running, including any that have exceeded their timeout. */
+    static get active(): boolean;
+    /**
+     * Waits until all forgotten promises have settled.
+     * @param interval - Polling interval in milliseconds.
+     * @param timeout - Optional maximum wait time in milliseconds.
+     * @returns `0` when every forgotten promise has settled; otherwise the number still running.
+     * A non-zero return after `timeout` elapses can include promises whose timeout callback already
+     * ran but whose work is still in flight.
+     */
+    static awaitInactive(interval?: number, timeout?: number): Promise<number>;
+    /** Handles exceptions from forgotten promises by logging error details. */
+    static exceptionHandler(error: Error, { name }: ForgetConfig, externalStackTrace?: string): void;
+    /**
+     * Used to explicitly launch an async function (or Promise) with awaiting it
+     * @param promise The promise to forget
+     * @param config Configuration of forget settings
+     */
+    static forget<T>(promise: Promise<T> | PromiseEx<T> | PromisableFunction<T> | T, config?: ForgetConfig<T>): void;
+    /**
+     * Handles timeout events for forgotten promises by logging timeout details.
+     * Does not terminate the underlying promise; it may continue running after this is called.
+     */
+    static timeoutHandler(time: number, { name }: ForgetConfig, externalStackTrace?: string): void;
+}
+export {};
+//# sourceMappingURL=ForgetPromise.d.ts.map

package/dist/_pkg/forget/neutral/ForgetPromiseNode.d.ts

@@ -0,0 +1,15 @@
+import type { Promisable } from '../../promise/neutral/index.ts';
+import { type ForgetNodeConfig } from './ForgetNodeConfig.ts';
+import { ForgetPromise } from './ForgetPromise.ts';
+/**
+ * Node.js extension of ForgetPromise that can terminate the process on exceptions or timeouts.
+ */
+export declare class ForgetPromiseNode extends ForgetPromise {
+    /** Handles exceptions, optionally terminating the process based on config. */
+    static exceptionHandler(error: Error, config: ForgetNodeConfig, externalStackTrace?: string): void;
+    /** Forgets a promise using Node.js-specific configuration with process termination support. */
+    static forget<T>(promise: Promisable<T>, config?: ForgetNodeConfig<T>): void;
+    /** Handles timeouts, optionally terminating the process based on config. */
+    static timeoutHandler(time: number, config: ForgetNodeConfig, externalStackTrace?: string): void;
+}
+//# sourceMappingURL=ForgetPromiseNode.d.ts.map

package/dist/_pkg/forget/neutral/forget.d.ts

@@ -0,0 +1,10 @@
+import { type Promisable } from '../../promise/neutral/index.ts';
+import type { ForgetConfig } from './ForgetConfig.ts';
+/**
+ * Explicitly launches an async function or promise without awaiting it (fire-and-forget).
+ * @param promise - The promise or promisable value to forget.
+ * @param config - Optional configuration for timeout notification, error handling, and completion callbacks.
+ * Timeouts notify via `onCancel` but do not stop the underlying work; see `ForgetPromise.activeForgets`.
+ */
+export declare const forget: <T>(promise: Promisable<T>, config?: ForgetConfig<T>) => void;
+//# sourceMappingURL=forget.d.ts.map

package/dist/_pkg/forget/neutral/forgetNode.d.ts

@@ -0,0 +1,9 @@
+import { type Promisable } from '../../promise/neutral/index.ts';
+import type { ForgetNodeConfig } from './ForgetNodeConfig.ts';
+/**
+ * Node.js variant of forget that can optionally terminate the process on exceptions or timeouts.
+ * @param promise - The promise or promisable value to forget.
+ * @param config - Optional Node.js-specific configuration including process termination options.
+ */
+export declare const forgetNode: <T>(promise: Promisable<T>, config?: ForgetNodeConfig<T>) => void;
+//# sourceMappingURL=forgetNode.d.ts.map

package/dist/_pkg/forget/neutral/index.d.ts

@@ -0,0 +1,2 @@
+export * from './node/index.ts';
+//# sourceMappingURL=index.d.ts.map