pure-effect 0.9.0 → 0.11.0

package/test/all.js

@@ -16,6 +16,8 @@ import {
     replayEffect,
     timeTravel
 } from '../index.js';
+import * as lib from '../index.js';
+import ts from 'typescript';
 import { enableTelemetry, telemetryHooks } from '../examples/opentelemetry-example.js';
 import { enableRecording, recordingHooks } from '../examples/recording-example.js';
 
@@ -247,6 +249,14 @@ describe('Core', function () {
         assert.equal(result.next, next);
     });
 
+    it('should default next to Success of the values array when omitted', async () => {
+        const e1 = Command(async () => 'a');
+        const e2 = Command(async () => 'b');
+        const result = await runEffect(Parallel([e1, e2]));
+        assert.equal(result.type, 'Success');
+        assert.deepEqual(result.value, ['a', 'b']);
+    });
+
     it('should run effects concurrently and pass results to next', async () => {
         const e1 = Command(
             async () => 'a',
@@ -309,6 +319,138 @@ describe('Core', function () {
     });
 });
 
+describe('Retry onExhausted', function () {
+    beforeEach(() => configureEffect());
+
+    it('should run the fallback on exhaustion and feed its value downstream', async function () {
+        let liveCalls = 0;
+        /** @type {any} */
+        let sawError;
+        const flow = effectPipe(
+            (/** @type {any} */ sku) =>
+                Retry(
+                    Command(function cmdFetchLive() {
+                        liveCalls++;
+                        return Promise.reject(new Error('down'));
+                    }),
+                    {
+                        attempts: 2,
+                        delay: 0,
+                        onExhausted: (/** @type {any} */ err) => {
+                            sawError = err;
+                            return Command(function cmdFetchCached() {
+                                return Promise.resolve({ sku, amount: 95 });
+                            });
+                        }
+                    }
+                ),
+            (/** @type {any} */ price) => Success({ ...price, stale: true })
+        );
+        const result = /** @type {any} */ (await runEffect(flow('sku-1')));
+        assert.equal(result.type, 'Success');
+        assert.deepEqual(result.value, { sku: 'sku-1', amount: 95, stale: true });
+        assert.equal(liveCalls, 3, 'the primary still runs the full retry schedule first');
+        assert.equal(sawError.retryExhausted, true);
+        assert.equal(sawError.attempts, 2);
+        assert.equal(sawError.lastError.message, 'down');
+    });
+
+    it('should propagate a failing fallback unwrapped', async function () {
+        const flow = Retry(
+            Command(function cmdPrimary() {
+                return Promise.reject('primary down');
+            }),
+            { attempts: 0, delay: 0, onExhausted: () => Failure('cache empty') }
+        );
+        const result = /** @type {any} */ (await runEffect(flow));
+        assert.equal(result.type, 'Failure');
+        assert.equal(result.error, 'cache empty', 'the fallback failure must not be wrapped in retryExhausted');
+    });
+
+    it('should not run the fallback in a cancelled Parallel branch', async function () {
+        let fallbackRuns = 0;
+        const slowFailing = Retry(
+            Command(async function cmdSlowFail() {
+                await new Promise((resolve) => setTimeout(resolve, 30));
+                throw new Error('slow branch failed');
+            }),
+            {
+                attempts: 0,
+                delay: 0,
+                onExhausted: () => {
+                    fallbackRuns++;
+                    return Success('recovered');
+                }
+            }
+        );
+        const fastFailing = Command(async function cmdFastFail() {
+            await new Promise((resolve) => setTimeout(resolve, 5));
+            throw new Error('fast branch failed');
+        });
+        const result = /** @type {any} */ (await runEffect(Parallel([fastFailing, slowFailing])));
+        assert.equal(result.type, 'Failure');
+        assert.equal(result.error.message, 'fast branch failed');
+        assert.equal(fallbackRuns, 0, 'a cancelled branch must not start its fallback');
+    });
+
+    it('should record the fallback under its own path and replay it with zero I/O', async function () {
+        const calls = { live: 0, cached: 0 };
+        const flow = (/** @type {any} */ sku) =>
+            Retry(
+                Command(function cmdFetchLive() {
+                    calls.live++;
+                    return Promise.reject(new Error('down'));
+                }),
+                {
+                    attempts: 1,
+                    delay: 0,
+                    onExhausted: () =>
+                        Command(function cmdFetchCached() {
+                            calls.cached++;
+                            return Promise.resolve(95);
+                        })
+                }
+            );
+        const { result, trace } = await recordEffect(flow, 'sku-1');
+        assert.equal(result.type, 'Success');
+        assert.ok(
+            trace.trace.some((/** @type {any} */ e) => e.command === 'cmdFetchCached' && /f\//.test(e.path)),
+            'the fallback step must be recorded under a fallback path prefix'
+        );
+        const before = { ...calls };
+        const replayed = /** @type {any} */ (await replayEffect(flow('sku-1'), trace));
+        assert.equal(replayed.type, 'Success');
+        assert.deepEqual(replayed.value, /** @type {any} */ (result).value);
+        assert.deepEqual(calls, before, 'replay must perform no I/O');
+    });
+
+    it('should strip Retry delays inside the fallback during replay', async function () {
+        const flow = (/** @type {any} */ n) =>
+            Retry(
+                Command(function cmdPrimary() {
+                    return Promise.reject('nope');
+                }),
+                {
+                    attempts: 0,
+                    delay: 0,
+                    onExhausted: () =>
+                        Retry(
+                            Command(function cmdSecondary() {
+                                return Promise.reject('still nope');
+                            }),
+                            { attempts: 2, delay: 200 }
+                        )
+                }
+            );
+        const { trace } = await recordEffect(flow, 1);
+        const started = Date.now();
+        const replayed = /** @type {any} */ (await replayEffect(flow(1), trace));
+        const elapsed = Date.now() - started;
+        assert.equal(replayed.type, 'Failure');
+        assert.ok(elapsed < 150, `replay must not wait out the fallback backoff, took ${elapsed}ms`);
+    });
+});
+
 /** Reads `.value` off a runEffect result once its type has been asserted. */
 const valueOf = (/** @type {any} */ result) => result.value;
 
@@ -474,7 +616,7 @@ describe('Recording and replay', function () {
         assert.equal(error.lastError.message, 'down');
     });
 
-    it('should require name matching for Parallel, whose branches finish out of order', async function () {
+    it('should replay a Parallel flow whose branches finish out of order', async function () {
         const flow = (/** @type {any} */ id) =>
             Parallel(
                 [
@@ -500,14 +642,115 @@ describe('Recording and replay', function () {
             ['cmdFast', 'cmdSlow'],
             'recording order follows completion, not the effects array'
         );
+        assert.deepEqual(
+            trace.trace.map((e) => e.path),
+            ['0p1/0', '0p0/0'],
+            'each entry is labelled by its branch, so completion order does not matter'
+        );
 
-        const strictReplay = await replayEffect(flow('u1'), trace);
-        assert.equal(strictReplay.type, 'Failure', 'positional matching reports a false paradox');
-        assert.equal(/** @type {Error} */ (errorOf(strictReplay)).name, 'TimeParadox');
+        // No `strict: false` needed: paths are order-independent, so the default replays correctly.
+        const replayed = await replayEffect(flow('u1'), trace);
+        assert.equal(replayed.type, 'Success');
+        assert.deepEqual(valueOf(replayed), valueOf(result));
+    });
 
-        const replayed = await replayEffect(flow('u1'), trace, { strict: false });
+    it('should keep two Parallel branches that call the same Command apart', async function () {
+        // The failure this pins is silent: per-Command queues pair branches by completion order, so
+        // reversing the branch latencies between recording and replay swapped one branch's result
+        // onto the other and the replay still reported Success.
+        const flow = (/** @type {[number, number]} */ delays) =>
+            Parallel(
+                [
+                    Command(
+                        function cmdFetch() {
+                            return new Promise((r) => setTimeout(() => r('A'), delays[0]));
+                        },
+                        (/** @type {any} */ v) => Success(v)
+                    ),
+                    Command(
+                        function cmdFetch() {
+                            return new Promise((r) => setTimeout(() => r('B'), delays[1]));
+                        },
+                        (/** @type {any} */ v) => Success(v)
+                    )
+                ],
+                (/** @type {any} */ vals) => Success(vals)
+            );
+
+        const { result, trace } = await recordEffect(flow, [40, 5]);
+        assert.deepEqual(valueOf(result), ['A', 'B']);
+
+        // Replay with the latencies reversed, so completion order is the opposite of the recorded run.
+        const replayed = await replayEffect(flow([5, 40]), trace);
+        assert.equal(replayed.type, 'Success');
+        assert.deepEqual(valueOf(replayed), ['A', 'B'], 'branch results were not swapped');
+    });
+
+    it('should still resolve a legacy trace that carries no paths', async function () {
+        const a = makeFlow();
+        const { result, trace } = await recordEffect(a.flow, { id: 'legacy' });
+        const legacy = {
+            ...trace,
+            trace: trace.trace.map(({ path, ...rest }) => rest)
+        };
+        assert.ok(
+            legacy.trace.every((e) => e.path === undefined),
+            'the fixture really has no paths'
+        );
+
+        const b = makeFlow();
+        const replayed = await replayEffect(b.flow(trace.initialInput), legacy);
         assert.equal(replayed.type, 'Success');
         assert.deepEqual(valueOf(replayed), valueOf(result));
+        assert.deepEqual(b.calls, { read: 0, write: 0 }, 'a legacy trace still performs no I/O');
+    });
+
+    it('should raise a TimeParadox naming the path when a flow diverges', async function () {
+        const original = (/** @type {any} */ id) =>
+            effectPipe(
+                () =>
+                    Command(
+                        function cmdRead() {
+                            return id;
+                        },
+                        (/** @type {any} */ v) => Success(v)
+                    ),
+                (/** @type {any} */ v) =>
+                    Command(
+                        function cmdWrite() {
+                            return v;
+                        },
+                        (/** @type {any} */ w) => Success(w)
+                    )
+            )(id);
+        const { trace } = await recordEffect(original, 'x1');
+
+        // The second step is a different Command than the trace recorded at that path.
+        const diverged = (/** @type {any} */ id) =>
+            effectPipe(
+                () =>
+                    Command(
+                        function cmdRead() {
+                            return id;
+                        },
+                        (/** @type {any} */ v) => Success(v)
+                    ),
+                (/** @type {any} */ v) =>
+                    Command(
+                        function cmdAudit() {
+                            return v;
+                        },
+                        (/** @type {any} */ w) => Success(w)
+                    )
+            )(id);
+
+        const replayed = await replayEffect(diverged('x1'), trace);
+        assert.equal(replayed.type, 'Failure');
+        const error = /** @type {any} */ (errorOf(replayed));
+        assert.equal(error.name, 'TimeParadox');
+        assert.equal(error.path, '1');
+        assert.equal(error.expected, 'cmdWrite');
+        assert.equal(error.actual, 'cmdAudit');
     });
 
     it('should accept a trace directly, without building a Resolver', async function () {
@@ -527,6 +770,41 @@ describe('Recording and replay', function () {
         assert.deepEqual(valueOf(fromEntries), valueOf(result));
     });
 
+    it('should carry an error cause through a trace and back', async function () {
+        const flow = (/** @type {any} */ input) =>
+            Command(function cmdCharge() {
+                return Promise.reject(new Error('charge declined', { cause: new Error('card expired') }));
+            });
+
+        const { result, trace } = await recordEffect(flow, { id: 'cause' });
+        assert.equal(result.type, 'Failure');
+
+        // The trace must survive JSON, which is where a non-enumerable cause would silently vanish.
+        const stored = JSON.parse(JSON.stringify(trace));
+        const replayed = await replayEffect(flow(stored.initialInput), stored);
+        assert.equal(replayed.type, 'Failure');
+        const error = /** @type {any} */ (errorOf(replayed));
+        assert.equal(error.message, 'charge declined');
+        assert.ok(error.cause instanceof Error, 'the revived error must keep its cause');
+        assert.equal(error.cause.message, 'card expired');
+    });
+
+    it('should carry a nested cause chain and a non-Error cause', async function () {
+        const flow = (/** @type {any} */ input) =>
+            Command(function cmdFetch() {
+                return Promise.reject(
+                    new Error('fetch failed', { cause: new Error('socket closed', { cause: 'ECONNRESET' }) })
+                );
+            });
+
+        const { trace } = await recordEffect(flow, { id: 'chain' });
+        const stored = JSON.parse(JSON.stringify(trace));
+        const replayed = await replayEffect(flow(stored.initialInput), stored);
+        const error = /** @type {any} */ (errorOf(replayed));
+        assert.equal(error.cause.message, 'socket closed');
+        assert.equal(error.cause.cause, 'ECONNRESET', 'a non-Error cause must pass through unchanged');
+    });
+
     it('should reject a malformed trace as a ReplayError, not a TypeError', async function () {
         const { flow } = makeFlow();
         for (const bad of [undefined, null, 42, {}, { trace: 'nope' }]) {
@@ -1665,8 +1943,11 @@ describe('Documented sharp edges', function () {
         assert.equal(charges.length, 3, 'one order, three charges: wrap the Command, not the pipeline');
     });
 
-    it('should run every Parallel branch to completion even after one fails', async function () {
-        // Pinned deliberately: Promise.all has no cancellation, so a Failure does not stop sibling I/O.
+    it('should not stop an in-flight Command whose thunk ignores the signal', async function () {
+        // Pinned deliberately: cancellation is cooperative. The sibling's write is already in flight
+        // inside the branch's first Command, and a thunk that ignores its signal cannot be interrupted,
+        // so the write still lands. What cancellation does buy is in the suite below: no *later*
+        // Command in that branch starts, and a thunk that honours the signal is cut off.
         /** @type {string[]} */
         const written = [];
         const result = await runEffect(
@@ -1695,7 +1976,7 @@ describe('Documented sharp edges', function () {
         );
         assert.equal(result.type, 'Failure');
         assert.equal(errorOf(result), 'validation_failed');
-        assert.deepEqual(written, ['wrote'], 'the sibling branch still performed its write');
+        assert.deepEqual(written, ['wrote'], 'an uninterruptible in-flight write still performed');
     });
 
     it('should carry the initial input on every Failure', async function () {
@@ -1799,3 +2080,186 @@ describe('Malformed flows', function () {
         assert.equal(/** @type {Error} */ (errorOf(result)).message, 'boom');
     });
 });
+
+describe('Parallel cancellation', function () {
+    beforeEach(function () {
+        configureEffect();
+    });
+
+    /** Resolves after `ms`, or rejects as soon as `signal` aborts. */
+    const cancellableSleep = (/** @type {number} */ ms, /** @type {AbortSignal} */ signal) =>
+        new Promise((resolve, reject) => {
+            const timer = setTimeout(resolve, ms);
+            signal?.addEventListener(
+                'abort',
+                () => {
+                    clearTimeout(timer);
+                    reject(new Error('aborted'));
+                },
+                { once: true }
+            );
+        });
+
+    it('should cancel a branch whose thunk honours the signal', async function () {
+        let completed = false;
+        const started = Date.now();
+        const result = await runEffect(
+            Parallel(
+                [
+                    Command(function cmdFail() {
+                        throw new Error('fail_fast');
+                    }),
+                    Command(async function cmdSlow(/** @type {AbortSignal} */ signal) {
+                        await cancellableSleep(400, signal);
+                        completed = true;
+                        return 'wrote';
+                    })
+                ],
+                (/** @type {any} */ v) => Success(v)
+            )
+        );
+        assert.equal(result.type, 'Failure');
+        assert.equal(/** @type {Error} */ (errorOf(result)).message, 'fail_fast');
+        assert.equal(completed, false, 'the cancelled branch never finished its work');
+        assert.ok(Date.now() - started < 200, 'the run did not wait out the cancelled branch');
+    });
+
+    it('should not start a later Command in a cancelled branch', async function () {
+        /** @type {string[]} */
+        const ran = [];
+        const step = (/** @type {string} */ name) => () =>
+            Command(
+                async function cmdWrite() {
+                    await cancellableSleep(30, undefined);
+                    ran.push(name);
+                    return name;
+                },
+                (/** @type {any} */ v) => Success(v)
+            );
+        const result = await runEffect(
+            Parallel(
+                [
+                    Command(async function cmdFail() {
+                        await cancellableSleep(5, undefined);
+                        throw new Error('validation_failed');
+                    }),
+                    effectPipe(step('write1'), step('write2'), step('write3'))(null)
+                ],
+                (/** @type {any} */ v) => Success(v)
+            )
+        );
+        assert.equal(result.type, 'Failure');
+        assert.deepEqual(ran, ['write1'], 'the in-flight write landed; the two after it never started');
+    });
+
+    it('should stop retrying in a cancelled branch', async function () {
+        let attempts = 0;
+        const result = await runEffect(
+            Parallel(
+                [
+                    Command(async function cmdFail() {
+                        await cancellableSleep(30, undefined);
+                        throw new Error('primary_failed');
+                    }),
+                    Retry(
+                        Command(function cmdFlaky() {
+                            attempts++;
+                            throw new Error('flaky');
+                        }),
+                        { attempts: 5, delay: 100 }
+                    )
+                ],
+                (/** @type {any} */ v) => Success(v)
+            )
+        );
+        assert.equal(/** @type {Error} */ (errorOf(result)).message, 'primary_failed');
+        assert.ok(attempts < 5, `the cancelled branch stopped retrying (made ${attempts} attempts, not 6)`);
+    });
+
+    it('should propagate cancellation into a nested Parallel', async function () {
+        let inner = false;
+        const result = await runEffect(
+            Parallel(
+                [
+                    Command(function cmdOuterFail() {
+                        throw new Error('outer_failed');
+                    }),
+                    Parallel(
+                        [
+                            Command(async function cmdInner(/** @type {AbortSignal} */ signal) {
+                                await cancellableSleep(300, signal);
+                                inner = true;
+                                return 1;
+                            })
+                        ],
+                        (/** @type {any} */ v) => Success(v)
+                    )
+                ],
+                (/** @type {any} */ v) => Success(v)
+            )
+        );
+        assert.equal(/** @type {Error} */ (errorOf(result)).message, 'outer_failed');
+        assert.equal(inner, false, 'the inner branch was cancelled with the outer one');
+    });
+
+    it('should return the triggering Failure rather than the cancellation', async function () {
+        const result = await runEffect(
+            Parallel(
+                [
+                    Command(async function cmdSlowOk(/** @type {AbortSignal} */ signal) {
+                        await cancellableSleep(200, signal);
+                        return 'ok';
+                    }),
+                    Command(function cmdRealFailure() {
+                        throw new Error('THE_REAL_ERROR');
+                    })
+                ],
+                (/** @type {any} */ v) => Success(v)
+            )
+        );
+        assert.equal(
+            /** @type {Error} */ (errorOf(result)).message,
+            'THE_REAL_ERROR',
+            'a cancelled sibling must not displace the failure that caused the cancellation'
+        );
+    });
+
+    it('should still pick the first Failure by array order when branches fail together', async function () {
+        const result = await runEffect(Parallel([Failure('a'), Failure('b')], (/** @type {any} */ v) => Success(v)));
+        assert.equal(errorOf(result), 'a');
+    });
+
+    it('should pass no argument to a Command outside a Parallel', async function () {
+        /** @type {any[]} */
+        const args = [];
+        const result = await runEffect(
+            Command(function cmdRecordArgs() {
+                args.push([...arguments]);
+                return 'done';
+            })
+        );
+        assert.equal(result.type, 'Success');
+        assert.deepEqual(args, [[]], 'a thunk outside a Parallel is called with no arguments at all');
+    });
+});
+
+describe('Declaration parity', function () {
+    it('should declare exactly the exports the runtime ships', function () {
+        // index.d.ts is hand-maintained beside index.js, so the two can drift silently: a
+        // declaration once vanished as edit collateral while every check stayed green. This pins
+        // existence in both directions; signatures remain tsd's job.
+        const program = ts.createProgram(['index.d.ts'], { noEmit: true });
+        const source = program.getSourceFile('index.d.ts');
+        assert.ok(source, 'index.d.ts must be part of the program');
+        const checker = program.getTypeChecker();
+        const moduleSymbol = checker.getSymbolAtLocation(/** @type {import('typescript').Node} */ (source));
+        assert.ok(moduleSymbol, 'index.d.ts must be a module');
+        const declared = checker
+            .getExportsOfModule(moduleSymbol)
+            .filter((s) => s.flags & ts.SymbolFlags.Value)
+            .map((s) => s.name)
+            .sort();
+        const shipped = Object.keys(lib).sort();
+        assert.deepEqual(declared, shipped);
+    });
+});

package/test/types.test-d.ts

@@ -104,13 +104,14 @@ const innerCmd = Command(
     (n) => Success(n)
 );
 
-// Retry with options preserves T
+// Retry with options preserves T; the error type is the exhaustion failure, not the inner error,
+// because the interpreter wraps the last inner error rather than letting it escape
 const retried = Retry(innerCmd, { attempts: 3 });
-expectType<RetryState<number, unknown>>(retried);
+expectType<RetryState<number, RetryExhaustedError<unknown>>>(retried);
 
 // Retry without options is valid
 const retriedNoOpts = Retry(innerCmd);
-expectType<RetryState<number, unknown>>(retriedNoOpts);
+expectType<RetryState<number, RetryExhaustedError<unknown>>>(retriedNoOpts);
 
 // Retry in effectPipe preserves type flow
 const retryFlow = effectPipe((input: User) =>
@@ -122,7 +123,35 @@ const retryFlow = effectPipe((input: User) =>
         { attempts: 2 }
     )
 );
-expectType<Effect<SavedUser>>(retryFlow({ email: 'a@b.com', password: 'secret123' }));
+expectType<Effect<SavedUser, RetryExhaustedError<unknown>>>(retryFlow({ email: 'a@b.com', password: 'secret123' }));
+
+// The inner error type survives inside the exhaustion failure, so lastError is typed
+const retriedTyped = Retry(Success(1) as Effect<number, 'net_down'>);
+expectType<RetryState<number, RetryExhaustedError<'net_down'>>>(retriedTyped);
+
+const retryResult = await runEffect(Retry(Success(1) as Effect<number, 'flaky'>, { attempts: 1 }));
+if (retryResult.type === 'Failure') {
+    expectType<RetryExhaustedError<'flaky'>>(retryResult.error);
+    expectType<'flaky'>(retryResult.error.lastError);
+}
+
+// onExhausted consumes the exhaustion, so the fallback's error type is what remains
+const recovered = Retry(Success(1) as Effect<number, 'flaky'>, {
+    attempts: 1,
+    onExhausted: (err) => {
+        expectType<RetryExhaustedError<'flaky'>>(err);
+        return Success(0) as Effect<number, 'cache_miss'>;
+    }
+});
+expectType<RetryState<number, 'cache_miss'>>(recovered);
+
+const recoveredResult = await runEffect(recovered);
+if (recoveredResult.type === 'Failure') {
+    expectType<'cache_miss'>(recoveredResult.error);
+}
+
+// onExhausted is per-use only: global retry defaults cannot carry a fallback
+expectError(configureEffect({ retry: { attempts: 2, onExhausted: () => Success(1) } }));
 
 // RetryExhaustedError shape is usable for narrowing exhaustion failures
 const exhaustedErr: RetryExhaustedError<Error> = {
@@ -168,6 +197,14 @@ expectType<Effect<{ email: string; password: string }>>(parallelFlow({ email: 'a
 const parallelResult = await runEffect(Parallel([Success(1), Success('x')], ([n, s]) => Success({ n, s })));
 expectType<SuccessState<{ n: number; s: string }> | FailureState<unknown>>(parallelResult);
 
+// With next omitted, the Parallel resolves to the values tuple itself
+const parBare = Parallel([Success(42), Success('hello')]);
+expectType<ParallelState<[number, string], [number, string]>>(parBare);
+const parBareResult = await runEffect(parBare);
+if (parBareResult.type === 'Success') {
+    expectType<[number, string]>(parBareResult.value);
+}
+
 // --- Ctx (context type) ---
 
 interface AppCtx {

package/tsconfig.check.json

@@ -0,0 +1,12 @@
+{
+    "compilerOptions": {
+        "allowJs": true,
+        "checkJs": true,
+        "noEmit": true,
+        "target": "es2022",
+        "module": "nodenext",
+        "moduleResolution": "nodenext",
+        "lib": ["es2022", "dom"]
+    },
+    "files": ["index.js"]
+}

package/.claude/settings.local.json

@@ -1,17 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(npm test *)",
-      "Bash(npm view *)",
-      "Bash(npx mocha *)",
-      "Bash(echo \"exit: $?\")",
-      "Bash(npx prettier *)",
-      "Bash(echo \"npm test exit: $?\")",
-      "Bash(npx tsc *)",
-      "Bash(echo \"tsc exit: $?\")",
-      "Read(//tmp/**)",
-      "Bash(npx esbuild *)",
-      "Bash(gzip -9)"
-    ]
-  }
-}