alternative idea: drop the second operation entirely and allow a native (search from the end) position argument on...

haystack.indexOfSequence(needle, -10);  // search forward from 10 elements from the end, etc

can you elaborate on this

(sorry, moving out of thread because threads have a painful UI)

ambiguity bites the first time you read it, but it's relatively easy to internalize. whereas inconsistency bites every single time because it is much harder to learn/remember an inconsistency

Could leverage AsyncContext.Variable for this. I just threw together a rough implementation using AsyncContext and AbortController that looks something like this:

declare class Scope {
    [Symbol.asyncDispose](): Promise<void>;
    fork<R>(cb: () => R): Promise<R>;
    static get hasExited(): boolean;

    // DOM extension?
    // static get signal(): AbortSignal;
}

async function f() {
    await using scope = new Scope();
    const a = scope.fork(async () => { ... if (Scope.hasExited) return; ... });
    const b = scope.fork(async () => {});
    const c = scope.fork(async () => {});
    const [aa, bb, cc] = await Promise.all([a, b, c]);
}

No AsyncContext, just Promise enlistment tracking and a cleanup callback:

const controller = new AbortController();
const { signal } = controller;

await using scope = new Scope(() => controller.abort());
const [a, b, c] = await Promise.all([
  scope.enlist(fetchUser(userId, { signal })),
  scope.enlist(fetchOrders(userId, { signal })),
  scope.enlist(fetchRecommendations(userId, { signal }))
]);