Add nextTick support with shared timer queue helpers

- Add a separate scheduleNextTick API with Node-native resolution and browser/worker fallback behavior.
- Preserve existing scheduleMicrotask semantics while sharing cancellable queue and timer-backed queue logic.
- Hook nextTick ordering into the timeout path so nextTick runs before microtasks and normal timers.
- Export the new API from the package entrypoint and add coverage plus size-limit updates.

Author: nev21

.size-limit.json

@@ -2,14 +2,14 @@
   {
     "name": "es5-full",
     "path": "lib/dist/es5/mod/ts-utils.js",
-    "limit": "33.5 kb",
+    "limit": "34.5 kb",
     "brotli": false,
     "running": false
   },
   {
     "name": "es6-full",
     "path": "lib/dist/es6/mod/ts-utils.js",
-    "limit": "32 kb",
+    "limit": "33.5 kb",
     "brotli": false,
     "running": false
   },
@@ -23,14 +23,14 @@
   {
     "name": "es6-full-brotli",
     "path": "lib/dist/es6/mod/ts-utils.js",
-    "limit": "11.5 kb",
+    "limit": "12 kb",
     "brotli": true,
     "running": false
   },
   {
     "name": "es5-zip",
     "path": "lib/dist/es5/mod/ts-utils.js",
-    "limit": "13 Kb",
+    "limit": "13.5 Kb",
     "gzip": true,
     "running": false
   },
@@ -107,9 +107,25 @@
   {
     "name": "es5-scheduleMicrotask",
     "path": "lib/dist/es5/mod/ts-utils.js",
-    "limit": "1.5 kb",
+    "limit": "1.75 kb",
     "import": "{ scheduleMicrotask }",
     "gzip": true,
     "running": false
+  },
+  {
+    "name": "es5-scheduleNextTick",
+    "path": "lib/dist/es5/mod/ts-utils.js",
+    "limit": "2 kb",
+    "import": "{ scheduleNextTick }",
+    "gzip": true,
+    "running": false
+  },
+  {
+    "name": "es5-scheduleNextTickAndMicrotask",
+    "path": "lib/dist/es5/mod/ts-utils.js",
+    "limit": "2 kb",
+    "import": "{ scheduleNextTick, scheduleMicrotask }",
+    "gzip": true,
+    "running": false
   }
 ]

lib/src/helpers/environment.ts

@@ -223,7 +223,10 @@ export const getHistory = (/*#__PURE__*/_getGlobalInstFn<History>(getInst, ["his
  * @returns True if you are
  */
 export const isNode = (/*#__PURE__*/_getGlobalInstFn<boolean>(() => {
-    return !!safe(() => (process && (process.versions||{}).node)).v;
+    return !!safe(() => {
+        let processInst = getInst<any>("process");
+        return processInst && (processInst.versions || {}).node;
+    }).v;
 }));
 
 /**

lib/src/index.ts

@@ -170,6 +170,7 @@ export {
     hasQueueMicrotask, scheduleMicrotask, getQueueMicrotask,
     ScheduleMicrotaskFn, MicroTaskOptions, setMicroTaskFallbackOptions
 } from "./timer/microtask";
+export { hasProcessNextTick, scheduleNextTick, getProcessNextTick, NextTickOptions, setNextTickFallbackOptions } from "./timer/nextTick";
 export {
     TimeoutOverrideFn, ClearTimeoutOverrideFn, TimeoutOverrideFuncs, scheduleTimeout, scheduleTimeoutWith,
     createTimeout, createTimeoutWith, setTimeoutOverrides, setGlobalTimeoutOverrides

lib/src/timer/microtask.ts

@@ -6,11 +6,13 @@
  * Licensed under the MIT license.
  */
 
-import { isStrictUndefined } from "../helpers/base";
 import { _getGlobalInstFn, getInst } from "../helpers/environment";
-import { ITimerHandler, _TimerHandler, _createTimerHandler } from "./handler";
-import { _getPromiseMicrotaskFn } from "./microtasks/promiseMicrotask";
-import { _addMicrotaskToQueue } from "./microtasks/timerMicrotask";
+import { ITimerHandler } from "./handler";
+import { _createCancellableTask } from "./microtasks/cancellableTask";
+import { isStrictUndefined } from "../helpers/base";
+import { _getPromiseQueueFn } from "./microtasks/promiseQueue";
+import { _eTaskQueueType } from "./microtasks/taskQueue";
+import { _addMicrotaskQueue } from "./microtasks/timerQueue";
 
 let _defaultOptions: MicroTaskOptions | undefined;
 
@@ -31,8 +33,10 @@ export type MicrotaskFn = () => void;
  * @group Timer
  * @group Environment
  * @param callback - The microtask callback function to schedule.
+ * @param maxQueuedTasks - Optional, the maximum number of queued tasks allowed before the scheduler
+ * starts dropping tasks or throwing errors, depending on the implementation.
  */
-export type ScheduleMicrotaskFn = (callback: MicrotaskFn) => void;
+export type ScheduleMicrotaskFn = (callback: MicrotaskFn, maxQueuedTasks?: number) => void | boolean;
 
 /**
  * Controls how `scheduleMicrotask` chooses fallback behavior when native
@@ -183,45 +187,10 @@ export function scheduleMicrotask(callback: () => void, options?: MicroTaskOptio
                 : (_defaultOptions && _defaultOptions.useTimeout));
             if (usePromise) {
                 // Use the Promise based fallback if available, otherwise use setTimeout
-                queueMicrotaskFn = _getPromiseMicrotaskFn();
-            }
-        }
-    }
-
-    return _createCancellableMicroTask(callback, scheduleFn || queueMicrotaskFn || _addMicrotaskToQueue);
-}
-
-/**
- * @internal
- * @since 0.15.0
- */
-function _createCancellableMicroTask(callback: () => void, queueFn: ScheduleMicrotaskFn): ITimerHandler {
-    let handler: _TimerHandler;
-    // Used to track the currently scheduled task, incremented to cancel pending tasks when needed
-    let currentTask = 0;
-
-    function _scheduleTask() {
-        let taskId = ++currentTask;
-        queueFn(() => {
-            if (taskId === currentTask) {
-                handler.dn();
-                callback();
+                queueMicrotaskFn = _getPromiseQueueFn(_eTaskQueueType.microtask);
             }
-        });
-
-        return taskId;
-    }
-
-    function _cancelTask(taskId: number) {
-        if (taskId === currentTask) {
-            currentTask++;
         }
     }
 
-    handler = _createTimerHandler(false, _scheduleTask, _cancelTask);
-    // Start the timer only after handler is fully assigned so that any synchronous
-    // queueFn implementation that fires the callback immediately can safely access handler.dn().
-    handler.h.refresh();
-
-    return handler.h;
+    return _createCancellableTask(callback, scheduleFn || queueMicrotaskFn || _addMicrotaskQueue);
 }

lib/src/timer/microtasks/cancellableTask.ts

@@ -0,0 +1,47 @@
+/*
+ * @nevware21/ts-utils
+ * https://github.com/nevware21/ts-utils
+ *
+ * Copyright (c) 2026 NevWare21 Solutions LLC
+ * Licensed under the MIT license.
+ */
+
+import { ITimerHandler, _TimerHandler, _createTimerHandler } from "../handler";
+import { ScheduleMicrotaskFn } from "../microtask";
+
+/**
+ * @internal
+ * @since 0.15.0
+ */
+export function _createCancellableTask(callback: () => void, queueFn: ScheduleMicrotaskFn, maxQueuedTasks?: number): ITimerHandler {
+    let handler: _TimerHandler;
+    let currentTask = 0;
+
+    function _scheduleTask() {
+        let taskId = ++currentTask;
+        let queued = queueFn(() => {
+            if (taskId === currentTask) {
+                handler.dn();
+                callback();
+            }
+        }, maxQueuedTasks);
+
+        if (queued === false) {
+            handler.dn();
+        }
+
+        return taskId;
+    }
+
+    function _cancelTask(taskId: number) {
+        if (taskId === currentTask) {
+            currentTask++;
+        }
+    }
+
+    handler = _createTimerHandler(false, _scheduleTask, _cancelTask);
+    // Start after handler assignment in case queueFn executes synchronously.
+    handler.h.refresh();
+
+    return handler.h;
+}

lib/src/timer/microtasks/processNextTick.ts

@@ -0,0 +1,57 @@
+/*
+ * @nevware21/ts-utils
+ * https://github.com/nevware21/ts-utils
+ *
+ * Copyright (c) 2026 NevWare21 Solutions LLC
+ * Licensed under the MIT license.
+ */
+
+import { isFunction } from "../../helpers/base";
+import { createCachedValue, ICachedValue } from "../../helpers/cache";
+import { getInst, isNode } from "../../helpers/environment";
+import { _globalLazyTestHooks, _initTestHooks } from "../../helpers/lazy";
+import { UNDEF_VALUE } from "../../internal/constants";
+import { ScheduleMicrotaskFn } from "../microtask";
+import { _runMicroTask } from "./runMicrotask";
+
+interface IProcessLike {
+    nextTick?: (callback: () => void) => void;
+}
+
+let _nextTickFn: ICachedValue<ScheduleMicrotaskFn | undefined>;
+
+/**
+ * @internal
+ * @since 0.15.0
+ */
+function _nextTickScheduleFn(processInst: IProcessLike): ScheduleMicrotaskFn {
+    return function(callback: () => void): void {
+        processInst.nextTick(() => {
+            _runMicroTask(callback);
+        });
+    };
+}
+
+/**
+ * @internal
+ * Resolves the process.nextTick-based scheduler from the current global state without caching.
+ * @since 0.15.0
+ */
+function _resolveProcessNextTickFn(): ScheduleMicrotaskFn | undefined {
+    let processInst = getInst<IProcessLike>("process");
+    return (isNode() && processInst && isFunction(processInst.nextTick)) ? _nextTickScheduleFn(processInst) : UNDEF_VALUE as any;
+}
+
+/**
+ * @internal
+ * Returns the process.nextTick-based scheduler, re-resolving globals when lazy bypass is active (e.g. tests).
+ * @since 0.15.0
+ */
+export function _getProcessNextTickFn(): ScheduleMicrotaskFn | undefined {
+    !_globalLazyTestHooks && _initTestHooks();
+    if (!_nextTickFn || _globalLazyTestHooks.lzy) {
+        _nextTickFn = createCachedValue(_resolveProcessNextTickFn());
+    }
+
+    return _nextTickFn.v;
+}

lib/src/timer/microtasks/promiseMicrotask.ts

@@ -0,0 +1,69 @@
+/*
+ * @nevware21/ts-utils
+ * https://github.com/nevware21/ts-utils
+ *
+ * Copyright (c) 2026 NevWare21 Solutions LLC
+ * Licensed under the MIT license.
+ */
+
+import { isFunction } from "../../helpers/base";
+import { createCachedValue, ICachedValue } from "../../helpers/cache";
+import { getInst } from "../../helpers/environment";
+import { _globalLazyTestHooks, _initTestHooks } from "../../helpers/lazy";
+import { ScheduleMicrotaskFn } from "../microtask";
+import { _addToQueue, _eTaskQueueType, _flushQueues } from "./taskQueue";
+
+let _promiseCls: ICachedValue<PromiseConstructor | undefined>;
+let _promisePending = false;
+let _promiseQueueFns: { [key in _eTaskQueueType]?: ScheduleMicrotaskFn } | undefined;
+
+function _ensurePromiseTask(promiseCls: PromiseConstructor): void {
+    if (!_promisePending) {
+        _promisePending = true;
+        promiseCls.resolve().then(() => {
+            _promisePending = false;
+            _flushQueues();
+        });
+    }
+}
+
+function _promiseScheduleFn(promiseCls: PromiseConstructor, queueType: _eTaskQueueType): ScheduleMicrotaskFn {
+    return function(callback: () => void, maxQueuedTasks?: number): boolean {
+        let added = _addToQueue(queueType, callback, maxQueuedTasks);
+        if (added) {
+            _ensurePromiseTask(promiseCls);
+        }
+
+        return added;
+    };
+}
+
+/**
+ * @internal
+ * Returns the Promise-based microtask scheduler, re-resolving the global Promise when the lazy
+ * bypass flag is active (e.g. during tests) so that changes to the global Promise are reflected.
+ * @since 0.15.0
+ */
+export function _getPromiseQueueFn(queueType: _eTaskQueueType): ScheduleMicrotaskFn | undefined {
+    !_globalLazyTestHooks && _initTestHooks();
+    if (!_promiseCls || _globalLazyTestHooks.lzy) {
+        let promClass = getInst<PromiseConstructor>("Promise");
+        if (promClass && isFunction(promClass.resolve)) {
+            _promiseCls = createCachedValue(promClass);
+            _promiseQueueFns = undefined;
+        }
+    }
+
+    let result: ScheduleMicrotaskFn | undefined;
+    if (_promiseCls && _promiseCls.v) {
+        !_promiseQueueFns && (_promiseQueueFns = {});
+        result = _promiseQueueFns[queueType];
+        if (!result) {
+            result = _promiseScheduleFn(_promiseCls.v, queueType);
+            _promiseQueueFns[queueType] = result;
+        }
+    }
+
+    return result;
+}
+