presetter 8.2.0 → 8.3.0

package/README.md

@@ -299,6 +299,46 @@ Presetter uses a sophisticated **two-pass resolution system** that makes configu
 - **Deep Merging**: Sophisticated algorithms handle complex inheritance
 - **Script Composition**: Local scripts merge with preset scripts intelligently
 
+### 🔧 Binary Path Resolution
+
+When running tasks via `run`, `run-s`, or `run-p`, Presetter automatically prepends binary paths from preset packages to the PATH environment variable. This makes tools in each preset's `node_modules/.bin` directory available without additional configuration.
+
+**How it works:**
+
+- Direct preset binaries are checked first
+- Extended preset binaries are checked next
+- Finally, the existing PATH is checked
+
+**Benefits:**
+
+- No need to install shared dev tools at the repository root
+- No need for pnpm's `shamefullyHoist: true` or `public-hoist-pattern` for every tool
+- Preset dependencies are automatically available to templated scripts
+
+**Limitation - Dynamic Imports:**
+
+Libraries loaded via dynamic `import()` may fail because dynamic imports are resolved from the project root, not the preset. This affects libraries that are loaded at runtime rather than through direct imports.
+
+**Notable example:** `@vitest/coverage-v8` - required by vitest when using v8 as the coverage engine.
+
+**Workarounds:**
+
+1. **Install directly:** Add the library to your project's `package.json` (or monorepo root):
+
+   ```bash
+   npm install -D @vitest/coverage-v8
+   ```
+
+2. **Use pnpm hoisting:** Add the library to pnpm's `public-hoist-pattern` in `pnpm-workspace.yaml`:
+
+   ```yaml
+   packages:
+     - 'packages/*'
+   settings:
+     public-hoist-pattern:
+       - '@vitest/coverage-v8'
+   ```
+
 ---
 
 ## 🛠️ Advanced Usage
@@ -443,6 +483,10 @@ Absolutely! Presets are just npm packages that export configuration templates. S
 
 Yes! Presetter supports monorepo setups and can bootstrap multiple projects with glob patterns. Use [presetter-preset-monorepo](https://github.com/alvis/presetter/blob/master/packages/preset-monorepo) for monorepo-specific configurations.
 
+### Why do some dynamically imported libraries fail to resolve?
+
+While Presetter makes preset tools available via PATH, libraries loaded through dynamic `import()` (like `@vitest/coverage-v8`) resolve from your project root, not the preset. Install such libraries directly at your project root or add them to pnpm's `public-hoist-pattern` in `pnpm-workspace.yaml`.
+
 ---
 
 ## 🤝 Contributing

package/lib/parsing.d.ts

@@ -0,0 +1,92 @@
+/** represents a parsed call expression from command text */
+export interface ParsedCallExpr {
+    /** the command name (e.g., "run") */
+    command: string;
+    /** positional arguments before "--" */
+    args: string[];
+    /** extra arguments after "--" */
+    extraArgs: string[];
+}
+/** represents a run command match with its position */
+export interface RunMatch {
+    /** the matched text */
+    match: string;
+    /** start offset in source */
+    start: number;
+    /** end offset in source */
+    end: number;
+}
+/** parsed command structure */
+export type ParsedCommand = ParsedSimpleCommand | ParsedBinaryCmd | ParsedSubshell | ParsedBlock;
+/** simple command (e.g., `run build`, `echo test`) */
+export interface ParsedSimpleCommand {
+    type: 'CallExpr';
+    /** command name (first word) */
+    command: string;
+    /** arguments after command name */
+    args: string[];
+    /** extra arguments after "--" */
+    extraArgs: string[];
+    /** start offset in original source */
+    start: number;
+    /** end offset in original source */
+    end: number;
+}
+/** binary operator type */
+type BinaryOperator = '&&' | '||' | '|';
+/** binary command (e.g., `cmd1 && cmd2`) */
+export interface ParsedBinaryCmd {
+    type: 'BinaryCmd';
+    /** operator: && || | */
+    op: BinaryOperator;
+    /** left side command */
+    left: ParsedCommand;
+    /** right side command */
+    right: ParsedCommand;
+    /** start offset in original source */
+    start: number;
+    /** end offset in original source */
+    end: number;
+}
+/** subshell (e.g., `(cmd1 && cmd2)`) */
+export interface ParsedSubshell {
+    type: 'Subshell';
+    /** inner command */
+    body: ParsedCommand;
+    /** start offset in original source */
+    start: number;
+    /** end offset in original source */
+    end: number;
+}
+/** block (e.g., `{ cmd1; cmd2; }`) */
+export interface ParsedBlock {
+    type: 'Block';
+    /** inner command */
+    body: ParsedCommand;
+    /** start offset in original source */
+    start: number;
+    /** end offset in original source */
+    end: number;
+}
+/**
+ * parses command text into ParsedCallExpr structure (pure)
+ * @param cmdText the command text to parse
+ * @returns the parsed call expression
+ */
+export declare const parseCommandText: (cmdText: string) => Readonly<ParsedCallExpr>;
+/**
+ * parses command text into structured form
+ * @param text command text to parse
+ * @param baseOffset offset in original source
+ * @returns parsed command structure
+ */
+export declare const parseCommandStructure: (text: string, baseOffset: number) => ParsedCommand;
+/**
+ * finds all run commands in parsed structure
+ * @param cmd parsed command to search
+ * @param source original source string
+ * @returns array of run command matches
+ */
+export declare const findRunInParsed: (cmd: ParsedCommand, source: string) => RunMatch[];
+export {};
+//# sourceMappingURL=parsing.d.ts.map

package/lib/parsing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parsing.d.ts","sourceRoot":"","sources":["../src/parsing.ts"],"names":[],"mappings":"AAEA,4DAA4D;AAC5D,MAAM,WAAW,cAAc;IAC7B,qCAAqC;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,uCAAuC;IACvC,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,iCAAiC;IACjC,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAED,uDAAuD;AACvD,MAAM,WAAW,QAAQ;IACvB,uBAAuB;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,6BAA6B;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,2BAA2B;IAC3B,GAAG,EAAE,MAAM,CAAC;CACb;AAED,+BAA+B;AAC/B,MAAM,MAAM,aAAa,GACrB,mBAAmB,GACnB,eAAe,GACf,cAAc,GACd,WAAW,CAAC;AAEhB,sDAAsD;AACtD,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,UAAU,CAAC;IACjB,gCAAgC;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,mCAAmC;IACnC,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,iCAAiC;IACjC,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,sCAAsC;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,oCAAoC;IACpC,GAAG,EAAE,MAAM,CAAC;CACb;AAED,2BAA2B;AAC3B,KAAK,cAAc,GAAG,IAAI,GAAG,IAAI,GAAG,GAAG,CAAC;AAExC,4CAA4C;AAC5C,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,WAAW,CAAC;IAClB,wBAAwB;IACxB,EAAE,EAAE,cAAc,CAAC;IACnB,wBAAwB;IACxB,IAAI,EAAE,aAAa,CAAC;IACpB,yBAAyB;IACzB,KAAK,EAAE,aAAa,CAAC;IACrB,sCAAsC;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,oCAAoC;IACpC,GAAG,EAAE,MAAM,CAAC;CACb;AAED,wCAAwC;AACxC,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,UAAU,CAAC;IACjB,oBAAoB;IACpB,IAAI,EAAE,aAAa,CAAC;IACpB,sCAAsC;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,oCAAoC;IACpC,GAAG,EAAE,MAAM,CAAC;CACb;AAED,sCAAsC;AACtC,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,OAAO,CAAC;IACd,oBAAoB;IACpB,IAAI,EAAE,aAAa,CAAC;IACpB,sCAAsC;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,oCAAoC;IACpC,GAAG,EAAE,MAAM,CAAC;CACb;AA2ID;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAAI,SAAS,MAAM,KAAG,QAAQ,CAAC,cAAc,CAWzE,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,GAChC,MAAM,MAAM,EACZ,YAAY,MAAM,KACjB,aA4DF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,eAAe,GAC1B,KAAK,aAAa,EAClB,QAAQ,MAAM,KACb,QAAQ,EAkCV,CAAC"}

package/lib/parsing.js

@@ -0,0 +1,207 @@
+import parseArgs from 'yargs-parser';
+/**
+ * updates depth counters based on character
+ * @param char the character
+ * @param parenDepth current parenthesis depth
+ * @param braceDepth current brace depth
+ * @returns updated depths
+ */
+const updateDepths = (char, parenDepth, braceDepth) => {
+    let newParenDepth = parenDepth;
+    let newBraceDepth = braceDepth;
+    if (char === '(') {
+        newParenDepth++;
+    }
+    else if (char === ')') {
+        newParenDepth--;
+    }
+    else if (char === '{') {
+        newBraceDepth++;
+    }
+    else if (char === '}') {
+        newBraceDepth--;
+    }
+    return [newParenDepth, newBraceDepth];
+};
+/**
+ * checks if a character ends a quote
+ * @param char the character
+ * @param inSingleQuote whether in single quote
+ * @param inDoubleQuote whether in double quote
+ * @returns updated quote states
+ */
+const updateQuotes = (char, inSingleQuote, inDoubleQuote) => {
+    let newSingleQuote = inSingleQuote;
+    let newDoubleQuote = inDoubleQuote;
+    if (char === "'" && !inDoubleQuote) {
+        newSingleQuote = !inSingleQuote;
+    }
+    else if (char === '"' && !inSingleQuote) {
+        newDoubleQuote = !inDoubleQuote;
+    }
+    return [newSingleQuote, newDoubleQuote];
+};
+/**
+ * checks for binary operators at current position
+ * @param char current character
+ * @param nextChar next character
+ * @param parenDepth parenthesis depth
+ * @param braceDepth brace depth
+ * @returns operator match or null
+ */
+const checkBinaryOp = (char, nextChar, parenDepth, braceDepth) => {
+    if (parenDepth !== 0 || braceDepth !== 0) {
+        return null;
+    }
+    if (char === '&' && nextChar === '&') {
+        return { op: '&&' };
+    }
+    if (char === '|' && nextChar === '|') {
+        return { op: '||' };
+    }
+    if (char === '|' && nextChar !== '|') {
+        return { op: '|' };
+    }
+    return null;
+};
+/**
+ * finds the first top-level binary operator in command text
+ * @param text command text to search
+ * @returns operator match or null if none found
+ */
+const findTopLevelOperator = (text) => {
+    let parenDepth = 0;
+    let braceDepth = 0;
+    let inSingleQuote = false;
+    let inDoubleQuote = false;
+    let escaped = false;
+    for (let i = 0; i < text.length; i++) {
+        const char = text[i];
+        const nextChar = text[i + 1];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (char === '\\' && !inSingleQuote) {
+            escaped = true;
+            continue;
+        }
+        [inSingleQuote, inDoubleQuote] = updateQuotes(char, inSingleQuote, inDoubleQuote);
+        if (inSingleQuote || inDoubleQuote) {
+            continue;
+        }
+        [parenDepth, braceDepth] = updateDepths(char, parenDepth, braceDepth);
+        const opMatch = checkBinaryOp(char, nextChar, parenDepth, braceDepth);
+        if (opMatch) {
+            return { ...opMatch, index: i };
+        }
+    }
+    return null;
+};
+/**
+ * parses command text into ParsedCallExpr structure (pure)
+ * @param cmdText the command text to parse
+ * @returns the parsed call expression
+ */
+export const parseCommandText = (cmdText) => {
+    const arg = parseArgs(cmdText, {
+        configuration: { 'populate--': true, 'unknown-options-as-args': true },
+    });
+    const parts = arg._;
+    const command = parts[0] ?? '';
+    const args = parts.slice(1);
+    const extraArgs = (arg['--'] ?? []);
+    return { command, args, extraArgs };
+};
+/**
+ * parses command text into structured form
+ * @param text command text to parse
+ * @param baseOffset offset in original source
+ * @returns parsed command structure
+ */
+export const parseCommandStructure = (text, baseOffset) => {
+    const trimmed = text.trim();
+    const trimOffset = text.indexOf(trimmed);
+    const start = baseOffset + trimOffset;
+    const end = start + trimmed.length;
+    // check for Subshell: (...)
+    if (trimmed.startsWith('(') && trimmed.endsWith(')')) {
+        const inner = trimmed.slice(1, -1);
+        return {
+            type: 'Subshell',
+            body: parseCommandStructure(inner, start + 1),
+            start,
+            end,
+        };
+    }
+    // check for Block: { ... }
+    if (trimmed.startsWith('{') && trimmed.endsWith('}')) {
+        const inner = trimmed.slice(1, -1);
+        return {
+            type: 'Block',
+            body: parseCommandStructure(inner, start + 1),
+            start,
+            end,
+        };
+    }
+    // check for BinaryCmd: cmd1 && cmd2
+    const opMatch = findTopLevelOperator(trimmed);
+    if (opMatch) {
+        const leftText = trimmed.slice(0, opMatch.index);
+        const rightText = trimmed.slice(opMatch.index + opMatch.op.length);
+        return {
+            type: 'BinaryCmd',
+            op: opMatch.op,
+            left: parseCommandStructure(leftText, start),
+            right: parseCommandStructure(rightText, start + opMatch.index + opMatch.op.length),
+            start,
+            end,
+        };
+    }
+    // otherwise it's a CallExpr
+    const parsed = parseCommandText(trimmed);
+    return {
+        type: 'CallExpr',
+        command: parsed.command,
+        args: parsed.args,
+        extraArgs: parsed.extraArgs,
+        start,
+        end,
+    };
+};
+/**
+ * finds all run commands in parsed structure
+ * @param cmd parsed command to search
+ * @param source original source string
+ * @returns array of run command matches
+ */
+export const findRunInParsed = (cmd, source) => {
+    const matches = [];
+    const visit = (node) => {
+        switch (node.type) {
+            case 'CallExpr':
+                // check if command is 'run' with at least one task
+                if (node.command === 'run' && node.args.length > 0) {
+                    matches.push({
+                        match: source.slice(node.start, node.end),
+                        start: node.start,
+                        end: node.end,
+                    });
+                }
+                break;
+            case 'BinaryCmd':
+                visit(node.left);
+                visit(node.right);
+                break;
+            case 'Subshell':
+            case 'Block':
+                visit(node.body);
+                break;
+            default:
+                break;
+        }
+    };
+    visit(cmd);
+    return matches;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/lib/preset/resolution/index.d.ts

@@ -1,6 +1,7 @@
 export * from './asset.js';
 export * from './object.js';
 export * from './preset.js';
+export * from './roots.js';
 export * from './script.js';
 export * from './variable.js';
 //# sourceMappingURL=index.d.ts.map

package/lib/preset/resolution/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/preset/resolution/index.ts"],"names":[],"mappings":"AAEA,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/preset/resolution/index.ts"],"names":[],"mappings":"AAEA,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC"}

package/lib/preset/resolution/index.js

@@ -2,6 +2,7 @@
 export * from './asset.js';
 export * from './object.js';
 export * from './preset.js';
+export * from './roots.js';
 export * from './script.js';
 export * from './variable.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcHJlc2V0L3Jlc29sdXRpb24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEscUJBQXFCO0FBRXJCLGNBQWMsU0FBUyxDQUFDO0FBQ3hCLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsWUFBWSxDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcHJlc2V0L3Jlc29sdXRpb24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEscUJBQXFCO0FBRXJCLGNBQWMsU0FBUyxDQUFDO0FBQ3hCLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsU0FBUyxDQUFDO0FBQ3hCLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsWUFBWSxDQUFDIn0=

package/lib/preset/resolution/roots.d.ts

@@ -0,0 +1,15 @@
+import type { PresetNode } from 'presetter-types';
+/**
+ * recursively extracts all preset root paths from a preset node tree (pure function)
+ *
+ * Order: closest to consumer first, then child presets
+ * Example: consumer -> preset-esm -> preset-essentials
+ * Returns: [esm-root, essentials-root]
+ *
+ * This ensures the direct preset's binaries have highest PATH priority,
+ * allowing more specific presets to override base preset binaries.
+ * @param node the root preset node to traverse
+ * @returns array of unique preset root paths, closest to consumer first
+ */
+export declare const extractPresetRoots: (node: PresetNode) => readonly string[];
+//# sourceMappingURL=roots.d.ts.map

package/lib/preset/resolution/roots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roots.d.ts","sourceRoot":"","sources":["../../../src/preset/resolution/roots.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAElD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,kBAAkB,GAAI,MAAM,UAAU,KAAG,SAAS,MAAM,EAYpE,CAAC"}

package/lib/preset/resolution/roots.js

@@ -0,0 +1,24 @@
+/**
+ * recursively extracts all preset root paths from a preset node tree (pure function)
+ *
+ * Order: closest to consumer first, then child presets
+ * Example: consumer -> preset-esm -> preset-essentials
+ * Returns: [esm-root, essentials-root]
+ *
+ * This ensures the direct preset's binaries have highest PATH priority,
+ * allowing more specific presets to override base preset binaries.
+ * @param node the root preset node to traverse
+ * @returns array of unique preset root paths, closest to consumer first
+ */
+export const extractPresetRoots = (node) => {
+    const collectRoots = (current) => {
+        // add THIS node's root first (closer to consumer, higher priority)
+        const thisRoot = current.definition.root ? [current.definition.root] : [];
+        // then collect extended preset roots (further from consumer, lower priority)
+        const childRoots = current.nodes.flatMap(collectRoots);
+        return [...thisRoot, ...childRoots];
+    };
+    // deduplicate while preserving priority order (first occurrence wins)
+    return [...new Set(collectRoots(node))];
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm9vdHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcHJlc2V0L3Jlc29sdXRpb24vcm9vdHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUE7Ozs7Ozs7Ozs7O0dBV0c7QUFDSCxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxDQUFDLElBQWdCLEVBQXFCLEVBQUU7SUFDeEUsTUFBTSxZQUFZLEdBQUcsQ0FBQyxPQUFtQixFQUFxQixFQUFFO1FBQzlELG1FQUFtRTtRQUNuRSxNQUFNLFFBQVEsR0FBRyxPQUFPLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUM7UUFDMUUsNkVBQTZFO1FBQzdFLE1BQU0sVUFBVSxHQUFHLE9BQU8sQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLFlBQVksQ0FBQyxDQUFDO1FBRXZELE9BQU8sQ0FBQyxHQUFHLFFBQVEsRUFBRSxHQUFHLFVBQVUsQ0FBQyxDQUFDO0lBQ3RDLENBQUMsQ0FBQztJQUVGLHNFQUFzRTtJQUN0RSxPQUFPLENBQUMsR0FBRyxJQUFJLEdBQUcsQ0FBQyxZQUFZLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDO0FBQzFDLENBQUMsQ0FBQyJ9

package/lib/preset/resolution/script.d.ts

@@ -5,5 +5,8 @@ import type { PresetNode, ProjectContext, Scripts } from 'presetter-types';
  * @param context the context in which the node is being resolved
  * @returns a promise that resolves to the RESOLVED scripts
  */
-export declare function resolveScripts(node: PresetNode, context: ProjectContext): Promise<Scripts>;
+export declare function resolveScripts(node: PresetNode, context: ProjectContext): Promise<{
+    paths: string[];
+    scripts: Scripts;
+}>;
 //# sourceMappingURL=script.d.ts.map

package/lib/preset/resolution/script.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"script.d.ts","sourceRoot":"","sources":["../../../src/preset/resolution/script.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAE3E;;;;;GAKG;AACH,wBAAsB,cAAc,CAClC,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,OAAO,CAAC,CAoClB"}
+{"version":3,"file":"script.d.ts","sourceRoot":"","sources":["../../../src/preset/resolution/script.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAE3E;;;;;GAKG;AACH,wBAAsB,cAAc,CAClC,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC;IAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC,CA4ChD"}

package/lib/preset/resolution/script.js

@@ -1,6 +1,8 @@
+import { resolve } from 'node:path';
 import { substitute } from '../../template/index.js';
 import { resolveNodeContent } from './content.js';
 import Debug from './debugger.js';
+import { extractPresetRoots } from './roots.js';
 import { resolveVariables } from './variable.js';
 /**
  * resolves all scripts for a given preset node
@@ -34,6 +36,9 @@ export async function resolveScripts(node, context) {
         select: ({ override }) => override?.scripts,
     })) ?? {};
     debug('RESOLVED SCRIPTS (FINAL PASS)\n%O', final);
-    return substitute(final, variables);
+    const presetRoots = extractPresetRoots(node);
+    const paths = presetRoots.map((path) => resolve(path, 'node_modules', '.bin'));
+    debug('RESOLVED PATHS\n%O', paths);
+    return { paths, scripts: substitute(final, variables) };
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NyaXB0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3ByZXNldC9yZXNvbHV0aW9uL3NjcmlwdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFFNUMsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sV0FBVyxDQUFDO0FBQy9DLE9BQU8sS0FBSyxNQUFNLFlBQVksQ0FBQztBQUMvQixPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFJOUM7Ozs7O0dBS0c7QUFDSCxNQUFNLENBQUMsS0FBSyxVQUFVLGNBQWMsQ0FDbEMsSUFBZ0IsRUFDaEIsT0FBdUI7SUFFdkIsTUFBTSxJQUFJLEdBQUcsU0FBUyxDQUFDO0lBQ3ZCLE1BQU0sS0FBSyxHQUFHLEtBQUssQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLENBQUM7SUFFakMsaUNBQWlDO0lBQ2pDLE1BQU0sU0FBUyxHQUFHLE1BQU0sZ0JBQWdCLENBQUMsSUFBSSxFQUFFLE9BQU8sQ0FBQyxDQUFDO0lBRXhELEtBQUssQ0FBQyxrQ0FBa0MsQ0FBQyxDQUFDO0lBRTFDLDJDQUEyQztJQUMzQyxNQUFNLE9BQU8sR0FBRyxNQUFNLGtCQUFrQixDQUFDO1FBQ3ZDLElBQUk7UUFDSixJQUFJO1FBQ0osT0FBTztRQUNQLFNBQVM7UUFDVCxNQUFNLEVBQUUsQ0FBQyxFQUFFLE9BQU8sRUFBRSxFQUFFLEVBQUUsQ0FBQyxPQUFPO0tBQ2pDLENBQUMsQ0FBQztJQUVILEtBQUssQ0FBQyxxQ0FBcUMsRUFBRSxPQUFPLENBQUMsQ0FBQztJQUV0RCxLQUFLLENBQUMsZ0NBQWdDLENBQUMsQ0FBQztJQUV4QyxnRUFBZ0U7SUFDaEUsTUFBTSxLQUFLLEdBQ1QsQ0FBQyxNQUFNLGtCQUFrQixDQUFDO1FBQ3hCLElBQUk7UUFDSixJQUFJO1FBQ0osT0FBTztRQUNQLE9BQU87UUFDUCxTQUFTO1FBQ1QsTUFBTSxFQUFFLENBQUMsRUFBRSxRQUFRLEVBQUUsRUFBRSxFQUFFLENBQUMsUUFBUSxFQUFFLE9BQU87S0FDNUMsQ0FBQyxDQUFDLElBQUksRUFBRSxDQUFDO0lBRVosS0FBSyxDQUFDLG1DQUFtQyxFQUFFLEtBQUssQ0FBQyxDQUFDO0lBRWxELE9BQU8sVUFBVSxDQUFDLEtBQUssRUFBRSxTQUFTLENBQUMsQ0FBQztBQUN0QyxDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NyaXB0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3ByZXNldC9yZXNvbHV0aW9uL3NjcmlwdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sV0FBVyxDQUFDO0FBRXBDLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUU1QyxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxXQUFXLENBQUM7QUFDL0MsT0FBTyxLQUFLLE1BQU0sWUFBWSxDQUFDO0FBQy9CLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUM3QyxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFJOUM7Ozs7O0dBS0c7QUFDSCxNQUFNLENBQUMsS0FBSyxVQUFVLGNBQWMsQ0FDbEMsSUFBZ0IsRUFDaEIsT0FBdUI7SUFFdkIsTUFBTSxJQUFJLEdBQUcsU0FBUyxDQUFDO0lBQ3ZCLE1BQU0sS0FBSyxHQUFHLEtBQUssQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLENBQUM7SUFFakMsaUNBQWlDO0lBQ2pDLE1BQU0sU0FBUyxHQUFHLE1BQU0sZ0JBQWdCLENBQUMsSUFBSSxFQUFFLE9BQU8sQ0FBQyxDQUFDO0lBRXhELEtBQUssQ0FBQyxrQ0FBa0MsQ0FBQyxDQUFDO0lBRTFDLDJDQUEyQztJQUMzQyxNQUFNLE9BQU8sR0FBRyxNQUFNLGtCQUFrQixDQUFDO1FBQ3ZDLElBQUk7UUFDSixJQUFJO1FBQ0osT0FBTztRQUNQLFNBQVM7UUFDVCxNQUFNLEVBQUUsQ0FBQyxFQUFFLE9BQU8sRUFBRSxFQUFFLEVBQUUsQ0FBQyxPQUFPO0tBQ2pDLENBQUMsQ0FBQztJQUVILEtBQUssQ0FBQyxxQ0FBcUMsRUFBRSxPQUFPLENBQUMsQ0FBQztJQUV0RCxLQUFLLENBQUMsZ0NBQWdDLENBQUMsQ0FBQztJQUV4QyxnRUFBZ0U7SUFDaEUsTUFBTSxLQUFLLEdBQ1QsQ0FBQyxNQUFNLGtCQUFrQixDQUFDO1FBQ3hCLElBQUk7UUFDSixJQUFJO1FBQ0osT0FBTztRQUNQLE9BQU87UUFDUCxTQUFTO1FBQ1QsTUFBTSxFQUFFLENBQUMsRUFBRSxRQUFRLEVBQUUsRUFBRSxFQUFFLENBQUMsUUFBUSxFQUFFLE9BQU87S0FDNUMsQ0FBQyxDQUFDLElBQUksRUFBRSxDQUFDO0lBRVosS0FBSyxDQUFDLG1DQUFtQyxFQUFFLEtBQUssQ0FBQyxDQUFDO0lBRWxELE1BQU0sV0FBVyxHQUFHLGtCQUFrQixDQUFDLElBQUksQ0FBQyxDQUFDO0lBRTdDLE1BQU0sS0FBSyxHQUFHLFdBQVcsQ0FBQyxHQUFHLENBQUMsQ0FBQyxJQUFJLEVBQUUsRUFBRSxDQUNyQyxPQUFPLENBQUMsSUFBSSxFQUFFLGNBQWMsRUFBRSxNQUFNLENBQUMsQ0FDdEMsQ0FBQztJQUVGLEtBQUssQ0FBQyxvQkFBb0IsRUFBRSxLQUFLLENBQUMsQ0FBQztJQUVuQyxPQUFPLEVBQUUsS0FBSyxFQUFFLE9BQU8sRUFBRSxVQUFVLENBQUMsS0FBSyxFQUFFLFNBQVMsQ0FBQyxFQUFFLENBQUM7QUFDMUQsQ0FBQyJ9

package/lib/preset/scripts.d.ts

@@ -1,6 +1,10 @@
+import type { Script } from '#scripts';
 /**
- * get the merged scripts templates
+ * get the merged scripts templates (pure function)
  * @returns scripts template
  */
-export declare function getScripts(): Promise<Record<string, string>>;
+export declare const getScripts: () => Promise<{
+    paths: string[];
+    scripts: Script;
+}>;
 //# sourceMappingURL=scripts.d.ts.map

package/lib/preset/scripts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scripts.d.ts","sourceRoot":"","sources":["../../src/preset/scripts.ts"],"names":[],"mappings":"AAKA;;;GAGG;AACH,wBAAsB,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAOlE"}
+{"version":3,"file":"scripts.d.ts","sourceRoot":"","sources":["../../src/preset/scripts.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEvC;;;GAGG;AACH,eAAO,MAAM,UAAU,QAAa,OAAO,CAAC;IAC1C,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,CAKA,CAAC"}

package/lib/preset/scripts.js

@@ -2,13 +2,12 @@ import { resolveProjectContext } from '#context';
 import { resolveProjectPreset } from './project.js';
 import { resolveScripts } from './resolution/index.js';
 /**
- * get the merged scripts templates
+ * get the merged scripts templates (pure function)
  * @returns scripts template
  */
-export async function getScripts() {
+export const getScripts = async () => {
     const context = await resolveProjectContext();
     const node = await resolveProjectPreset(context);
-    const script = await resolveScripts(node, context);
-    return script;
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NyaXB0cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wcmVzZXQvc2NyaXB0cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxVQUFVLENBQUM7QUFFakQsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sV0FBVyxDQUFDO0FBQ2pELE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFFOUM7OztHQUdHO0FBQ0gsTUFBTSxDQUFDLEtBQUssVUFBVSxVQUFVO0lBQzlCLE1BQU0sT0FBTyxHQUFHLE1BQU0scUJBQXFCLEVBQUUsQ0FBQztJQUM5QyxNQUFNLElBQUksR0FBRyxNQUFNLG9CQUFvQixDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBRWpELE1BQU0sTUFBTSxHQUFHLE1BQU0sY0FBYyxDQUFDLElBQUksRUFBRSxPQUFPLENBQUMsQ0FBQztJQUVuRCxPQUFPLE1BQU0sQ0FBQztBQUNoQixDQUFDIn0=
+    return resolveScripts(node, context);
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NyaXB0cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wcmVzZXQvc2NyaXB0cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxVQUFVLENBQUM7QUFFakQsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sV0FBVyxDQUFDO0FBQ2pELE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFJOUM7OztHQUdHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHLEtBQUssSUFHNUIsRUFBRTtJQUNILE1BQU0sT0FBTyxHQUFHLE1BQU0scUJBQXFCLEVBQUUsQ0FBQztJQUM5QyxNQUFNLElBQUksR0FBRyxNQUFNLG9CQUFvQixDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBRWpELE9BQU8sY0FBYyxDQUFDLElBQUksRUFBRSxPQUFPLENBQUMsQ0FBQztBQUN2QyxDQUFDLENBQUMifQ==

package/lib/run.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../src/run.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AA4JnC;;;;;;GAMG;AACH,wBAAsB,GAAG,CACvB,KAAK,EAAE,IAAI,EAAE,EACb,OAAO,CAAC,EAAE;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,YAAY,CAAC,EAAE,OAAO,CAAA;CAAE,GACvD,OAAO,CAAC,IAAI,CAAC,CAmCf"}
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../src/run.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AA+KnC;;;;;;GAMG;AACH,wBAAsB,GAAG,CACvB,KAAK,EAAE,IAAI,EAAE,EACb,OAAO,CAAC,EAAE;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,YAAY,CAAC,EAAE,OAAO,CAAA;CAAE,GACvD,OAAO,CAAC,IAAI,CAAC,CA6Cf"}

package/lib/run.js

@@ -1,3 +1,4 @@
+import { delimiter } from 'node:path';
 import npmRunScript from '@npmcli/run-script';
 import { Listr } from 'listr2';
 import parse from 'yargs-parser';
@@ -9,19 +10,20 @@ import { parseGlobalArgs, parseTaskSpec, selectTasks } from './task.js';
 /**
  * create an array of Listr tasks based on the provided inputs
  * @param _ collection of arguments
- * @param _.composed composed script object containing script definitions
+ * @param _.scripts composed script object containing script definitions
  * @param _.template template object containing script definitions
  * @param _.context project context
+ * @param _.paths additional binary paths from preset roots
  * @param _.task task name
  * @param _.args array of arguments
  * @returns array of Listr tasks
  */
 function createListrTask(_) {
-    const { composed, template, task, args, context } = _;
+    const { scripts, template, task, args, context, paths } = _;
     return {
         title: `Running ${task}...`,
         task: async (_, taskControl) => {
-            const command = composed[task];
+            const command = scripts[task];
             // parse the command and extract the executable and task specifications
             const argv = parse(command, {
                 configuration: { 'populate--': true, 'unknown-options-as-args': true },
@@ -31,19 +33,20 @@ function createListrTask(_) {
             if (['run-s', 'run-p'].includes(executable)) {
                 const globalArgs = [...parseGlobalArgs(argv), ...args];
                 // get subtasks based on the task specifications and global arguments
-                const subTasks = taskSpecs.flatMap((taskSpec) => getListrTasksBySpec({ template, context, taskSpec, globalArgs }));
+                const subTasks = (await Promise.all(taskSpecs.map(async (taskSpec) => getListrTasksBySpec({
+                    template,
+                    context,
+                    paths,
+                    taskSpec,
+                    globalArgs,
+                })))).flat();
                 const concurrent = executable === 'run-p';
                 return taskControl.newListr(subTasks, { concurrent });
             }
             else {
-                taskControl.output = `${composed[task]} ${args.join(' ')}`;
+                taskControl.output = `${scripts[task]} ${args.join(' ')}`;
                 // run the npm script with the provided arguments and package information
-                return runWithNPM({
-                    task,
-                    args,
-                    context,
-                    composedScript: composed,
-                });
+                return runWithNPM({ task, args, context, paths, scripts });
             }
         },
     };
@@ -53,18 +56,20 @@ function createListrTask(_) {
  * @param _ collection of arguments
  * @param _.template template object containing script definitions
  * @param _.context package context
+ * @param _.paths additional binary paths from preset roots
  * @param _.taskSpec task specification string
  * @param _.globalArgs array of global arguments
- * @returns array of Listr tasks
+ * @returns a promise resolving to an array of Listr tasks
  */
-function getListrTasksBySpec(_) {
-    const { template, context, taskSpec, globalArgs } = _;
+async function getListrTasksBySpec(_) {
+    const { template, context, paths, taskSpec, globalArgs } = _;
     // parse the task specification and remove any quotes
     const task = parseTaskSpec(taskSpec.toString().replace(/^(['"])([^]*?)\1$/, '$2'), globalArgs);
     // get Listr tasks based on the provided inputs
     return getListrTasks({
         template,
         context,
+        paths,
         selector: task.selector,
         args: task.args,
     });
@@ -74,20 +79,21 @@ function getListrTasksBySpec(_) {
  * @param _ collection of arguments
  * @param _.template template object containing script definitions
  * @param _.context project context
+ * @param _.paths additional binary paths from preset roots
  * @param _.selector task selector string
  * @param _.args array of arguments
- * @returns array of Listr tasks
+ * @returns a promise resolving to an array of Listr tasks
  */
-function getListrTasks(_) {
-    const { template, context, selector, args } = _;
+async function getListrTasks(_) {
+    const { paths, template, context, selector, args } = _;
     // clone the content for immutability
     const target = { ...context.packageJson.scripts };
     // compose the script using the provided template and target
-    const composed = composeScripts({ template, target });
+    const scripts = await composeScripts({ template, target });
     // select tasks based on the composed script and selector
-    const tasks = selectTasks(Object.keys(composed), selector);
+    const tasks = selectTasks(Object.keys(scripts), selector);
     // create Listr tasks based on the selected tasks
-    return tasks.map((task) => createListrTask({ composed, template, context, task, args }));
+    return tasks.map((task) => createListrTask({ paths, scripts, template, context, task, args }));
 }
 /**
  * run a task defined in the combined script definitions using npm-run-script
@@ -95,16 +101,21 @@ function getListrTasks(_) {
  * @param _.task task name
  * @param _.args array of arguments
  * @param _.context project context
- * @param _.composedScript combined script definitions
+ * @param _.paths additional binary paths from preset roots
+ * @param _.scripts combined script definitions
  * @returns a promise that will be resolved when the task is completed
  */
 async function runWithNPM(_) {
-    const { task, args, context: { projectRoot }, composedScript, } = _;
-    debug('RUNNING\n%O', { task, command: composedScript[task] });
+    const { task, args, context: { projectRoot }, scripts, } = _;
+    const paths = [..._.paths, ...process.env.PATH.split(delimiter)];
+    debug('RUNNING\n%O', { task, command: scripts[task], paths });
     await npmRunScript({
         event: task,
         args,
-        pkg: { scripts: composedScript },
+        env: {
+            PATH: paths.join(delimiter),
+        },
+        pkg: { scripts },
         path: projectRoot,
         stdio: 'inherit',
     });
@@ -128,9 +139,15 @@ export async function run(tasks, options) {
         }
         : context;
     // get the merged script definitions
-    const template = await getScripts();
+    const { paths, scripts: template } = await getScripts();
     // get Listr tasks based on the provided tasks and package information
-    const listTasks = tasks.flatMap((task) => getListrTasks({ template, context: distilled, ...task }));
+    const listTasks = (await Promise.all(tasks.map(async (taskItem) => getListrTasks({
+        paths,
+        template,
+        context: distilled,
+        selector: taskItem.selector,
+        args: taskItem.args,
+    })))).flat();
     // create a Listr instance with the list of tasks and configuration options
     const listr = new Listr(listTasks, {
         concurrent: parallel,
@@ -145,4 +162,4 @@ export async function run(tasks, options) {
         process.exit(1);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/scripts.d.ts

@@ -1,21 +1,19 @@
 /** pseudo type for representing the name of a script */
 type ScriptName = string;
-/** pseudo type for representing the command */
-type Command = string;
 /** collection of scripts */
-export type Script = Record<ScriptName, Command>;
+export type Script = Record<ScriptName, string>;
 /**
  * merge the script definitions from the template and the target package.json
  * @param args template and customized scripts to be merged
  * @param args.template scripts defined from the template
  * @param args.target scripts defined from target's package.json
- * @returns a dictionary of merged definitions
+ * @returns a promise resolving to a dictionary of merged definitions
  */
 export declare function composeScripts(args: {
     /** scripts defined from the template */
     template: Script;
     /** scripts defined from target's package.json */
     target: Script;
-}): Script;
+}): Promise<Script>;
 export {};
 //# sourceMappingURL=scripts.d.ts.map

package/lib/scripts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scripts.d.ts","sourceRoot":"","sources":["../src/scripts.ts"],"names":[],"mappings":"AAUA,wDAAwD;AACxD,KAAK,UAAU,GAAG,MAAM,CAAC;AAEzB,+CAA+C;AAC/C,KAAK,OAAO,GAAG,MAAM,CAAC;AAEtB,4BAA4B;AAC5B,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;AAkBjD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE;IACnC,wCAAwC;IACxC,QAAQ,EAAE,MAAM,CAAC;IACjB,iDAAiD;IACjD,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,MAAM,CA4BT"}
+{"version":3,"file":"scripts.d.ts","sourceRoot":"","sources":["../src/scripts.ts"],"names":[],"mappings":"AAcA,wDAAwD;AACxD,KAAK,UAAU,GAAG,MAAM,CAAC;AAEzB,4BAA4B;AAC5B,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;AAwBhD;;;;;;GAMG;AACH,wBAAsB,cAAc,CAAC,IAAI,EAAE;IACzC,wCAAwC;IACxC,QAAQ,EAAE,MAAM,CAAC;IACjB,iDAAiD;IACjD,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,OAAO,CAAC,MAAM,CAAC,CAuClB"}

package/lib/scripts.js

@@ -1,96 +1,123 @@
-import { basename } from 'node:path';
-import mvdan from 'mvdan-sh';
-import parse from 'yargs-parser';
+import { parse, print } from 'sh-syntax';
 import debug from './debugger.js';
-import { mapValues } from './utilities/index.js';
-const { syntax } = mvdan;
-// shell command parser
-const parser = syntax.NewParser();
-// shell command generator
-const printer = syntax.NewPrinter();
+import { findRunInParsed, parseCommandStructure, parseCommandText, } from './parsing.js';
+import { mapValuesAsync } from './utilities/index.js';
+const MAX_DEPTH = 10;
 /**
  * merge the script definitions from the template and the target package.json
  * @param args template and customized scripts to be merged
  * @param args.template scripts defined from the template
  * @param args.target scripts defined from target's package.json
- * @returns a dictionary of merged definitions
+ * @returns a promise resolving to a dictionary of merged definitions
  */
-export function composeScripts(args) {
+export async function composeScripts(args) {
     const { template, target } = args;
     debug('SCRIPT PROVIDED BY PROJECT\n%O', target);
-    const script = mapValues({ ...template, ...target }, (command) => {
+    const script = await mapValuesAsync({ ...template, ...target }, async (command) => {
         try {
-            // parse the shell command into its ast
-            const ast = parser.Parse(command);
-            // walk through the tree and replace any call to the runner e.g. preset task1 task2 -- --help
-            syntax.Walk(ast, (node) => replaceRunnerNode(node, { template, target }));
-            // generate the code from ast
-            return printer.Print(ast).trim();
+            // first validate the shell command syntax
+            await parse(command);
+            // resolve any 'run' commands in the script
+            const context = { template, target };
+            const resolvedCommand = await resolveAllRunCommands(command, context);
+            // parse and print to normalize formatting
+            const ast = await parse(resolvedCommand);
+            const printed = await print(ast, { originalText: resolvedCommand });
+            return printed.trim();
         }
         catch (error) {
-            if (error instanceof Error) {
+            // check if it's a resolution error (our own error)
+            if (error instanceof Error &&
+                error.message.includes('cannot be resolved')) {
                 throw error;
             }
-            else {
-                // parser.Parse may throw an empty object as an error, catch here
-                throw new Error(`failed to parse command: ${command}`);
-            }
+            // otherwise it's a parse error
+            throw new Error(`failed to parse command: ${command}`);
         }
     });
     debug('SCRIPT RESOLVED FROM PRESET AND PROJECT\n%O', script);
     return script;
 }
-function isNodeType(node, type) {
-    return syntax.NodeType(node) === type;
-}
 /**
- * resolve a runner command
- * @param command the command to be replaced
+ * resolves a runner command into its expanded form (pure)
+ * @param parsedExpr the parsed call expression
+ * @param originalCommand the original full command (for error messages)
  * @param context resource context
- * @returns the resolved command
+ * @returns the resolved command string
  */
-function resolveRunner(command, context) {
-    const arg = parse(command, {
-        configuration: { 'populate--': true, 'unknown-options-as-args': true },
-    });
-    // extract tasks and their arguments
-    const destinations = arg._.slice(1);
-    const destinationArgs = arg['--'] ?? [];
+const resolveRunner = (parsedExpr, originalCommand, context) => {
+    const { args, extraArgs } = parsedExpr;
+    const destinations = args.filter((arg) => !arg.startsWith('--'));
     // resolve tasks into its full form e.g. task1 task2
     return destinations
         .map((destination) => {
         const expandedCommand = context.template[destination] ||
-            (context.target[destination] === command
+            (context.target[destination] === originalCommand
                 ? undefined
                 : context.target[destination]);
         if (expandedCommand === undefined) {
-            throw new Error(`"${destination}" cannot be resolved in "${command}"`);
+            throw new Error(`"${destination}" cannot be resolved in "${originalCommand}"`);
         }
-        return [expandedCommand, ...destinationArgs].join(' ');
+        return [expandedCommand, ...extraArgs].join(' ');
     })
         .join(' && ');
-}
+};
 /**
- * replace a runner node with the actual command
- * @param node an expression node
+ * finds all replacements needed for run commands
+ * @param command the original source command string
  * @param context resource context
- * @returns boolean true for no error
+ * @param ast the parsed AST from sh-syntax
+ * @returns array of replacements to apply
  */
-function replaceRunnerNode(node, context) {
-    // replace only it's a runner call, not anything else
-    if (isNodeType(node, 'Stmt') && isNodeType(node.Cmd, 'CallExpr')) {
-        // parse assigned arguments e.g. task1 args --help
-        const parts = node.Cmd.Args.map((part) => part.Lit());
-        // only resolve if the `run` cli shipped in this package is invoke
-        if (parts.length && basename(parts[0]) === 'run') {
-            // resolve tasks into its full form e.g. task1 task2
-            const resolvedCommand = resolveRunner(parts.join(' '), context);
-            // replace the task definition with its expanded statement
-            node.Cmd = parser.Parse(resolvedCommand).Stmts[0].Cmd;
-            // recursively replace any runner call in the expanded statement
-            replaceRunnerNode(node.Cmd, context);
+const findReplacements = (command, context, ast) => {
+    const matches = [];
+    // iterate over statements from sh-syntax
+    for (const stmt of ast.Stmt) {
+        if (stmt.Cmd) {
+            // extract command text using sh-syntax positions
+            const cmdText = command.slice(stmt.Cmd.Pos.Offset, stmt.Cmd.End.Offset);
+            // parse structure ourselves
+            const parsed = parseCommandStructure(cmdText, stmt.Cmd.Pos.Offset);
+            // find run commands
+            matches.push(...findRunInParsed(parsed, command));
         }
     }
-    return true;
-}
-//# sourceMappingURL=data:application/json;base64,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
+    return matches.map((runMatch) => {
+        const parsedExpr = parseCommandText(runMatch.match);
+        const resolved = resolveRunner(parsedExpr, command, context);
+        return {
+            start: runMatch.start,
+            end: runMatch.end,
+            text: resolved,
+        };
+    });
+};
+/**
+ * apply replacements to source (pure, processes right-to-left)
+ * @param source the original source string
+ * @param replacements the replacements to apply
+ * @returns the source with all replacements applied
+ */
+const applyReplacements = (source, replacements) => [...replacements]
+    .sort((a, b) => b.start - a.start) // right to left to preserve positions
+    .reduce((text, { start, end, text: replacement }) => text.slice(0, start) + replacement + text.slice(end), source);
+/**
+ * recursively resolve all run commands (immutable recursion)
+ * @param command the command to process
+ * @param context resource context
+ * @param depth current recursion depth (for cycle detection)
+ * @returns the resolved command with all run patterns replaced
+ */
+const resolveAllRunCommands = async (command, context, depth = 0) => {
+    if (depth > MAX_DEPTH) {
+        throw new Error('Maximum recursion depth exceeded');
+    }
+    const ast = await parse(command);
+    const replacements = findReplacements(command, context, ast);
+    if (replacements.length === 0) {
+        return command;
+    }
+    const resolved = applyReplacements(command, replacements);
+    return resolveAllRunCommands(resolved, context, depth + 1);
+};
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utilities/mapping.d.ts

@@ -5,4 +5,11 @@
  * @returns the mapped object
  */
 export declare function mapValues<T, U>(obj: Record<string, T>, fn: (value: T) => U): Record<string, U>;
+/**
+ * map the values of an object asynchronously to a new object with the same keys
+ * @param obj the object to be mapped
+ * @param fn the async mapping function
+ * @returns a promise resolving to the mapped object
+ */
+export declare function mapValuesAsync<T, U>(obj: Record<string, T>, fn: (value: T) => Promise<U>): Promise<Record<string, U>>;
 //# sourceMappingURL=mapping.d.ts.map

package/lib/utilities/mapping.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mapping.d.ts","sourceRoot":"","sources":["../../src/utilities/mapping.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAC5B,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,EACtB,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAClB,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAInB"}
+{"version":3,"file":"mapping.d.ts","sourceRoot":"","sources":["../../src/utilities/mapping.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAC5B,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,EACtB,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAClB,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAInB;AAED;;;;;GAKG;AACH,wBAAsB,cAAc,CAAC,CAAC,EAAE,CAAC,EACvC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,EACtB,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GAC3B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAM5B"}

package/lib/utilities/mapping.js

@@ -7,4 +7,14 @@
 export function mapValues(obj, fn) {
     return Object.fromEntries(Object.entries(obj).map(([key, value]) => [key, fn(value)]));
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFwcGluZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlsaXRpZXMvbWFwcGluZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7R0FLRztBQUNILE1BQU0sVUFBVSxTQUFTLENBQ3ZCLEdBQXNCLEVBQ3RCLEVBQW1CO0lBRW5CLE9BQU8sTUFBTSxDQUFDLFdBQVcsQ0FDdkIsTUFBTSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEdBQUcsRUFBRSxLQUFLLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxHQUFHLEVBQUUsRUFBRSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FDNUQsQ0FBQztBQUNKLENBQUMifQ==
+/**
+ * map the values of an object asynchronously to a new object with the same keys
+ * @param obj the object to be mapped
+ * @param fn the async mapping function
+ * @returns a promise resolving to the mapped object
+ */
+export async function mapValuesAsync(obj, fn) {
+    const entries = await Promise.all(Object.entries(obj).map(async ([key, value]) => [key, await fn(value)]));
+    return Object.fromEntries(entries);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFwcGluZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlsaXRpZXMvbWFwcGluZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7R0FLRztBQUNILE1BQU0sVUFBVSxTQUFTLENBQ3ZCLEdBQXNCLEVBQ3RCLEVBQW1CO0lBRW5CLE9BQU8sTUFBTSxDQUFDLFdBQVcsQ0FDdkIsTUFBTSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEdBQUcsRUFBRSxLQUFLLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxHQUFHLEVBQUUsRUFBRSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FDNUQsQ0FBQztBQUNKLENBQUM7QUFFRDs7Ozs7R0FLRztBQUNILE1BQU0sQ0FBQyxLQUFLLFVBQVUsY0FBYyxDQUNsQyxHQUFzQixFQUN0QixFQUE0QjtJQUU1QixNQUFNLE9BQU8sR0FBRyxNQUFNLE9BQU8sQ0FBQyxHQUFHLENBQy9CLE1BQU0sQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLENBQUMsR0FBRyxDQUFDLEtBQUssRUFBRSxDQUFDLEdBQUcsRUFBRSxLQUFLLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxHQUFHLEVBQUUsTUFBTSxFQUFFLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUN4RSxDQUFDO0lBRUYsT0FBTyxNQUFNLENBQUMsV0FBVyxDQUFDLE9BQU8sQ0FBQyxDQUFDO0FBQ3JDLENBQUMifQ==

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "presetter",
-  "version": "8.2.0",
+  "version": "8.3.0",
   "description": "Make project configurations clean with presets",
   "keywords": [
     "config",
@@ -69,16 +69,16 @@
     "debug": "^4.3.5",
     "execa": "^9.3.0",
     "find-up-simple": "^1.0.0",
-    "globby": "^15.0.0",
+    "globby": "^16.0.0",
     "jiti": "^2.4.0",
     "js-yaml": "^4.1.0",
     "listr2": "^9.0.0",
-    "mvdan-sh": "^0.10.0",
     "pupa": "^3.1.0",
+    "sh-syntax": "^0.5.0",
     "source-map-support": "^0.5.0",
     "yargs": "^18.0.0",
     "yargs-parser": "^22.0.0",
-    "presetter-types": "8.2.0"
+    "presetter-types": "8.3.0"
   },
   "devDependencies": {
     "@types/debug": "^4.0.0",
@@ -86,9 +86,9 @@
     "@types/node": "^24.0.0",
     "@types/yargs": "^17.0.0",
     "type-fest": "^5.0.0",
-    "presetter-preset-esm": "8.2.0",
-    "presetter-preset-essentials": "8.2.0",
-    "presetter-preset-strict": "8.2.0"
+    "presetter-preset-esm": "8.3.0",
+    "presetter-preset-strict": "8.3.0",
+    "presetter-preset-essentials": "8.3.0"
   },
   "engines": {
     "node": ">=20.0.0"
@@ -101,6 +101,7 @@
     "script": "tsx --conditions=development --eval \"process.argv = [...process.argv.slice(0, 2), 'run', ...process.argv.slice(2)]; import('./src/executable/index.ts');\" -- run --template",
     "stage": "npm run script -- stage --",
     "test": "npm run script -- test --",
+    "typecheck": "npm run script -- typecheck --",
     "watch": "npm run script -- watch --"
   }
 }

package/types/npmcli__run-script/index.d.ts

@@ -8,6 +8,7 @@ declare module '@npmcli/run-script' {
     event: string;
     args: string[];
     pkg: PackageJson;
+    env?: Record<string, string>;
     path?: string;
     stdio?: T;
     stdioString?: S;

package/types/mvdan-sh/index.d.ts

@@ -1,44 +0,0 @@
-declare module 'mvdan-sh' {
-  export type Node = CallExpr | File | Subshell | Stmt;
-
-  export interface File {
-    Stmts: Stmt[];
-  }
-
-  export interface Stmt {
-    Cmd: Node;
-  }
-
-  export interface Subshell {
-    Stmts: Stmt[];
-  }
-
-  export interface CallExpr {
-    Args: Word[];
-  }
-
-  interface Word {
-    Parts: WordPart[];
-    Lit(): string;
-  }
-
-  interface WordPart {
-    Value: string;
-  }
-
-  declare class Parser {
-    Parse(name: string): File;
-  }
-
-  declare class Printer {
-    Print(node: Node): string;
-  }
-
-  export namespace syntax {
-    declare function DebugPrint(node: Node): void;
-    declare function NewParser(): Parser;
-    declare function NewPrinter(): Printer;
-    declare function Walk(node: Node, callback: (node: Node) => boolean): void;
-    declare function NodeType(node: Node): string;
-  }
-}