@ariestools/sdk 7.0.3

package/dist/_pkg/platform/browser/index-browser.mjs

@@ -0,0 +1,18 @@
+// src/browser/index.ts
+var isBrowser = () => {
+  return !isWebworker() && globalThis.constructor?.name === "Window";
+};
+var isWebworker = () => {
+  return typeof globalThis === "object" && globalThis.constructor?.name === "DedicatedWorkerGlobalScope";
+};
+var isNode = () => {
+  return false;
+};
+var subtle = globalThis.crypto.subtle;
+export {
+  isBrowser,
+  isNode,
+  isWebworker,
+  subtle
+};
+//# sourceMappingURL=index-browser.mjs.map

package/dist/_pkg/platform/browser/index-node.d.ts

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

package/dist/_pkg/platform/browser/node/index.d.ts

@@ -0,0 +1,9 @@
+/** The Web Crypto API's SubtleCrypto interface, re-exported from Node.js crypto module. */
+export { subtle } from 'node:crypto';
+/** Returns whether the current environment is a browser. Always returns false in Node.js. */
+export declare const isBrowser: () => boolean;
+/** Returns whether the current environment is a web worker. Always returns false in Node.js. */
+export declare const isWebworker: () => boolean;
+/** Returns whether the current environment is Node.js. Always returns true in this entry point. */
+export declare const isNode: () => boolean;
+//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/platform/node/browser/index.d.ts

@@ -0,0 +1,9 @@
+/** Returns whether the current environment is a browser window (not a web worker). */
+export declare const isBrowser: () => boolean;
+/** Returns whether the current environment is a dedicated web worker. */
+export declare const isWebworker: () => boolean;
+/** Returns whether the current environment is Node.js. Always returns false in the browser entry point. */
+export declare const isNode: () => boolean;
+/** The Web Crypto API's SubtleCrypto interface, sourced from the browser's globalThis.crypto. */
+export declare const subtle: SubtleCrypto;
+//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/platform/node/index-browser.d.ts

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

package/dist/_pkg/platform/node/index-node.d.ts

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

package/dist/_pkg/platform/node/index-node.mjs

@@ -0,0 +1,18 @@
+// src/node/index.ts
+import { subtle } from "node:crypto";
+var isBrowser = () => {
+  return false;
+};
+var isWebworker = () => {
+  return false;
+};
+var isNode = () => {
+  return true;
+};
+export {
+  isBrowser,
+  isNode,
+  isWebworker,
+  subtle
+};
+//# sourceMappingURL=index-node.mjs.map

package/dist/_pkg/platform/node/node/index.d.ts

@@ -0,0 +1,9 @@
+/** The Web Crypto API's SubtleCrypto interface, re-exported from Node.js crypto module. */
+export { subtle } from 'node:crypto';
+/** Returns whether the current environment is a browser. Always returns false in Node.js. */
+export declare const isBrowser: () => boolean;
+/** Returns whether the current environment is a web worker. Always returns false in Node.js. */
+export declare const isWebworker: () => boolean;
+/** Returns whether the current environment is Node.js. Always returns true in this entry point. */
+export declare const isNode: () => boolean;
+//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -0,0 +1,37 @@
+// src/profiler.ts
+var createProfiler = () => {
+  return {};
+};
+var profile = (profiler, name) => {
+  const timeData = profiler[name] ?? [];
+  timeData.push(Date.now());
+  profiler[name] = timeData;
+};
+var profileReport = (profiler) => {
+  let lowest = Date.now();
+  let highest = 0;
+  const results = Object.entries(profiler).reduce((prev, [name, readings]) => {
+    const start = readings.at(0);
+    if (start !== void 0) {
+      if (start < lowest) {
+        lowest = start;
+      }
+      const end = readings.at(-1) ?? Date.now();
+      if (end > highest) {
+        highest = end;
+      }
+      prev[name] = end - start;
+    }
+    return prev;
+  }, {});
+  if (highest > 0) {
+    results["-all-"] = highest - lowest;
+  }
+  return results;
+};
+export {
+  createProfiler,
+  profile,
+  profileReport
+};
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1,2 @@
+export type { Profiler } from './profiler.ts';
+//# sourceMappingURL=model.d.ts.map

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

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

package/dist/_pkg/profile/neutral/profiler.d.ts

@@ -0,0 +1,17 @@
+/** A record of named timing entries, where each key maps to an array of timestamps. */
+export type Profiler = Record<string, number[]>;
+/** Creates a new empty profiler instance. */
+export declare const createProfiler: () => Profiler;
+/**
+ * Records a timestamp for the given profile name.
+ * @param profiler - The profiler instance to record into.
+ * @param name - The name of the timing entry.
+ */
+export declare const profile: (profiler: Profiler, name: string) => void;
+/**
+ * Generates a report of elapsed times for each profiled entry.
+ * @param profiler - The profiler instance to report on.
+ * @returns A record mapping each profile name to its elapsed time in milliseconds, plus a '-all-' total.
+ */
+export declare const profileReport: (profiler: Profiler) => Record<string, number>;
+//# sourceMappingURL=profiler.d.ts.map

package/dist/_pkg/promise/neutral/PromiseEx.d.ts

@@ -0,0 +1,24 @@
+/** A resolve/reject callback used within PromiseEx. */
+export type PromiseExSubFunc<T, TResult = T> = (value: T) => TResult;
+/** The executor function passed to the PromiseEx constructor. */
+export type PromiseExFunc<T> = (resolve?: PromiseExSubFunc<T, void>, reject?: PromiseExSubFunc<T, void>) => void;
+/** A callback that inspects the attached value and returns whether to cancel the promise. */
+export type PromiseExValueFunc<V> = (value?: V) => boolean;
+/**
+ * An extended Promise that carries an optional attached value and supports cancellation.
+ * The value can be inspected via the `then` or `value` methods to conditionally cancel.
+ */
+export declare class PromiseEx<T, V = void> extends Promise<T> {
+    /** Whether the promise has been cancelled via a value callback. */
+    cancelled?: boolean;
+    private _value?;
+    constructor(func: PromiseExFunc<T>, value?: V);
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null, onvalue?: (value?: V) => boolean): Promise<TResult1 | TResult2>;
+    /**
+     * Inspects the attached value via the callback; if it returns true, marks the promise as cancelled.
+     * @param onvalue - A callback that receives the attached value and returns whether to cancel.
+     * @returns This instance for chaining.
+     */
+    value(onvalue?: (value?: V) => boolean): this;
+}
+//# sourceMappingURL=PromiseEx.d.ts.map

package/dist/_pkg/promise/neutral/fulfilled.d.ts

@@ -0,0 +1,7 @@
+/**
+ * For use with Promise.allSettled to filter only successful results
+ * @param val
+ * @returns
+ */
+export declare const fulfilled: <T>(val: PromiseSettledResult<T>) => val is PromiseFulfilledResult<T>;
+//# sourceMappingURL=fulfilled.d.ts.map

package/dist/_pkg/promise/neutral/fulfilledValues.d.ts

@@ -0,0 +1,20 @@
+/**
+ * For use with Promise.allSettled to reduce to only successful result values
+ * @example <caption>Casting the initialValue provided to reduce</caption>
+ * const resolved = Promise.resolve('resolved')
+ * const rejected = Promise.reject('rejected')
+ * const settled = await Promise.allSettled([resolved, rejected])
+ * const results = settled.reduce(fulfilledValues, [] as string[])
+ * // results === [ 'resolved' ]
+ * @example <caption>Providing type parameter to reduce and initialValue type can be inferred</caption>
+ * const resolved = Promise.resolve('resolved')
+ * const rejected = Promise.reject('rejected')
+ * const settled = await Promise.allSettled([resolved, rejected])
+ * const results = settled.reduce<string[]>(fulfilledValues, [])
+ * // results === [ 'resolved' ]
+ * @param previousValue
+ * @param currentValue
+ * @returns
+ */
+export declare const fulfilledValues: <T>(previousValue: T[], currentValue: PromiseSettledResult<T>) => T[];
+//# sourceMappingURL=fulfilledValues.d.ts.map

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

@@ -0,0 +1,7 @@
+export { fulfilled } from './fulfilled.ts';
+export { fulfilledValues } from './fulfilledValues.ts';
+export * from './PromiseEx.ts';
+export { rejected } from './rejected.ts';
+export * from './toPromise.ts';
+export * from './types.ts';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,57 @@
+// src/fulfilled.ts
+var fulfilled = (val) => {
+  return val.status === "fulfilled";
+};
+
+// src/fulfilledValues.ts
+var fulfilledValues = (previousValue, currentValue) => {
+  if (currentValue.status === "fulfilled") previousValue.push(currentValue.value);
+  return previousValue;
+};
+
+// src/PromiseEx.ts
+var PromiseEx = class extends Promise {
+  /** Whether the promise has been cancelled via a value callback. */
+  cancelled;
+  _value;
+  constructor(func, value) {
+    super(func);
+    this._value = value;
+  }
+  // eslint-disable-next-line unicorn/no-thenable
+  then(onfulfilled, onrejected, onvalue) {
+    if (onvalue?.(this._value) === true) {
+      this.cancelled = true;
+    }
+    return super.then(onfulfilled, onrejected);
+  }
+  /**
+   * Inspects the attached value via the callback; if it returns true, marks the promise as cancelled.
+   * @param onvalue - A callback that receives the attached value and returns whether to cancel.
+   * @returns This instance for chaining.
+   */
+  value(onvalue) {
+    if (onvalue?.(this._value) === true) {
+      this.cancelled = true;
+    }
+    return this;
+  }
+};
+
+// src/rejected.ts
+var rejected = (val) => {
+  return val.status === "rejected";
+};
+
+// src/toPromise.ts
+function toPromise(value) {
+  return value instanceof Promise ? value : Promise.resolve(value);
+}
+export {
+  PromiseEx,
+  fulfilled,
+  fulfilledValues,
+  rejected,
+  toPromise
+};
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1,3 @@
+export type { PromiseExFunc, PromiseExSubFunc, PromiseExValueFunc, } from './PromiseEx.ts';
+export type * from './types.ts';
+//# sourceMappingURL=model.d.ts.map

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

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

package/dist/_pkg/promise/neutral/rejected.d.ts

@@ -0,0 +1,7 @@
+/**
+ * For use with Promise.allSettled to filter only rejected results
+ * @param val
+ * @returns
+ */
+export declare const rejected: <T>(val: PromiseSettledResult<T>) => val is PromiseRejectedResult;
+//# sourceMappingURL=rejected.d.ts.map

package/dist/_pkg/promise/neutral/toPromise.d.ts

@@ -0,0 +1,8 @@
+import type { Promisable } from './types.ts';
+/**
+ * Wraps a value in a Promise if it is not already one.
+ * @param value - A value that may or may not be a Promise.
+ * @returns A Promise resolving to the value.
+ */
+export declare function toPromise<T>(value: Promisable<T>): Promise<T>;
+//# sourceMappingURL=toPromise.d.ts.map

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

@@ -0,0 +1,23 @@
+import type { TypedValue } from '../../typeof/neutral/index.ts';
+import type { PromiseEx } from './PromiseEx.ts';
+/** A value that may be a Promise, PromiseEx, or a plain synchronous value. */
+export type Promisable<T, V = never> = PromiseEx<T, V> | Promise<T> | T;
+/** A Promisable that resolves to an array. */
+export type PromisableArray<T, V = never> = Promisable<T[], V>;
+/** A Promisable that may resolve to undefined. */
+export type OptionalPromisable<T, V = never> = Promisable<T | undefined, V>;
+/** A Promisable array where elements may be undefined. */
+export type OptionalPromisableArray<T, V = never> = PromisableArray<T | undefined, V>;
+/** A Promisable that may resolve to null. */
+export type NullablePromisable<T, V = never> = Promisable<T | null, V>;
+/** A Promisable array where elements may be null. */
+export type NullablePromisableArray<T, V = never> = PromisableArray<T | null, V>;
+/** @description Used to document promises that are being used as Mutexes */
+export type AsyncMutex<T> = Promise<T>;
+/** An interface representing any thenable (promise-like) object. */
+export interface PromiseType {
+    then: () => unknown;
+}
+/** Any non-promise typed value, excluding thenables. */
+export type AnyNonPromise = Exclude<TypedValue, PromiseType>;
+//# sourceMappingURL=types.d.ts.map

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

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

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

@@ -0,0 +1,28 @@
+// src/retry.ts
+import { delay } from "../../delay/neutral/index.mjs";
+var retry = async (func, config) => {
+  const {
+    complete = (value) => value !== void 0,
+    retries = 0,
+    interval = 100,
+    backoff = 2
+  } = config ?? {};
+  const result = await func();
+  if (complete(result)) {
+    return result;
+  }
+  if (retries <= 0) {
+    return void 0;
+  }
+  await delay(interval);
+  return retry(func, {
+    backoff,
+    complete,
+    interval: interval * backoff,
+    retries: retries - 1
+  });
+};
+export {
+  retry
+};
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1,2 @@
+export type { RetryConfig, RetryConfigWithComplete, } from './retry.ts';
+//# sourceMappingURL=model.d.ts.map

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

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

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

@@ -0,0 +1,23 @@
+import type { Promisable } from '../../promise/neutral/index.ts';
+/** Configuration for retry behavior. */
+export interface RetryConfig {
+    /** Multiplier applied to the interval after each retry. Defaults to 2. */
+    backoff?: number;
+    /** Initial delay in milliseconds between retries. Defaults to 100. */
+    interval?: number;
+    /** Maximum number of retry attempts. Defaults to 0 (no retries). */
+    retries?: number;
+}
+/** Retry configuration extended with a custom completion check. */
+export interface RetryConfigWithComplete<T = unknown> extends RetryConfig {
+    /** Determines whether the result is considered complete. Defaults to checking for a defined value. */
+    complete?: (result?: T) => boolean;
+}
+/**
+ * Retries an async function with exponential backoff until it completes or retries are exhausted.
+ * @param func - The function to retry.
+ * @param config - Optional retry configuration including backoff, interval, retries, and completion check.
+ * @returns The result of the function, or undefined if all retries were exhausted.
+ */
+export declare const retry: <T = unknown>(func: () => Promisable<T | undefined>, config?: RetryConfigWithComplete<T>) => Promise<T | undefined>;
+//# sourceMappingURL=retry.d.ts.map

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

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

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

@@ -0,0 +1,20 @@
+// src/lib/difference.ts
+var difference = (a, b) => {
+  return a.difference(b);
+};
+
+// src/lib/intersection.ts
+var intersection = (a, b) => {
+  return a.intersection(b);
+};
+
+// src/lib/union.ts
+var union = (a, b) => {
+  return a.union(b);
+};
+export {
+  difference,
+  intersection,
+  union
+};
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/set/neutral/lib/difference.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns a new set containing elements in `a` that are not in `b`.
+ * @param a - The source set
+ * @param b - The set of elements to exclude
+ * @returns A new set representing the difference of `a` and `b`
+ */
+export declare const difference: <TKey>(a: Set<TKey>, b: Set<TKey>) => Set<TKey>;
+//# sourceMappingURL=difference.d.ts.map

package/dist/_pkg/set/neutral/lib/index.d.ts

@@ -0,0 +1,4 @@
+export * from './difference.ts';
+export * from './intersection.ts';
+export * from './union.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/set/neutral/lib/intersection.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns a new set containing only elements present in both `a` and `b`.
+ * @param a - The first set
+ * @param b - The second set
+ * @returns A new set representing the intersection of `a` and `b`
+ */
+export declare const intersection: <TKey>(a: Set<TKey>, b: Set<TKey>) => Set<TKey>;
+//# sourceMappingURL=intersection.d.ts.map

package/dist/_pkg/set/neutral/lib/union.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns a new set containing all elements from both `a` and `b`.
+ * @param a - The first set
+ * @param b - The second set
+ * @returns A new set representing the union of `a` and `b`
+ */
+export declare const union: <TKey>(a: Set<TKey>, b: Set<TKey>) => Set<TKey>;
+//# sourceMappingURL=union.d.ts.map

package/dist/_pkg/static-implements/neutral/index.d.ts

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

package/dist/_pkg/static-implements/neutral/index.mjs

@@ -0,0 +1,10 @@
+// src/staticImplements.ts
+function staticImplements() {
+  return (constructor) => {
+    constructor;
+  };
+}
+export {
+  staticImplements
+};
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/static-implements/neutral/staticImplements.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Annotation to decorate classes which implement static methods
+ * @returns The decorated class requiring it to implement
+ * the members of the the type as static properties/methods
+ */
+export declare function staticImplements<T>(): <U extends T>(constructor: U) => void;
+//# sourceMappingURL=staticImplements.d.ts.map

package/dist/_pkg/storage/neutral/KeyValueStore.d.ts

@@ -0,0 +1,34 @@
+import type { Promisable } from '../../promise/neutral/index.ts';
+/**
+ * A readonly storage device.
+ */
+export interface ReadonlyKeyValueStore<TValue, TKey = string> {
+    /**
+     * Returns a promise that resolves to the value for the given key.
+     * @param key The key to get the value for.
+     */
+    get(key: TKey): Promisable<TValue | undefined>;
+    /**
+     * The keys an array of keys.
+     */
+    keys?(): Promisable<TKey[]>;
+}
+/**
+ * A read/write storage device.
+ */
+export interface KeyValueStore<TValue, TKey = string> extends ReadonlyKeyValueStore<TValue, TKey> {
+    /** Removes all entries from the store. */
+    clear?(): Promisable<void>;
+    /**
+     * Deletes the entry with the given key.
+     * @param key The key of the entry to delete
+     */
+    delete(key: TKey): Promisable<void>;
+    /**
+     * Sets a value for the given key, creating or updating the entry.
+     * @param key The key to set
+     * @param value The value to store
+     */
+    set(key: TKey, value: TValue): Promisable<void>;
+}
+//# sourceMappingURL=KeyValueStore.d.ts.map

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

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

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

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

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

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

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

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

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

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