@ariestools/sdk 7.0.7 → 7.0.8

package/dist/browser/index.mjs

@@ -1,31 +1,3424 @@
-export * from '../_pkg/api/neutral/index.mjs'
-export * from '../_pkg/array/neutral/index.mjs'
-export * from '../_pkg/arraybuffer/neutral/index.mjs'
-export * from '../_pkg/assert/neutral/index.mjs'
-export * from '../_pkg/base/neutral/index.mjs'
-export * from '../_pkg/creatable/neutral/index.mjs'
-export * from '../_pkg/decimal-precision/neutral/index.mjs'
-export * from '../_pkg/delay/neutral/index.mjs'
-export * from '../_pkg/ellipsize/neutral/index.mjs'
-export * from '../_pkg/enum/neutral/index.mjs'
-export * from '../_pkg/error/neutral/index.mjs'
-export * from '../_pkg/events/neutral/index.mjs'
-export * from '../_pkg/exists/neutral/index.mjs'
-export * from '../_pkg/fetch/neutral/index.mjs'
-export * from '../_pkg/forget/neutral/index.mjs'
-export * from '../_pkg/function-name/neutral/index.mjs'
-export * from '../_pkg/hex/neutral/index.mjs'
-export * from '../_pkg/logger/neutral/index.mjs'
-export * from '../_pkg/object/neutral/index-un-deprecated.mjs'
-export * from '../_pkg/platform/browser/index-browser.mjs'
-export * from '../_pkg/profile/neutral/index.mjs'
-export * from '../_pkg/promise/neutral/index.mjs'
-export * from '../_pkg/retry/neutral/index.mjs'
-export * from '../_pkg/set/neutral/index.mjs'
-export * from '../_pkg/static-implements/neutral/index.mjs'
-export * from '../_pkg/storage/neutral/index.mjs'
-export * from '../_pkg/telemetry/neutral/index.mjs'
-export * from '../_pkg/telemetry-exporter/neutral/index.mjs'
-export * from '../_pkg/timer/neutral/index.mjs'
-export * from '../_pkg/typeof/neutral/index.mjs'
-export * from '../_pkg/url/browser/index-browser.mjs'
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+
+// src/modules/enum/Enum.ts
+var Enum = (obj) => {
+  return obj;
+};
+
+// src/modules/api/ApiStage.ts
+var ApiStage = Enum({
+  Beta: "beta",
+  Local: "local",
+  Prod: "prod"
+});
+
+// src/modules/api/ApiClient.ts
+var ApiClient = class {
+  stage;
+  token;
+  constructor(token, stage) {
+    this.stage = stage ?? ApiStage.Prod;
+    this.token = token;
+  }
+};
+
+// src/modules/fetch/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, context2 = {}) {
+    super(message, { cause: context2.cause });
+    this.name = "FetchError";
+    this.type = context2.type ?? "unknown";
+    this.code = context2.code;
+    this.url = context2.url;
+    this.method = context2.method;
+    this.status = context2.status;
+    this.statusText = context2.statusText;
+    this.response = context2.response;
+    this.body = context2.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, context2 = {}) {
+  if (isFetchError(error)) return error;
+  const { type, code } = classifyFetchError(error);
+  const message = error instanceof Error ? error.message : String(error);
+  return new FetchError(message, {
+    ...context2,
+    type,
+    code,
+    cause: error
+  });
+}
+
+// src/modules/fetch/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/modules/fetch/parseJson.ts
+async function parseJsonResponse(response, context2 = {}) {
+  let text;
+  try {
+    text = await response.text();
+  } catch (error) {
+    throw toFetchError(error, context2);
+  }
+  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: context2.url,
+      method: context2.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/modules/fetch/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/modules/fetch/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/modules/fetch/FetchJsonClient.ts
+var FetchJsonClient = class _FetchJsonClient extends FetchClient {
+  constructor(config) {
+    super(config);
+  }
+  static create(config) {
+    return new _FetchJsonClient(config);
+  }
+};
+var fetchJsonClient = new FetchJsonClient();
+
+// src/modules/fetch/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" });
+}
+
+// src/modules/typeof/typeOf.ts
+var typeOf = (item) => {
+  return Array.isArray(item) ? "array" : typeof item;
+};
+
+// src/modules/typeof/ifDefined.ts
+var ifDefined = (value, func) => {
+  switch (typeOf(value)) {
+    case "undefined":
+    case "null": {
+      break;
+    }
+    default: {
+      func(value);
+      return value;
+    }
+  }
+};
+
+// src/modules/typeof/ifTypeOf.ts
+var ifTypeOf = (typeName, value, trueFunc, isFunc) => {
+  switch (typeOf(value)) {
+    case typeName: {
+      return !isFunc || isFunc(value) ? trueFunc(value) : void 0;
+    }
+  }
+};
+
+// src/modules/typeof/is.ts
+function isUndefined(value) {
+  return value === void 0;
+}
+function isDefined(value) {
+  return !isUndefined(value);
+}
+function isNull(value) {
+  return value === null;
+}
+function isDefinedNotNull(value) {
+  return !isUndefined(value) && !isNull(value);
+}
+function isUndefinedOrNull(value) {
+  return isUndefined(value) || isNull(value);
+}
+function isBigInt(value) {
+  return typeof value === "bigint";
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isNumber(value) {
+  return typeof value === "number";
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isSymbol(value) {
+  return typeof value === "symbol";
+}
+function isEmptyObject(value) {
+  return isObject(value) && Object.keys(value).length === 0;
+}
+function isEmptyString(value) {
+  return isString(value) && value.length === 0;
+}
+function isEmptyArray(value) {
+  return isArray(value) && value.length === 0;
+}
+function isPopulatedArray(value) {
+  return isArray(value) && value.length > 0;
+}
+function isEmpty(value) {
+  return isEmptyString(value) || isEmptyArray(value) || isEmptyObject(value);
+}
+function isFalsy(value) {
+  return !value;
+}
+function isTruthy(value) {
+  return !!value;
+}
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+function isDateString(value) {
+  return isString(value) && !Number.isNaN(Date.parse(value));
+}
+function isDate(value) {
+  return value instanceof Date;
+}
+function isRegExp(value) {
+  return value instanceof RegExp;
+}
+function isError(value) {
+  return value instanceof Error;
+}
+function isPromise(value) {
+  return value instanceof Promise;
+}
+function isPromiseLike(value) {
+  return typeof value === "object" && value !== null && typeof value.then === "function";
+}
+function isMap(value) {
+  return value instanceof Map;
+}
+function isArrayBufferView(value) {
+  return ArrayBuffer.isView(value);
+}
+function isSet(value) {
+  return value instanceof Set;
+}
+function isWeakMap(value) {
+  return value instanceof WeakMap;
+}
+function isWeakSet(value) {
+  return value instanceof WeakSet;
+}
+function isDataView(value) {
+  return value instanceof DataView;
+}
+function isBlob(value) {
+  return typeof Blob !== "undefined" && value instanceof Blob;
+}
+function isFile(value) {
+  return typeof File !== "undefined" && value instanceof File;
+}
+
+// src/modules/typeof/isType.ts
+var isType = (value, expectedType) => {
+  const typeofValue = typeof value;
+  switch (expectedType) {
+    case "array": {
+      return Array.isArray(value);
+    }
+    case "null": {
+      return value === null;
+    }
+    case "undefined": {
+      return value === void 0;
+    }
+    case "object": {
+      if (value === null) {
+        return false;
+      }
+      return typeofValue === "object" && !Array.isArray(value);
+    }
+    default: {
+      return typeofValue === expectedType;
+    }
+  }
+};
+
+// src/modules/typeof/Typed.ts
+var isTypedKey = (value) => {
+  switch (typeof value) {
+    case "string":
+    case "bigint":
+    case "number":
+    case "symbol": {
+      return true;
+    }
+    default: {
+      return false;
+    }
+  }
+};
+var isTypedValue = (value) => {
+  switch (typeof value) {
+    case "string":
+    case "number":
+    case "boolean": {
+      return true;
+    }
+    default: {
+      return value === null || isTypedObject(value) || isTypedArray(value);
+    }
+  }
+};
+var isTypedArray = (value) => {
+  return Array.isArray(value) && value.every((item) => isTypedValue(item));
+};
+var isValidTypedFieldPair = (pair) => {
+  const [key, value] = pair;
+  return isTypedKey(key) && isTypedValue(value);
+};
+var isTypedObject = (value) => {
+  return isType(value, "object") && Object.entries(value).every((item) => isValidTypedFieldPair(item));
+};
+
+// src/modules/typeof/validateType.ts
+var validateType = (typeName, value, optional = false) => {
+  switch (typeOf(value)) {
+    case typeName: {
+      return [value, []];
+    }
+    default: {
+      if (optional && typeOf(value) === "undefined") {
+        return [value, []];
+      }
+      return [void 0, [new Error(`value type is not '${typeName}:${typeof value}'`)]];
+    }
+  }
+};
+
+// src/modules/api/ApiEndpoint.ts
+var ApiEndpoint = class {
+  _value;
+  config;
+  path;
+  constructor(config, path) {
+    this.config = config;
+    this.path = path;
+  }
+  get value() {
+    return this._value;
+  }
+  get headers() {
+    return isUndefined(this.config.jwtToken) ? void 0 : { Authorization: this.config.jwtToken };
+  }
+  get url() {
+    return `${this.config.apiDomain}/${this.path}`;
+  }
+  async fetch() {
+    const response = await fetchJsonGet(this.url, { headers: this.headers });
+    if (response.status === 200) {
+      this._value = response.data ?? void 0;
+    } else {
+      throw new Error("Unexpected Status Code");
+    }
+    return this._value;
+  }
+  async get() {
+    return this._value ?? await this.fetch();
+  }
+  async insert(value) {
+    const response = await fetchJsonPost(this.url, value, { headers: this.headers });
+    if (response.status === 200) {
+      this._value = response.data ?? void 0;
+    } else {
+      throw new Error("Unexpected Status Code");
+    }
+    return this._value;
+  }
+};
+
+// src/modules/api/getApiStage.ts
+var getApiStage = (hostname) => {
+  if (hostname.startsWith("localhost")) {
+    return ApiStage.Local;
+  }
+  if (hostname.startsWith("beta.")) {
+    return ApiStage.Beta;
+  }
+  return ApiStage.Prod;
+};
+
+// src/modules/array/containsAll.ts
+var containsAll = (source, target) => target.every((i) => source.includes(i));
+
+// src/modules/array/distinct.ts
+var distinct = (value, index, array2) => {
+  if (Number.isNaN(value)) {
+    return array2.findIndex((item) => Number.isNaN(item)) === index;
+  }
+  return array2.indexOf(value) === index;
+};
+
+// src/modules/exists/index.ts
+var exists = (x) => {
+  return x === void 0 || x === null ? false : true;
+};
+
+// src/modules/array/filterAs.ts
+var filterAs = (x, predicate) => {
+  return x.map(predicate).filter(exists);
+};
+
+// src/modules/array/filterAsync.ts
+var filterAsync = async (array2, predicate, concurrency = 16) => {
+  if (array2.length === 0) {
+    return [];
+  }
+  const results = Array.from({ length: array2.length });
+  let nextIndex = 0;
+  const limit = Math.max(1, concurrency);
+  const worker = async () => {
+    while (true) {
+      const index = nextIndex++;
+      if (index >= array2.length) {
+        return;
+      }
+      results[index] = await predicate(array2[index], index, array2);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(limit, array2.length) }, () => worker()));
+  return array2.filter((_, index) => results[index]);
+};
+
+// src/modules/array/findAs.ts
+var findAs = (x, predicate) => {
+  return x.map(predicate).find(exists);
+};
+var findLastAs = (x, predicate) => {
+  return x.map(predicate).findLast(exists);
+};
+
+// src/modules/array/flatten.ts
+var flatten = (a, b) => {
+  return [].concat(a).concat(b).filter(exists);
+};
+
+// src/modules/array/uniq.ts
+var uniq = (arr) => {
+  return [...new Set(arr)];
+};
+var uniqBy = (arr, iteratee) => {
+  const seen = /* @__PURE__ */ new Set();
+  return arr.filter((item) => {
+    const key = iteratee(item);
+    if (!seen.has(key)) {
+      seen.add(key);
+      return true;
+    }
+    return false;
+  });
+};
+
+// src/modules/arraybuffer/equalArrayBuffers.ts
+var equalArrayBuffers = (a1, a2) => {
+  const u1 = new Uint8Array(a1);
+  const u2 = new Uint8Array(a2);
+  if (u1.byteLength !== u2.byteLength) return false;
+  for (let i = 0; i < u1.byteLength; i++) {
+    if (u1[i] !== u2[i]) return false;
+  }
+  return true;
+};
+
+// src/modules/arraybuffer/isArrayBuffer.ts
+function isArrayBuffer(value) {
+  return value instanceof ArrayBuffer;
+}
+function isArrayBufferLike(value) {
+  return value !== null && typeof value === "object" && "byteLength" in value && typeof value.byteLength === "number" && "slice" in value && typeof value.slice === "function";
+}
+
+// src/modules/assert/assertDefinedEx.ts
+function assertDefinedEx(expr, func) {
+  if (expr !== void 0) return expr;
+  if (typeof func === "function") {
+    const errorOrMessage = func(expr);
+    throw typeof errorOrMessage === "string" ? new Error(errorOrMessage) : errorOrMessage;
+  }
+  if (func !== void 0) {
+    throw new Error("Invalid assertDefinedEx usage: second argument must be a function or undefined");
+  }
+  throw new Error("Assertion failed: value is undefined");
+}
+
+// src/modules/assert/assertEx.ts
+function assertEx(expr, func) {
+  if (expr !== void 0 && expr !== null && expr !== false && expr !== 0 && expr !== "" && expr !== 0n) return expr;
+  if (typeof func === "function") {
+    const errorOrMessage = func(expr);
+    throw typeof errorOrMessage === "string" ? new Error(errorOrMessage) : errorOrMessage;
+  }
+  if (func !== void 0) {
+    throw new Error("Invalid assertEx usage: second argument must be a function or undefined");
+  }
+  throw new Error("Assertion failed");
+}
+
+// src/modules/hex/address/address.ts
+import * as z from "zod/mini";
+
+// src/modules/hex/HexRegEx.ts
+var HexRegExMinMax = (minBytes = 0, maxBytes = Number.MAX_SAFE_INTEGER / 2) => {
+  return new RegExp(`^[a-f0-9]{${minBytes * 2},${maxBytes * 2}}$`);
+};
+var HexRegExMinMaxMixedCaseWithPrefix = (minBytes = 0, maxBytes = Number.MAX_SAFE_INTEGER / 2) => {
+  return new RegExp(`^0x[a-fA-F0-9]{${minBytes * 2},${maxBytes * 2}}$`);
+};
+var HexRegEx = /^[0-9a-f]+$/;
+var HexRegExWithPrefix = /^0x[0-9a-f]+$/;
+
+// src/modules/hex/address/address.ts
+var ZERO_ADDRESS = "0000000000000000000000000000000000000000";
+var ADDRESS_LENGTH = 40;
+var AddressRegEx = HexRegExMinMax(ADDRESS_LENGTH / 2, ADDRESS_LENGTH / 2);
+var AddressZod = z.pipe(
+  z.string().check(z.regex(AddressRegEx)),
+  z.transform((v) => v)
+);
+
+// src/modules/hex/address/AddressTransformZod.ts
+import * as z4 from "zod/mini";
+
+// src/modules/hex/address/AddressValidationZod.ts
+import * as z3 from "zod/mini";
+
+// src/modules/error/assert.ts
+var assertError = (value, assert, defaultMessage) => {
+  if (!isUndefined(assert)) {
+    const assertString = typeof assert === "string" ? assert : typeof assert === "boolean" ? defaultMessage : assert(value, defaultMessage);
+    if (isString(assertString) || assertString) {
+      throw new Error(assertString === true ? defaultMessage : assertString);
+    }
+  }
+  return void 0;
+};
+
+// src/modules/error/handleError.ts
+var handleError = (error, handler) => {
+  if (isError(error)) {
+    return handler(error);
+  }
+  throw error;
+};
+var handleErrorAsync = async (error, handler) => {
+  if (isError(error)) {
+    return await handler(error);
+  }
+  throw error;
+};
+
+// src/modules/hex/hex/nibble.ts
+var bitsToNibbles = (value) => {
+  const nibbles = value >> 2;
+  if (value !== nibbles << 2) throw new Error("Bits for nibbles must multiple of 4");
+  return nibbles;
+};
+var nibblesToBits = (value) => {
+  return value << 2;
+};
+
+// src/modules/hex/hex/is.ts
+var isHex = (value, config) => {
+  if (typeof value !== "string") return false;
+  const valueCharLength = value.length - (config?.prefix === true ? 2 : 0);
+  if (config?.bitLength !== void 0 && valueCharLength !== bitsToNibbles(config?.bitLength)) return false;
+  const regex5 = config?.prefix === true ? HexRegExWithPrefix : HexRegEx;
+  return regex5.test(value);
+};
+
+// src/modules/hex/hex/from/fromHexString.ts
+var hexFromHexString = (value, config = {}) => {
+  const {
+    prefix: isPrefix = false,
+    byteSize = 8,
+    bitLength
+  } = config;
+  const nibbleBoundary = bitsToNibbles(byteSize);
+  const unEvened = (value.startsWith("0x") ? value.slice(2) : value).toLowerCase();
+  if (isHex(unEvened)) {
+    const evenCharacters = unEvened.padStart(Math.ceil(unEvened.length / nibbleBoundary) * nibbleBoundary, "0");
+    const padded = isNumber(bitLength) ? evenCharacters.padStart(bitLength / 4, "0") : evenCharacters;
+    return (isPrefix ? `0x${padded}` : padded).toLowerCase();
+  }
+  throw new Error("Received string is not a value hex");
+};
+
+// src/modules/hex/hex/from/fromArrayBuffer.ts
+var hexFromArrayBuffer = (buffer, config) => {
+  const unPadded = [...new Uint8Array(buffer)].map((x) => x.toString(16).padStart(2, "0")).join("");
+  return hexFromHexString(unPadded, config);
+};
+
+// src/modules/hex/hex/from/fromBigInt.ts
+var hexFromBigInt = (value, config = {}) => {
+  const unPadded = value.toString(16);
+  return hexFromHexString(unPadded, config);
+};
+
+// src/modules/hex/hex/from/fromNumber.ts
+var hexFromNumber = (value, config) => {
+  return hexFromBigInt(BigInt(value), config);
+};
+
+// src/modules/hex/hex/from/from.ts
+var hexFrom = (value, config) => {
+  switch (typeof value) {
+    case "string": {
+      return hexFromHexString(value, config);
+    }
+    case "bigint": {
+      return hexFromBigInt(value, config);
+    }
+    case "number": {
+      return hexFromNumber(value, config);
+    }
+    case "object": {
+      return hexFromArrayBuffer(value, config);
+    }
+    default: {
+      throw new Error(`Invalid type: ${typeof value}`);
+    }
+  }
+};
+
+// src/modules/hex/hex/as.ts
+function asHex(value, assert) {
+  switch (typeof value) {
+    case "string": {
+      const stringValue = hexFromHexString(value);
+      return isHex(stringValue) ? stringValue : assertError(value, assert, `Value is not Hex [${value}]`);
+    }
+    default: {
+      return assertError(value, assert, `Unsupported type [${typeof value}]`);
+    }
+  }
+}
+
+// src/modules/hex/hex/hex.ts
+import * as z2 from "zod/mini";
+var HexZod = z2.pipe(
+  z2.string().check(z2.regex(HexRegEx, { error: "Invalid hex format" })),
+  z2.transform((val) => val)
+);
+
+// src/modules/hex/hex/isHexZero.ts
+var isHexZero = (value) => {
+  return isString(value) ? BigInt(hexFromHexString(value, { prefix: true })) === 0n : void 0;
+};
+
+// src/modules/hex/hex/legacy.ts
+var toHexLegacy = (buffer) => {
+  return [...new Uint8Array(buffer)].map((x) => x.toString(16).padStart(2, "0")).join("");
+};
+
+// src/modules/hex/hex/to.ts
+var toHex = (value, config = {}) => {
+  const { prefix: isPrefix = false } = config;
+  return hexFrom(value, { prefix: isPrefix, ...config });
+};
+
+// src/modules/hex/address/AddressValidationZod.ts
+var AddressValidationZod = z3.pipe(
+  z3.string().check(
+    z3.refine((x) => HexZod.safeParse(x).success),
+    z3.refine((x) => x.length === ADDRESS_LENGTH, { error: (e) => new Error(`Address must have 40 characters [${String(e.input)}]`) })
+  ),
+  z3.transform((v) => v)
+);
+
+// src/modules/hex/address/AddressTransformZod.ts
+var AddressTransformZod = z4.pipe(
+  z4.pipe(
+    z4.union([z4.string(), z4.bigint(), z4.number()]),
+    z4.transform((value) => {
+      if (typeof value === "bigint") {
+        return value.toString(16).padStart(ADDRESS_LENGTH, "0");
+      }
+      if (typeof value === "string") {
+        return value.startsWith("0x") ? value.slice(2) : value;
+      }
+      return BigInt(value).toString(16).padStart(ADDRESS_LENGTH, "0");
+    })
+  ).check(z4.refine((x) => AddressValidationZod.safeParse(x).success)),
+  z4.transform((x) => x)
+);
+
+// src/modules/hex/address/is.ts
+var isAddress = (value, config = {}) => {
+  const { bitLength = 160, prefix: isPrefix = false } = config;
+  return isHex(value, { bitLength, prefix: isPrefix });
+};
+function isAddressV2(value) {
+  return AddressValidationZod.safeParse(value).success;
+}
+
+// src/modules/hex/address/as.ts
+function asAddress(value, assert) {
+  try {
+    let stringValue;
+    switch (typeof value) {
+      case "string": {
+        stringValue = hexFromHexString(value, { prefix: false, byteSize: 4 });
+        break;
+      }
+      default: {
+        return isObject(assert) ? assertError(value, assert, `Unsupported type [${typeof value}]`) : void 0;
+      }
+    }
+    return isAddress(stringValue) ? stringValue : assertError(value, assert, `Value is not an Address [${value}]`);
+  } catch (ex) {
+    const error = ex;
+    return assertError(void 0, assert, error.message);
+  }
+}
+function asAddressV2(value, assert = false) {
+  return assert ? AddressValidationZod.parse(value) : AddressValidationZod.safeParse(value).data;
+}
+
+// src/modules/hex/address/to.ts
+var toAddress = (value, config = {}) => {
+  const { bitLength = 160, prefix: isPrefix = false } = config;
+  return hexFrom(value, {
+    bitLength,
+    prefix: isPrefix,
+    ...config
+  });
+};
+function toAddressV2(value, assert = false) {
+  return assert ? AddressTransformZod.parse(value) : AddressTransformZod.safeParse(value).data;
+}
+
+// src/modules/hex/ethAddress.ts
+import * as z5 from "zod/mini";
+var EthAddressRegEx = HexRegExMinMaxMixedCaseWithPrefix(20, 20);
+var EthAddressToStringZod = z5.string().check(z5.regex(EthAddressRegEx));
+var EthAddressToStringSchema = EthAddressToStringZod;
+var EthAddressFromStringZod = z5.pipe(
+  z5.string().check(z5.regex(EthAddressRegEx)),
+  z5.transform((v) => toEthAddress(v))
+);
+var EthAddressFromStringSchema = EthAddressFromStringZod;
+var ETH_ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+var toEthAddress = (value, config = {}) => {
+  const { bitLength = 160, prefix: isPrefix = false } = config;
+  return `0x${hexFrom(value, {
+    bitLength,
+    prefix: isPrefix,
+    ...config
+  })}`;
+};
+var isEthAddress = (value, config = {}) => {
+  const { bitLength = 160, prefix: isPrefix = true } = config;
+  const loweredValue = typeof value === "string" ? value.toLowerCase() : value;
+  return isHex(loweredValue, { bitLength, prefix: isPrefix });
+};
+var EthAddressZod = z5.string().check(
+  z5.regex(EthAddressRegEx, { error: "Invalid address format" }),
+  z5.refine(isEthAddress)
+);
+function asEthAddress(value, assert) {
+  try {
+    let stringValue;
+    switch (typeof value) {
+      case "string": {
+        stringValue = hexFromHexString(value, { prefix: true, byteSize: 4 });
+        break;
+      }
+      default: {
+        if (value !== void 0) {
+          return assertError(value, assert, `Unsupported type [${typeof value}]`);
+        }
+      }
+    }
+    return isEthAddress(stringValue) ? stringValue : assertError(value, assert, `Value is not an EthAddress [${value}]`);
+  } catch (ex) {
+    const error = ex;
+    return assertError(void 0, assert, error.message);
+  }
+}
+
+// src/modules/hex/hash/is.ts
+var isHash = (value, bitLength = 256) => {
+  return isHex(value, { bitLength });
+};
+
+// src/modules/hex/hash/as.ts
+function asHash(value, assert) {
+  switch (typeof value) {
+    case "string": {
+      const stringValue = hexFromHexString(value);
+      return isHash(stringValue) ? stringValue : assertError(value, assert, `Value is not a Hash [${value}]`);
+    }
+    default: {
+      return isUndefined(assert) ? void 0 : assertError(value, assert, `Unsupported type [${typeof value}]`);
+    }
+  }
+}
+
+// src/modules/hex/hash/hash.ts
+import * as z6 from "zod/mini";
+var HASH_LENGTH = 32;
+var HashRegEx = HexRegExMinMax(HASH_LENGTH, HASH_LENGTH);
+var ZERO_HASH = "0000000000000000000000000000000000000000000000000000000000000000";
+var HashBitLength = [32, 64, 128, 256, 512, 1024, 2048, 4096];
+var isHashBitLength = (value) => {
+  return typeof value === "number" && HashBitLength.includes(value);
+};
+var HashZod = z6.pipe(
+  z6.string().check(z6.regex(HashRegEx, { error: "Invalid hex format" })),
+  z6.transform((val) => val)
+);
+
+// src/modules/hex/hash/zod.ts
+import * as z7 from "zod/mini";
+var HashToJsonZod = z7.pipe(HashZod, z7.transform((v) => v));
+var JsonToHashZod = z7.pipe(z7.string(), z7.transform((v) => asHash(v, true)));
+
+// src/modules/hex/hexToBigInt.ts
+function hexToBigInt(hex) {
+  return BigInt(hexFromHexString(hex, { prefix: true }));
+}
+
+// src/modules/hex/zod.ts
+import * as z8 from "zod/mini";
+var BigIntToJsonZod = z8.pipe(
+  z8.bigint().check(z8.nonnegative()),
+  z8.transform((x) => toHex(x))
+);
+var JsonToBigIntZod = z8.pipe(
+  z8.string(),
+  z8.transform((x) => hexToBigInt(toHex(x)))
+);
+
+// src/modules/arraybuffer/toArrayBuffer.ts
+function hexToArrayBuffer(value) {
+  if (value.length % 2 !== 0) {
+    throw new Error("Invalid hex value");
+  }
+  const length = value.length / 2;
+  const result = new Uint8Array(new ArrayBuffer(length));
+  for (let i = 0; i < length; i++) {
+    const byte = value.slice(i * 2, i * 2 + 2);
+    result[i] = Number.parseInt(byte, 16);
+  }
+  return result;
+}
+function stringToArrayBuffer(value, base = 16) {
+  switch (base) {
+    case 16: {
+      return hexToArrayBuffer(toHex((value.startsWith("0x") ? value.slice(2) : value).toUpperCase()));
+    }
+    default: {
+      throw new Error(`Unsupported base [${base}]`);
+    }
+  }
+}
+function toArrayBuffer(value, padLength = 0, base) {
+  if (isUndefined(value)) return void 0;
+  if (typeof value === "bigint" && value < 0) {
+    throw new Error(`negative bigint values are not supported: ${typeof value}`);
+  }
+  let result = typeof value === "string" ? stringToArrayBuffer(value, base) : typeof value === "bigint" ? stringToArrayBuffer(value.toString(16)) : new Uint8Array(value);
+  if (result === void 0) {
+    throw new Error(`toArrayBuffer - Unknown type: ${typeof value}`);
+  }
+  if (result.length < padLength) {
+    result = new Uint8Array([...new Uint8Array(padLength - result.length), ...result]);
+    assertEx(result?.length <= padLength, () => "Resulting length is greater than padLength");
+  }
+  return result.buffer;
+}
+
+// src/modules/arraybuffer/toUint8Array.ts
+function toUint8Array(value, padLength, base) {
+  const arrayBuffer = toArrayBuffer(value, padLength, base);
+  return arrayBuffer ? new Uint8Array(arrayBuffer) : void 0;
+}
+
+// src/modules/base/Base.ts
+var DEFAULT_HISTORY_INTERVAL = 1e3 * 5;
+var DEFAULT_HISTORY_TIME = 60 * 60 * 1e3;
+var MAX_GC_FREQUENCY = 1e3 * 60;
+var MIN_GC_FREQUENCY = 1e3;
+var MIN_HISTORY_INTERVAL = 1e3;
+var Base = class _Base {
+  static defaultLogger;
+  static globalInstances = {};
+  static globalInstancesCountHistory = {};
+  static _historyInterval = DEFAULT_HISTORY_INTERVAL;
+  static _historyTime = DEFAULT_HISTORY_TIME;
+  static _historyTimeout;
+  static _lastGC = 0;
+  static _maxGcFrequency = MAX_GC_FREQUENCY;
+  _params;
+  constructor(params) {
+    this._params = params;
+    params?.logger?.debug(`Base constructed [${this.constructor.name}]`);
+    this.recordInstance();
+  }
+  static get historyInterval() {
+    return this._historyInterval;
+  }
+  static set historyInterval(value) {
+    assertEx(value <= this.historyTime, () => `historyInterval [${value}] must be less than or equal to historyTime [${this.historyTime}]`);
+    this._historyInterval = Math.max(value, MIN_HISTORY_INTERVAL);
+  }
+  static get historyTime() {
+    return this._historyTime;
+  }
+  static set historyTime(value) {
+    assertEx(value >= this.historyInterval, () => `historyTime [${value}] must be greater than or equal to historyInterval [${this.historyInterval}]`);
+    this._historyInterval = value;
+  }
+  static get maxGcFrequency() {
+    return this._maxGcFrequency;
+  }
+  static set maxGcFrequency(value) {
+    this._maxGcFrequency = Math.max(value, MIN_GC_FREQUENCY);
+  }
+  static get maxHistoryDepth() {
+    return Math.floor(this.historyTime / this.historyInterval);
+  }
+  get logger() {
+    return this.params?.logger ?? _Base.defaultLogger;
+  }
+  get meter() {
+    return this.params?.meterProvider?.getMeter(this.constructor.name);
+  }
+  get params() {
+    return this._params;
+  }
+  get tracer() {
+    return this.params?.traceProvider?.getTracer(this.constructor.name);
+  }
+  static gc(classNameOrForce = false) {
+    if (typeof classNameOrForce === "string") {
+      this.gcClass(classNameOrForce);
+    } else {
+      if (classNameOrForce || Date.now() - this._lastGC > this._maxGcFrequency) {
+        this.gcAll();
+      }
+    }
+  }
+  static instanceCount(className) {
+    return this.globalInstances[className]?.length ?? 0;
+  }
+  static instanceCounts() {
+    this.gc();
+    const result = {};
+    for (const [className, instances] of Object.entries(this.globalInstances)) result[className] = instances.length;
+    return result;
+  }
+  static startHistory() {
+    if (this._historyTimeout !== void 0) {
+      this.stopHistory();
+    }
+    const timeoutHandler = () => {
+      if (this._historyTimeout === void 0) {
+        return;
+      }
+      this.addToHistory();
+      this._historyTimeout = setTimeout(timeoutHandler, this.historyInterval);
+    };
+    this._historyTimeout = setTimeout(timeoutHandler, this.historyInterval);
+  }
+  static stopHistory() {
+    if (this._historyTimeout === void 0) {
+      return;
+    }
+    clearTimeout(this._historyTimeout);
+    this._historyTimeout = void 0;
+  }
+  static addToHistory() {
+    const counts = this.instanceCounts();
+    for (const className of Object.keys(this.globalInstances)) {
+      this.globalInstancesCountHistory[className] = this.globalInstancesCountHistory[className]?.slice(-this.maxHistoryDepth) ?? [];
+      this.globalInstancesCountHistory[className].push(counts[className]);
+    }
+  }
+  static gcAll() {
+    for (const className of Object.keys(this.globalInstances)) {
+      this.gcClass(className);
+    }
+  }
+  static gcClass(className) {
+    this.globalInstances[className] = this.globalInstances[className]?.filter((ref) => ref.deref() !== null) ?? [];
+  }
+  recordInstance() {
+    const baseClassName = this.constructor.name;
+    const instanceArray = _Base.globalInstances[baseClassName] ?? [];
+    instanceArray.push(new WeakRef(this));
+    _Base.globalInstances[baseClassName] = instanceArray;
+  }
+};
+
+// src/modules/base/globallyUnique.ts
+var xyoGlobal = () => {
+  if (globalThis.xylabs === void 0) {
+    Reflect.set(globalThis, "xylabs", {});
+  }
+  return globalThis.xylabs;
+};
+var disableGloballyUnique = () => {
+  xyoGlobal().uniqueDisabled = true;
+};
+var globallyUnique = (name, value, domain = "global") => {
+  const uniqueName = [domain, ...domain === "bundle" ? [name] : [import.meta.url, name]].join(":");
+  if (xyoGlobal().uniqueDisabled !== true) {
+    const xylabs = xyoGlobal();
+    xylabs.unique ??= {};
+    const unique = xylabs.unique;
+    if (unique[uniqueName] === void 0) {
+      unique[uniqueName] = value;
+    } else {
+      if (unique[uniqueName] !== value) {
+        throw new Error(
+          `Global unique item ${uniqueName} already defined.  Make sure you are not importing two versions of the package that contains this item`
+        );
+      }
+    }
+  }
+  return uniqueName;
+};
+
+// src/modules/creatable/AbstractCreatable.ts
+import { Mutex } from "async-mutex";
+
+// src/modules/forget/ForgetConfig.ts
+var defaultForgetConfig = { timeout: 3e4 };
+
+// src/modules/forget/ForgetNodeConfig.ts
+var defaultForgetNodeConfig = {
+  ...defaultForgetConfig,
+  terminateOnTimeout: false,
+  terminateOnException: false
+};
+
+// src/modules/timer/setTimeoutEx.ts
+var TimerScheduler = class {
+  currentTimeout;
+  interval = -1;
+  timeouts = [];
+  /**
+   * Cancels a timeout previously created with setTimeoutEx.
+   * @param id - The timeout ID returned by setTimeoutEx.
+   */
+  clearTimeoutEx(id) {
+    this.timeouts = this.timeouts.filter((timeout) => timeout.id !== id);
+    this.update(this.timeouts);
+  }
+  /** Clears all scheduled timeouts and resets internal state. */
+  reset() {
+    this.interval = -1;
+    clearTimeout(this.currentTimeout);
+    this.currentTimeout = void 0;
+    this.timeouts = [];
+  }
+  /**
+   * Sets a timeout using an optimized internal timer that coalesces multiple timeouts into a single native timer.
+   * @param func - The function to call after the delay.
+   * @param delay - The delay in milliseconds (must be >= 0).
+   * @returns A unique string ID that can be used with clearTimeoutEx to cancel the timeout.
+   */
+  setTimeoutEx(func, delay2) {
+    assertEx(delay2 >= 0, () => "delay must be >= 0");
+    const id = `${Date.now()}|${Math.random() * 9999999999}`;
+    this.timeouts.push({
+      delay: delay2,
+      func,
+      id
+    });
+    this.update();
+    return id;
+  }
+  timerFunc() {
+    const notFiring = this.timeouts.filter((timeout) => timeout.delay > this.interval);
+    const firing = this.timeouts.filter((timeout) => timeout.delay <= this.interval);
+    this.update(notFiring, this.interval);
+    for (const timeout of firing) {
+      timeout.func();
+    }
+  }
+  update(newTimeouts = this.timeouts, delayPassed = 0) {
+    if (newTimeouts.length === 0) {
+      this.reset();
+    } else {
+      const newInterval = Math.min(...newTimeouts.map((timeout) => timeout.delay));
+      if (newInterval === this.interval && this.currentTimeout !== void 0) {
+        return;
+      }
+      clearTimeout(this.currentTimeout);
+      this.timeouts = newTimeouts.map((timeout) => ({
+        delay: timeout.delay - delayPassed,
+        func: timeout.func,
+        id: timeout.id
+      }));
+      this.interval = newInterval;
+      this.currentTimeout = setTimeout(() => this.timerFunc(), this.interval);
+    }
+  }
+};
+var defaultTimerScheduler = new TimerScheduler();
+var setTimeoutEx = (func, delay2) => defaultTimerScheduler.setTimeoutEx(func, delay2);
+var clearTimeoutEx = (id) => defaultTimerScheduler.clearTimeoutEx(id);
+
+// src/modules/delay/delay.ts
+var delay = (ms) => {
+  return new Promise((resolve) => setTimeoutEx(() => resolve(), ms));
+};
+
+// src/modules/forget/ForgetPromise.ts
+var ForgetPromise = class {
+  /**
+   * 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 = 0;
+  /** Number of forgotten promises that threw exceptions. */
+  static exceptedForgets = 0;
+  /** Logger instance used for error and warning output. */
+  static logger = console;
+  /** Whether any forgotten promises are still running, including any that have exceeded their timeout. */
+  static get active() {
+    return this.activeForgets > 0;
+  }
+  /**
+   * 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 async awaitInactive(interval = 100, timeout) {
+    let timeoutRemaining = timeout;
+    while (this.active) {
+      await delay(interval);
+      if (timeoutRemaining !== void 0) {
+        timeoutRemaining -= interval;
+        if (timeoutRemaining <= 0) {
+          return this.activeForgets;
+        }
+      }
+    }
+    return 0;
+  }
+  /** Handles exceptions from forgotten promises by logging error details. */
+  static exceptionHandler(error, { name }, externalStackTrace) {
+    this.logger.error(`forget promise handler excepted [${name}]: ${error.message}`, error);
+    if (externalStackTrace !== void 0) {
+      this.logger.warn(`External Stack trace [${name}]:`, externalStackTrace);
+    }
+  }
+  /**
+   * 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(promise, config) {
+    const stackError = new Error("Stack");
+    const externalStackTrace = stackError.stack;
+    const resolvedConfig = {
+      ...defaultForgetConfig,
+      ...globalThis.xy?.forget?.config,
+      ...config
+    };
+    const resolvedPromise2 = typeof promise === "function" ? promise() : promise;
+    if (isPromise(resolvedPromise2)) {
+      try {
+        let isCompleted = false;
+        this.activeForgets++;
+        const promiseWrapper = async () => {
+          try {
+            const result = await resolvedPromise2;
+            this.activeForgets--;
+            isCompleted = true;
+            resolvedConfig?.onComplete?.([result, void 0]);
+          } catch (error) {
+            const caughtError = error instanceof Error ? error : new Error(String(error));
+            this.activeForgets--;
+            isCompleted = true;
+            this.logger.error(`forgotten promise excepted [${config?.name ?? "unknown"}]: ${caughtError.message}`, caughtError);
+            resolvedConfig?.onComplete?.([void 0, caughtError]);
+          }
+        };
+        const promises = [promiseWrapper()];
+        const timeout = resolvedConfig.timeout ?? defaultForgetConfig.timeout;
+        if (isNumber(timeout)) {
+          const timeoutFunc = async () => {
+            await delay(timeout);
+            if (!isCompleted) {
+              resolvedConfig.onCancel?.();
+              this.timeoutHandler(timeout, resolvedConfig, externalStackTrace);
+            }
+          };
+          promises.push(timeoutFunc());
+        }
+        const race = Promise.race(promises);
+        void race.catch(() => {
+        });
+      } catch (ex) {
+        this.exceptedForgets += 1;
+        resolvedConfig?.onException?.(ex);
+        this.exceptionHandler(ex, resolvedConfig, externalStackTrace);
+      }
+    } else {
+      return;
+    }
+  }
+  /**
+   * 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, { name = "unknown" }, externalStackTrace) {
+    this.logger.error(`forget promise timed out after ${time}ms [still running] [${name}]`);
+    if (externalStackTrace !== void 0) {
+      this.logger.warn(`External Stack trace [${name}]:`, externalStackTrace);
+    }
+  }
+};
+
+// src/modules/forget/ForgetPromiseNode.ts
+var ForgetPromiseNode = class extends ForgetPromise {
+  /** Handles exceptions, optionally terminating the process based on config. */
+  static exceptionHandler(error, config, externalStackTrace) {
+    super.exceptionHandler(error, config, externalStackTrace);
+    if (config?.terminateOnException === true) {
+      this.logger.error(`Attempting to terminate process [${config?.name ?? "unknown"}]...`);
+      process.exit(1);
+    }
+  }
+  /** Forgets a promise using Node.js-specific configuration with process termination support. */
+  static forget(promise, config) {
+    const resolvedConfig = {
+      ...defaultForgetNodeConfig,
+      ...globalThis.xy?.forget?.config,
+      ...config
+    };
+    super.forget(promise, resolvedConfig);
+  }
+  /** Handles timeouts, optionally terminating the process based on config. */
+  static timeoutHandler(time, config, externalStackTrace) {
+    super.timeoutHandler(time, config, externalStackTrace);
+    if (config?.terminateOnTimeout === true) {
+      this.logger.error(`Attempting to terminate process [${config?.name ?? "unknown"}]...`);
+      process.exit(2);
+    }
+  }
+};
+
+// src/modules/forget/forgetNode.ts
+var forgetNode = (promise, config) => {
+  ForgetPromiseNode.forget(promise, config);
+};
+
+// src/modules/events/Events/Events.ts
+var NO_META_EVENT_ERROR_MESSAGE = "`eventName` cannot be meta event `listenerAdded` or `listenerRemoved`";
+var processGlobal = globalThis;
+var resolvedPromise = Promise.resolve();
+var isMetaEvent = (eventName) => eventName === "listenerAdded" || eventName === "listenerRemoved";
+var Events = class _Events extends Base {
+  static anyMap = /* @__PURE__ */ new WeakMap();
+  static eventsMap = /* @__PURE__ */ new WeakMap();
+  static isGlobalDebugEnabled = false;
+  // this is here to be able to query the type, not use
+  eventData = {};
+  _canEmitMetaEvents = false;
+  constructor(params = {}) {
+    const mutatedParams = { ...params };
+    if (mutatedParams.debug) {
+      mutatedParams.debug.logger ??= (type, debugName, eventName, eventData) => {
+        let eventDataString;
+        try {
+          eventDataString = JSON.stringify(eventData);
+        } catch {
+          eventDataString = `Object with the following keys failed to stringify: ${Object.keys(eventData ?? {}).join(",")}`;
+        }
+        const eventNameString = typeof eventName === "symbol" || typeof eventName === "number" ? eventName.toString() : eventName;
+        const currentTime = /* @__PURE__ */ new Date();
+        const logTime = `${currentTime.getHours()}:${currentTime.getMinutes()}:${currentTime.getSeconds()}.${currentTime.getMilliseconds()}`;
+        this.logger?.log(`[${logTime}][events:${type}][${debugName}] Event Name: ${eventNameString}
+	data: ${eventDataString}`);
+      };
+    }
+    super(mutatedParams);
+    _Events.anyMap.set(this, /* @__PURE__ */ new Set());
+    _Events.eventsMap.set(this, /* @__PURE__ */ new Map());
+  }
+  /** Whether debug mode is enabled globally or via the DEBUG environment variable. */
+  static get isDebugEnabled() {
+    if (typeof processGlobal.process?.env !== "object") {
+      return this.isGlobalDebugEnabled;
+    }
+    const env = processGlobal.process?.env;
+    return env?.DEBUG === "events" || env?.DEBUG === "*" || this.isGlobalDebugEnabled;
+  }
+  static set isDebugEnabled(newValue) {
+    this.isGlobalDebugEnabled = newValue;
+  }
+  /** The debug configuration for this instance, if provided. */
+  get debug() {
+    return this.params.debug;
+  }
+  /**
+   * Removes all listeners for the specified event name(s).
+   * @param eventNames - One or more event names to clear listeners for.
+   */
+  clearListeners(eventNames) {
+    const eventNamesArray = Array.isArray(eventNames) ? eventNames : [eventNames];
+    for (const eventName of eventNamesArray) {
+      this.logIfDebugEnabled("clear", eventName);
+      if (typeof eventName === "string" || typeof eventName === "symbol" || typeof eventName === "number") {
+        const set = this.getListeners(eventName);
+        if (set) {
+          set.clear();
+        }
+      } else {
+        _Events.anyMap.get(this)?.clear();
+        const eventEntries = assertEx(_Events.eventsMap.get(this));
+        for (const [eventName2, listeners] of eventEntries) {
+          listeners.clear();
+          _Events.eventsMap.get(this)?.delete(eventName2);
+        }
+      }
+    }
+  }
+  /**
+   * Emits an event, invoking all registered listeners concurrently.
+   * @param eventName - The event to emit.
+   * @param eventArgs - The data to pass to listeners.
+   */
+  async emit(eventName, eventArgs) {
+    return await this.emitInternal(eventName, eventArgs);
+  }
+  /**
+   * Emits an internal meta event (listenerAdded or listenerRemoved).
+   * @param eventName - The meta event name.
+   * @param eventArgs - The meta event data containing listener and event information.
+   * @returns True if the meta event was emitted successfully.
+   */
+  async emitMetaEvent(eventName, eventArgs) {
+    if (isMetaEvent(eventName)) {
+      try {
+        this._canEmitMetaEvents = true;
+        await this.emitMetaEventInternal(eventName, eventArgs);
+        return true;
+      } finally {
+        this._canEmitMetaEvents = false;
+      }
+    }
+  }
+  /**
+   * Emits an event, invoking all registered listeners sequentially in order.
+   * @param eventName - The event to emit.
+   * @param eventArgs - The data to pass to listeners.
+   */
+  async emitSerial(eventName, eventArgs) {
+    if (isMetaEvent(eventName) && !this._canEmitMetaEvents) {
+      throw new TypeError(NO_META_EVENT_ERROR_MESSAGE);
+    }
+    const filterMatch = (args, filter) => {
+      switch (typeof filter) {
+        case "object": {
+          if (filter === null || args === null || typeof args !== "object") return args === filter;
+          return Object.entries(args).reduce((prev, [key, value]) => filter[key] === value ? true : prev, false);
+        }
+        default: {
+          return args === filter;
+        }
+      }
+    };
+    this.logIfDebugEnabled("emitSerial", eventName, eventArgs);
+    const listeners = this.getListeners(eventName) ?? /* @__PURE__ */ new Set();
+    const filteredListeners = [...listeners].filter((value) => isDefined(value.filter) ? filterMatch(eventArgs, value.filter) : true).map((info) => info.listener);
+    const anyListeners = assertEx(_Events.anyMap.get(this));
+    const staticListeners = [...filteredListeners];
+    const staticAnyListeners = [...anyListeners];
+    await resolvedPromise;
+    for (const listener of staticListeners) {
+      await this.safeCallListener(eventName, eventArgs, listener);
+    }
+    for (const listener of staticAnyListeners) {
+      await this.safeCallAnyListener(eventName, eventArgs, listener);
+    }
+  }
+  /**
+   * Returns the total number of listeners registered for the specified event name(s).
+   * @param eventNames - One or more event names to count listeners for.
+   * @returns The total listener count.
+   */
+  // TODO: Make test for this
+  listenerCount(eventNames) {
+    const eventNamesArray = Array.isArray(eventNames) ? eventNames : [eventNames];
+    let count = 0;
+    for (const eventName of eventNamesArray) {
+      if (typeof eventName === "string") {
+        count += assertEx(_Events.anyMap.get(this)).size + (this.getListeners(eventName)?.size ?? 0);
+        continue;
+      }
+      count += assertEx(_Events.anyMap.get(this)).size;
+      const eventListeners = assertEx(_Events.eventsMap.get(this)).values();
+      for (const value of eventListeners) {
+        count += value.size;
+      }
+    }
+    return count;
+  }
+  /**
+   * Logs debug information if debug mode is enabled.
+   * @param type - The type of operation being logged.
+   * @param eventName - The event name, if applicable.
+   * @param eventArgs - The event data, if applicable.
+   */
+  logIfDebugEnabled(type, eventName, eventArgs) {
+    if (_Events.isDebugEnabled || this.debug?.enabled === true) {
+      this.debug?.logger?.(type, this.debug.name, eventName, eventArgs);
+    }
+  }
+  /**
+   * Removes a specific listener from the specified event name(s).
+   * @param eventNames - One or more event names to unsubscribe from.
+   * @param listener - The listener to remove.
+   */
+  off(eventNames, listener) {
+    const eventNamesArray = Array.isArray(eventNames) ? eventNames : [eventNames];
+    for (const eventName of eventNamesArray) {
+      const set = this.getListeners(eventName);
+      if (set) {
+        set.delete(listener);
+        if (set.size === 0) {
+          const events = _Events.eventsMap.get(this);
+          events?.delete(eventName);
+        }
+      }
+      this.logIfDebugEnabled("unsubscribe", eventName);
+      if (!isMetaEvent(eventName)) {
+        forgetNode(this.emitMetaEvent("listenerRemoved", { eventName, listener }));
+      }
+    }
+  }
+  /**
+   * Removes a wildcard listener that was receiving all events.
+   * @param listener - The wildcard listener to remove.
+   */
+  offAny(listener) {
+    this.logIfDebugEnabled("unsubscribeAny");
+    const typedMap = _Events.anyMap.get(this);
+    typedMap?.delete(listener);
+    forgetNode(this.emitMetaEvent("listenerRemoved", { listener }));
+  }
+  /**
+   * Subscribes a listener to the specified event name(s).
+   * @param eventNames - One or more event names to listen for.
+   * @param listener - The callback to invoke when the event fires.
+   * @param filter - Optional filter to selectively invoke the listener based on event data.
+   * @returns An unsubscribe function.
+   */
+  on(eventNames, listener, filter) {
+    const eventNamesArray = Array.isArray(eventNames) ? eventNames : [eventNames];
+    for (const eventName of eventNamesArray) {
+      let set = this.getListeners(eventName);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        const events = _Events.eventsMap.get(this);
+        events?.set(eventName, set);
+      }
+      set.add({ filter, listener });
+      this.logIfDebugEnabled("subscribe", eventName);
+      if (!isMetaEvent(eventName)) {
+        forgetNode(this.emitMetaEvent("listenerAdded", { eventName, listener }));
+      }
+    }
+    return this.off.bind(this, eventNames, listener);
+  }
+  /**
+   * Subscribes a wildcard listener that receives all events.
+   * @param listener - The callback to invoke for any event.
+   * @returns An unsubscribe function.
+   */
+  onAny(listener) {
+    this.logIfDebugEnabled("subscribeAny");
+    _Events.anyMap.get(this)?.add(listener);
+    forgetNode(this.emitMetaEvent("listenerAdded", { listener }));
+    return this.offAny.bind(this, listener);
+  }
+  /**
+   * Subscribes a listener that will be invoked only once for the specified event, then automatically removed.
+   * @param eventName - The event to listen for.
+   * @param listener - The callback to invoke once.
+   * @returns An unsubscribe function.
+   */
+  once(eventName, listener) {
+    const subListener = async (args) => {
+      this.off(eventName, subListener);
+      await this.safeCallListener(eventName, args, listener);
+    };
+    this.on(eventName, subListener);
+    return this.off.bind(this, eventName, subListener);
+  }
+  async emitInternal(eventName, eventArgs, filter) {
+    if (isMetaEvent(eventName) && !this._canEmitMetaEvents) {
+      throw new TypeError(NO_META_EVENT_ERROR_MESSAGE);
+    }
+    this.logIfDebugEnabled("emit", eventName, eventArgs);
+    const listeners = this.getListeners(eventName) ?? /* @__PURE__ */ new Set();
+    const filteredListeners = [...listeners].filter((value) => isDefined(filter) ? isDefined(value.listener) : true).map((info) => info.listener);
+    const anyListeners = assertEx(_Events.anyMap.get(this));
+    const staticListeners = [...filteredListeners];
+    const staticAnyListeners = isMetaEvent(eventName) ? [] : [...anyListeners];
+    await resolvedPromise;
+    await Promise.all([
+      ...staticListeners.map(async (listener) => {
+        await this.safeCallListener(eventName, eventArgs, listener);
+      }),
+      ...staticAnyListeners.map(async (listener) => {
+        if (anyListeners.has(listener)) {
+          await this.safeCallAnyListener(eventName, eventArgs, listener);
+        }
+      })
+    ]);
+  }
+  async emitMetaEventInternal(eventName, eventArgs) {
+    if (isMetaEvent(eventName) && !this._canEmitMetaEvents) {
+      throw new TypeError("`eventName` cannot be meta event `listenerAdded` or `listenerRemoved`");
+    }
+    this.logIfDebugEnabled("emit", eventName, eventArgs);
+    const listeners = this.getListeners(eventName) ?? /* @__PURE__ */ new Set();
+    const filteredListeners = [...listeners].map((info) => info.listener);
+    const anyListeners = assertEx(_Events.anyMap.get(this));
+    const staticListeners = [...filteredListeners];
+    const staticAnyListeners = isMetaEvent(eventName) ? [] : [...anyListeners];
+    await resolvedPromise;
+    await Promise.all([
+      ...staticListeners.map(async (listener) => {
+        await this.safeCallListener(eventName, eventArgs, listener);
+      }),
+      /* v8 ignore start -- race condition guard */
+      ...staticAnyListeners.map(async (listener) => {
+        if (anyListeners.has(listener)) {
+          await this.safeCallAnyListener(eventName, eventArgs, listener);
+        }
+      })
+      /* v8 ignore stop */
+    ]);
+    return true;
+  }
+  getListeners(eventName) {
+    const events = assertEx(_Events.eventsMap.get(this));
+    if (!events.has(eventName)) {
+      return;
+    }
+    return events.get(eventName);
+  }
+  async safeCallAnyListener(eventName, eventArgs, listener) {
+    try {
+      return await listener(eventName, eventArgs);
+    } catch (ex) {
+      handleError(ex, (error) => {
+        this.logger?.error(`Listener[${String(eventName)}] Excepted: ${error.message}`);
+      });
+    }
+  }
+  async safeCallListener(eventName, eventArgs, listener) {
+    try {
+      return await listener(eventArgs);
+    } catch (ex) {
+      handleError(ex, (error) => {
+        this.logger?.error(`Listener[${String(eventName)}] Excepted: ${error.message}`);
+      });
+    }
+  }
+};
+
+// src/modules/events/BaseEmitter.ts
+var BaseEmitter = class extends Base {
+  // just here to query types
+  eventData = {};
+  events;
+  constructor(params) {
+    super(params);
+    this.events = new Events();
+  }
+  /**
+   * Removes all listeners for the specified event name(s).
+   * @param eventNames - One or more event names to clear listeners for.
+   * @returns This instance for chaining.
+   */
+  clearListeners(eventNames) {
+    this.events.clearListeners(eventNames);
+    return this;
+  }
+  /**
+   * Emits an event, invoking all registered listeners concurrently.
+   * @param eventName - The event to emit.
+   * @param eventArgs - The data to pass to listeners.
+   */
+  emit(eventName, eventArgs) {
+    return this.events.emit(eventName, eventArgs);
+  }
+  /**
+   * Emits an event, invoking all registered listeners sequentially in order.
+   * @param eventName - The event to emit.
+   * @param eventArgs - The data to pass to listeners.
+   */
+  emitSerial(eventName, eventArgs) {
+    return this.events.emitSerial(eventName, eventArgs);
+  }
+  /**
+   * Returns the total number of listeners registered for the specified event name(s).
+   * @param eventNames - One or more event names to count listeners for.
+   * @returns The total listener count.
+   */
+  listenerCount(eventNames) {
+    return this.events.listenerCount(eventNames);
+  }
+  /**
+   * Removes a specific listener from the specified event name(s).
+   * @param eventNames - One or more event names to unsubscribe from.
+   * @param listener - The listener to remove.
+   */
+  off(eventNames, listener) {
+    return this.events.off(eventNames, listener);
+  }
+  /**
+   * Removes a wildcard listener that was receiving all events.
+   * @param listener - The wildcard listener to remove.
+   */
+  offAny(listener) {
+    return this.events.offAny(listener);
+  }
+  /**
+   * Subscribes a listener to the specified event name(s).
+   * @param eventNames - One or more event names to listen for.
+   * @param listener - The callback to invoke when the event fires.
+   * @returns An unsubscribe function.
+   */
+  on(eventNames, listener) {
+    return this.events.on(eventNames, listener);
+  }
+  /**
+   * Subscribes a wildcard listener that receives all events.
+   * @param listener - The callback to invoke for any event.
+   * @returns An unsubscribe function.
+   */
+  onAny(listener) {
+    return this.events.onAny(listener);
+  }
+  /**
+   * Subscribes a listener that will be invoked only once for the specified event, then automatically removed.
+   * @param eventName - The event to listen for.
+   * @param listener - The callback to invoke once.
+   * @returns An unsubscribe function.
+   */
+  once(eventName, listener) {
+    return this.events.once(eventName, listener);
+  }
+};
+
+// src/modules/telemetry/span.ts
+import {
+  context,
+  propagation,
+  ROOT_CONTEXT,
+  SpanStatusCode,
+  trace as TRACE_API
+} from "@opentelemetry/api";
+
+// src/modules/telemetry/timeBudget.ts
+async function timeBudget(name, logger, func, budget, status = false) {
+  const start = Date.now();
+  const timer = status ? setInterval(() => {
+    const duration2 = Date.now() - start;
+    if (budget > 0 && duration2 > budget) {
+      logger?.warn(`Function [${name}] execution is exceeding budget: ${duration2}ms > ${budget}ms`);
+    }
+  }, Math.max(100, budget)) : void 0;
+  const result = await func();
+  const duration = Date.now() - start;
+  if (timer === void 0 && budget > 0 && duration > budget) {
+    logger?.warn(`Function [${name}] execution exceeded budget: ${duration}ms > ${budget}ms`);
+  }
+  if (timer !== void 0) {
+    clearInterval(timer);
+  }
+  return result;
+}
+
+// src/modules/telemetry/span.ts
+function cloneContextWithoutSpan(activeCtx, configKeys = []) {
+  let newCtx = ROOT_CONTEXT;
+  const baggage = propagation.getBaggage(activeCtx);
+  if (baggage) {
+    newCtx = propagation.setBaggage(newCtx, baggage);
+  }
+  for (const key of configKeys) {
+    const value = activeCtx.getValue(key);
+    if (value !== void 0) {
+      newCtx = newCtx.setValue(key, value);
+    }
+  }
+  return newCtx;
+}
+function span(name, fn, traceProvider = TRACE_API) {
+  const activeTracer = traceProvider.getTracer(name);
+  if (isDefined(activeTracer)) {
+    const span2 = activeTracer.startSpan(name);
+    return context.with(TRACE_API.setSpan(context.active(), span2), () => {
+      try {
+        const result = fn();
+        span2.setStatus({ code: SpanStatusCode.OK });
+        return result;
+      } catch (ex) {
+        const error = ex;
+        span2.recordException(error);
+        span2.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+        throw ex;
+      } finally {
+        span2.end();
+      }
+    });
+  }
+  return fn();
+}
+function spanRoot(name, fn, tracer) {
+  const activeTracer = tracer ?? TRACE_API.getTracer(name);
+  if (isDefined(activeTracer)) {
+    const activeContext = context.active();
+    const noSpanContext = cloneContextWithoutSpan(activeContext);
+    const span2 = activeTracer.startSpan(name, {}, noSpanContext);
+    return context.with(TRACE_API.setSpan(noSpanContext, span2), () => {
+      try {
+        const result = fn();
+        span2.setStatus({ code: SpanStatusCode.OK });
+        return result;
+      } catch (ex) {
+        const error = ex;
+        span2.recordException(error);
+        span2.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+        throw ex;
+      } finally {
+        span2.end();
+      }
+    });
+  }
+  return fn();
+}
+async function spanAsync(name, fn, {
+  timeBudgetLimit,
+  logger,
+  tracer
+} = {}) {
+  const activeTracer = tracer ?? TRACE_API.getTracer(name);
+  const funcToRun = isDefined(timeBudgetLimit) ? () => timeBudget(name, logger ?? console, fn, timeBudgetLimit) : fn;
+  if (isDefined(activeTracer)) {
+    const span2 = activeTracer.startSpan(name);
+    return await context.with(TRACE_API.setSpan(context.active(), span2), async () => {
+      try {
+        const result = await funcToRun();
+        span2.setStatus({ code: SpanStatusCode.OK });
+        return result;
+      } catch (ex) {
+        const error = ex;
+        span2.recordException(error);
+        span2.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+        throw ex;
+      } finally {
+        span2.end();
+      }
+    });
+  }
+  return await funcToRun();
+}
+async function spanRootAsync(name, fn, {
+  timeBudgetLimit,
+  logger,
+  tracer
+} = {}) {
+  const funcToRun = isDefined(timeBudgetLimit) ? () => timeBudget(name, logger ?? console, fn, timeBudgetLimit) : fn;
+  const activeTracer = tracer ?? TRACE_API.getTracer(name);
+  if (isDefined(activeTracer)) {
+    const activeContext = context.active();
+    const noSpanContext = cloneContextWithoutSpan(activeContext);
+    const span2 = activeTracer.startSpan(name, {}, noSpanContext);
+    return await context.with(TRACE_API.setSpan(noSpanContext, span2), async () => {
+      try {
+        const result = await funcToRun();
+        span2.setStatus({ code: SpanStatusCode.OK });
+        return result;
+      } catch (ex) {
+        const error = ex;
+        span2.recordException(error);
+        span2.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+        throw ex;
+      } finally {
+        span2.end();
+      }
+    });
+  }
+  return await funcToRun();
+}
+
+// src/modules/creatable/Creatable.ts
+function creatable() {
+  return (constructor) => {
+    constructor;
+  };
+}
+function creatableFactory() {
+  return (constructor) => {
+    constructor;
+  };
+}
+
+// src/modules/creatable/Factory.ts
+var Factory = class _Factory {
+  /** The Creatable class this factory delegates creation to. */
+  creatable;
+  /** Default parameters merged into every `create` call. */
+  defaultParams;
+  /** Labels identifying resources created by this factory. */
+  labels;
+  constructor(creatable2, params, labels = {}) {
+    this.creatable = creatable2;
+    this.defaultParams = params;
+    this.labels = Object.assign({}, creatable2.labels ?? {}, labels ?? {});
+  }
+  /**
+   * Creates a new Factory instance with the given default params and labels.
+   * @param creatableModule - The Creatable class to wrap
+   * @param params - Default parameters for new instances
+   * @param labels - Labels to assign to created instances
+   */
+  static withParams(creatableModule, params, labels = {}) {
+    return new _Factory(creatableModule, params, labels);
+  }
+  /**
+   * Creates a new instance, merging the provided params over the factory defaults.
+   * @param params - Optional parameters to override the factory defaults
+   */
+  create(params) {
+    const mergedParams = {
+      ...this.defaultParams,
+      ...params
+    };
+    return this.creatable.create(mergedParams);
+  }
+};
+
+// src/modules/creatable/lib/getFunctionName.ts
+function getFunctionName(depth = 2) {
+  const error = new Error("Stack");
+  let newIndex;
+  const stackParts = error.stack?.split("\n")[depth]?.split(" ");
+  const funcName = stackParts?.find((item, index) => {
+    if (!(item.length > 0 && item !== "at")) {
+      return;
+    }
+    if (item === "new") {
+      newIndex = index;
+    }
+    return true;
+  }) ?? "<unknown>";
+  return isNumber(newIndex) ? `${funcName} ${stackParts?.[newIndex + 1]}` : funcName;
+}
+
+// src/modules/creatable/lib/getRootFunction.ts
+var getPrototype = (value) => {
+  const prototype = Object.getPrototypeOf(value);
+  return typeof prototype === "object" ? prototype : null;
+};
+function getRootFunction(obj, funcName) {
+  if (obj === null || typeof obj !== "object") return void 0;
+  let current = obj;
+  let prototype = getPrototype(current);
+  while (prototype !== null && prototype[funcName] !== void 0) {
+    current = prototype;
+    prototype = getPrototype(current);
+  }
+  return current[funcName];
+}
+
+// src/modules/creatable/AbstractCreatable.ts
+var AbstractCreatableConstructorKey = /* @__PURE__ */ Symbol.for("AbstractCreatableConstructor");
+var CREATABLE_NOT_STARTED = "Creatable not Started";
+var AbstractCreatable = class extends BaseEmitter {
+  /** Optional default logger for this instance. */
+  defaultLogger;
+  _startPromise;
+  _status = null;
+  _statusMutex = new Mutex();
+  _validatedParams;
+  constructor(key, params) {
+    assertEx(key === AbstractCreatableConstructorKey, () => "AbstractCreatable should not be instantiated directly, use the static create method instead");
+    super(params);
+  }
+  /** The name identifier for this creatable instance. */
+  get name() {
+    return this.params.name;
+  }
+  /** The validated and merged parameters for this instance. */
+  get params() {
+    this._validatedParams ??= this.paramsValidator(super.params);
+    return this._validatedParams;
+  }
+  /** Whether this instance can be started (must be in 'created' or 'stopped' status). */
+  get startable() {
+    return this.status === "created" || this.status === "stopped";
+  }
+  /** The current lifecycle status of this instance, or null if not yet initialized. */
+  get status() {
+    return this._status;
+  }
+  /** The status reporter used to broadcast lifecycle changes. */
+  get statusReporter() {
+    return this.params.statusReporter;
+  }
+  /**
+   * Asynchronously creates a new instance by processing params, constructing,
+   * and running both static and instance createHandlers.
+   * @param inParams - Optional partial parameters to configure the instance
+   * @returns The fully initialized instance
+   */
+  static async create(inParams = {}) {
+    const params = await this.paramsHandler(inParams);
+    const name = params.name ?? this.name;
+    try {
+      const [Constructor] = [this];
+      const instance = new Constructor(AbstractCreatableConstructorKey, params);
+      instance.setStatus("creating");
+      const initializedInstance = await this.createHandler(instance);
+      await instance.createHandler();
+      instance.setStatus("created");
+      return initializedInstance;
+    } catch (ex) {
+      params.statusReporter?.report(name, "error", isError(ex) ? ex : new Error(`Error creating: ${name}`));
+      params.logger?.error(`Error creating creatable [${name}]: ${isError(ex) ? `${ex.message} ${ex.stack}` : String(ex)}`);
+      throw isError(ex) ? ex : new Error(`Error creating: ${name}`);
+    }
+  }
+  /**
+   * Static hook called during creation to perform additional initialization.
+   * Override in subclasses to customize post-construction setup.
+   * @param instance - The newly constructed instance
+   * @returns The instance, potentially modified
+   */
+  static createHandler(instance) {
+    return instance;
+  }
+  /**
+   * Static hook called during creation to validate and transform params.
+   * Override in subclasses to add default values or validation.
+   * @param params - The raw partial params provided to `create`
+   * @returns The processed params ready for construction
+   */
+  static paramsHandler(params = {}) {
+    return { ...params };
+  }
+  /** Instance-level creation hook. Override in subclasses to perform setup after construction. */
+  createHandler() {
+    assertEx(this._status === "creating", () => `createHandler can not be called [status = ${this.status}]`);
+  }
+  /**
+   * Validates and returns the merged params, ensuring required fields are present.
+   * Override in subclasses to add custom validation logic.
+   * @param params - The raw partial params to validate
+   * @returns The validated params
+   */
+  paramsValidator(params) {
+    return { ...params, name: params.name };
+  }
+  /**
+   * Executes a function within a telemetry span.
+   * @param name - The span name
+   * @param fn - The function to execute within the span
+   */
+  span(name, fn) {
+    return spanRoot(name, fn, this.tracer);
+  }
+  /**
+   * Executes an async function within a telemetry span.
+   * @param name - The span name
+   * @param fn - The async function to execute within the span
+   * @param config - Optional span configuration
+   */
+  async spanAsync(name, fn, config = {}) {
+    return await spanRootAsync(name, fn, {
+      ...config,
+      tracer: config.tracer ?? this.tracer,
+      logger: config.logger ?? this.defaultLogger
+    });
+  }
+  /**
+   * Starts the instance, transitioning through 'starting' to 'started' status.
+   * Thread-safe via mutex. Returns true if already started or started successfully.
+   */
+  async start() {
+    this._noOverride("start");
+    if (this.status === "started") {
+      return true;
+    }
+    return await this._statusMutex.runExclusive(async () => {
+      try {
+        if (this.status === "started") {
+          return true;
+        }
+        assertEx(this.startable, () => `Creatable [${this.name}] is not startable in status [${this.status}]`);
+        this.setStatus("starting");
+        await this.startHandler();
+        this.setStatus("started");
+        return true;
+      } catch (ex) {
+        this.setStatus("error", isError(ex) ? ex : new Error(`Error starting: ${String(ex)}`));
+        this.logger?.error(`Error starting creatable [${this.name}]: ${isError(ex) ? `${ex.message} ${ex.stack}` : String(ex)}`);
+        return false;
+      }
+    });
+  }
+  /**
+   * Checks whether this instance is currently started.
+   * Takes an action if not started, based on the notStartedAction parameter.
+   * @param notStartedAction - What to do if not started: 'error'/'throw' throws, 'warn'/'log' logs, 'none' is silent
+   * @returns True if started, false otherwise
+   */
+  started(notStartedAction = "log") {
+    if (isString(this.status) && this.status === "started") {
+      return true;
+    }
+    const message = () => `${CREATABLE_NOT_STARTED} [${this.name}] current state: ${this.status}`;
+    switch (notStartedAction) {
+      case "error": {
+        throw new Error(message());
+      }
+      case "throw": {
+        throw new Error(message());
+      }
+      case "warn": {
+        this.logger?.warn(message());
+        break;
+      }
+      case "log": {
+        this.logger?.log(message());
+        break;
+      }
+      case "none": {
+        break;
+      }
+      default: {
+        throw new Error(`Unknown notStartedAction: ${notStartedAction}`);
+      }
+    }
+    return false;
+  }
+  /**
+   * Async version of `started` that can optionally auto-start the instance.
+   * @param notStartedAction - What to do if not started and auto-start is disabled
+   * @param tryStart - If true, attempts to start the instance automatically
+   * @returns True if the instance is or becomes started
+   */
+  async startedAsync(notStartedAction = "log", tryStart = true) {
+    if (isString(this.status) && this.status === "started") {
+      return true;
+    }
+    if (this.status !== null && ["created", "stopped", "starting"].includes(this.status)) {
+      this._startPromise ??= (async () => {
+        if (tryStart) {
+          try {
+            return await this.start();
+          } finally {
+            this._startPromise = void 0;
+          }
+        }
+        return this.started(notStartedAction);
+      })();
+    } else {
+      const message = `${CREATABLE_NOT_STARTED} [${this.name}] current state: ${this.status}`;
+      throw new Error(message);
+    }
+    if (isUndefined(this._startPromise)) {
+      throw new Error(`Failed to create start promise: ${this.status}`);
+    }
+    return await this._startPromise;
+  }
+  /**
+   * Stops the instance, transitioning through 'stopping' to 'stopped' status.
+   * Thread-safe via mutex. Returns true if already stopped or stopped successfully.
+   */
+  async stop() {
+    this._noOverride("stop");
+    if (this.status === "stopped") {
+      return true;
+    }
+    return await this._statusMutex.runExclusive(async () => {
+      try {
+        if (this.status === "stopped") {
+          return true;
+        }
+        assertEx(this.status === "started", () => `Creatable [${this.name}] is not stoppable in status [${this.status}]`);
+        this.setStatus("stopping");
+        await this.stopHandler();
+        this.setStatus("stopped");
+        return true;
+      } catch (ex) {
+        this.setStatus("error", isError(ex) ? ex : new Error(`Error stopping: ${String(ex)}`));
+        return false;
+      }
+    });
+  }
+  /**
+   * Asserts that the given function has not been overridden in a subclass.
+   * Used to enforce the handler pattern (override `startHandler` not `start`).
+   */
+  _noOverride(functionName2 = getFunctionName(3)) {
+    const thisFunc = this[functionName2];
+    const rootFunc = getRootFunction(this, functionName2);
+    assertEx(thisFunc === rootFunc, () => `Override not allowed for [${functionName2}] - override ${functionName2}Handler instead`);
+  }
+  setStatus(value, progressOrError) {
+    this._status = value;
+    if (value !== null) {
+      if (value === "error") {
+        if (isError(progressOrError)) {
+          this.statusReporter?.report(this.name, value, progressOrError);
+          return;
+        }
+      } else {
+        if (isNumber(progressOrError)) {
+          this.statusReporter?.report(this.name, value, progressOrError);
+          return;
+        }
+      }
+      this.statusReporter?.report(this.name, value);
+    }
+  }
+  /** Override in subclasses to define start behavior. Throw an error on failure. */
+  startHandler() {
+  }
+  /** Override in subclasses to define stop behavior. Throw an error on failure. */
+  stopHandler() {
+  }
+};
+AbstractCreatable = __decorateClass([
+  creatable()
+], AbstractCreatable);
+var AbstractCreatableWithFactory = class extends AbstractCreatable {
+  /**
+   * Creates a factory that produces instances of this class with pre-configured params and labels.
+   * @param params - Default parameters for instances created by the factory
+   * @param labels - Labels to assign to created instances
+   */
+  static factory(params, labels) {
+    return Factory.withParams(this, params, labels);
+  }
+};
+AbstractCreatableWithFactory = __decorateClass([
+  creatable()
+], AbstractCreatableWithFactory);
+
+// src/modules/creatable/model/Labels.ts
+var hasAllLabels = (source, required) => {
+  if (!required) return true;
+  return Object.entries(required).every(([key, value]) => {
+    return Object.hasOwn(source ?? {}, key) && source?.[key] === value;
+  });
+};
+
+// src/modules/decimal-precision/fromFixedPoint.ts
+var fromFixedPoint = (value, places = 18) => {
+  if (!Number.isSafeInteger(places)) throw new Error(`places (${places}) must be an Integer`);
+  return value / 10n ** BigInt(places);
+};
+
+// src/modules/decimal-precision/toDecimalPrecision.ts
+var toDecimalPrecision = (value, digits) => {
+  let fixed = 0;
+  const result = Number(value.toPrecision(digits));
+  while (Number(result.toFixed(fixed)) !== result && fixed < 20) {
+    fixed++;
+  }
+  return result.toFixed(fixed);
+};
+
+// src/modules/decimal-precision/toFixedPoint.ts
+var toFixedPoint = (value, places = 18) => {
+  if (!Number.isSafeInteger(places)) throw new Error(`places (${places}) must be an Integer`);
+  if (typeof value === "string") {
+    const parts = value.split(".");
+    if (parts.length > 2) {
+      throw new Error("Too many decimals in value");
+    }
+    if (parts.length === 1) {
+      return BigInt(value) * 10n ** BigInt(places);
+    }
+    const [whole, fraction] = parts;
+    const trimmed = fraction.slice(0, places);
+    return BigInt(whole + trimmed.padEnd(Number(places), "0"));
+  }
+  return value * 10n ** BigInt(places);
+};
+
+// src/modules/ellipsize/index.ts
+var ellipsize = (value, length = 2) => {
+  const part1 = value.slice(0, length);
+  const part2 = value.slice(value.length - length);
+  return `${part1}...${part2}`;
+};
+
+// src/modules/function-name/functionName.ts
+var functionName = (depth = 2) => {
+  try {
+    throw new Error("Getting function name");
+  } catch (ex) {
+    return handleError(ex, (error) => {
+      let newIndex;
+      const stackParts = error.stack?.split("\n")[depth].split(" ");
+      const funcName = stackParts?.find((item, index) => {
+        if (!(item.length > 0 && item !== "at")) {
+          return;
+        }
+        if (item === "new") {
+          newIndex = index;
+        }
+        return true;
+      }) ?? "<unknown>";
+      return isNumber(newIndex) ? `${funcName} ${stackParts?.[newIndex + 1]}` : funcName;
+    });
+  }
+};
+
+// src/modules/logger/NoOpLogFunction.ts
+var NoOpLogFunction = (..._data) => void {};
+
+// src/modules/logger/LevelLogger.ts
+var LogLevel = Enum({
+  error: 1,
+  warn: 2,
+  info: 3,
+  log: 4,
+  debug: 5,
+  trace: 6
+});
+var LevelLogger = class {
+  level;
+  logger;
+  constructor(logger, level = LogLevel.warn) {
+    this.level = level;
+    this.logger = logger;
+  }
+  get debug() {
+    return this.level >= LogLevel.debug ? this.logger.debug : NoOpLogFunction;
+  }
+  get error() {
+    return this.level >= LogLevel.error ? this.logger.error : NoOpLogFunction;
+  }
+  get info() {
+    return this.level >= LogLevel.info ? this.logger.info : NoOpLogFunction;
+  }
+  get log() {
+    return this.level >= LogLevel.log ? this.logger.log : NoOpLogFunction;
+  }
+  get trace() {
+    return this.level >= LogLevel.trace ? this.logger.trace : NoOpLogFunction;
+  }
+  get warn() {
+    return this.level >= LogLevel.warn ? this.logger.warn : NoOpLogFunction;
+  }
+};
+
+// src/modules/logger/ConsoleLogger.ts
+var ConsoleLogger = class extends LevelLogger {
+  constructor(level = LogLevel.warn) {
+    super(console, level);
+  }
+};
+
+// src/modules/logger/getFunctionName.ts
+var getFunctionName2 = (depth = 2) => {
+  try {
+    throw new Error("Getting function name");
+  } catch (ex) {
+    return handleError(ex, (error) => {
+      let newIndex;
+      const stackParts = error.stack?.split("\n")[depth]?.split(" ");
+      const funcName = stackParts?.find((item, index) => {
+        if (!(item.length > 0 && item !== "at")) {
+          return;
+        }
+        if (item === "new") {
+          newIndex = index;
+        }
+        return true;
+      }) ?? "<unknown>";
+      return isNumber(newIndex) ? `${funcName} ${stackParts?.[newIndex + 1]}` : funcName;
+    });
+  }
+};
+
+// src/modules/logger/IdLogger.ts
+var IdLogger = class {
+  _id;
+  _logger;
+  constructor(logger, id) {
+    this._logger = logger;
+    this._id = id;
+  }
+  set id(id) {
+    this._id = () => id;
+  }
+  debug(...data) {
+    this._logger?.debug(this.prefix(), ...data);
+  }
+  error(...data) {
+    this._logger?.error(this.prefix(), ...data);
+  }
+  info(...data) {
+    this._logger?.info(this.prefix(), ...data);
+  }
+  log(...data) {
+    this._logger?.log(this.prefix(), ...data);
+  }
+  trace(...data) {
+    this._logger?.trace(this.prefix(), ...data);
+  }
+  warn(...data) {
+    this._logger?.warn(this.prefix(), ...data);
+  }
+  prefix() {
+    return `[${this._id?.()}]`;
+  }
+};
+
+// src/modules/logger/SilentLogger.ts
+var SilentLogger = class {
+  debug = NoOpLogFunction;
+  error = NoOpLogFunction;
+  info = NoOpLogFunction;
+  log = NoOpLogFunction;
+  trace = NoOpLogFunction;
+  warn = NoOpLogFunction;
+};
+
+// src/modules/object/AsTypeFactory.ts
+var AsTypeFactory = {
+  create: (typeCheck) => {
+    const func = (value, assertOrConfig, config) => {
+      const isPredicate = typeof assertOrConfig === "number";
+      const resolvedAssert = isPredicate || typeof assertOrConfig === "object" ? void 0 : assertOrConfig;
+      const resolvedConfig = isPredicate ? void 0 : typeof assertOrConfig === "object" ? assertOrConfig : config;
+      const isRequired = isTruthy(resolvedConfig?.required);
+      if (!isRequired && (value === void 0 || value === null)) {
+        return void 0;
+      }
+      if (isPromise(value)) {
+        throw new TypeError('un-awaited promises may not be sent to "as" functions');
+      }
+      const result = typeCheck(value, resolvedConfig) ? value : void 0;
+      if (resolvedAssert !== void 0) {
+        const message = typeof resolvedAssert === "function" ? resolvedAssert : () => resolvedAssert;
+        return assertDefinedEx(result, message);
+      }
+      return result;
+    };
+    return func;
+  },
+  createOptional: (typeCheck) => {
+    const func = (value) => {
+      if (value === void 0 || value === null) return void 0;
+      if (isPromise(value)) {
+        throw new TypeError('un-awaited promises may not be sent to "as" functions');
+      }
+      return typeCheck(value) ? value : void 0;
+    };
+    return func;
+  }
+};
+
+// src/modules/object/AsObjectFactory.ts
+var AsObjectFactory = {
+  create: (typeCheck) => {
+    return AsTypeFactory.create(typeCheck);
+  },
+  createOptional: (typeCheck) => {
+    return AsTypeFactory.createOptional(typeCheck);
+  }
+};
+
+// src/modules/object/asObject.ts
+var asAnyObject = (() => AsObjectFactory.create((obj) => isObject(obj)))();
+
+// src/modules/object/deepMerge.ts
+var isUnsafeKey = (key) => typeof key === "string" && ["__proto__", "constructor", "prototype"].includes(key);
+var isPlainObject = (value) => {
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+};
+function merge(target, source, options) {
+  if (!source || typeof source !== "object") return target;
+  for (const key of Reflect.ownKeys(source)) {
+    if (isUnsafeKey(key)) {
+      continue;
+    }
+    const value = source[key];
+    if (Array.isArray(value)) {
+      const targetValue = target[key];
+      target[key] = options?.arrayStrategy === "concat" && Array.isArray(targetValue) ? [...targetValue, ...value] : value;
+    } else if (value !== null && typeof value === "object" && isPlainObject(value)) {
+      const targetValue = target[key];
+      if (targetValue === void 0 || targetValue === null || typeof targetValue !== "object" || !isPlainObject(targetValue)) {
+        target[key] = {};
+      }
+      merge(target[key], value, options);
+    } else {
+      target[key] = value;
+    }
+  }
+  return target;
+}
+function createDeepMerge(options) {
+  return function deepMerge2(...objects) {
+    const result = options.mutate === true ? objects[0] ?? {} : {};
+    for (const obj of objects) {
+      merge(result, obj, options);
+    }
+    return result;
+  };
+}
+var deepMerge = createDeepMerge({ arrayStrategy: "overwrite", mutate: false });
+
+// src/modules/object/IsObjectFactory.ts
+var IsObjectFactory = class {
+  /**
+   * Creates a type-guard function that validates an object matches the given shape and passes additional checks.
+   * @param shape - An optional map of property names to expected types.
+   * @param additionalChecks - Optional extra type-check functions to run after shape validation.
+   * @returns A type-guard function for type T.
+   */
+  create(shape, additionalChecks) {
+    return (obj, config) => {
+      if (!isObject(obj)) {
+        return false;
+      }
+      const log = typeof config === "object" ? config.log : void 0;
+      return (
+        // do primary check
+        Object.entries(shape ?? {}).filter(([key, type]) => {
+          const isResult = isType(obj[key], type);
+          if (!isResult && isTruthy(log)) {
+            const logger = typeof log === "object" ? log : console;
+            logger.warn(`isType Failed: ${key}: ${type}`);
+          }
+          return !isResult;
+        }).length === 0 && (additionalChecks?.reduce((prev, check) => prev && check(obj, { log }), true) ?? true)
+      );
+    };
+  }
+};
+
+// src/modules/object/JsonObject.ts
+import * as z12 from "zod/mini";
+
+// src/modules/zod/zodAsFactory.ts
+import * as z9 from "zod/v4/core";
+var formatZodValue = (value) => {
+  const json = JSON.stringify(value);
+  return json ?? String(value);
+};
+function zodAsFactory(zod, name) {
+  function asFunc(value, assert) {
+    const result = z9.safeParse(zod, value);
+    if (result.success) {
+      return value;
+    }
+    if (assert !== void 0) {
+      let assertConfig;
+      switch (typeof assert) {
+        case "string": {
+          assertConfig = `[${name}][${formatZodValue(value)}] ${assert}`;
+          break;
+        }
+        case "object": {
+          assertConfig = `[${name}][${assert.name}][${formatZodValue(value)}] ${result.error.message}`;
+          break;
+        }
+        case "boolean": {
+          assertConfig = `[${name}][${formatZodValue(value)}] ${result.error.message}`;
+          break;
+        }
+        case "function": {
+          assertConfig = assert(value, result.error.message);
+          break;
+        }
+      }
+      return assertError(value, assertConfig, result.error.message);
+    }
+  }
+  return asFunc;
+}
+
+// src/modules/zod/zodIsFactory.ts
+import * as z10 from "zod/v4/core";
+function zodIsFactory(zod) {
+  return (value) => z10.safeParse(zod, value).success;
+}
+
+// src/modules/zod/zodToFactory.ts
+function zodToFactory(zod, name) {
+  const as = zodAsFactory(zod, name);
+  function toFunc(value, assert) {
+    if (isDefined(assert)) {
+      return as(value, assert);
+    }
+    return as(value);
+  }
+  return toFunc;
+}
+
+// src/modules/zod/zodAllFactory.ts
+function zodAllFactory(zod, name) {
+  return {
+    [`is${name}`]: zodIsFactory(zod),
+    [`as${name}`]: zodAsFactory(zod, `as${name}`),
+    [`to${name}`]: zodToFactory(zod, `to${name}`)
+  };
+}
+
+// src/modules/zod/zodAsAsyncFactory.ts
+import * as z11 from "zod/v4/core";
+var formatZodValue2 = (value) => {
+  const json = JSON.stringify(value);
+  return json ?? String(value);
+};
+function zodAsAsyncFactory(zod, name) {
+  async function asFunc(value, assert) {
+    const result = await z11.safeParseAsync(zod, value);
+    if (result.success) {
+      return value;
+    }
+    if (assert !== void 0) {
+      let assertConfig;
+      switch (typeof assert) {
+        case "string": {
+          assertConfig = `[${name}][${formatZodValue2(value)}] ${assert}`;
+          break;
+        }
+        case "object": {
+          assertConfig = `[${name}][${assert.name}][${formatZodValue2(value)}] ${result.error.message}`;
+          break;
+        }
+        case "boolean": {
+          assertConfig = `[${name}][${formatZodValue2(value)}] ${result.error.message}`;
+          break;
+        }
+        case "function": {
+          assertConfig = assert(value, result.error.message);
+          break;
+        }
+      }
+      return assertError(value, assertConfig, result.error.message);
+    }
+  }
+  return asFunc;
+}
+
+// src/modules/zod/zodToAsyncFactory.ts
+function zodToAsyncFactory(zod, name) {
+  const as = zodAsAsyncFactory(zod, name);
+  async function toFunc(value, assert) {
+    if (isDefined(assert)) {
+      return await as(value, assert);
+    }
+    return await as(value);
+  }
+  return toFunc;
+}
+
+// src/modules/object/JsonObject.ts
+var JsonArrayZod = z12.array(z12.lazy(() => JsonValueZod));
+var JsonValueZod = z12.lazy(() => z12.union([
+  z12.string(),
+  z12.number(),
+  z12.boolean(),
+  z12.null(),
+  z12.array(JsonValueZod),
+  z12.record(z12.string(), JsonValueZod)
+  // object with string keys and JSON values
+]));
+var JsonObjectZod = z12.record(z12.string(), JsonValueZod);
+var isJsonValue = zodIsFactory(JsonValueZod);
+var asJsonValue = zodAsFactory(JsonValueZod, "asJsonValue");
+var toJsonValue = zodToFactory(JsonValueZod, "toJsonValue");
+var isJsonArray = zodIsFactory(JsonArrayZod);
+var asJsonArray = zodAsFactory(JsonArrayZod, "asJsonArray");
+var toJsonArray = zodToFactory(JsonArrayZod, "toJsonArray");
+var isJsonObject = zodIsFactory(JsonObjectZod);
+var asJsonObject = zodAsFactory(JsonObjectZod, "asJsonObject");
+var toJsonObject = zodToFactory(JsonObjectZod, "toJsonObject");
+
+// src/modules/object/ObjectWrapper.ts
+var ObjectWrapper = class {
+  obj;
+  constructor(obj) {
+    this.obj = obj;
+  }
+  get stringKeyObj() {
+    return this.obj;
+  }
+};
+
+// src/modules/object/omitBy.ts
+var omitByArray = (obj, predicate, maxDepth) => {
+  return obj.map((value) => {
+    return value !== null && typeof value === "object" ? omitBy(value, predicate, maxDepth) : value;
+  });
+};
+var omitByObject = (obj, predicate, maxDepth) => {
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    const value = obj[key];
+    if (!predicate(value, key)) {
+      result[key] = value !== null && typeof value === "object" ? omitBy(value, predicate, maxDepth - 1) : value;
+    }
+  }
+  return result;
+};
+var omitBy = (obj, predicate, maxDepth = 1) => {
+  if (maxDepth <= 0) {
+    return obj;
+  }
+  return Array.isArray(obj) ? omitByArray(obj, predicate, maxDepth - 1) : omitByObject(obj, predicate, maxDepth - 1);
+};
+var omitByPrefixPredicate = (prefix) => (_, key) => {
+  assertEx(typeof key === "string", () => `Invalid key type [${key}, ${typeof key}]`);
+  return key.startsWith(prefix);
+};
+var omitByPrefix = (payload, prefix, maxDepth = 100) => {
+  return omitBy(payload, omitByPrefixPredicate(prefix), maxDepth);
+};
+
+// src/modules/object/pickBy.ts
+var pickByArray = (obj, predicate, maxDepth) => {
+  return obj.map((value) => {
+    return value !== null && typeof value === "object" ? pickBy(value, predicate, maxDepth) : value;
+  });
+};
+var pickByObject = (obj, predicate, maxDepth) => {
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    const value = obj[key];
+    if (predicate(value, key)) {
+      result[key] = value !== null && typeof value === "object" ? pickBy(value, predicate, maxDepth - 1) : value;
+    }
+  }
+  return result;
+};
+var pickBy = (obj, predicate, maxDepth = 1) => {
+  if (maxDepth <= 0) {
+    return obj;
+  }
+  return Array.isArray(obj) ? pickByArray(obj, predicate, maxDepth - 1) : pickByObject(obj, predicate, maxDepth - 1);
+};
+var pickByPrefixPredicate = (prefix) => (_, key) => {
+  assertEx(typeof key === "string", () => `Invalid key type [${key}, ${typeof key}]`);
+  return key.startsWith(prefix);
+};
+var pickByPrefix = (payload, prefix, maxDepth = 100) => {
+  return pickBy(payload, pickByPrefixPredicate(prefix), maxDepth);
+};
+
+// src/modules/object/removeFields.ts
+var removeFields = (obj, fields) => {
+  const clone = { ...obj };
+  for (const field of fields) {
+    delete clone[field];
+  }
+  return clone;
+};
+
+// src/modules/object/toSafeJson.ts
+var toSafeJsonArray = (value, cycleList, maxDepth = 3) => {
+  return value.map((item) => toSafeJsonValue(item, cycleList, maxDepth));
+};
+var toSafeJsonObject = (value, cycleList, maxDepth = 3) => {
+  const result = {};
+  for (const [key, entry] of Object.entries(value)) {
+    result[key] = entry === void 0 ? "[Undefined]" : toSafeJsonValue(entry, cycleList, maxDepth);
+  }
+  return result;
+};
+var toSafeJsonValue = (value, cycleList, maxDepth = 3) => {
+  if (maxDepth <= 0 && typeof value === "object") {
+    return "[MaxDepth]";
+  }
+  if (cycleList?.includes(value) === true) {
+    return "[Circular]";
+  }
+  switch (typeof value) {
+    case "string":
+    case "boolean":
+    case "number": {
+      return value;
+    }
+    case "object": {
+      if (value === null) {
+        return null;
+      }
+      const newCycleList = cycleList ?? [];
+      newCycleList.push(value);
+      if (Array.isArray(value)) {
+        return toSafeJsonArray(value, newCycleList, maxDepth - 1);
+      }
+      return toSafeJsonObject(value, newCycleList, maxDepth - 1);
+    }
+    default: {
+      return `[${typeof value}]`;
+    }
+  }
+};
+var toSafeJsonString = (value, maxDepth = 3) => {
+  return JSON.stringify(toSafeJson(value, maxDepth), null, 2);
+};
+var toSafeJson = (value, maxDepth = 3) => {
+  return toSafeJsonValue(value, void 0, maxDepth);
+};
+
+// src/modules/object/Validator.ts
+var ValidatorBase = class extends ObjectWrapper {
+};
+
+// src/modules/profile/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;
+};
+
+// src/modules/promise/fulfilled.ts
+var fulfilled = (val) => {
+  return val.status === "fulfilled";
+};
+
+// src/modules/promise/fulfilledValues.ts
+var fulfilledValues = (previousValue, currentValue) => {
+  if (currentValue.status === "fulfilled") previousValue.push(currentValue.value);
+  return previousValue;
+};
+
+// src/modules/promise/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/modules/promise/rejected.ts
+var rejected = (val) => {
+  return val.status === "rejected";
+};
+
+// src/modules/promise/toPromise.ts
+function toPromise(value) {
+  return value instanceof Promise ? value : Promise.resolve(value);
+}
+
+// src/modules/retry/retry.ts
+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
+  });
+};
+
+// src/modules/set/lib/difference.ts
+var difference = (a, b) => {
+  return a.difference(b);
+};
+
+// src/modules/set/lib/intersection.ts
+var intersection = (a, b) => {
+  return a.intersection(b);
+};
+
+// src/modules/set/lib/union.ts
+var union3 = (a, b) => {
+  return a.union(b);
+};
+
+// src/modules/static-implements/staticImplements.ts
+function staticImplements() {
+  return (constructor) => {
+    constructor;
+  };
+}
+
+// src/modules/telemetry-exporter/XyConsoleSpanExporter.ts
+import { ConsoleSpanExporter } from "@opentelemetry/sdk-trace-base";
+var color = (open, close = 39) => {
+  return (value) => `\x1B[${open}m${value}\x1B[${close}m`;
+};
+var logColors = {
+  green: color(32),
+  grey: color(90),
+  magenta: color(35),
+  red: color(31),
+  white: color(37),
+  yellow: color(33)
+};
+function spanDurationInMillis(span2) {
+  return span2.duration[0] * 1e3 + span2.duration[1] / 1e6;
+}
+var XyConsoleSpanExporter = class _XyConsoleSpanExporter extends ConsoleSpanExporter {
+  /** Duration thresholds (in ms) that map to increasing log levels. */
+  static durationToLogLevel = [
+    0,
+    1,
+    10,
+    100,
+    1e3
+  ];
+  /** Chalk color functions corresponding to each log level. */
+  static logLevelToChalkColor = [
+    logColors.grey,
+    logColors.white,
+    logColors.green,
+    logColors.yellow,
+    logColors.red
+  ];
+  logger;
+  _logLevel;
+  constructor(logLevel = 0, logger = console) {
+    super();
+    this._logLevel = logLevel;
+    this.logger = logger;
+  }
+  /** The minimum log level required for a span to be exported. */
+  get logLevel() {
+    return this._logLevel;
+  }
+  export(spans) {
+    for (const span2 of spans) {
+      const spanLevel = this.spanLevel(span2);
+      if (spanLevel < this.logLevel) {
+        continue;
+      }
+      const duration = spanDurationInMillis(span2);
+      this.logger.log(logColors.grey([
+        `Span [${span2.name}]`,
+        this.logColor(spanLevel)(`${duration}ms`),
+        `TraceId: ${span2.spanContext().traceId}`
+      ].join(", ")));
+    }
+  }
+  /**
+   * Returns the chalk color function for the given log level.
+   * @param level - The log level index.
+   * @returns A chalk color function.
+   */
+  logColor(level) {
+    return _XyConsoleSpanExporter.logLevelToChalkColor[level] ?? logColors.magenta;
+  }
+  /**
+   * Determines the log level of a span based on its duration.
+   * @param span - The span to evaluate.
+   * @returns The numeric log level (index into durationToLogLevel).
+   */
+  spanLevel(span2) {
+    let logLevel = 0;
+    const duration = spanDurationInMillis(span2);
+    for (let x = _XyConsoleSpanExporter.durationToLogLevel.length - 1; x >= 0; x--) {
+      if (duration > _XyConsoleSpanExporter.durationToLogLevel[x]) {
+        logLevel = x;
+        break;
+      }
+    }
+    return logLevel;
+  }
+};
+export {
+  ADDRESS_LENGTH,
+  AbstractCreatable,
+  AbstractCreatableWithFactory,
+  AddressRegEx,
+  AddressTransformZod,
+  AddressValidationZod,
+  AddressZod,
+  ApiClient,
+  ApiEndpoint,
+  ApiStage,
+  AsObjectFactory,
+  AsTypeFactory,
+  Base,
+  BaseEmitter,
+  BigIntToJsonZod,
+  ConsoleLogger,
+  ETH_ZERO_ADDRESS,
+  Enum,
+  EthAddressFromStringSchema,
+  EthAddressFromStringZod,
+  EthAddressRegEx,
+  EthAddressToStringSchema,
+  EthAddressToStringZod,
+  EthAddressZod,
+  Events,
+  Factory,
+  FetchClient,
+  FetchClientError,
+  FetchError,
+  FetchJsonClient,
+  ForgetPromiseNode as ForgetPromise,
+  HASH_LENGTH,
+  HashBitLength,
+  HashRegEx,
+  HashToJsonZod,
+  HashZod,
+  HexRegEx,
+  HexRegExMinMax,
+  HexRegExMinMaxMixedCaseWithPrefix,
+  HexRegExWithPrefix,
+  HexZod,
+  IdLogger,
+  IsObjectFactory,
+  JsonObjectZod,
+  JsonToBigIntZod,
+  JsonToHashZod,
+  LevelLogger,
+  LogLevel,
+  NoOpLogFunction,
+  ObjectWrapper,
+  PromiseEx,
+  SilentLogger,
+  TimerScheduler,
+  ValidatorBase,
+  XyConsoleSpanExporter,
+  ZERO_ADDRESS,
+  ZERO_HASH,
+  asAddress,
+  asAddressV2,
+  asAnyObject,
+  asEthAddress,
+  asHash,
+  asHex,
+  asJsonArray,
+  asJsonObject,
+  asJsonValue,
+  assertDefinedEx,
+  assertError,
+  assertEx,
+  bitsToNibbles,
+  classifyFetchError,
+  clearTimeoutEx,
+  cloneContextWithoutSpan,
+  containsAll,
+  creatable,
+  creatableFactory,
+  createDeepMerge,
+  createProfiler,
+  deepMerge,
+  defaultForgetNodeConfig,
+  defaultTimerScheduler,
+  delay,
+  difference,
+  disableGloballyUnique,
+  distinct,
+  ellipsize,
+  equalArrayBuffers,
+  exists,
+  fetchCompress,
+  fetchJson,
+  fetchJsonClient,
+  fetchJsonDelete,
+  fetchJsonGet,
+  fetchJsonPatch,
+  fetchJsonPost,
+  fetchJsonPut,
+  filterAs,
+  filterAsync,
+  findAs,
+  findLastAs,
+  flatten,
+  forgetNode as forget,
+  fromFixedPoint,
+  fulfilled,
+  fulfilledValues,
+  functionName,
+  getApiStage,
+  getFunctionName2 as getFunctionName,
+  globallyUnique,
+  handleError,
+  handleErrorAsync,
+  hasAllLabels,
+  hexFrom,
+  hexFromArrayBuffer,
+  hexFromBigInt,
+  hexFromHexString,
+  hexFromNumber,
+  hexToBigInt,
+  ifDefined,
+  ifTypeOf,
+  intersection,
+  isAddress,
+  isAddressV2,
+  isArray,
+  isArrayBuffer,
+  isArrayBufferLike,
+  isArrayBufferView,
+  isBigInt,
+  isBlob,
+  isBoolean,
+  isDataView,
+  isDate,
+  isDateString,
+  isDefined,
+  isDefinedNotNull,
+  isEmpty,
+  isEmptyArray,
+  isEmptyObject,
+  isEmptyString,
+  isError,
+  isEthAddress,
+  isFalsy,
+  isFetchError,
+  isFile,
+  isFunction,
+  isHash,
+  isHashBitLength,
+  isHex,
+  isHexZero,
+  isJsonArray,
+  isJsonObject,
+  isJsonValue,
+  isMap,
+  isNull,
+  isNumber,
+  isObject,
+  isPopulatedArray,
+  isPromise,
+  isPromiseLike,
+  isRegExp,
+  isSet,
+  isString,
+  isSymbol,
+  isTruthy,
+  isType,
+  isTypedArray,
+  isTypedKey,
+  isTypedObject,
+  isTypedValue,
+  isUndefined,
+  isUndefinedOrNull,
+  isValidTypedFieldPair,
+  isWeakMap,
+  isWeakSet,
+  nibblesToBits,
+  omitBy,
+  omitByPrefix,
+  pickBy,
+  pickByPrefix,
+  profile,
+  profileReport,
+  rejected,
+  removeFields,
+  retry,
+  setTimeoutEx,
+  span,
+  spanAsync,
+  spanDurationInMillis,
+  spanRoot,
+  spanRootAsync,
+  staticImplements,
+  timeBudget,
+  toAddress,
+  toAddressV2,
+  toArrayBuffer,
+  toDecimalPrecision,
+  toEthAddress,
+  toFetchError,
+  toFixedPoint,
+  toHex,
+  toHexLegacy,
+  toJsonArray,
+  toJsonObject,
+  toJsonValue,
+  toPromise,
+  toSafeJson,
+  toSafeJsonArray,
+  toSafeJsonObject,
+  toSafeJsonString,
+  toSafeJsonValue,
+  toUint8Array,
+  typeOf,
+  union3 as union,
+  uniq,
+  uniqBy,
+  validateType,
+  zodAllFactory,
+  zodAsAsyncFactory,
+  zodAsFactory,
+  zodIsFactory,
+  zodToAsyncFactory,
+  zodToFactory
+};
+//# sourceMappingURL=index.mjs.map