@jujulego/jill 3.0.0-alpha.6 → 3.0.0-alpha.8

package/dist/main.js

@@ -1,20 +1,21 @@
-;{try{(function(){var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="dacd5c15-8247-4915-b30c-252fb53065d6",e._sentryDebugIdIdentifier="sentry-dbid-dacd5c15-8247-4915-b30c-252fb53065d6");})();}catch(e){}};!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{};e.SENTRY_RELEASE={id:"3.0.0-alpha.6"};}catch(e){}}();import { token$, inject$, asyncScope$ } from '@kyrielle/injector';
+;{try{(function(){var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="928a37d5-5913-4d87-9031-9d670b857132",e._sentryDebugIdIdentifier="sentry-dbid-928a37d5-5913-4d87-9031-9d670b857132");})();}catch(e){}};!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{};e.SENTRY_RELEASE={id:"3.0.0-alpha.8"};}catch(e){}}();import { token$, inject$, asyncScope$ } from '@kyrielle/injector';
 import { startSpan, getActiveSpan, updateSpanName, getRootSpan, startInactiveSpan, captureException } from '@sentry/node';
 import process$1 from 'node:process';
 import { hideBin } from 'yargs/helpers';
-import { pipe$, waitFor$, filter$, observable$, off$, once$, map$, collect$, asyncIterator$, var$, flow$ } from 'kyrielle';
+import { pipe$, waitFor$, filter$, map$, collect$, asyncIterator$, var$, flow$ } from 'kyrielle';
 import yargs from 'yargs';
-import { TaskManager, plan, SpawnTask, GroupTask, TaskSet, ParallelGroup, FallbackGroup, SequenceGroup } from '@jujulego/tasks';
+import { scheduler$, isWorkloadEnded, WorkloadState, spawn$, sequenceFlow$, parallelFlow$, fallbackFlow$ } from '@jujulego/tasks';
 import { logger$, withTimestamp, withLabel, qLogDelay, LogLevel, LogGateway, logDelay$, toStderr } from '@kyrielle/logger';
 import fs from 'node:fs';
 import { PathScurry } from 'path-scurry';
 import { _ } from '@swc/helpers/_/_apply_decs_2203_r';
+import { text } from 'node:stream/consumers';
 import path from 'node:path';
 import { Glob } from 'glob';
 import normalize from 'normalize-package-data';
 import { satisfies, compare, parse } from 'semver';
 import moo from 'moo';
-import cp from 'node:child_process';
+import { spawn } from 'node:child_process';
 import chalk from 'chalk';
 import slugify from 'slugify';
 import { qjson, qprop, q$, defineQuickFormat, qerror, qarg, qwrap } from '@jujulego/quick-tag';
@@ -23,14 +24,16 @@ import os from 'node:os';
 import { cosmiconfig, defaultLoaders } from 'cosmiconfig';
 import { chalkTemplateStderr } from 'chalk-template';
 
-var version = "3.0.0-alpha.6";
+var version = "3.0.0-alpha.8";
 
 function trace(fun, opts) {
     const name = typeof opts === 'string' ? opts : opts.name;
-    const use = typeof opts === 'object' ? opts.use : (_, r)=>r;
+    const op = typeof opts === 'object' ? opts.op : undefined;
+    const use = typeof opts === 'object' && opts.use || ((_, r)=>r);
     return function(...args) {
         return pipe$(startSpan({
-            name
+            name,
+            op
         }, ()=>fun.call(this, ...args)), (r)=>use(name, r));
     };
 }
@@ -44,27 +47,19 @@ function instrument(opts) {
         });
     };
 }
-function traceAsyncGenerator(name, generator) {
-    const instrumented = {
-        ...generator,
-        next: async ()=>startSpan({
-                name,
-                op: 'iterator.next'
-            }, ()=>generator.next()),
-        [Symbol.asyncIterator]: ()=>instrumented
-    };
-    return instrumented;
-}
 function traceImport(name, loader) {
     return startSpan({
-        name: `load ${name}`,
+        name: name,
         op: 'resource.script'
     }, loader);
 }
 
 function command$5(module) {
-    const name = getCommandName(module);
-    const handler = trace(module.handler, 'cli.handler');
+    const name = commandName(module);
+    const handler = trace(module.handler, {
+        name: commandName(module),
+        op: 'cli.handler'
+    });
     return (parser)=>parser.command({
             ...module,
             async handler (args) {
@@ -76,7 +71,7 @@ function command$5(module) {
             }
         });
 }
-function getCommandName(module) {
+function commandName(module) {
     if (!module.command) {
         return '[unknown]';
     }
@@ -96,61 +91,69 @@ const LOGGER = token$('Logger', ()=>logger$(withTimestamp()));
 const PATH_SCURRY = token$('PathScurry', ()=>new PathScurry('/', {
         fs
     }));
-const TASK_MANAGER = token$('TaskManager', async ()=>{
-    const manager = new TaskManager({
-        jobs: (await inject$(CONFIG, asyncScope$())).jobs,
-        logger: inject$(LOGGER)
+const SCHEDULER = token$('Scheduler', async ()=>{
+    const config = await inject$(CONFIG, asyncScope$());
+    const logger = inject$(LOGGER);
+    const scheduler = scheduler$({
+        strength: config.jobs
     });
-    let rootSpan = getActiveSpan();
-    if (rootSpan) rootSpan = getRootSpan(rootSpan);
-    const spans = new Map();
-    manager.events$.on('added', (task)=>{
-        // Main span
-        const span = startInactiveSpan({
-            name: task.name,
-            parentSpan: (task.group && spans.get(task.group.id)) ?? rootSpan,
-            op: 'task'
-        });
-        task.events$.on('completed', ({ status })=>{
-            span.setStatus({
-                code: status === 'done' ? 1 : 2
-            });
-            span.end();
+    scheduler.events$.on('started', (job)=>{
+        logger.verbose(`job "${job.label}" started`);
+    });
+    scheduler.events$.on('ended', (job)=>{
+        logger.verbose(`job "${job.label}" ended in state ${job.state()}`);
+    });
+    // Task instrumentation
+    scheduler.events$.on('added', (job)=>{
+        const jobSpan = startInactiveSpan({
+            op: 'job',
+            name: job.label,
+            attributes: {
+                'job.id': job.id,
+                'job.type': job.type,
+                'job.weight': job.weight
+            }
         });
-        spans.set(task.id, span);
         // Status spans
-        let statusSpan = startInactiveSpan({
-            name: task.status,
-            parentSpan: span,
-            op: 'task.status'
-        });
-        task.events$.on('status', ({ status })=>{
-            statusSpan.end();
-            if (!task.completed) {
-                statusSpan = startInactiveSpan({
-                    name: status,
-                    parentSpan: span,
-                    op: 'task.status'
-                });
+        let stateSpan;
+        let subscription;
+        job.state$.subscribe({
+            start: (sub)=>{
+                subscription = sub;
+            },
+            next: (state)=>{
+                stateSpan?.end();
+                if (isWorkloadEnded(state)) {
+                    jobSpan.setAttribute('job.final_state', state);
+                    jobSpan.setAttribute('job.duration', job.duration().seconds());
+                    jobSpan.setStatus({
+                        code: state === WorkloadState.Succeeded ? 1 : 2
+                    });
+                    jobSpan.end();
+                    subscription.unsubscribe();
+                } else {
+                    stateSpan = startInactiveSpan({
+                        op: 'job.state',
+                        name: state,
+                        parentSpan: jobSpan
+                    });
+                }
             }
         });
     });
-    return manager;
+    return scheduler;
 });
 
-// Utils
-function printJson(data, stream = process.stdout) {
-    if (stream.isTTY) {
-        stream.write(JSON.stringify(data, null, 2));
-    } else {
-        stream.write(JSON.stringify(data));
-    }
-}
-
 // Utils
 function executeCommand(module) {
-    const prepare = trace(module.prepare, 'cli.prepare');
-    const execute = module.execute && trace(module.execute, 'cli.execute');
+    const prepare = trace(module.prepare, {
+        name: commandName(module),
+        op: 'cli.prepare'
+    });
+    const execute = module.execute && trace(module.execute, {
+        name: commandName(module),
+        op: 'cli.execute'
+    });
     return command$5({
         ...module,
         builder (base) {
@@ -162,23 +165,14 @@ function executeCommand(module) {
             }
         },
         async handler (args) {
-            const tasks = await prepare(args);
-            if (args.plan) {
-                if (args.planMode === 'json') {
-                    printJson(Array.from(plan(tasks)));
-                } else {
-                    const { default: TaskPlanInk } = await traceImport('TaskPlanInk', ()=>import('./task-plan.ink.js'));
-                    await TaskPlanInk({
-                        tasks
-                    });
-                }
-            } else {
+            const job = await prepare(args) ?? null;
+            if (args.plan) ; else {
                 if (execute) {
-                    await execute(args, tasks);
-                } else if (tasks.tasks.length > 0) {
-                    const { default: TaskExecInk } = await traceImport('TaskExecInk', ()=>import('./task-exec.ink.js'));
-                    await TaskExecInk({
-                        tasks,
+                    await execute(args, job);
+                } else if (job) {
+                    const { default: JobExecInk } = await traceImport('JobExecInk', ()=>import('./job-exec.ink.js'));
+                    await JobExecInk({
+                        job,
                         verbose: [
                             'verbose',
                             'debug'
@@ -193,9 +187,12 @@ function executeCommand(module) {
         }
     });
 }
-function planCommand(module, tasks$) {
+function planCommand(module, job$) {
     if ('prepare' in module) {
-        const prepare = trace(module.prepare, 'cli.prepare');
+        const prepare = trace(module.prepare, {
+            name: commandName(module),
+            op: 'cli.prepare'
+        });
         return command$5({
             ...module,
             builder (base) {
@@ -207,7 +204,7 @@ function planCommand(module, tasks$) {
                 }
             },
             async handler (args) {
-                tasks$.mutate(await prepare(args));
+                job$.mutate(await prepare(args) ?? null);
             }
         });
     } else {
@@ -252,158 +249,105 @@ function hasEveryScript$(scripts) {
     });
 }
 
-// Utils
-async function* combine(...generators) {
-    for (const gen of generators){
-        yield* gen;
+class ClientError extends Error {
+    name = 'ClientError';
+    constructor(message){
+        super(message);
     }
 }
-function streamLines$(task, stream = 'stdout') {
-    return observable$((observer, signal)=>{
-        const off = off$();
-        let current = '';
-        // End
-        off.add(once$(task.events$, 'completed', ()=>{
-            if (current) observer.next(current);
-            observer.complete();
-            off.unsubscribe();
-        }));
-        // Abort
-        signal.addEventListener('abort', ()=>off.unsubscribe(), {
-            once: true
-        });
-        // Steam
-        off.add(task.events$.on(`stream.${stream}`, (chunk)=>{
-            const data = current + chunk.data.toString('utf-8');
-            const lines = data.split(/\r?\n/);
-            current = lines.pop() ?? '';
-            for (const line of lines){
-                observer.next(line);
-            }
-        }));
-    });
-}
 
-var _dec$4, _dec1$3, _dec2$1, _initProto$4;
-_dec$4 = instrument('GitService.isAffected'), _dec1$3 = instrument('GitService.listBranches'), _dec2$1 = instrument('GitService.listTags');
+var _dec$2, _dec1$1, _dec2, _initProto$2;
+_dec$2 = instrument('GitService.isAffected'), _dec1$1 = instrument('GitService.listBranches'), _dec2 = instrument('GitService.listTags');
 class GitService {
     static{
-        ({ e: [_initProto$4] } = _(this, [
+        ({ e: [_initProto$2] } = _(this, [
             [
-                _dec$4,
+                _dec$2,
                 2,
                 "isAffected"
             ],
             [
-                _dec1$3,
+                _dec1$1,
                 2,
                 "listBranches"
             ],
             [
-                _dec2$1,
+                _dec2,
                 2,
                 "listTags"
             ]
         ], []));
     }
     // Attributes
-    _manager = (_initProto$4(this), inject$(TASK_MANAGER));
+    _scheduler = (_initProto$2(this), inject$(SCHEDULER));
     _logger = inject$(LOGGER);
     // Methods
     /**
-   * Runs a git command inside a SpawnTask
-   *
-   * @param cmd
-   * @param args
-   * @param options
-   */ async command(cmd, args, options = {}) {
-        const opts = {
-            logger: this._logger,
-            ...options
-        };
-        // Create task
-        const task = new SpawnTask('git', [
+   * Runs a git command inside
+   */ async command(cmd, args, opts = {}) {
+        const { logger = this._logger, ...props } = opts;
+        // Create job
+        const job = spawn$('git', [
             cmd,
             ...args
-        ], {
-            command: cmd,
-            hidden: true
-        }, opts);
-        task.events$.on('stream', ({ data })=>opts.logger.debug(data.toString('utf-8')));
-        (await this._manager).add(task);
-        return task;
+        ], props);
+        job.stdout.on('data', (data)=>logger.debug(data.toString('utf-8').trimEnd()));
+        job.stderr.on('data', (data)=>logger.warn(data.toString('utf-8').trimEnd()));
+        (await this._scheduler).register(job);
+        return job;
     }
     /**
    * Runs git branch
-   *
-   * @param args
-   * @param options
-   */ branch(args, options) {
-        return this.command('branch', args, options);
+   */ branch(args, opts) {
+        return this.command('branch', args, opts);
     }
     /**
    * Runs git diff
-   *
-   * @param args
-   * @param options
-   */ diff(args, options) {
-        return this.command('diff', args, options);
+   */ diff(args, opts) {
+        return this.command('diff', args, opts);
     }
     /**
    * Runs git tag
-   *
-   * @param args
-   * @param options
-   */ tag(args, options) {
-        return this.command('tag', args, options);
+   */ tag(args, opts) {
+        return this.command('tag', args, opts);
     }
     /**
    * Uses git diff to detect if given files have been affected since given reference
-   *
-   * @param reference
-   * @param files
-   * @param opts
    */ async isAffected(reference, files = [], opts) {
-        const task = await this.diff([
+        const job = await this.diff([
             '--quiet',
             reference,
             '--',
             ...files
         ], opts);
-        return new Promise((resolve, reject)=>{
-            once$(task.events$, 'status.done', ()=>resolve(false));
-            once$(task.events$, 'status.failed', ()=>{
-                if (task.exitCode) {
-                    resolve(true);
-                } else {
-                    reject(new Error(`Task ${task.name} failed`));
-                }
-            });
-        });
+        await waitFor$(pipe$(job.state$, filter$(isWorkloadEnded)));
+        if (job.exitCode() === 0) {
+            return false;
+        }
+        if (job.exitCode() === 1) {
+            return true;
+        }
+        throw new ClientError(`Error "git diff" command failed (exit code ${job.exitCode()})`);
     }
     /**
    * List git branches
-   *
-   * @param args
-   * @param opts
    */ async listBranches(args = [], opts) {
-        const task = await this.branch([
+        const job = await this.branch([
             '-l',
             ...args
         ], opts);
-        return waitFor$(pipe$(streamLines$(task), map$((line)=>line.replace(/^[ *] /, '')), collect$()));
+        const output = await text(job.stdout);
+        return pipe$(output.split(/\r?\n/), map$((line)=>line.replace(/^[ *] /, '')), filter$((line)=>!!line), collect$());
     }
     /**
    * List git tags
-   *
-   * @param args
-   * @param opts
    */ async listTags(args = [], opts) {
-        const task = await this.tag([
+        const job = await this.tag([
             '-l',
             ...args
         ], opts);
-        return waitFor$(pipe$(streamLines$(task), collect$()));
+        const output = await text(job.stdout);
+        return output.split(/\r?\n/).filter((line)=>!!line);
     }
 }
 
@@ -500,58 +444,37 @@ async function with$(lock, fn) {
     }
 }
 
-// Class
-class CommandTask extends SpawnTask {
-    workspace;
-    // Constructor
-    constructor(workspace, command, args, opts = {}){
-        let cmd = command;
-        if (opts.superCommand) {
-            if (typeof opts.superCommand === 'string') {
-                opts.superCommand = [
-                    opts.superCommand
-                ];
-            }
-            if (opts.superCommand.length > 0) {
-                cmd = opts.superCommand[0];
-                args = [
-                    ...opts.superCommand.slice(1),
-                    command,
-                    ...args
-                ];
-            }
+function command$(workspace, cmd, args, opts = {}) {
+    const { superCommand, logger = inject$(LOGGER), ...rest } = opts;
+    // Apply super command
+    if (superCommand) {
+        if (typeof superCommand === 'string') {
+            args = [
+                cmd,
+                ...args
+            ];
+            cmd = superCommand;
+        } else if (superCommand.length) {
+            args = [
+                ...superCommand.slice(1),
+                cmd,
+                ...args
+            ];
+            cmd = superCommand[0];
+        }
+    }
+    // Prepare job
+    const job = spawn$(cmd, args, {
+        ...rest,
+        cwd: workspace.root,
+        env: {
+            FORCE_COLOR: '1',
+            ...rest.env
         }
-        super(cmd, args, {
-            workspace,
-            command
-        }, {
-            ...opts,
-            cwd: workspace.root,
-            env: {
-                FORCE_COLOR: '1',
-                ...opts.env
-            }
-        }), this.workspace = workspace;
-        this._logStreams();
-    }
-    // Methods
-    _logStreams() {
-        const off = off$(streamLines$(this, 'stdout').subscribe((line)=>this.logger$.info(line)), streamLines$(this, 'stderr').subscribe((line)=>this.logger$.info(line)));
-        once$(this.events$, 'completed', ()=>{
-            off.unsubscribe();
-        });
-    }
-}
-// Utils
-function isCommandCtx(ctx) {
-    return 'workspace' in ctx && 'command' in ctx;
-}
-
-class ClientError extends Error {
-    name = 'ClientError';
-    constructor(message){
-        super(message);
-    }
+    });
+    job.stdout.on('data', (data)=>logger.info(data.toString('utf-8').trimEnd()));
+    job.stderr.on('data', (data)=>logger.info(data.toString('utf-8').trimEnd()));
+    return job;
 }
 
 // Utils
@@ -585,173 +508,84 @@ function splitCommandLine(line) {
     return parts;
 }
 
-// Class
-class ScriptTask extends GroupTask {
-    workspace;
-    script;
-    args;
-    // Attributes
-    _preHookTasks = null;
-    _postHookTasks = null;
-    _scriptTasks = null;
-    _runHooks;
-    // Constructor
-    constructor(workspace, script, args, opts){
-        super(script, {
-            workspace,
-            script
-        }, opts), this.workspace = workspace, this.script = script, this.args = args;
-        this._runHooks = opts?.runHooks ?? true;
-    }
-    // Methods
-    async _runScript(script, args) {
-        const line = this.workspace.getScript(script);
-        if (!line) {
-            return null;
-        }
-        // Create command task for script
-        const [command, ...commandArgs] = splitCommandLine(line);
-        const set = new TaskSet();
-        if (!command) {
-            return set;
-        }
-        if (command === 'jill') {
-            const argv = commandArgs.map((arg)=>arg.replace(/^["'](.+)["']$/, '$1'));
-            const { PlannerService } = await import('./planner.service.js');
-            const plannerService = inject$(PlannerService);
-            const tasks = await plannerService.plan(argv, this.workspace.root);
-            if (tasks) {
-                return tasks;
-            }
-        }
-        const pm = await this.workspace.project.packageManager();
-        set.add(new CommandTask(this.workspace, command, [
-            ...commandArgs,
-            ...args
-        ], {
-            logger: this.logger$,
-            superCommand: pm === 'yarn' ? [
-                'yarn',
-                'exec'
-            ] : undefined
-        }));
-        return set;
-    }
-    async prepare() {
-        // Prepare script run
-        this._scriptTasks = await this._runScript(this.script, this.args);
-        if (!this._scriptTasks) {
-            throw new ScriptNotFound(`No script ${this.script} in ${this.workspace.name}`);
-        }
-        // Prepare hooks run
-        if (this._runHooks) {
-            this._preHookTasks = await this._runScript(`pre${this.script}`, []);
-            this._postHookTasks = await this._runScript(`post${this.script}`, []);
-        }
-        // Add tasks to group
-        if (this._preHookTasks) {
-            this.logger$.verbose(`found pre-hook script "pre${this.script}"`);
-            for (const tsk of this._preHookTasks){
-                this.add(tsk);
-            }
-        }
-        for (const tsk of this._scriptTasks){
-            this.add(tsk);
-        }
-        if (this._postHookTasks) {
-            this.logger$.verbose(`found post-hook script "post${this.script}"`);
-            for (const tsk of this._postHookTasks){
-                this.add(tsk);
-            }
-        }
-    }
-    async *onOrchestrate() {
-        if (!this._scriptTasks) {
-            throw new Error('ScriptTask needs to be prepared. Call prepare before starting it');
-        }
-        // Run pre-hook
-        if (this._preHookTasks) {
-            yield* this._preHookTasks;
-            if (await this._hasFailed(this._preHookTasks)) {
-                return this.setStatus('failed');
-            }
-        }
-        // Run script
-        yield* this._scriptTasks;
-        if (await this._hasFailed(this._scriptTasks)) {
-            return this.setStatus('failed');
-        }
-        // Run post-hook
-        if (this._postHookTasks) {
-            yield* this._postHookTasks;
-            if (await this._hasFailed(this._postHookTasks)) {
-                return this.setStatus('failed');
-            }
-        }
-        this.setStatus('done');
-    }
-    async _hasFailed(set) {
-        const results = await waitFor$(set.events$, 'finished');
-        return results.failed > 0;
-    }
-    async onStop() {
-        if (!this._scriptTasks) return;
-        for (const tsk of this._scriptTasks){
-            await tsk.stop();
-        }
-    }
-    complexity(cache = new Map()) {
-        let complexity = super.complexity(cache);
-        if (this._scriptTasks) {
-            complexity += this._scriptTasks.tasks.reduce((cpl, tsk)=>cpl + tsk.complexity(cache), 0);
-        }
-        cache.set(this.id, complexity);
-        return complexity;
-    }
-    // Properties
-    get project() {
-        return this.workspace.project;
-    }
+async function runScript$(workspace, script, args, opts = {}) {
+    // Run script itself
+    const jobs = [
+        await planScript$(workspace, script, args, opts)
+    ];
+    if (!jobs[0]) {
+        throw new ScriptNotFound(`No script ${script} in ${workspace.name}`);
+    }
+    // Run hooks
+    if (opts.runHooks) {
+        jobs.unshift(await planScript$(workspace, `pre${script}`, [], opts));
+        jobs.push(await planScript$(workspace, `post${script}`, [], opts));
+    }
+    // Prepare workflow
+    const flow = pipe$(jobs, filter$((job)=>job !== null), collect$(sequenceFlow$({
+        label: script,
+        type: 'script'
+    })));
+    return {
+        ...flow,
+        script,
+        workspace
+    };
 }
 // Utils
-function isScriptCtx(ctx) {
-    return 'workspace' in ctx && 'script' in ctx;
+async function planScript$(workspace, script, args, opts) {
+    // Load script
+    const line = workspace?.getScript(script);
+    if (!line) {
+        return null;
+    }
+    // Parse script
+    const [command, ...commandArgs] = splitCommandLine(line);
+    if (!command) {
+        return null;
+    }
+    if (command === 'jill') {
+        const argv = commandArgs.map((arg)=>arg.replace(/^["'](.+)["']$/, '$1'));
+        const { PlannerService } = await import('./planner.service.js');
+        const plannerService = inject$(PlannerService);
+        const job = await plannerService.plan(argv, workspace.root);
+        if (job) {
+            return job;
+        }
+    }
+    // Run command
+    const pm = await workspace.project.packageManager();
+    return command$(workspace, command, [
+        ...commandArgs,
+        ...args
+    ], {
+        logger: opts.logger,
+        superCommand: pm === 'yarn' ? [
+            'yarn',
+            'exec'
+        ] : undefined
+    });
 }
 class ScriptNotFound extends ClientError {
     name = 'ScriptNotFound';
 }
 
-var _dec$3, _dec1$2, _initProto$3;
-_dec$3 = instrument({
-    name: 'Workspace.dependencies',
-    use: traceAsyncGenerator
-}), _dec1$2 = instrument({
-    name: 'Workspace.devDependencies',
-    use: traceAsyncGenerator
-});
+// Utils
+async function* combine(...generators) {
+    for (const gen of generators){
+        yield* gen;
+    }
+}
+
 class Workspace {
     manifest;
     project;
-    static{
-        ({ e: [_initProto$3] } = _(this, [
-            [
-                _dec$3,
-                2,
-                "dependencies"
-            ],
-            [
-                _dec1$2,
-                2,
-                "devDependencies"
-            ]
-        ], []));
-    }
     // Attributes
-    _affectedCache = (_initProto$3(this), new Map());
+    _affectedCache = new Map();
     _logger;
     _git = inject$(GitService);
     _root;
-    _tasks = new Map();
+    _jobs = new Map();
     // Constructor
     constructor(root, manifest, project){
         this.manifest = manifest;
@@ -760,7 +594,7 @@ class Workspace {
         this._logger = inject$(LOGGER).child(withLabel(manifest.name));
     }
     // Methods
-    async _buildDependencies(task, opts) {
+    async _buildDependencies(job, opts) {
         const generators = [];
         switch(opts.buildDeps ?? 'all'){
             case 'all':
@@ -773,7 +607,7 @@ class Workspace {
         for await (const dep of combine(...generators)){
             const build = await dep.build(opts);
             if (build) {
-                task.dependsOn(build);
+                job.dependsOn(build);
             }
         }
     }
@@ -838,15 +672,15 @@ class Workspace {
     }
     async build(opts = {}) {
         const script = opts.buildScript ?? 'build';
-        const task = await this.run(script, [], opts);
-        if (!task) {
+        const job = await this.run(script, [], opts);
+        if (!job) {
             this._logger.warning(`will not be built (no "${script}" script found)`);
         }
-        return task;
+        return job;
     }
     async exec(command, args = [], opts = {}) {
         const pm = await this.project.packageManager();
-        const task = new CommandTask(this, command, args, {
+        const job = command$(this, command, args, {
             ...opts,
             logger: this._logger.child(withLabel(`${this.name}$${command}`)),
             superCommand: pm === 'yarn' ? [
@@ -854,8 +688,8 @@ class Workspace {
                 'exec'
             ] : undefined
         });
-        await this._buildDependencies(task, opts);
-        return task;
+        await this._buildDependencies(job, opts);
+        return job;
     }
     getScript(script) {
         const { scripts = {} } = this.manifest;
@@ -867,19 +701,18 @@ class Workspace {
             return null;
         }
         // Create task if it doesn't exist yet
-        let task = this._tasks.get(script);
-        if (!task) {
+        let job = this._jobs.get(script);
+        if (!job) {
             const config = await inject$(CONFIG, asyncScope$());
-            task = new ScriptTask(this, script, args, {
+            job = await runScript$(this, script, args, {
                 ...opts,
                 logger: this._logger.child(withLabel(`${this.name}#${script}`)),
                 runHooks: config.hooks
             });
-            await task.prepare();
-            await this._buildDependencies(task, opts);
-            this._tasks.set(script, task);
+            await this._buildDependencies(job, opts);
+            this._jobs.set(script, job);
         }
-        return task;
+        return job;
     }
     toJSON() {
         return {
@@ -903,43 +736,9 @@ class Workspace {
     }
 }
 
-var _dec$2, _dec1$1, _dec2, _dec3, _dec4, _initProto$2;
-_dec$2 = instrument('Project.currentWorkspace'), _dec1$1 = instrument('Project.mainWorkspace'), _dec2 = instrument('Project.packageManager'), _dec3 = instrument('Project.workspace'), _dec4 = instrument({
-    name: 'Project.workspaces',
-    use: traceAsyncGenerator
-});
 class Project {
-    static{
-        ({ e: [_initProto$2] } = _(this, [
-            [
-                _dec$2,
-                2,
-                "currentWorkspace"
-            ],
-            [
-                _dec1$1,
-                2,
-                "mainWorkspace"
-            ],
-            [
-                _dec2,
-                2,
-                "packageManager"
-            ],
-            [
-                _dec3,
-                2,
-                "workspace"
-            ],
-            [
-                _dec4,
-                2,
-                "workspaces"
-            ]
-        ], []));
-    }
     // Attributes
-    _isFullyLoaded = (_initProto$2(this), false);
+    _isFullyLoaded = false;
     _lock = mutex$();
     _mainWorkspace;
     _packageManager;
@@ -1192,7 +991,7 @@ class TaskSyntaxError extends ClientError {
 }
 
 var _dec, _dec1, _initProto;
-_dec = instrument('TaskParserService.parse'), _dec1 = instrument('TaskParserService.buildTask');
+_dec = instrument('TaskParserService.parse'), _dec1 = instrument('TaskParserService.buildJob');
 // Service
 class TaskParserService {
     static{
@@ -1205,7 +1004,7 @@ class TaskParserService {
             [
                 _dec1,
                 2,
-                "buildTask"
+                "buildJob"
             ]
         ], []));
     }
@@ -1392,42 +1191,36 @@ class TaskParserService {
             }
         }
     }
-    async buildTask(node, workspace, opts) {
+    async buildJob(node, workspace, opts) {
         if (TaskParserService.isTaskNode(node)) {
-            const task = await workspace.run(node.script, node.args, opts);
-            if (!task) {
+            const job = await workspace.run(node.script, node.args, opts);
+            if (!job) {
                 throw new TaskExpressionError(`Workspace ${workspace.name} have no ${node.script} script`);
             }
-            return task;
+            return job;
         } else {
-            let group;
+            let flow;
             if (node.operator === '//') {
-                group = new ParallelGroup('In parallel', {
-                    workspace
-                }, {
-                    logger: this._logger
+                flow = parallelFlow$({
+                    label: 'In parallel'
                 });
             } else if (node.operator === '||') {
-                group = new FallbackGroup('Fallbacks', {
-                    workspace
-                }, {
-                    logger: this._logger
+                flow = fallbackFlow$({
+                    label: 'Fallbacks'
                 });
             } else {
                 if (node.operator === '->' && TaskParserService._sequenceOperatorWarn) {
                     this._logger.warn('Sequence operator -> is deprecated in favor of &&. It will be removed in a next major release.');
                     TaskParserService._sequenceOperatorWarn = true;
                 }
-                group = new SequenceGroup('In sequence', {
-                    workspace
-                }, {
-                    logger: this._logger
+                flow = sequenceFlow$({
+                    label: 'In sequence'
                 });
             }
             for (const child of node.tasks){
-                group.add(await this.buildTask(child, workspace, opts));
+                flow.push(await this.buildJob(child, workspace, opts));
             }
-            return group;
+            return flow;
         }
     }
 }
@@ -1517,16 +1310,22 @@ const command$4 = {
         const scripts = Array.from(taskParser.extractScripts(tree));
         // Load workspaces
         const project = loadProject(args);
-        const workspaces = pipe$(asyncIterator$(project.workspaces()), hasEveryScript$(scripts), filters.build());
+        const workspaces = await waitFor$(pipe$(asyncIterator$(project.workspaces()), hasEveryScript$(scripts), filters.build(), collect$()));
+        workspaces.sort((a, b)=>a.name.localeCompare(b.name));
+        if (workspaces.length === 0) {
+            return;
+        }
         // Prepare tasks
-        const tasks = new TaskSet();
-        for await (const wks of workspaces){
-            tasks.add(await taskParser.buildTask(tree.roots[0], wks, {
+        const flow = parallelFlow$({
+            label: '[hidden]'
+        });
+        for (const wks of workspaces){
+            flow.push(await taskParser.buildJob(tree.roots[0], wks, {
                 buildScript: args.buildScript,
                 buildDeps: args.depsMode
             }));
         }
-        return tasks;
+        return flow;
     }
 };
 
@@ -1602,51 +1401,68 @@ const command$3 = {
             rest.splice(0, 1);
         }
         // Run script in workspace
-        const tasks = new TaskSet();
-        tasks.add(await workspace.exec(args.command, rest, {
+        return await workspace.exec(args.command, rest, {
             buildScript: args.buildScript,
             buildDeps: args.depsMode
-        }));
-        return tasks;
+        });
     },
-    async execute (args, tasks) {
-        const task = tasks.tasks[0];
-        if (task.dependencies.length > 0) {
-            const dependencies = new TaskSet();
-            for (const dep of task.dependencies){
-                dependencies.add(dep);
-            }
+    async execute (args, arg) {
+        const job = arg;
+        if (job.dependencies().length > 0) {
+            const dependencies = pipe$(job.dependencies(), collect$(parallelFlow$({
+                label: 'build dependencies'
+            })));
             // Run dependencies first with spinners
-            const { default: TaskExecInk } = await traceImport('TaskExecInk', ()=>import('./task-exec.ink.js'));
-            await TaskExecInk({
-                tasks: dependencies,
+            const { default: JobExecInk } = await traceImport('JobExecInk', ()=>import('./job-exec.ink.js'));
+            await JobExecInk({
+                job: dependencies,
                 verbose: [
                     'verbose',
                     'debug'
                 ].includes(args.verbose)
             });
+            if (dependencies.state() !== WorkloadState.Succeeded) {
+                return;
+            }
         } else {
             const logger = inject$(LOGGER);
             logger.verbose('No dependency to build');
         }
-        const child = cp.spawn(task.cmd, task.args, {
-            stdio: 'inherit',
-            cwd: task.cwd,
-            env: {
-                ...process$1.env,
-                ...task.env
-            },
-            shell: true,
-            windowsHide: true
-        });
-        process$1.exitCode = await new Promise((resolve)=>{
-            child.on('close', (code)=>{
-                resolve(code ?? 0);
+        await startSpan({
+            op: 'subprocess',
+            name: [
+                job.cmd,
+                ...job.args
+            ].join(' ')
+        }, async ()=>{
+            const child = spawn(job.cmd, job.args, {
+                stdio: 'inherit',
+                cwd: job.cwd,
+                env: {
+                    ...process$1.env,
+                    ...job.env
+                },
+                shell: true,
+                windowsHide: true
+            });
+            process$1.exitCode = await new Promise((resolve)=>{
+                child.on('close', (code)=>{
+                    resolve(code ?? 0);
+                });
             });
         });
     }
 };
 
+// Utils
+function printJson(data, stream = process.stdout) {
+    if (stream.isTTY) {
+        stream.write(JSON.stringify(data, null, 2));
+    } else {
+        stream.write(JSON.stringify(data));
+    }
+}
+
 // Command
 const command$2 = {
     command: 'list',
@@ -1882,12 +1698,10 @@ const command$1 = {
         // Parse task expression
         const taskParser = inject$(TaskParserService);
         const tree = taskParser.parse(expr.join(' '));
-        const tasks = new TaskSet();
-        tasks.add(await taskParser.buildTask(tree.roots[0], workspace, {
+        return await taskParser.buildJob(tree.roots[0], workspace, {
             buildScript: args.buildScript,
             buildDeps: args.depsMode
-        }));
-        return tasks;
+        });
     }
 };
 
@@ -2097,8 +1911,8 @@ function baseParser() {
 }
 /**
  * Prepare parser planning commands
- */ function planParser(tasks$) {
-    return pipe$(baseParser(), planCommand(command$4, tasks$), planCommand(command$3, tasks$), planCommand(command$2, tasks$), planCommand(command$1, tasks$), planCommand(command, tasks$));
+ */ function planParser(job$) {
+    return pipe$(baseParser(), planCommand(command$4, job$), planCommand(command$3, job$), planCommand(command$2, job$), planCommand(command$1, job$), planCommand(command, job$));
 }
 
 // Bootstrap
@@ -2107,25 +1921,37 @@ const parser = executeParser();
 void startSpan({
     name: 'jill',
     op: 'cli.main',
+    startTime: 0,
     attributes: {
         'cli.argv': argv
     }
-}, ()=>parser.wrap(parser.terminalWidth()).fail((msg, err)=>{
-        const logger = inject$(LOGGER);
-        if (msg) {
-            logger.error(msg);
-        } else if (err instanceof ClientError) {
-            logger.warning(err.message);
-        } else {
-            captureException(err, {
-                tags: {
-                    handled: false
-                }
-            });
-            logger.error(err.message);
-        }
-        process$1.exitCode = 1;
-    }).parseAsync(argv).catch(()=>{}));
+}, async ()=>{
+    try {
+        startInactiveSpan({
+            name: 'bootstrap',
+            op: 'cli.bootstrap',
+            startTime: 0
+        }).end();
+        return await parser.wrap(parser.terminalWidth()).fail((msg, err)=>{
+            const logger = inject$(LOGGER);
+            if (msg) {
+                logger.error(msg);
+            } else if (err instanceof ClientError) {
+                logger.error(err.message);
+            } else {
+                captureException(err, {
+                    tags: {
+                        handled: false
+                    }
+                });
+                logger.error(err.message);
+            }
+            process$1.exitCode = 1;
+        }).parseAsync(argv);
+    } catch  {
+    // Already handled
+    }
+});
 
-export { CommandTask as C, LOGGER as L, ScriptTask as S, TASK_MANAGER as T, isScriptCtx as a, CWD as b, capitalize as c, ConfigService as d, instrument as e, isCommandCtx as i, logFormat as l, planParser as p };
+export { CWD as C, LOGGER as L, SCHEDULER as S, ConfigService as a, capitalize as c, instrument as i, logFormat as l, planParser as p };
 //# sourceMappingURL=main.js.map