What do Promise.withResolvers and Promise.try solve?

Promise.withResolvers() returns a plain object { promise, resolve, reject }. It replaces the old pattern of declaring let resolve, reject outside and assigning them inside the executor. Use it when the thing that settles the promise is not the code that creates it: event handlers, message queues, request/response matching, test helpers, or a "ready" signal. It is the same promise with the same once-only rules. The spec simply makes NewPromiseCapability available directly.

One difference from new Promise(executor): there is no executor, so there is no automatic "throw becomes rejection". Setup code you write next to it throws normally.

Promise.try(callback, ...args) calls callback(...args) immediately and synchronously, then:

• if it returns a value or a promise, the result promise resolves with it, with the usual adoption rules;
• if it throws, the result promise is rejected with the error.

It solves the "sometimes sync, sometimes async" function. Without it, fn() may throw before you get a promise, so a .catch never sees the error. Promise.resolve().then(fn) catches it but delays fn by a microtask. new Promise((resolve) => resolve(fn())) and (async () => fn())() work but are noisy. Promise.try does it in one call, and passes arguments.

Both are static methods that read this as the constructor, so they must be called as Promise.try(...), not detached.

Availability. Both run in Node 24. By MDN's browser-compat-data, withResolvers shipped in Chrome 119, Firefox 121 and Safari 17.4 (Node 22) and is Baseline widely available. try shipped in Chrome 128, Firefox 134 and Safari 18.2 (Node 23) and is Baseline newly available (since January 2025), so older browsers need a polyfill.

const target = new EventTarget();

function nextEvent(name) {
  const { promise, resolve } = Promise.withResolvers();
  target.addEventListener(name, resolve, { once: true });
  return promise;
}

const waiting = nextEvent('ready');
target.dispatchEvent(new Event('ready'));
console.log((await waiting).type); // → ready

const parse = (text) => JSON.parse(text);
console.log(await Promise.try(parse, '{"ok":true}')); // → { ok: true }
await Promise.try(parse, '{bad').catch((error) => console.log(error.name)); // → SyntaxError

const order = [];
Promise.try(() => order.push('try callback')); // runs synchronously
Promise.resolve().then(() => order.push('then callback'));
order.push('after');
await null;
console.log(order);
// → [ 'try callback', 'after', 'then callback' ]

• Detaching the method: const { try: t } = Promise; t(fn) throws a TypeError, because this is no longer the constructor.
• Expecting Promise.try to defer the callback. It runs synchronously, before the call returns. Use Promise.resolve().then(fn) or queueMicrotask if you need it deferred.
• Handing out resolve/reject widely. Anyone holding them can settle the promise, and only the first call counts. A promise whose resolvers are lost stays pending forever.
• Using withResolvers where an executor would do. If the promise settles inside the code that creates it, new Promise is simpler and also converts throws into rejections.