@xylabs/forget 4.10.1 → 4.11.1

package/dist/neutral/index.mjs

@@ -1,11 +1,24 @@
-// src/forget.ts
+// src/ForgetPromise.ts
 import { delay } from "@xylabs/delay";
 import { isPromise } from "@xylabs/promise";
+import { isNumber } from "@xylabs/typeof";
+
+// src/ForgetConfig.ts
+var defaultForgetConfig = { timeout: 3e4 };
+
+// src/ForgetPromise.ts
 var ForgetPromise = {
   get active() {
     return this.activeForgets > 0;
   },
   activeForgets: 0,
+  exceptedForgets: 0,
+  exceptionHandler: (error, _config) => {
+    console.error(`forget promise handler excepted: ${error.message}`, error);
+  },
+  timeoutHandler: (time, _config) => {
+    console.error(`forget promise timeout out after ${time}ms [Cancelling]`);
+  },
   async awaitInactive(interval = 100, timeout) {
     let timeoutRemaining = timeout;
     while (this.active) {
@@ -24,48 +37,63 @@ var ForgetPromise = {
    * @param promise The promise to forget
    * @param config Configuration of forget settings
    */
-  forget(promise, onComplete, config) {
+  forget(promise, config) {
+    const resolvedConfig = {
+      ...defaultForgetConfig,
+      ...globalThis.xy?.forget?.config,
+      ...config
+    };
     if (isPromise(promise)) {
-      let completed = false;
-      this.activeForgets++;
-      const promiseWrapper = async () => {
-        await promise.then((result) => {
-          this.activeForgets--;
-          completed = true;
-          onComplete?.([result, void 0]);
-        }).catch((error) => {
-          this.activeForgets--;
-          completed = true;
-          onComplete?.([void 0, error]);
-        });
-      };
-      const promises = [promiseWrapper()];
-      if (config) {
-        const timeoutFunc = async () => {
-          await delay(config.delay);
-          if (!completed) {
-            console.log(`forget promise timeout out after ${config.delay}ms [Cancelling]`);
-            config.cancel?.();
-          }
+      try {
+        let completed = false;
+        this.activeForgets++;
+        const promiseWrapper = async () => {
+          await promise.then((result) => {
+            this.activeForgets--;
+            completed = true;
+            resolvedConfig?.onComplete?.([result, void 0]);
+          }).catch((error) => {
+            this.activeForgets--;
+            completed = true;
+            resolvedConfig?.onComplete?.([void 0, error]);
+          });
         };
-        promises.push(timeoutFunc());
+        const promises = [promiseWrapper()];
+        const timeout = resolvedConfig.timeout ?? defaultForgetConfig.timeout;
+        if (isNumber(timeout)) {
+          const timeoutFunc = async () => {
+            await delay(timeout);
+            if (!completed) {
+              resolvedConfig.onCancel?.();
+              this.timeoutHandler(timeout, resolvedConfig);
+            }
+          };
+          promises.push(timeoutFunc());
+        }
+        const all = Promise.race(promises);
+        all.then(() => {
+          return;
+        }).catch(() => {
+          return;
+        });
+      } catch (ex) {
+        this.exceptedForgets += 1;
+        resolvedConfig?.onException?.(ex);
+        this.exceptionHandler(ex, resolvedConfig);
       }
-      const all = Promise.race(promises);
-      all.then(() => {
-        return;
-      }).catch(() => {
-        return;
-      });
     } else {
       return promise();
     }
   }
 };
-var forget = (promise, onComplete, timeout) => {
-  ForgetPromise.forget(promise, onComplete, timeout);
+
+// src/forget.ts
+var forget = (promise, config) => {
+  ForgetPromise.forget(promise, config);
 };
 export {
   ForgetPromise,
+  defaultForgetConfig,
   forget
 };
 //# sourceMappingURL=index.mjs.map

package/dist/neutral/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/forget.ts"],"sourcesContent":["import { delay } from '@xylabs/delay'\nimport { isPromise, type Promisable } from '@xylabs/promise'\n\nexport interface ForgetTimeoutConfig {\n  cancel: () => void\n  delay: number\n}\n\nexport const ForgetPromise = {\n  get active() {\n    return this.activeForgets > 0\n  },\n\n  activeForgets: 0,\n\n  async awaitInactive(interval = 100, timeout?: number) {\n    let timeoutRemaining = timeout\n    while (this.active) {\n      await delay(interval)\n      if (timeoutRemaining !== undefined) {\n        timeoutRemaining -= interval\n        if (timeoutRemaining <= 0) {\n          return this.activeForgets\n        }\n      }\n    }\n    return 0\n  },\n\n  /**\n   * Used to explicitly launch an async function (or Promise) with awaiting it\n   * @param promise The promise to forget\n   * @param config Configuration of forget settings\n   */\n  forget<T>(promise: Promisable<T>, onComplete?: (result: [T | undefined, Error | undefined]) => void, config?: ForgetTimeoutConfig) {\n    if (isPromise(promise)) {\n      let completed = false\n      this.activeForgets++\n\n      const promiseWrapper = async () => {\n        await promise\n          .then((result: T) => {\n            this.activeForgets--\n            completed = true\n            onComplete?.([result, undefined])\n          })\n          .catch((error) => {\n            this.activeForgets--\n            completed = true\n            onComplete?.([undefined, error])\n          })\n      }\n\n      const promises = [promiseWrapper()]\n\n      // if there is a timeout, add it to the race\n      if (config) {\n        const timeoutFunc = async () => {\n          await delay(config.delay)\n          if (!completed) {\n            console.log(`forget promise timeout out after ${config.delay}ms [Cancelling]`)\n            config.cancel?.()\n          }\n        }\n        promises.push(timeoutFunc())\n      }\n\n      const all = Promise.race(promises)\n\n      all\n        .then(() => {\n          return\n        })\n        .catch(() => {\n          return\n        })\n    } else {\n      return (promise as () => void)()\n    }\n  },\n}\n\n// used to explicitly launch an async function (or Promise) with awaiting it\nexport const forget = <T>(promise: Promisable<T>, onComplete?: (result: [T | undefined, Error | undefined]) => void, timeout?: ForgetTimeoutConfig) => {\n  ForgetPromise.forget<T>(promise, onComplete, timeout)\n}\n"],"mappings":";AAAA,SAAS,aAAa;AACtB,SAAS,iBAAkC;AAOpC,IAAM,gBAAgB;AAAA,EAC3B,IAAI,SAAS;AACX,WAAO,KAAK,gBAAgB;AAAA,EAC9B;AAAA,EAEA,eAAe;AAAA,EAEf,MAAM,cAAc,WAAW,KAAK,SAAkB;AACpD,QAAI,mBAAmB;AACvB,WAAO,KAAK,QAAQ;AAClB,YAAM,MAAM,QAAQ;AACpB,UAAI,qBAAqB,QAAW;AAClC,4BAAoB;AACpB,YAAI,oBAAoB,GAAG;AACzB,iBAAO,KAAK;AAAA,QACd;AAAA,MACF;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAU,SAAwB,YAAmE,QAA8B;AACjI,QAAI,UAAU,OAAO,GAAG;AACtB,UAAI,YAAY;AAChB,WAAK;AAEL,YAAM,iBAAiB,YAAY;AACjC,cAAM,QACH,KAAK,CAAC,WAAc;AACnB,eAAK;AACL,sBAAY;AACZ,uBAAa,CAAC,QAAQ,MAAS,CAAC;AAAA,QAClC,CAAC,EACA,MAAM,CAAC,UAAU;AAChB,eAAK;AACL,sBAAY;AACZ,uBAAa,CAAC,QAAW,KAAK,CAAC;AAAA,QACjC,CAAC;AAAA,MACL;AAEA,YAAM,WAAW,CAAC,eAAe,CAAC;AAGlC,UAAI,QAAQ;AACV,cAAM,cAAc,YAAY;AAC9B,gBAAM,MAAM,OAAO,KAAK;AACxB,cAAI,CAAC,WAAW;AACd,oBAAQ,IAAI,oCAAoC,OAAO,KAAK,iBAAiB;AAC7E,mBAAO,SAAS;AAAA,UAClB;AAAA,QACF;AACA,iBAAS,KAAK,YAAY,CAAC;AAAA,MAC7B;AAEA,YAAM,MAAM,QAAQ,KAAK,QAAQ;AAEjC,UACG,KAAK,MAAM;AACV;AAAA,MACF,CAAC,EACA,MAAM,MAAM;AACX;AAAA,MACF,CAAC;AAAA,IACL,OAAO;AACL,aAAQ,QAAuB;AAAA,IACjC;AAAA,EACF;AACF;AAGO,IAAM,SAAS,CAAI,SAAwB,YAAmE,YAAkC;AACrJ,gBAAc,OAAU,SAAS,YAAY,OAAO;AACtD;","names":[]}
+{"version":3,"sources":["../../src/ForgetPromise.ts","../../src/ForgetConfig.ts","../../src/forget.ts"],"sourcesContent":["import { delay } from '@xylabs/delay'\nimport { isPromise, type Promisable } from '@xylabs/promise'\nimport { isNumber } from '@xylabs/typeof'\n\nimport { defaultForgetConfig, type ForgetConfig } from './ForgetConfig.ts'\n\nexport const ForgetPromise = {\n  get active() {\n    return this.activeForgets > 0\n  },\n\n  activeForgets: 0,\n  exceptedForgets: 0,\n\n  exceptionHandler: (error: Error, _config: ForgetConfig) => {\n    console.error(`forget promise handler excepted: ${error.message}`, error)\n  },\n\n  timeoutHandler: (time: number, _config: ForgetConfig) => {\n    console.error(`forget promise timeout out after ${time}ms [Cancelling]`)\n  },\n\n  async awaitInactive(interval = 100, timeout?: number) {\n    let timeoutRemaining = timeout\n    while (this.active) {\n      await delay(interval)\n      if (timeoutRemaining !== undefined) {\n        timeoutRemaining -= interval\n        if (timeoutRemaining <= 0) {\n          return this.activeForgets\n        }\n      }\n    }\n    return 0\n  },\n\n  /**\n   * Used to explicitly launch an async function (or Promise) with awaiting it\n   * @param promise The promise to forget\n   * @param config Configuration of forget settings\n   */\n  forget<T>(promise: Promisable<T>, config?: ForgetConfig<T>) {\n    // default | global | provided priorities for config (not deep merge)\n    const resolvedConfig = {\n      ...defaultForgetConfig, ...globalThis.xy?.forget?.config, ...config,\n    }\n    if (isPromise(promise)) {\n      try {\n        let completed = false\n        this.activeForgets++\n\n        const promiseWrapper = async () => {\n          await promise\n            .then((result: T) => {\n              this.activeForgets--\n              completed = true\n              resolvedConfig?.onComplete?.([result, undefined])\n            })\n            .catch((error) => {\n              this.activeForgets--\n              completed = true\n              resolvedConfig?.onComplete?.([undefined, error])\n            })\n        }\n\n        const promises = [promiseWrapper()]\n\n        // if there is a timeout, add it to the race\n        const timeout = resolvedConfig.timeout ?? defaultForgetConfig.timeout\n        if (isNumber(timeout)) {\n          const timeoutFunc = async () => {\n            await delay(timeout)\n            if (!completed) {\n              resolvedConfig.onCancel?.()\n              this.timeoutHandler(timeout, resolvedConfig)\n            }\n          }\n          promises.push(timeoutFunc())\n        }\n\n        const all = Promise.race(promises)\n\n        all\n          .then(() => {\n            return\n          })\n          .catch(() => {\n            return\n          })\n      } catch (ex) {\n        this.exceptedForgets += 1\n        resolvedConfig?.onException?.(ex as Error)\n        this.exceptionHandler(ex as Error, resolvedConfig)\n      }\n    } else {\n      return (promise as () => void)()\n    }\n  },\n}\n","// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport interface ForgetConfig<T = any> {\n  onCancel?: () => void\n  onComplete?: (result: [T | undefined, Error | undefined]) => void\n  onException?: (error: Error) => void\n  timeout?: number\n}\n\nexport const defaultForgetConfig: ForgetConfig<unknown> = { timeout: 30_000 }\n","import { type Promisable } from '@xylabs/promise'\n\nimport type { ForgetConfig } from './ForgetConfig.ts'\nimport { ForgetPromise } from './ForgetPromise.ts'\n\n// used to explicitly launch an async function (or Promise) with awaiting it\nexport const forget = <T>(promise: Promisable<T>, config?: ForgetConfig<T>) => {\n  ForgetPromise.forget<T>(promise, config)\n}\n"],"mappings":";AAAA,SAAS,aAAa;AACtB,SAAS,iBAAkC;AAC3C,SAAS,gBAAgB;;;ACMlB,IAAM,sBAA6C,EAAE,SAAS,IAAO;;;ADFrE,IAAM,gBAAgB;AAAA,EAC3B,IAAI,SAAS;AACX,WAAO,KAAK,gBAAgB;AAAA,EAC9B;AAAA,EAEA,eAAe;AAAA,EACf,iBAAiB;AAAA,EAEjB,kBAAkB,CAAC,OAAc,YAA0B;AACzD,YAAQ,MAAM,oCAAoC,MAAM,OAAO,IAAI,KAAK;AAAA,EAC1E;AAAA,EAEA,gBAAgB,CAAC,MAAc,YAA0B;AACvD,YAAQ,MAAM,oCAAoC,IAAI,iBAAiB;AAAA,EACzE;AAAA,EAEA,MAAM,cAAc,WAAW,KAAK,SAAkB;AACpD,QAAI,mBAAmB;AACvB,WAAO,KAAK,QAAQ;AAClB,YAAM,MAAM,QAAQ;AACpB,UAAI,qBAAqB,QAAW;AAClC,4BAAoB;AACpB,YAAI,oBAAoB,GAAG;AACzB,iBAAO,KAAK;AAAA,QACd;AAAA,MACF;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAU,SAAwB,QAA0B;AAE1D,UAAM,iBAAiB;AAAA,MACrB,GAAG;AAAA,MAAqB,GAAG,WAAW,IAAI,QAAQ;AAAA,MAAQ,GAAG;AAAA,IAC/D;AACA,QAAI,UAAU,OAAO,GAAG;AACtB,UAAI;AACF,YAAI,YAAY;AAChB,aAAK;AAEL,cAAM,iBAAiB,YAAY;AACjC,gBAAM,QACH,KAAK,CAAC,WAAc;AACnB,iBAAK;AACL,wBAAY;AACZ,4BAAgB,aAAa,CAAC,QAAQ,MAAS,CAAC;AAAA,UAClD,CAAC,EACA,MAAM,CAAC,UAAU;AAChB,iBAAK;AACL,wBAAY;AACZ,4BAAgB,aAAa,CAAC,QAAW,KAAK,CAAC;AAAA,UACjD,CAAC;AAAA,QACL;AAEA,cAAM,WAAW,CAAC,eAAe,CAAC;AAGlC,cAAM,UAAU,eAAe,WAAW,oBAAoB;AAC9D,YAAI,SAAS,OAAO,GAAG;AACrB,gBAAM,cAAc,YAAY;AAC9B,kBAAM,MAAM,OAAO;AACnB,gBAAI,CAAC,WAAW;AACd,6BAAe,WAAW;AAC1B,mBAAK,eAAe,SAAS,cAAc;AAAA,YAC7C;AAAA,UACF;AACA,mBAAS,KAAK,YAAY,CAAC;AAAA,QAC7B;AAEA,cAAM,MAAM,QAAQ,KAAK,QAAQ;AAEjC,YACG,KAAK,MAAM;AACV;AAAA,QACF,CAAC,EACA,MAAM,MAAM;AACX;AAAA,QACF,CAAC;AAAA,MACL,SAAS,IAAI;AACX,aAAK,mBAAmB;AACxB,wBAAgB,cAAc,EAAW;AACzC,aAAK,iBAAiB,IAAa,cAAc;AAAA,MACnD;AAAA,IACF,OAAO;AACL,aAAQ,QAAuB;AAAA,IACjC;AAAA,EACF;AACF;;;AE5FO,IAAM,SAAS,CAAI,SAAwB,WAA6B;AAC7E,gBAAc,OAAU,SAAS,MAAM;AACzC;","names":[]}

package/dist/node/index-node.mjs

@@ -0,0 +1,134 @@
+// src/ForgetConfig.ts
+var defaultForgetConfig = { timeout: 3e4 };
+
+// src/ForgetNodeConfig.ts
+var defaultForgetNodeConfig = {
+  ...defaultForgetConfig,
+  terminateOnTimeout: true,
+  terminateOnException: true
+};
+
+// src/ForgetPromise.ts
+import { delay } from "@xylabs/delay";
+import { isPromise } from "@xylabs/promise";
+import { isNumber } from "@xylabs/typeof";
+var ForgetPromise = {
+  get active() {
+    return this.activeForgets > 0;
+  },
+  activeForgets: 0,
+  exceptedForgets: 0,
+  exceptionHandler: (error, _config) => {
+    console.error(`forget promise handler excepted: ${error.message}`, error);
+  },
+  timeoutHandler: (time, _config) => {
+    console.error(`forget promise timeout out after ${time}ms [Cancelling]`);
+  },
+  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;
+  },
+  /**
+   * Used to explicitly launch an async function (or Promise) with awaiting it
+   * @param promise The promise to forget
+   * @param config Configuration of forget settings
+   */
+  forget(promise, config) {
+    const resolvedConfig = {
+      ...defaultForgetConfig,
+      ...globalThis.xy?.forget?.config,
+      ...config
+    };
+    if (isPromise(promise)) {
+      try {
+        let completed = false;
+        this.activeForgets++;
+        const promiseWrapper = async () => {
+          await promise.then((result) => {
+            this.activeForgets--;
+            completed = true;
+            resolvedConfig?.onComplete?.([result, void 0]);
+          }).catch((error) => {
+            this.activeForgets--;
+            completed = true;
+            resolvedConfig?.onComplete?.([void 0, error]);
+          });
+        };
+        const promises = [promiseWrapper()];
+        const timeout = resolvedConfig.timeout ?? defaultForgetConfig.timeout;
+        if (isNumber(timeout)) {
+          const timeoutFunc = async () => {
+            await delay(timeout);
+            if (!completed) {
+              resolvedConfig.onCancel?.();
+              this.timeoutHandler(timeout, resolvedConfig);
+            }
+          };
+          promises.push(timeoutFunc());
+        }
+        const all = Promise.race(promises);
+        all.then(() => {
+          return;
+        }).catch(() => {
+          return;
+        });
+      } catch (ex) {
+        this.exceptedForgets += 1;
+        resolvedConfig?.onException?.(ex);
+        this.exceptionHandler(ex, resolvedConfig);
+      }
+    } else {
+      return promise();
+    }
+  }
+};
+
+// src/ForgetPromiseNode.ts
+var ForgetPromiseNode = {
+  ...ForgetPromise,
+  exceptionHandler: (error, config) => {
+    ForgetPromise.exceptionHandler(error, config);
+    if (config?.terminateOnException === true) {
+      process.exit(1);
+    }
+  },
+  timeoutHandler: (time, config) => {
+    ForgetPromise.timeoutHandler(time, config);
+    if (config?.terminateOnTimeout === true) {
+      process.exit(2);
+    }
+  },
+  /**
+     * Used to explicitly launch an async function (or Promise) with awaiting it
+     * @param promise The promise to forget
+     * @param config Configuration of forget settings
+     */
+  forget(promise, config) {
+    const resolvedConfig = {
+      ...defaultForgetNodeConfig,
+      ...globalThis.xy?.forget?.config,
+      ...config
+    };
+    ForgetPromise.forget(promise, resolvedConfig);
+  }
+};
+
+// src/forgetNode.ts
+var forgetNode = (promise, config) => {
+  ForgetPromiseNode.forget(promise, config);
+};
+export {
+  ForgetPromiseNode as ForgetPromise,
+  defaultForgetConfig,
+  forgetNode as forget
+};
+//# sourceMappingURL=index-node.mjs.map

package/dist/node/index-node.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/ForgetConfig.ts","../../src/ForgetNodeConfig.ts","../../src/ForgetPromise.ts","../../src/ForgetPromiseNode.ts","../../src/forgetNode.ts"],"sourcesContent":["// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport interface ForgetConfig<T = any> {\n  onCancel?: () => void\n  onComplete?: (result: [T | undefined, Error | undefined]) => void\n  onException?: (error: Error) => void\n  timeout?: number\n}\n\nexport const defaultForgetConfig: ForgetConfig<unknown> = { timeout: 30_000 }\n","import { defaultForgetConfig, type ForgetConfig } from './ForgetConfig.ts'\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport interface ForgetNodeConfig<T = any> extends ForgetConfig<T> {\n  terminateOnException?: boolean // terminate the process on an exception that happens outside of the promise being forgotten\n  terminateOnTimeout?: boolean // terminate the process if the promise times out\n}\n\nexport const defaultForgetNodeConfig: ForgetNodeConfig<unknown> = {\n  ...defaultForgetConfig,\n  terminateOnTimeout: true,\n  terminateOnException: true,\n}\n","import { delay } from '@xylabs/delay'\nimport { isPromise, type Promisable } from '@xylabs/promise'\nimport { isNumber } from '@xylabs/typeof'\n\nimport { defaultForgetConfig, type ForgetConfig } from './ForgetConfig.ts'\n\nexport const ForgetPromise = {\n  get active() {\n    return this.activeForgets > 0\n  },\n\n  activeForgets: 0,\n  exceptedForgets: 0,\n\n  exceptionHandler: (error: Error, _config: ForgetConfig) => {\n    console.error(`forget promise handler excepted: ${error.message}`, error)\n  },\n\n  timeoutHandler: (time: number, _config: ForgetConfig) => {\n    console.error(`forget promise timeout out after ${time}ms [Cancelling]`)\n  },\n\n  async awaitInactive(interval = 100, timeout?: number) {\n    let timeoutRemaining = timeout\n    while (this.active) {\n      await delay(interval)\n      if (timeoutRemaining !== undefined) {\n        timeoutRemaining -= interval\n        if (timeoutRemaining <= 0) {\n          return this.activeForgets\n        }\n      }\n    }\n    return 0\n  },\n\n  /**\n   * Used to explicitly launch an async function (or Promise) with awaiting it\n   * @param promise The promise to forget\n   * @param config Configuration of forget settings\n   */\n  forget<T>(promise: Promisable<T>, config?: ForgetConfig<T>) {\n    // default | global | provided priorities for config (not deep merge)\n    const resolvedConfig = {\n      ...defaultForgetConfig, ...globalThis.xy?.forget?.config, ...config,\n    }\n    if (isPromise(promise)) {\n      try {\n        let completed = false\n        this.activeForgets++\n\n        const promiseWrapper = async () => {\n          await promise\n            .then((result: T) => {\n              this.activeForgets--\n              completed = true\n              resolvedConfig?.onComplete?.([result, undefined])\n            })\n            .catch((error) => {\n              this.activeForgets--\n              completed = true\n              resolvedConfig?.onComplete?.([undefined, error])\n            })\n        }\n\n        const promises = [promiseWrapper()]\n\n        // if there is a timeout, add it to the race\n        const timeout = resolvedConfig.timeout ?? defaultForgetConfig.timeout\n        if (isNumber(timeout)) {\n          const timeoutFunc = async () => {\n            await delay(timeout)\n            if (!completed) {\n              resolvedConfig.onCancel?.()\n              this.timeoutHandler(timeout, resolvedConfig)\n            }\n          }\n          promises.push(timeoutFunc())\n        }\n\n        const all = Promise.race(promises)\n\n        all\n          .then(() => {\n            return\n          })\n          .catch(() => {\n            return\n          })\n      } catch (ex) {\n        this.exceptedForgets += 1\n        resolvedConfig?.onException?.(ex as Error)\n        this.exceptionHandler(ex as Error, resolvedConfig)\n      }\n    } else {\n      return (promise as () => void)()\n    }\n  },\n}\n","/// <reference types=\"node\" />\n\nimport type { Promisable } from '@xylabs/promise'\n\nimport { defaultForgetNodeConfig, type ForgetNodeConfig } from './ForgetNodeConfig.ts'\nimport { ForgetPromise } from './ForgetPromise.ts'\n\nexport const ForgetPromiseNode = {\n  ...ForgetPromise,\n  exceptionHandler: (error: Error, config: ForgetNodeConfig) => {\n    // default | global | provided priorities for config (not deep merge)\n    ForgetPromise.exceptionHandler(error, config)\n\n    if (config?.terminateOnException === true) {\n      // eslint-disable-next-line unicorn/no-process-exit\n      process.exit(1)\n    }\n  },\n  timeoutHandler: (time: number, config: ForgetNodeConfig) => {\n    ForgetPromise.timeoutHandler(time, config)\n    if (config?.terminateOnTimeout === true) {\n      // eslint-disable-next-line unicorn/no-process-exit\n      process.exit(2)\n    }\n  },\n\n  /**\n     * Used to explicitly launch an async function (or Promise) with awaiting it\n     * @param promise The promise to forget\n     * @param config Configuration of forget settings\n     */\n  forget<T>(promise: Promisable<T>, config?: ForgetNodeConfig<T>) {\n    const resolvedConfig = {\n      ...defaultForgetNodeConfig, ...globalThis.xy?.forget?.config, ...config,\n    }\n    ForgetPromise.forget<T>(promise, resolvedConfig)\n  },\n}\n","import { type Promisable } from '@xylabs/promise'\n\nimport type { ForgetConfig } from './ForgetConfig.ts'\nimport { ForgetPromiseNode } from './ForgetPromiseNode.ts'\n\n// used to explicitly launch an async function (or Promise) with awaiting it\nexport const forgetNode = <T>(promise: Promisable<T>, config?: ForgetConfig<T>) => {\n  ForgetPromiseNode.forget<T>(promise, config)\n}\n"],"mappings":"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","names":[]}

package/dist/types/ForgetConfig.d.ts

@@ -0,0 +1,8 @@
+export interface ForgetConfig<T = any> {
+    onCancel?: () => void;
+    onComplete?: (result: [T | undefined, Error | undefined]) => void;
+    onException?: (error: Error) => void;
+    timeout?: number;
+}
+export declare const defaultForgetConfig: ForgetConfig<unknown>;
+//# sourceMappingURL=ForgetConfig.d.ts.map

package/dist/types/ForgetConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ForgetConfig.d.ts","sourceRoot":"","sources":["../../src/ForgetConfig.ts"],"names":[],"mappings":"AACA,MAAM,WAAW,YAAY,CAAC,CAAC,GAAG,GAAG;IACnC,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAA;IACrB,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,SAAS,EAAE,KAAK,GAAG,SAAS,CAAC,KAAK,IAAI,CAAA;IACjE,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;IACpC,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,eAAO,MAAM,mBAAmB,EAAE,YAAY,CAAC,OAAO,CAAuB,CAAA"}

package/dist/types/ForgetNodeConfig.d.ts

@@ -0,0 +1,7 @@
+import { type ForgetConfig } from './ForgetConfig.ts';
+export interface ForgetNodeConfig<T = any> extends ForgetConfig<T> {
+    terminateOnException?: boolean;
+    terminateOnTimeout?: boolean;
+}
+export declare const defaultForgetNodeConfig: ForgetNodeConfig<unknown>;
+//# sourceMappingURL=ForgetNodeConfig.d.ts.map

package/dist/types/ForgetNodeConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ForgetNodeConfig.d.ts","sourceRoot":"","sources":["../../src/ForgetNodeConfig.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAG1E,MAAM,WAAW,gBAAgB,CAAC,CAAC,GAAG,GAAG,CAAE,SAAQ,YAAY,CAAC,CAAC,CAAC;IAChE,oBAAoB,CAAC,EAAE,OAAO,CAAA;IAC9B,kBAAkB,CAAC,EAAE,OAAO,CAAA;CAC7B;AAED,eAAO,MAAM,uBAAuB,EAAE,gBAAgB,CAAC,OAAO,CAI7D,CAAA"}

package/dist/types/ForgetPromise.d.ts

@@ -0,0 +1,17 @@
+import { type Promisable } from '@xylabs/promise';
+import { type ForgetConfig } from './ForgetConfig.ts';
+export declare const ForgetPromise: {
+    readonly active: boolean;
+    activeForgets: number;
+    exceptedForgets: number;
+    exceptionHandler: (error: Error, _config: ForgetConfig) => void;
+    timeoutHandler: (time: number, _config: ForgetConfig) => void;
+    awaitInactive(interval?: number, timeout?: number): Promise<number>;
+    /**
+     * Used to explicitly launch an async function (or Promise) with awaiting it
+     * @param promise The promise to forget
+     * @param config Configuration of forget settings
+     */
+    forget<T>(promise: Promisable<T>, config?: ForgetConfig<T>): void;
+};
+//# sourceMappingURL=ForgetPromise.d.ts.map

package/dist/types/ForgetPromise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ForgetPromise.d.ts","sourceRoot":"","sources":["../../src/ForgetPromise.ts"],"names":[],"mappings":"AACA,OAAO,EAAa,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAG5D,OAAO,EAAuB,KAAK,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAE1E,eAAO,MAAM,aAAa;;;;8BAQE,KAAK,WAAW,YAAY;2BAI/B,MAAM,WAAW,YAAY;+CAIN,MAAM;IAcpD;;;;OAIG;WACI,CAAC,WAAW,UAAU,CAAC,CAAC,CAAC,WAAW,YAAY,CAAC,CAAC,CAAC;CAyD3D,CAAA"}

package/dist/types/ForgetPromiseNode.d.ts

@@ -0,0 +1,17 @@
+import type { Promisable } from '@xylabs/promise';
+import { type ForgetNodeConfig } from './ForgetNodeConfig.ts';
+export declare const ForgetPromiseNode: {
+    exceptionHandler: (error: Error, config: ForgetNodeConfig) => void;
+    timeoutHandler: (time: number, config: ForgetNodeConfig) => void;
+    /**
+       * Used to explicitly launch an async function (or Promise) with awaiting it
+       * @param promise The promise to forget
+       * @param config Configuration of forget settings
+       */
+    forget<T>(promise: Promisable<T>, config?: ForgetNodeConfig<T>): void;
+    active: boolean;
+    activeForgets: number;
+    exceptedForgets: number;
+    awaitInactive(interval?: number, timeout?: number): Promise<number>;
+};
+//# sourceMappingURL=ForgetPromiseNode.d.ts.map

package/dist/types/ForgetPromiseNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ForgetPromiseNode.d.ts","sourceRoot":"","sources":["../../src/ForgetPromiseNode.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD,OAAO,EAA2B,KAAK,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AAGtF,eAAO,MAAM,iBAAiB;8BAEF,KAAK,UAAU,gBAAgB;2BASlC,MAAM,UAAU,gBAAgB;IAQvD;;;;SAIK;WACE,CAAC,WAAW,UAAU,CAAC,CAAC,CAAC,WAAW,gBAAgB,CAAC,CAAC,CAAC;;;;;CAM/D,CAAA"}

package/dist/types/forget.d.ts

@@ -1,18 +1,4 @@
 import { type Promisable } from '@xylabs/promise';
-export interface ForgetTimeoutConfig {
-    cancel: () => void;
-    delay: number;
-}
-export declare const ForgetPromise: {
-    readonly active: boolean;
-    activeForgets: number;
-    awaitInactive(interval?: number, timeout?: number): Promise<number>;
-    /**
-     * Used to explicitly launch an async function (or Promise) with awaiting it
-     * @param promise The promise to forget
-     * @param config Configuration of forget settings
-     */
-    forget<T>(promise: Promisable<T>, onComplete?: (result: [T | undefined, Error | undefined]) => void, config?: ForgetTimeoutConfig): void;
-};
-export declare const forget: <T>(promise: Promisable<T>, onComplete?: (result: [T | undefined, Error | undefined]) => void, timeout?: ForgetTimeoutConfig) => void;
+import type { ForgetConfig } from './ForgetConfig.ts';
+export declare const forget: <T>(promise: Promisable<T>, config?: ForgetConfig<T>) => void;
 //# sourceMappingURL=forget.d.ts.map

package/dist/types/forget.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"forget.d.ts","sourceRoot":"","sources":["../../src/forget.ts"],"names":[],"mappings":"AACA,OAAO,EAAa,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAE5D,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,IAAI,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;CACd;AAED,eAAO,MAAM,aAAa;;;+CAOsB,MAAM;IAcpD;;;;OAIG;WACI,CAAC,WAAW,UAAU,CAAC,CAAC,CAAC,eAAe,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,SAAS,EAAE,KAAK,GAAG,SAAS,CAAC,KAAK,IAAI,WAAW,mBAAmB;CA8ClI,CAAA;AAGD,eAAO,MAAM,MAAM,GAAI,CAAC,EAAE,SAAS,UAAU,CAAC,CAAC,CAAC,EAAE,aAAa,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,SAAS,EAAE,KAAK,GAAG,SAAS,CAAC,KAAK,IAAI,EAAE,UAAU,mBAAmB,SAEjJ,CAAA"}
+{"version":3,"file":"forget.d.ts","sourceRoot":"","sources":["../../src/forget.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAIrD,eAAO,MAAM,MAAM,GAAI,CAAC,EAAE,SAAS,UAAU,CAAC,CAAC,CAAC,EAAE,SAAS,YAAY,CAAC,CAAC,CAAC,SAEzE,CAAA"}

package/dist/types/forgetNode.d.ts

@@ -0,0 +1,4 @@
+import { type Promisable } from '@xylabs/promise';
+import type { ForgetConfig } from './ForgetConfig.ts';
+export declare const forgetNode: <T>(promise: Promisable<T>, config?: ForgetConfig<T>) => void;
+//# sourceMappingURL=forgetNode.d.ts.map

package/dist/types/forgetNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forgetNode.d.ts","sourceRoot":"","sources":["../../src/forgetNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAIrD,eAAO,MAAM,UAAU,GAAI,CAAC,EAAE,SAAS,UAAU,CAAC,CAAC,CAAC,EAAE,SAAS,YAAY,CAAC,CAAC,CAAC,SAE7E,CAAA"}

package/dist/types/index-node.d.ts

@@ -0,0 +1,4 @@
+export * from './ForgetConfig.ts';
+export { forgetNode as forget } from './forgetNode.ts';
+export { ForgetPromiseNode as ForgetPromise } from './ForgetPromiseNode.ts';
+//# sourceMappingURL=index-node.d.ts.map

package/dist/types/index-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-node.d.ts","sourceRoot":"","sources":["../../src/index-node.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA;AACjC,OAAO,EAAE,UAAU,IAAI,MAAM,EAAE,MAAM,iBAAiB,CAAA;AACtD,OAAO,EAAE,iBAAiB,IAAI,aAAa,EAAE,MAAM,wBAAwB,CAAA"}

package/dist/types/index.d.ts

@@ -1,2 +1,4 @@
 export * from './forget.ts';
+export * from './ForgetConfig.ts';
+export * from './ForgetPromise.ts';
 //# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,mBAAmB,CAAA;AACjC,cAAc,oBAAoB,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xylabs/forget",
-  "version": "4.10.1",
+  "version": "4.11.1",
   "description": "Base functionality used throughout XY Labs TypeScript/JavaScript libraries",
   "keywords": [
     "forget",
@@ -28,6 +28,10 @@
   "type": "module",
   "exports": {
     ".": {
+      "node": {
+        "types": "./dist/types/index-node.d.ts",
+        "default": "./dist/node/index-node.mjs"
+      },
       "types": "./dist/types/index.d.ts",
       "default": "./dist/neutral/index.mjs"
     },
@@ -36,8 +40,9 @@
   "module": "./dist/neutral/index.mjs",
   "types": "./dist/types/index.d.ts",
   "dependencies": {
-    "@xylabs/delay": "^4.10.1",
-    "@xylabs/promise": "^4.10.1"
+    "@xylabs/delay": "^4.11.1",
+    "@xylabs/promise": "^4.11.1",
+    "@xylabs/typeof": "^4.11.1"
   },
   "devDependencies": {
     "@xylabs/ts-scripts-yarn3": "^6.5.7",

package/src/ForgetConfig.ts

@@ -0,0 +1,9 @@
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export interface ForgetConfig<T = any> {
+  onCancel?: () => void
+  onComplete?: (result: [T | undefined, Error | undefined]) => void
+  onException?: (error: Error) => void
+  timeout?: number
+}
+
+export const defaultForgetConfig: ForgetConfig<unknown> = { timeout: 30_000 }

package/src/ForgetNodeConfig.ts

@@ -0,0 +1,13 @@
+import { defaultForgetConfig, type ForgetConfig } from './ForgetConfig.ts'
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export interface ForgetNodeConfig<T = any> extends ForgetConfig<T> {
+  terminateOnException?: boolean // terminate the process on an exception that happens outside of the promise being forgotten
+  terminateOnTimeout?: boolean // terminate the process if the promise times out
+}
+
+export const defaultForgetNodeConfig: ForgetNodeConfig<unknown> = {
+  ...defaultForgetConfig,
+  terminateOnTimeout: true,
+  terminateOnException: true,
+}

package/src/ForgetPromise.ts

@@ -0,0 +1,99 @@
+import { delay } from '@xylabs/delay'
+import { isPromise, type Promisable } from '@xylabs/promise'
+import { isNumber } from '@xylabs/typeof'
+
+import { defaultForgetConfig, type ForgetConfig } from './ForgetConfig.ts'
+
+export const ForgetPromise = {
+  get active() {
+    return this.activeForgets > 0
+  },
+
+  activeForgets: 0,
+  exceptedForgets: 0,
+
+  exceptionHandler: (error: Error, _config: ForgetConfig) => {
+    console.error(`forget promise handler excepted: ${error.message}`, error)
+  },
+
+  timeoutHandler: (time: number, _config: ForgetConfig) => {
+    console.error(`forget promise timeout out after ${time}ms [Cancelling]`)
+  },
+
+  async awaitInactive(interval = 100, timeout?: number) {
+    let timeoutRemaining = timeout
+    while (this.active) {
+      await delay(interval)
+      if (timeoutRemaining !== undefined) {
+        timeoutRemaining -= interval
+        if (timeoutRemaining <= 0) {
+          return this.activeForgets
+        }
+      }
+    }
+    return 0
+  },
+
+  /**
+   * Used to explicitly launch an async function (or Promise) with awaiting it
+   * @param promise The promise to forget
+   * @param config Configuration of forget settings
+   */
+  forget<T>(promise: Promisable<T>, config?: ForgetConfig<T>) {
+    // default | global | provided priorities for config (not deep merge)
+    const resolvedConfig = {
+      ...defaultForgetConfig, ...globalThis.xy?.forget?.config, ...config,
+    }
+    if (isPromise(promise)) {
+      try {
+        let completed = false
+        this.activeForgets++
+
+        const promiseWrapper = async () => {
+          await promise
+            .then((result: T) => {
+              this.activeForgets--
+              completed = true
+              resolvedConfig?.onComplete?.([result, undefined])
+            })
+            .catch((error) => {
+              this.activeForgets--
+              completed = true
+              resolvedConfig?.onComplete?.([undefined, error])
+            })
+        }
+
+        const promises = [promiseWrapper()]
+
+        // if there is a timeout, add it to the race
+        const timeout = resolvedConfig.timeout ?? defaultForgetConfig.timeout
+        if (isNumber(timeout)) {
+          const timeoutFunc = async () => {
+            await delay(timeout)
+            if (!completed) {
+              resolvedConfig.onCancel?.()
+              this.timeoutHandler(timeout, resolvedConfig)
+            }
+          }
+          promises.push(timeoutFunc())
+        }
+
+        const all = Promise.race(promises)
+
+        all
+          .then(() => {
+            return
+          })
+          .catch(() => {
+            return
+          })
+      } catch (ex) {
+        this.exceptedForgets += 1
+        resolvedConfig?.onException?.(ex as Error)
+        this.exceptionHandler(ex as Error, resolvedConfig)
+      }
+    } else {
+      return (promise as () => void)()
+    }
+  },
+}

package/src/ForgetPromiseNode.ts

@@ -0,0 +1,38 @@
+/// <reference types="node" />
+
+import type { Promisable } from '@xylabs/promise'
+
+import { defaultForgetNodeConfig, type ForgetNodeConfig } from './ForgetNodeConfig.ts'
+import { ForgetPromise } from './ForgetPromise.ts'
+
+export const ForgetPromiseNode = {
+  ...ForgetPromise,
+  exceptionHandler: (error: Error, config: ForgetNodeConfig) => {
+    // default | global | provided priorities for config (not deep merge)
+    ForgetPromise.exceptionHandler(error, config)
+
+    if (config?.terminateOnException === true) {
+      // eslint-disable-next-line unicorn/no-process-exit
+      process.exit(1)
+    }
+  },
+  timeoutHandler: (time: number, config: ForgetNodeConfig) => {
+    ForgetPromise.timeoutHandler(time, config)
+    if (config?.terminateOnTimeout === true) {
+      // eslint-disable-next-line unicorn/no-process-exit
+      process.exit(2)
+    }
+  },
+
+  /**
+     * Used to explicitly launch an async function (or Promise) with awaiting it
+     * @param promise The promise to forget
+     * @param config Configuration of forget settings
+     */
+  forget<T>(promise: Promisable<T>, config?: ForgetNodeConfig<T>) {
+    const resolvedConfig = {
+      ...defaultForgetNodeConfig, ...globalThis.xy?.forget?.config, ...config,
+    }
+    ForgetPromise.forget<T>(promise, resolvedConfig)
+  },
+}

package/src/forget.ts

@@ -1,86 +1,9 @@
-import { delay } from '@xylabs/delay'
-import { isPromise, type Promisable } from '@xylabs/promise'
+import { type Promisable } from '@xylabs/promise'
 
-export interface ForgetTimeoutConfig {
-  cancel: () => void
-  delay: number
-}
-
-export const ForgetPromise = {
-  get active() {
-    return this.activeForgets > 0
-  },
-
-  activeForgets: 0,
-
-  async awaitInactive(interval = 100, timeout?: number) {
-    let timeoutRemaining = timeout
-    while (this.active) {
-      await delay(interval)
-      if (timeoutRemaining !== undefined) {
-        timeoutRemaining -= interval
-        if (timeoutRemaining <= 0) {
-          return this.activeForgets
-        }
-      }
-    }
-    return 0
-  },
-
-  /**
-   * Used to explicitly launch an async function (or Promise) with awaiting it
-   * @param promise The promise to forget
-   * @param config Configuration of forget settings
-   */
-  forget<T>(promise: Promisable<T>, onComplete?: (result: [T | undefined, Error | undefined]) => void, config?: ForgetTimeoutConfig) {
-    if (isPromise(promise)) {
-      let completed = false
-      this.activeForgets++
-
-      const promiseWrapper = async () => {
-        await promise
-          .then((result: T) => {
-            this.activeForgets--
-            completed = true
-            onComplete?.([result, undefined])
-          })
-          .catch((error) => {
-            this.activeForgets--
-            completed = true
-            onComplete?.([undefined, error])
-          })
-      }
-
-      const promises = [promiseWrapper()]
-
-      // if there is a timeout, add it to the race
-      if (config) {
-        const timeoutFunc = async () => {
-          await delay(config.delay)
-          if (!completed) {
-            console.log(`forget promise timeout out after ${config.delay}ms [Cancelling]`)
-            config.cancel?.()
-          }
-        }
-        promises.push(timeoutFunc())
-      }
-
-      const all = Promise.race(promises)
-
-      all
-        .then(() => {
-          return
-        })
-        .catch(() => {
-          return
-        })
-    } else {
-      return (promise as () => void)()
-    }
-  },
-}
+import type { ForgetConfig } from './ForgetConfig.ts'
+import { ForgetPromise } from './ForgetPromise.ts'
 
 // used to explicitly launch an async function (or Promise) with awaiting it
-export const forget = <T>(promise: Promisable<T>, onComplete?: (result: [T | undefined, Error | undefined]) => void, timeout?: ForgetTimeoutConfig) => {
-  ForgetPromise.forget<T>(promise, onComplete, timeout)
+export const forget = <T>(promise: Promisable<T>, config?: ForgetConfig<T>) => {
+  ForgetPromise.forget<T>(promise, config)
 }

package/src/forgetNode.ts

@@ -0,0 +1,9 @@
+import { type Promisable } from '@xylabs/promise'
+
+import type { ForgetConfig } from './ForgetConfig.ts'
+import { ForgetPromiseNode } from './ForgetPromiseNode.ts'
+
+// used to explicitly launch an async function (or Promise) with awaiting it
+export const forgetNode = <T>(promise: Promisable<T>, config?: ForgetConfig<T>) => {
+  ForgetPromiseNode.forget<T>(promise, config)
+}

package/src/global-config-node.d.ts

@@ -0,0 +1,9 @@
+import type { ForgetNodeConfig } from './ForgetNodeConfig.ts'
+
+declare global {
+  var xy: {
+    forget: {
+      config: ForgetNodeConfig | undefined
+    } | undefined
+  } | undefined
+}

package/src/global-config.d.ts

@@ -0,0 +1,9 @@
+import type { ForgetConfig } from './ForgetConfig.ts'
+
+declare global {
+  var xy: {
+    forget: {
+      config: ForgetConfig | undefined
+    } | undefined
+  } | undefined
+}

package/src/index-node.ts

@@ -0,0 +1,3 @@
+export * from './ForgetConfig.ts'
+export { forgetNode as forget } from './forgetNode.ts'
+export { ForgetPromiseNode as ForgetPromise } from './ForgetPromiseNode.ts'

package/src/index.ts

@@ -1 +1,3 @@
 export * from './forget.ts'
+export * from './ForgetConfig.ts'
+export * from './ForgetPromise.ts'

package/xy.config.ts

@@ -2,8 +2,8 @@ import type { XyTsupConfig } from '@xylabs/ts-scripts-yarn3'
 const config: XyTsupConfig = {
   compile: {
     browser: {},
-    neutral: { src: true },
-    node: {},
+    neutral: { src: { entry: ['src/index.ts'] } },
+    node: { src: { entry: ['src/index-node.ts'] } },
   },
 }