@gravito/core 2.0.4 → 3.0.0

package/dist/PlanetCore.d.ts

@@ -183,6 +183,12 @@ export declare class PlanetCore {
     private deferredProviders;
     private bootedProviders;
     private isShuttingDown;
+    /**
+     * Global shutdown timeout in milliseconds (D-10).
+     * If the entire shutdown sequence does not complete within this limit,
+     * a warning is logged and shutdown is force-completed so the process can exit.
+     */
+    private static readonly GLOBAL_SHUTDOWN_TIMEOUT;
     /**
      * Initialize observability asynchronously (metrics, tracing, Prometheus).
      * This is called from constructor but doesn't block initialization.

package/dist/compat/async-local-storage.browser.js

@@ -0,0 +1,71 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __require = import.meta.require;
+
+// src/compat/async-local-storage.browser.ts
+class AsyncLocalStorage {
+  store;
+  run(store, fn) {
+    const prev = this.store;
+    this.store = store;
+    try {
+      return fn();
+    } finally {
+      this.store = prev;
+    }
+  }
+  getStore() {
+    return this.store;
+  }
+  disable() {
+    this.store = undefined;
+  }
+}
+export {
+  AsyncLocalStorage
+};
+
+//# debugId=1CD94D2F311BBD0564756E2164756E21

package/dist/compat/async-local-storage.browser.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/compat/async-local-storage.browser.ts"],
+  "sourcesContent": [
+    "/**\n * Browser-safe AsyncLocalStorage mock\n */\nexport class AsyncLocalStorage<T> {\n  private store: T | undefined\n\n  run<R>(store: T, fn: () => R): R {\n    const prev = this.store\n    this.store = store\n    try {\n      return fn()\n    } finally {\n      this.store = prev\n    }\n  }\n\n  getStore(): T | undefined {\n    return this.store\n  }\n\n  disable(): void {\n    this.store = undefined\n  }\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGO,MAAM,kBAAqB;AAAA,EACxB;AAAA,EAER,GAAM,CAAC,OAAU,IAAgB;AAAA,IAC/B,MAAM,OAAO,KAAK;AAAA,IAClB,KAAK,QAAQ;AAAA,IACb,IAAI;AAAA,MACF,OAAO,GAAG;AAAA,cACV;AAAA,MACA,KAAK,QAAQ;AAAA;AAAA;AAAA,EAIjB,QAAQ,GAAkB;AAAA,IACxB,OAAO,KAAK;AAAA;AAAA,EAGd,OAAO,GAAS;AAAA,IACd,KAAK,QAAQ;AAAA;AAEjB;",
+  "debugId": "1CD94D2F311BBD0564756E2164756E21",
+  "names": []
+}

package/dist/compat/async-local-storage.js

@@ -0,0 +1,94 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __require = import.meta.require;
+
+// src/compat/async-local-storage.ts
+var AsyncLocalStorageClass;
+var tryGetNodeAsyncHooks = () => {
+  try {
+    if (typeof window === "undefined" && typeof process !== "undefined" && true) {
+      try {
+        const module = __require("async_hooks");
+        return module.AsyncLocalStorage;
+      } catch (_e1) {
+        try {
+          return eval("require")("node:async_hooks").AsyncLocalStorage;
+        } catch (_e2) {
+          return null;
+        }
+      }
+    }
+  } catch (_e) {
+    return null;
+  }
+};
+AsyncLocalStorageClass = tryGetNodeAsyncHooks();
+if (!AsyncLocalStorageClass) {
+  AsyncLocalStorageClass = class AsyncLocalStorage {
+    store;
+    run(store, fn) {
+      const prev = this.store;
+      this.store = store;
+      try {
+        return fn();
+      } finally {
+        this.store = prev;
+      }
+    }
+    getStore() {
+      return this.store;
+    }
+    disable() {
+      this.store = undefined;
+    }
+  };
+}
+var AsyncLocalStorage = AsyncLocalStorageClass;
+export {
+  AsyncLocalStorage
+};
+
+//# debugId=AEC51513D62BFF6864756E2164756E21

package/dist/compat/async-local-storage.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/compat/async-local-storage.ts"],
+  "sourcesContent": [
+    "/**\n * Universal AsyncLocalStorage wrapper.\n * Automatically switches between node:async_hooks and a browser mock.\n */\n\nlet AsyncLocalStorageClass: any\n\n// Try to load Node.js AsyncLocalStorage\nconst tryGetNodeAsyncHooks = () => {\n  try {\n    if (\n      typeof window === 'undefined' &&\n      typeof process !== 'undefined' &&\n      !(process as any).browser\n    ) {\n      // Try direct import for Bun/Node.js ESM compatibility\n      try {\n        const module = require('node:async_hooks')\n        return module.AsyncLocalStorage\n      } catch (_e1) {\n        // Fallback to eval for CommonJS require hiding\n        try {\n          // biome-ignore lint/security/noGlobalEval: specialized case for hiding node built-ins\n          return eval('require')('node:async_hooks').AsyncLocalStorage\n        } catch (_e2) {\n          return null\n        }\n      }\n    }\n  } catch (_e) {\n    return null\n  }\n}\n\nAsyncLocalStorageClass = tryGetNodeAsyncHooks()\n\nif (!AsyncLocalStorageClass) {\n  /**\n   * Browser-safe AsyncLocalStorage mock.\n   * Note: This mock only works with synchronous functions.\n   * For proper async support, ensure Node.js AsyncLocalStorage is available.\n   */\n  AsyncLocalStorageClass = class AsyncLocalStorage<T> {\n    private store: T | undefined\n\n    run<R>(store: T, fn: () => R): R {\n      const prev = this.store\n      this.store = store\n      try {\n        return fn()\n      } finally {\n        this.store = prev\n      }\n    }\n\n    getStore(): T | undefined {\n      return this.store\n    }\n\n    disable(): void {\n      this.store = undefined\n    }\n  }\n}\n\n// biome-ignore lint/suspicious/noExplicitAny: generic class mock\nexport const AsyncLocalStorage: { new <_T>(): any } = AsyncLocalStorageClass\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKA,IAAI;AAGJ,IAAM,uBAAuB,MAAM;AAAA,EACjC,IAAI;AAAA,IACF,IACE,OAAO,WAAW,eAClB,OAAO,YAAY,eACnB,MACA;AAAA,MAEA,IAAI;AAAA,QACF,MAAM;AAAA,QACN,OAAO,OAAO;AAAA,QACd,OAAO,KAAK;AAAA,QAEZ,IAAI;AAAA,UAEF,OAAO,KAAK,SAAS,EAAE,kBAAkB,EAAE;AAAA,UAC3C,OAAO,KAAK;AAAA,UACZ,OAAO;AAAA;AAAA;AAAA,IAGb;AAAA,IACA,OAAO,IAAI;AAAA,IACX,OAAO;AAAA;AAAA;AAIX,yBAAyB,qBAAqB;AAE9C,IAAI,CAAC,wBAAwB;AAAA,EAM3B,yBAAyB,MAAM,kBAAqB;AAAA,IAC1C;AAAA,IAER,GAAM,CAAC,OAAU,IAAgB;AAAA,MAC/B,MAAM,OAAO,KAAK;AAAA,MAClB,KAAK,QAAQ;AAAA,MACb,IAAI;AAAA,QACF,OAAO,GAAG;AAAA,gBACV;AAAA,QACA,KAAK,QAAQ;AAAA;AAAA;AAAA,IAIjB,QAAQ,GAAkB;AAAA,MACxB,OAAO,KAAK;AAAA;AAAA,IAGd,OAAO,GAAS;AAAA,MACd,KAAK,QAAQ;AAAA;AAAA,EAEjB;AACF;AAGO,IAAM,oBAAyC;",
+  "debugId": "AEC51513D62BFF6864756E2164756E21",
+  "names": []
+}

package/dist/compat/crypto.browser.js

@@ -0,0 +1,91 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __require = import.meta.require;
+
+// src/compat/crypto.browser.ts
+var randomUUID = () => {
+  if (typeof globalThis.crypto?.randomUUID === "function") {
+    return globalThis.crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+};
+var randomBytes = (size) => {
+  const bytes = new Uint8Array(size);
+  if (typeof globalThis.crypto?.getRandomValues === "function") {
+    globalThis.crypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0;i < size; i++) {
+      bytes[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  return {
+    length: size,
+    [Symbol.iterator]: () => bytes[Symbol.iterator](),
+    toString: (encoding) => {
+      if (encoding === "base64") {
+        let binary = "";
+        for (let i = 0;i < bytes.byteLength; i++) {
+          binary += String.fromCharCode(bytes[i]);
+        }
+        return btoa(binary);
+      }
+      if (encoding === "hex") {
+        return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+      }
+      return "";
+    }
+  };
+};
+export {
+  randomUUID,
+  randomBytes
+};
+
+//# debugId=DA2B8600ADBAB27E64756E2164756E21

package/dist/compat/crypto.browser.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/compat/crypto.browser.ts"],
+  "sourcesContent": [
+    "/**\n * Browser-safe crypto mock\n */\nexport const randomUUID = () => {\n  if (typeof globalThis.crypto?.randomUUID === 'function') {\n    return globalThis.crypto.randomUUID()\n  }\n  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {\n    const r = (Math.random() * 16) | 0\n    const v = c === 'x' ? r : (r & 0x3) | 0x8\n    return v.toString(16)\n  })\n}\n\nexport const randomBytes = (size: number) => {\n  const bytes = new Uint8Array(size)\n  if (typeof globalThis.crypto?.getRandomValues === 'function') {\n    globalThis.crypto.getRandomValues(bytes)\n  } else {\n    for (let i = 0; i < size; i++) {\n      bytes[i] = Math.floor(Math.random() * 256)\n    }\n  }\n\n  // Basic Buffer-like object for Str.ts compatibility\n  return {\n    length: size,\n    [Symbol.iterator]: () => bytes[Symbol.iterator](),\n    toString: (encoding: string) => {\n      if (encoding === 'base64') {\n        let binary = ''\n        for (let i = 0; i < bytes.byteLength; i++) {\n          binary += String.fromCharCode(bytes[i])\n        }\n        return btoa(binary)\n      }\n      if (encoding === 'hex') {\n        return Array.from(bytes)\n          .map((b) => b.toString(16).padStart(2, '0'))\n          .join('')\n      }\n      return ''\n    },\n  } as unknown as Buffer\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGO,IAAM,aAAa,MAAM;AAAA,EAC9B,IAAI,OAAO,WAAW,QAAQ,eAAe,YAAY;AAAA,IACvD,OAAO,WAAW,OAAO,WAAW;AAAA,EACtC;AAAA,EACA,OAAO,uCAAuC,QAAQ,SAAS,CAAC,MAAM;AAAA,IACpE,MAAM,IAAK,KAAK,OAAO,IAAI,KAAM;AAAA,IACjC,MAAM,IAAI,MAAM,MAAM,IAAK,IAAI,IAAO;AAAA,IACtC,OAAO,EAAE,SAAS,EAAE;AAAA,GACrB;AAAA;AAGI,IAAM,cAAc,CAAC,SAAiB;AAAA,EAC3C,MAAM,QAAQ,IAAI,WAAW,IAAI;AAAA,EACjC,IAAI,OAAO,WAAW,QAAQ,oBAAoB,YAAY;AAAA,IAC5D,WAAW,OAAO,gBAAgB,KAAK;AAAA,EACzC,EAAO;AAAA,IACL,SAAS,IAAI,EAAG,IAAI,MAAM,KAAK;AAAA,MAC7B,MAAM,KAAK,KAAK,MAAM,KAAK,OAAO,IAAI,GAAG;AAAA,IAC3C;AAAA;AAAA,EAIF,OAAO;AAAA,IACL,QAAQ;AAAA,KACP,OAAO,WAAW,MAAM,MAAM,OAAO,UAAU;AAAA,IAChD,UAAU,CAAC,aAAqB;AAAA,MAC9B,IAAI,aAAa,UAAU;AAAA,QACzB,IAAI,SAAS;AAAA,QACb,SAAS,IAAI,EAAG,IAAI,MAAM,YAAY,KAAK;AAAA,UACzC,UAAU,OAAO,aAAa,MAAM,EAAE;AAAA,QACxC;AAAA,QACA,OAAO,KAAK,MAAM;AAAA,MACpB;AAAA,MACA,IAAI,aAAa,OAAO;AAAA,QACtB,OAAO,MAAM,KAAK,KAAK,EACpB,IAAI,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC,EAC1C,KAAK,EAAE;AAAA,MACZ;AAAA,MACA,OAAO;AAAA;AAAA,EAEX;AAAA;",
+  "debugId": "DA2B8600ADBAB27E64756E2164756E21",
+  "names": []
+}

package/dist/compat/crypto.js

@@ -0,0 +1,111 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __require = import.meta.require;
+
+// src/compat/crypto.ts
+var randomUUIDFn;
+var randomBytesFn;
+var tryGetNodeCrypto = () => {
+  try {
+    if (typeof window === "undefined" && typeof process !== "undefined" && true) {
+      return eval("require")("node:crypto");
+    }
+  } catch (_e) {
+    return null;
+  }
+};
+var nodeCrypto = tryGetNodeCrypto();
+if (nodeCrypto) {
+  randomUUIDFn = nodeCrypto.randomUUID;
+  randomBytesFn = nodeCrypto.randomBytes;
+} else {
+  randomUUIDFn = () => {
+    if (typeof globalThis.crypto?.randomUUID === "function") {
+      return globalThis.crypto.randomUUID();
+    }
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+      const r = Math.random() * 16 | 0;
+      const v = c === "x" ? r : r & 3 | 8;
+      return v.toString(16);
+    });
+  };
+  randomBytesFn = (size) => {
+    const bytes = new Uint8Array(size);
+    if (typeof globalThis.crypto?.getRandomValues === "function") {
+      globalThis.crypto.getRandomValues(bytes);
+    } else {
+      for (let i = 0;i < size; i++) {
+        bytes[i] = Math.floor(Math.random() * 256);
+      }
+    }
+    return {
+      ...Array.from(bytes),
+      length: size,
+      [Symbol.iterator]: () => bytes[Symbol.iterator](),
+      toString: (encoding) => {
+        if (encoding === "base64") {
+          let binary = "";
+          for (let i = 0;i < bytes.byteLength; i++) {
+            binary += String.fromCharCode(bytes[i]);
+          }
+          return btoa(binary);
+        }
+        if (encoding === "hex") {
+          return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+        }
+        return "";
+      }
+    };
+  };
+}
+var randomUUID = randomUUIDFn;
+var randomBytes = randomBytesFn;
+export {
+  randomUUID,
+  randomBytes
+};
+
+//# debugId=90A5E907AAB9EDB264756E2164756E21

package/dist/compat/crypto.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/compat/crypto.ts"],
+  "sourcesContent": [
+    "/**\n * Universal Crypto wrapper.\n * Automatically switches between node:crypto and globalThis.crypto.\n */\n\nlet randomUUIDFn: () => string\nlet randomBytesFn: (size: number) => any\n\nconst tryGetNodeCrypto = () => {\n  try {\n    if (\n      typeof window === 'undefined' &&\n      typeof process !== 'undefined' &&\n      !(process as any).browser\n    ) {\n      // biome-ignore lint/security/noGlobalEval: specialized case for hiding node built-ins\n      return eval('require')('node:crypto')\n    }\n  } catch (_e) {\n    return null\n  }\n}\n\nconst nodeCrypto = tryGetNodeCrypto()\n\nif (nodeCrypto) {\n  randomUUIDFn = nodeCrypto.randomUUID\n  randomBytesFn = nodeCrypto.randomBytes\n} else {\n  // Browser implementations\n  randomUUIDFn = () => {\n    if (typeof globalThis.crypto?.randomUUID === 'function') {\n      return globalThis.crypto.randomUUID()\n    }\n    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {\n      const r = (Math.random() * 16) | 0\n      const v = c === 'x' ? r : (r & 0x3) | 0x8\n      return v.toString(16)\n    })\n  }\n\n  randomBytesFn = (size: number) => {\n    const bytes = new Uint8Array(size)\n    if (typeof globalThis.crypto?.getRandomValues === 'function') {\n      globalThis.crypto.getRandomValues(bytes)\n    } else {\n      for (let i = 0; i < size; i++) {\n        bytes[i] = Math.floor(Math.random() * 256)\n      }\n    }\n    // Return a Buffer-like object\n    return {\n      ...Array.from(bytes),\n      length: size,\n      [Symbol.iterator]: () => bytes[Symbol.iterator](),\n      toString: (encoding: string) => {\n        if (encoding === 'base64') {\n          let binary = ''\n          for (let i = 0; i < bytes.byteLength; i++) {\n            binary += String.fromCharCode(bytes[i])\n          }\n          return btoa(binary)\n        }\n        if (encoding === 'hex') {\n          return Array.from(bytes)\n            .map((b) => b.toString(16).padStart(2, '0'))\n            .join('')\n        }\n        return ''\n      },\n    }\n  }\n}\n\nexport const randomUUID = randomUUIDFn\nexport const randomBytes = randomBytesFn\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKA,IAAI;AACJ,IAAI;AAEJ,IAAM,mBAAmB,MAAM;AAAA,EAC7B,IAAI;AAAA,IACF,IACE,OAAO,WAAW,eAClB,OAAO,YAAY,eACnB,MACA;AAAA,MAEA,OAAO,KAAK,SAAS,EAAE,aAAa;AAAA,IACtC;AAAA,IACA,OAAO,IAAI;AAAA,IACX,OAAO;AAAA;AAAA;AAIX,IAAM,aAAa,iBAAiB;AAEpC,IAAI,YAAY;AAAA,EACd,eAAe,WAAW;AAAA,EAC1B,gBAAgB,WAAW;AAC7B,EAAO;AAAA,EAEL,eAAe,MAAM;AAAA,IACnB,IAAI,OAAO,WAAW,QAAQ,eAAe,YAAY;AAAA,MACvD,OAAO,WAAW,OAAO,WAAW;AAAA,IACtC;AAAA,IACA,OAAO,uCAAuC,QAAQ,SAAS,CAAC,MAAM;AAAA,MACpE,MAAM,IAAK,KAAK,OAAO,IAAI,KAAM;AAAA,MACjC,MAAM,IAAI,MAAM,MAAM,IAAK,IAAI,IAAO;AAAA,MACtC,OAAO,EAAE,SAAS,EAAE;AAAA,KACrB;AAAA;AAAA,EAGH,gBAAgB,CAAC,SAAiB;AAAA,IAChC,MAAM,QAAQ,IAAI,WAAW,IAAI;AAAA,IACjC,IAAI,OAAO,WAAW,QAAQ,oBAAoB,YAAY;AAAA,MAC5D,WAAW,OAAO,gBAAgB,KAAK;AAAA,IACzC,EAAO;AAAA,MACL,SAAS,IAAI,EAAG,IAAI,MAAM,KAAK;AAAA,QAC7B,MAAM,KAAK,KAAK,MAAM,KAAK,OAAO,IAAI,GAAG;AAAA,MAC3C;AAAA;AAAA,IAGF,OAAO;AAAA,SACF,MAAM,KAAK,KAAK;AAAA,MACnB,QAAQ;AAAA,OACP,OAAO,WAAW,MAAM,MAAM,OAAO,UAAU;AAAA,MAChD,UAAU,CAAC,aAAqB;AAAA,QAC9B,IAAI,aAAa,UAAU;AAAA,UACzB,IAAI,SAAS;AAAA,UACb,SAAS,IAAI,EAAG,IAAI,MAAM,YAAY,KAAK;AAAA,YACzC,UAAU,OAAO,aAAa,MAAM,EAAE;AAAA,UACxC;AAAA,UACA,OAAO,KAAK,MAAM;AAAA,QACpB;AAAA,QACA,IAAI,aAAa,OAAO;AAAA,UACtB,OAAO,MAAM,KAAK,KAAK,EACpB,IAAI,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC,EAC1C,KAAK,EAAE;AAAA,QACZ;AAAA,QACA,OAAO;AAAA;AAAA,IAEX;AAAA;AAAA;AAIG,IAAM,aAAa;AACnB,IAAM,cAAc;",
+  "debugId": "90A5E907AAB9EDB264756E2164756E21",
+  "names": []
+}

package/dist/events/CircuitBreaker.d.ts

@@ -1,3 +1,15 @@
+/**
+ * Event-system CircuitBreaker — standalone copy.
+ *
+ * NOTE: This is intentionally NOT a re-export from @gravito/resilience
+ * to avoid a circular dependency (core <-> resilience):
+ *   @gravito/core -> @gravito/resilience (peerDep of resilience -> core)
+ *
+ * The canonical CB implementation lives in @gravito/resilience.
+ * Keep this file in sync manually if the canonical CB API changes.
+ *
+ * Per D-02 decision recorded in 17-RESEARCH.md.
+ */
 /**
  * Circuit Breaker state enum.
  * @public

package/dist/exceptions/AuthException.d.ts

@@ -0,0 +1,10 @@
+import { type ExceptionOptions } from './GravitoException';
+import { DomainException } from './DomainException';
+/**
+ * Abstract base class for authentication/authorization-related domain errors.
+ * Used by fortify and sentinel packages.
+ * @public
+ */
+export declare abstract class AuthException extends DomainException {
+    constructor(status: number, code: string, options?: ExceptionOptions);
+}

package/dist/exceptions/AuthenticationException.d.ts

@@ -1,8 +1,8 @@
-import { GravitoException } from './GravitoException';
+import { DomainException } from './DomainException';
 /**
  * Exception thrown when authentication fails.
  * @public
  */
-export declare class AuthenticationException extends GravitoException {
+export declare class AuthenticationException extends DomainException {
     constructor(message?: string);
 }

package/dist/exceptions/AuthorizationException.d.ts

@@ -1,8 +1,8 @@
-import { GravitoException } from './GravitoException';
+import { DomainException } from './DomainException';
 /**
  * Exception thrown when user is not authorized to perform an action.
  * @public
  */
-export declare class AuthorizationException extends GravitoException {
+export declare class AuthorizationException extends DomainException {
     constructor(message?: string);
 }

package/dist/exceptions/CacheException.d.ts

@@ -0,0 +1,9 @@
+import { InfrastructureException, type InfrastructureExceptionOptions } from './InfrastructureException';
+/**
+ * Abstract base class for cache/Redis-related infrastructure errors.
+ * All plasma error classes extend this instead of bare Error.
+ * @public
+ */
+export declare abstract class CacheException extends InfrastructureException {
+    constructor(status: number, code: string, options?: InfrastructureExceptionOptions);
+}

package/dist/exceptions/CircularDependencyException.d.ts

@@ -1,9 +1,10 @@
 import type { ServiceKey } from '../Container';
+import { SystemException } from './SystemException';
 /**
  * CircularDependencyException - Thrown when the container detects an infinite loop.
  *
  * @module @gravito/core
  */
-export declare class CircularDependencyException extends Error {
+export declare class CircularDependencyException extends SystemException {
     constructor(key: ServiceKey, stack: ServiceKey[]);
 }

package/dist/exceptions/ConfigurationException.d.ts

@@ -0,0 +1,9 @@
+import { type ExceptionOptions } from './GravitoException';
+import { SystemException } from './SystemException';
+/**
+ * Thrown when the framework encounters an invalid or missing configuration value.
+ * @public
+ */
+export declare class ConfigurationException extends SystemException {
+    constructor(message: string, options?: Omit<ExceptionOptions, 'message'>);
+}

package/dist/exceptions/DatabaseException.d.ts

@@ -0,0 +1,9 @@
+import { InfrastructureException, type InfrastructureExceptionOptions } from './InfrastructureException';
+/**
+ * Abstract base class for database-related infrastructure errors.
+ * All atlas error classes extend this instead of bare Error.
+ * @public
+ */
+export declare abstract class DatabaseException extends InfrastructureException {
+    constructor(status: number, code: string, options?: InfrastructureExceptionOptions);
+}

package/dist/exceptions/DomainException.d.ts

@@ -0,0 +1,9 @@
+import { type ExceptionOptions, GravitoException } from './GravitoException';
+/**
+ * Abstract base class for business logic / domain rule violations.
+ * Extend this for exceptions that represent a caller mistake (invalid input, constraint violation, etc.).
+ * @public
+ */
+export declare abstract class DomainException extends GravitoException {
+    constructor(status: number, code: string, options?: ExceptionOptions);
+}

package/dist/exceptions/InfrastructureException.d.ts

@@ -0,0 +1,17 @@
+import { type ExceptionOptions, GravitoException } from './GravitoException';
+/**
+ * Options for creating an InfrastructureException
+ * @public
+ */
+export interface InfrastructureExceptionOptions extends ExceptionOptions {
+    retryable?: boolean;
+}
+/**
+ * Abstract base class for infrastructure / I/O errors (database, network, filesystem, etc.).
+ * Carries a `retryable` flag that callers can inspect to decide whether the operation should be retried.
+ * @public
+ */
+export declare abstract class InfrastructureException extends GravitoException {
+    readonly retryable: boolean;
+    constructor(status: number, code: string, options?: InfrastructureExceptionOptions);
+}

package/dist/exceptions/QueueException.d.ts

@@ -0,0 +1,9 @@
+import { InfrastructureException, type InfrastructureExceptionOptions } from './InfrastructureException';
+/**
+ * Abstract base class for message queue infrastructure errors.
+ * Used by quasar and flux packages.
+ * @public
+ */
+export declare abstract class QueueException extends InfrastructureException {
+    constructor(status: number, code: string, options?: InfrastructureExceptionOptions);
+}

package/dist/exceptions/StorageException.d.ts

@@ -0,0 +1,9 @@
+import { InfrastructureException, type InfrastructureExceptionOptions } from './InfrastructureException';
+/**
+ * Abstract base class for file/object storage infrastructure errors.
+ * Used by constellation, nebula, nebula-s3, freeze, stasis packages.
+ * @public
+ */
+export declare abstract class StorageException extends InfrastructureException {
+    constructor(status: number, code: string, options?: InfrastructureExceptionOptions);
+}

package/dist/exceptions/StreamException.d.ts

@@ -0,0 +1,9 @@
+import { InfrastructureException, type InfrastructureExceptionOptions } from './InfrastructureException';
+/**
+ * Abstract base class for stream/message processing infrastructure errors.
+ * Used by the stream package (Kafka, RabbitMQ, SQS).
+ * @public
+ */
+export declare abstract class StreamException extends InfrastructureException {
+    constructor(status: number, code: string, options?: InfrastructureExceptionOptions);
+}

package/dist/exceptions/SystemException.d.ts

@@ -0,0 +1,9 @@
+import { type ExceptionOptions, GravitoException } from './GravitoException';
+/**
+ * Abstract base class for internal framework / system-level errors.
+ * Extend this for exceptions that represent an unexpected or unrecoverable framework state.
+ * @public
+ */
+export declare abstract class SystemException extends GravitoException {
+    constructor(status: number, code: string, options?: ExceptionOptions);
+}

package/dist/exceptions/ValidationException.d.ts

@@ -1,4 +1,4 @@
-import { GravitoException } from './GravitoException';
+import { DomainException } from './DomainException';
 /**
  * Structure of a validation error
  * @public
@@ -12,7 +12,7 @@ export interface ValidationError {
  * Exception thrown when data validation fails.
  * @public
  */
-export declare class ValidationException extends GravitoException {
+export declare class ValidationException extends DomainException {
     readonly errors: ValidationError[];
     redirectTo?: string;
     input?: unknown;

package/dist/exceptions/index.d.ts

@@ -1,7 +1,17 @@
 export * from './AuthenticationException';
+export * from './AuthException';
 export * from './AuthorizationException';
+export * from './CacheException';
 export * from './CircularDependencyException';
+export * from './ConfigurationException';
+export * from './DatabaseException';
+export * from './DomainException';
 export * from './GravitoException';
 export * from './HttpException';
+export * from './InfrastructureException';
 export * from './ModelNotFoundException';
+export * from './QueueException';
+export * from './StorageException';
+export * from './StreamException';
+export * from './SystemException';
 export * from './ValidationException';