@jackwener/opencli 1.1.0 → 1.2.0

package/src/pipeline/executor.test.ts

@@ -4,6 +4,7 @@
 
 import { describe, it, expect, vi } from 'vitest';
 import { executePipeline } from './index.js';
+import { ConfigError } from '../errors.js';
 import type { IPage } from '../types.js';
 
 /** Create a minimal mock page for testing */
@@ -16,6 +17,7 @@ function createMockPage(overrides: Partial<IPage> = {}): IPage {
     click: vi.fn(),
     typeText: vi.fn(),
     pressKey: vi.fn(),
+    getFormState: vi.fn().mockResolvedValue({}),
     wait: vi.fn(),
     tabs: vi.fn().mockResolvedValue([]),
     closeTab: vi.fn(),
@@ -24,6 +26,7 @@ function createMockPage(overrides: Partial<IPage> = {}): IPage {
     networkRequests: vi.fn().mockResolvedValue([]),
     consoleMessages: vi.fn().mockResolvedValue(''),
     scroll: vi.fn(),
+    scrollTo: vi.fn(),
     autoScroll: vi.fn(),
     installInterceptor: vi.fn(),
     getInterceptedRequests: vi.fn().mockResolvedValue([]),
@@ -79,6 +82,32 @@ describe('executePipeline', () => {
     ]);
   });
 
+  it('runs inline select inside map step', async () => {
+    const page = createMockPage({
+      evaluate: vi.fn().mockResolvedValue({
+        posts: [
+          { title: 'First', rank: 1 },
+          { title: 'Second', rank: 2 },
+        ],
+      }),
+    });
+    const result = await executePipeline(page, [
+      { evaluate: 'test' },
+      {
+        map: {
+          select: 'posts',
+          title: '${{ item.title }}',
+          rank: '${{ item.rank }}',
+        },
+      },
+    ]);
+
+    expect(result).toEqual([
+      { title: 'First', rank: 1 },
+      { title: 'Second', rank: 2 },
+    ]);
+  });
+
   it('executes limit step', async () => {
     const page = createMockPage({
       evaluate: vi.fn().mockResolvedValue([1, 2, 3, 4, 5]),
@@ -120,13 +149,13 @@ describe('executePipeline', () => {
     expect(page.wait).toHaveBeenCalledWith(2);
   });
 
-  it('handles unknown steps gracefully in debug mode', async () => {
-    const stderr = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
-    await executePipeline(null, [
+  it('fails fast on unknown steps', async () => {
+    await expect(executePipeline(null, [
+      { unknownStep: 'test' },
+    ], { debug: true })).rejects.toBeInstanceOf(ConfigError);
+    await expect(executePipeline(null, [
       { unknownStep: 'test' },
-    ], { debug: true });
-    expect(stderr).toHaveBeenCalledWith(expect.stringContaining('Unknown step'));
-    stderr.mockRestore();
+    ], { debug: true })).rejects.toThrow('Unknown pipeline step "unknownStep"');
   });
 
   it('passes args through template rendering', async () => {

package/src/pipeline/executor.ts

@@ -6,20 +6,21 @@ import chalk from 'chalk';
 import type { IPage } from '../types.js';
 import { getStep, type StepHandler } from './registry.js';
 import { log } from '../logger.js';
+import { ConfigError } from '../errors.js';
 
 export interface PipelineContext {
-  args?: Record<string, any>;
+  args?: Record<string, unknown>;
   debug?: boolean;
 }
 
 export async function executePipeline(
   page: IPage | null,
-  pipeline: any[],
+  pipeline: unknown[],
   ctx: PipelineContext = {},
-): Promise<any> {
+): Promise<unknown> {
   const args = ctx.args ?? {};
   const debug = ctx.debug ?? false;
-  let data: any = null;
+  let data: unknown = null;
   const total = pipeline.length;
 
   for (let i = 0; i < pipeline.length; i++) {
@@ -32,7 +33,10 @@ export async function executePipeline(
       if (handler) {
         data = await handler(page, params, data, args);
       } else {
-        if (debug) log.warn(`Unknown step: ${op}`);
+        throw new ConfigError(
+          `Unknown pipeline step "${op}" at index ${i}.`,
+          'Check the YAML pipeline step name or register the custom step before execution.',
+        );
       }
 
       if (debug) debugStepResult(op, data);
@@ -41,7 +45,7 @@ export async function executePipeline(
   return data;
 }
 
-function debugStepStart(stepNum: number, total: number, op: string, params: any): void {
+function debugStepStart(stepNum: number, total: number, op: string, params: unknown): void {
   let preview = '';
   if (typeof params === 'string') {
     preview = params.length <= 80 ? ` → ${params}` : ` → ${params.slice(0, 77)}...`;
@@ -51,7 +55,7 @@ function debugStepStart(stepNum: number, total: number, op: string, params: any)
   log.step(stepNum, total, op, preview);
 }
 
-function debugStepResult(op: string, data: any): void {
+function debugStepResult(op: string, data: unknown): void {
   if (data === null || data === undefined) {
     log.stepResult('(no data)');
   } else if (Array.isArray(data)) {

package/src/pipeline/registry.ts

@@ -18,11 +18,11 @@ import { stepDownload } from './steps/download.js';
  * TData is the type of the `data` state flowing into the step.
  * TResult is the expected return type.
  */
-export type StepHandler<TData = any, TResult = any> = (
+export type StepHandler<TData = unknown, TResult = unknown, TParams = unknown> = (
   page: IPage | null,
-  params: any,
+  params: TParams,
   data: TData,
-  args: Record<string, any>
+  args: Record<string, unknown>
 ) => Promise<TResult>;
 
 const _stepRegistry = new Map<string, StepHandler>();

package/src/pipeline/steps/browser.ts

@@ -6,19 +6,28 @@
 import type { IPage } from '../../types.js';
 import { render } from '../template.js';
 
-export async function stepNavigate(page: IPage | null, params: any, data: any, args: Record<string, any>): Promise<any> {
-  const url = render(params, { args, data });
-  await page!.goto(String(url));
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+export async function stepNavigate(page: IPage | null, params: unknown, data: unknown, args: Record<string, unknown>): Promise<unknown> {
+  if (isRecord(params) && 'url' in params) {
+    const url = String(render(params.url, { args, data }));
+    await page!.goto(url, { waitUntil: params.waitUntil as 'load' | 'none' | undefined, settleMs: typeof params.settleMs === 'number' ? params.settleMs : undefined });
+  } else {
+    const url = render(params, { args, data });
+    await page!.goto(String(url));
+  }
   return data;
 }
 
-export async function stepClick(page: IPage | null, params: any, data: any, args: Record<string, any>): Promise<any> {
+export async function stepClick(page: IPage | null, params: unknown, data: unknown, args: Record<string, unknown>): Promise<unknown> {
   await page!.click(String(render(params, { args, data })).replace(/^@/, ''));
   return data;
 }
 
-export async function stepType(page: IPage | null, params: any, data: any, args: Record<string, any>): Promise<any> {
-  if (typeof params === 'object' && params) {
+export async function stepType(page: IPage | null, params: unknown, data: unknown, args: Record<string, unknown>): Promise<unknown> {
+  if (isRecord(params)) {
     const ref = String(render(params.ref ?? '', { args, data })).replace(/^@/, '');
     const text = String(render(params.text ?? '', { args, data }));
     await page!.typeText(ref, text);
@@ -27,32 +36,37 @@ export async function stepType(page: IPage | null, params: any, data: any, args:
   return data;
 }
 
-export async function stepWait(page: IPage | null, params: any, data: any, args: Record<string, any>): Promise<any> {
+export async function stepWait(page: IPage | null, params: unknown, data: unknown, args: Record<string, unknown>): Promise<unknown> {
   if (typeof params === 'number') await page!.wait(params);
-  else if (typeof params === 'object' && params) {
+  else if (isRecord(params)) {
     if ('text' in params) {
       await page!.wait({
         text: String(render(params.text, { args, data })),
-        timeout: params.timeout
+        timeout: typeof params.timeout === 'number' ? params.timeout : undefined,
       });
     } else if ('time' in params) await page!.wait(Number(params.time));
   } else if (typeof params === 'string') await page!.wait(Number(render(params, { args, data })));
   return data;
 }
 
-export async function stepPress(page: IPage | null, params: any, data: any, args: Record<string, any>): Promise<any> {
+export async function stepPress(page: IPage | null, params: unknown, data: unknown, args: Record<string, unknown>): Promise<unknown> {
   await page!.pressKey(String(render(params, { args, data })));
   return data;
 }
 
-export async function stepSnapshot(page: IPage | null, params: any, _data: any, _args: Record<string, any>): Promise<any> {
-  const opts = (typeof params === 'object' && params) ? params : {};
-  return page!.snapshot({ interactive: opts.interactive ?? false, compact: opts.compact ?? false, maxDepth: opts.max_depth, raw: opts.raw ?? false });
+export async function stepSnapshot(page: IPage | null, params: unknown, _data: unknown, _args: Record<string, unknown>): Promise<unknown> {
+  const opts = isRecord(params) ? params : {};
+  return page!.snapshot({
+    interactive: typeof opts.interactive === 'boolean' ? opts.interactive : false,
+    compact: typeof opts.compact === 'boolean' ? opts.compact : false,
+    maxDepth: typeof opts.max_depth === 'number' ? opts.max_depth : undefined,
+    raw: typeof opts.raw === 'boolean' ? opts.raw : false,
+  });
 }
 
-export async function stepEvaluate(page: IPage | null, params: any, data: any, args: Record<string, any>): Promise<any> {
+export async function stepEvaluate(page: IPage | null, params: unknown, data: unknown, args: Record<string, unknown>): Promise<unknown> {
   const js = String(render(params, { args, data }));
-  let result = await page!.evaluate(js);
+  let result: unknown = await page!.evaluate(js);
   // MCP may return JSON as a string — auto-parse it
   if (typeof result === 'string') {
     const trimmed = result.trim();

package/src/pipeline/steps/fetch.ts

@@ -5,6 +5,10 @@
 import type { IPage } from '../../types.js';
 import { render } from '../template.js';
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
 /** Simple async concurrency limiter */
 async function mapConcurrent<T, R>(items: T[], limit: number, fn: (item: T, index: number) => Promise<R>): Promise<R[]> {
   const results: R[] = new Array(items.length);
@@ -25,9 +29,9 @@ async function mapConcurrent<T, R>(items: T[], limit: number, fn: (item: T, inde
 /** Single URL fetch helper */
 async function fetchSingle(
   page: IPage | null, url: string, method: string,
-  queryParams: Record<string, any>, headers: Record<string, any>,
-  args: Record<string, any>, data: any,
-): Promise<any> {
+  queryParams: Record<string, unknown>, headers: Record<string, unknown>,
+  args: Record<string, unknown>, data: unknown,
+): Promise<unknown> {
   const renderedParams: Record<string, string> = {};
   for (const [k, v] of Object.entries(queryParams)) renderedParams[k] = String(render(v, { args, data }));
   const renderedHeaders: Record<string, string> = {};
@@ -65,10 +69,10 @@ async function fetchSingle(
 async function fetchBatchInBrowser(
   page: IPage, urls: string[], method: string,
   headers: Record<string, string>, concurrency: number,
-): Promise<any[]> {
+): Promise<unknown[]> {
   const headersJs = JSON.stringify(headers);
   const urlsJs = JSON.stringify(urls);
-  return page.evaluate(`
+  return (await page.evaluate(`
     async () => {
       const urls = ${urlsJs};
       const method = "${method}";
@@ -94,19 +98,20 @@ async function fetchBatchInBrowser(
       await Promise.all(workers);
       return results;
     }
-  `);
+  `)) as unknown[];
 }
 
-export async function stepFetch(page: IPage | null, params: any, data: any, args: Record<string, any>): Promise<any> {
-  const urlOrObj = typeof params === 'string' ? params : (params?.url ?? '');
-  const method = params?.method ?? 'GET';
-  const queryParams: Record<string, any> = params?.params ?? {};
-  const headers: Record<string, any> = params?.headers ?? {};
+export async function stepFetch(page: IPage | null, params: unknown, data: unknown, args: Record<string, unknown>): Promise<unknown> {
+  const paramObject = isRecord(params) ? params : {};
+  const urlOrObj = typeof params === 'string' ? params : (paramObject.url ?? '');
+  const method = typeof paramObject.method === 'string' ? paramObject.method : 'GET';
+  const queryParams = isRecord(paramObject.params) ? paramObject.params : {};
+  const headers = isRecord(paramObject.headers) ? paramObject.headers : {};
   const urlTemplate = String(urlOrObj);
 
   // Per-item fetch when data is array and URL references item
   if (Array.isArray(data) && urlTemplate.includes('item')) {
-    const concurrency = typeof params?.concurrency === 'number' ? params.concurrency : 5;
+    const concurrency = typeof paramObject.concurrency === 'number' ? paramObject.concurrency : 5;
 
     // Render all URLs upfront
     const renderedHeaders: Record<string, string> = {};
@@ -114,7 +119,7 @@ export async function stepFetch(page: IPage | null, params: any, data: any, args
     const renderedParams: Record<string, string> = {};
     for (const [k, v] of Object.entries(queryParams)) renderedParams[k] = String(render(v, { args, data }));
 
-    const urls = data.map((item: any, index: number) => {
+    const urls = data.map((item, index) => {
       let url = String(render(urlTemplate, { args, data, item, index }));
       if (Object.keys(renderedParams).length > 0) {
         const qs = new URLSearchParams(renderedParams).toString();

package/src/pipeline/steps/transform.ts

@@ -2,14 +2,19 @@
  * Pipeline steps: data transforms — select, map, filter, sort, limit.
  */
 
+import type { IPage } from '../../types.js';
 import { render, evalExpr } from '../template.js';
 
-export async function stepSelect(_page: any, params: any, data: any, args: Record<string, any>): Promise<any> {
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+export async function stepSelect(_page: IPage | null, params: unknown, data: unknown, args: Record<string, unknown>): Promise<unknown> {
   const pathStr = String(render(params, { args, data }));
   if (data && typeof data === 'object') {
-    let current = data;
+    let current: unknown = data;
     for (const part of pathStr.split('.')) {
-      if (current && typeof current === 'object' && !Array.isArray(current)) current = (current as any)[part];
+      if (isRecord(current)) current = current[part];
       else if (Array.isArray(current) && /^\d+$/.test(part)) current = current[parseInt(part, 10)];
       else return null;
     }
@@ -18,33 +23,53 @@ export async function stepSelect(_page: any, params: any, data: any, args: Recor
   return data;
 }
 
-export async function stepMap(_page: any, params: any, data: any, args: Record<string, any>): Promise<any> {
+export async function stepMap(_page: IPage | null, params: unknown, data: unknown, args: Record<string, unknown>): Promise<unknown> {
   if (!data || typeof data !== 'object') return data;
-  let items: any[] = Array.isArray(data) ? data : [data];
-  if (!Array.isArray(data) && typeof data === 'object' && 'data' in data) items = data.data;
-  const result: any[] = [];
+  let source: unknown = data;
+
+  // Support inline select: { map: { select: 'path', key: '${{ item.x }}' } }
+  if (isRecord(params) && 'select' in params) {
+    source = await stepSelect(null, params.select, data, args);
+  }
+
+  if (!source || typeof source !== 'object') return source;
+
+  let items: unknown[] = Array.isArray(source) ? source : [source];
+  if (isRecord(source) && Array.isArray(source.data)) items = source.data;
+  const result: Array<Record<string, unknown>> = [];
+  const templateParams = isRecord(params) ? params : {};
   for (let i = 0; i < items.length; i++) {
     const item = items[i];
-    const row: Record<string, any> = {};
-    for (const [key, template] of Object.entries(params)) row[key] = render(template, { args, data, item, index: i });
+    const row: Record<string, unknown> = {};
+    for (const [key, template] of Object.entries(templateParams)) {
+      if (key === 'select') continue;
+      row[key] = render(template, { args, data: source, item, index: i });
+    }
     result.push(row);
   }
   return result;
 }
 
-export async function stepFilter(_page: any, params: any, data: any, args: Record<string, any>): Promise<any> {
+export async function stepFilter(_page: IPage | null, params: unknown, data: unknown, args: Record<string, unknown>): Promise<unknown> {
   if (!Array.isArray(data)) return data;
   return data.filter((item, i) => evalExpr(String(params), { args, item, index: i }));
 }
 
-export async function stepSort(_page: any, params: any, data: any, _args: Record<string, any>): Promise<any> {
+export async function stepSort(_page: IPage | null, params: unknown, data: unknown, _args: Record<string, unknown>): Promise<unknown> {
   if (!Array.isArray(data)) return data;
-  const key = typeof params === 'object' ? (params.by ?? '') : String(params);
-  const reverse = typeof params === 'object' ? params.order === 'desc' : false;
-  return [...data].sort((a, b) => { const va = a[key] ?? ''; const vb = b[key] ?? ''; const cmp = va < vb ? -1 : va > vb ? 1 : 0; return reverse ? -cmp : cmp; });
+  const key = isRecord(params) ? String(params.by ?? '') : String(params);
+  const reverse = isRecord(params) ? params.order === 'desc' : false;
+  return [...data].sort((a, b) => {
+    const left = isRecord(a) ? a[key] : undefined;
+    const right = isRecord(b) ? b[key] : undefined;
+    const va = left ?? '';
+    const vb = right ?? '';
+    const cmp = va < vb ? -1 : va > vb ? 1 : 0;
+    return reverse ? -cmp : cmp;
+  });
 }
 
-export async function stepLimit(_page: any, params: any, data: any, args: Record<string, any>): Promise<any> {
+export async function stepLimit(_page: IPage | null, params: unknown, data: unknown, args: Record<string, unknown>): Promise<unknown> {
   if (!Array.isArray(data)) return data;
   return data.slice(0, Number(render(params, { args, data })));
 }

package/src/pipeline/template.test.ts

@@ -57,6 +57,15 @@ describe('evalExpr', () => {
   it('resolves simple path', () => {
     expect(evalExpr('item.title', { item: { title: 'Test' } })).toBe('Test');
   });
+  it('evaluates JS helper expressions', () => {
+    expect(evalExpr('encodeURIComponent(args.keyword)', { args: { keyword: 'hello world' } })).toBe('hello%20world');
+  });
+  it('evaluates ternary expressions', () => {
+    expect(evalExpr("args.kind === 'tech' ? 'technology' : args.kind", { args: { kind: 'tech' } })).toBe('technology');
+  });
+  it('evaluates method calls on values', () => {
+    expect(evalExpr("args.username.startsWith('@') ? args.username : '@' + args.username", { args: { username: 'alice' } })).toBe('@alice');
+  });
   it('applies join filter', () => {
     expect(evalExpr('item.tags | join(,)', { item: { tags: ['a', 'b', 'c'] } })).toBe('a,b,c');
   });
@@ -104,6 +113,15 @@ describe('render', () => {
   it('renders URL template', () => {
     expect(render('https://api.example.com/search?q=${{ args.keyword }}', { args: { keyword: 'test' } })).toBe('https://api.example.com/search?q=test');
   });
+  it('renders inline helper expressions', () => {
+    expect(render('https://example.com/search?q=${{ encodeURIComponent(args.keyword) }}', { args: { keyword: 'hello world' } })).toBe('https://example.com/search?q=hello%20world');
+  });
+  it('renders full multiline expressions', () => {
+    expect(render("${{\n  args.topic ? `https://medium.com/tag/${args.topic}` : 'https://medium.com/tag/technology'\n}}", { args: { topic: 'ai' } })).toBe('https://medium.com/tag/ai');
+  });
+  it('renders block expressions with surrounding whitespace', () => {
+    expect(render("\n  ${{ args.kind === 'tech' ? 'technology' : args.kind }}\n", { args: { kind: 'tech' } })).toBe('technology');
+  });
 });
 
 describe('normalizeEvaluateSource', () => {

package/src/pipeline/template.ts

@@ -3,20 +3,25 @@
  */
 
 export interface RenderContext {
-  args?: Record<string, any>;
-  data?: any;
-  item?: any;
+  args?: Record<string, unknown>;
+  data?: unknown;
+  item?: unknown;
   index?: number;
 }
 
-export function render(template: any, ctx: RenderContext): any {
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+export function render(template: unknown, ctx: RenderContext): unknown {
   if (typeof template !== 'string') return template;
+  const trimmed = template.trim();
   // Full expression: entire string is a single ${{ ... }}
   // Use [^}] to prevent matching across }} boundaries (e.g. "${{ a }}-${{ b }}")
-  const fullMatch = template.match(/^\$\{\{\s*([^}]*(?:\}[^}][^}]*)*)\s*\}\}$/);
-  if (fullMatch && !template.includes('}}-') && !template.includes('}}${{')) return evalExpr(fullMatch[1].trim(), ctx);
+  const fullMatch = trimmed.match(/^\$\{\{\s*([^}]*(?:\}[^}][^}]*)*)\s*\}\}$/);
+  if (fullMatch && !trimmed.includes('}}-') && !trimmed.includes('}}${{')) return evalExpr(fullMatch[1].trim(), ctx);
   // Check if the entire string is a single expression (no other text around it)
-  const singleExpr = template.match(/^\$\{\{\s*([\s\S]*?)\s*\}\}$/);
+  const singleExpr = trimmed.match(/^\$\{\{\s*([\s\S]*?)\s*\}\}$/);
   if (singleExpr) {
     // Verify it's truly a single expression (no other ${{ inside)
     const inner = singleExpr[1];
@@ -25,7 +30,7 @@ export function render(template: any, ctx: RenderContext): any {
   return template.replace(/\$\{\{\s*(.*?)\s*\}\}/g, (_m, expr) => String(evalExpr(expr.trim(), ctx)));
 }
 
-export function evalExpr(expr: string, ctx: RenderContext): any {
+export function evalExpr(expr: string, ctx: RenderContext): unknown {
   const args = ctx.args ?? {};
   const item = ctx.item ?? {};
   const data = ctx.data;
@@ -68,7 +73,10 @@ export function evalExpr(expr: string, ctx: RenderContext): any {
     return right.replace(/^['"]|['"]$/g, '');
   }
 
-  return resolvePath(expr, { args, item, data, index });
+  const resolved = resolvePath(expr, { args, item, data, index });
+  if (resolved !== null && resolved !== undefined) return resolved;
+
+  return evalJsExpr(expr, { args, item, data, index });
 }
 
 /**
@@ -77,7 +85,7 @@ export function evalExpr(expr: string, ctx: RenderContext): any {
  *   default(val), join(sep), upper, lower, truncate(n), trim,
  *   replace(old,new), keys, length, first, last, json
  */
-function applyFilter(filterExpr: string, value: any): any {
+function applyFilter(filterExpr: string, value: unknown): unknown {
   const match = filterExpr.match(/^(\w+)(?:\((.+)\))?$/);
   if (!match) return value;
   const [, name, rawArgs] = match;
@@ -145,32 +153,97 @@ function applyFilter(filterExpr: string, value: any): any {
       const parts = value.split(/[/\\]/);
       return parts[parts.length - 1] || value;
     }
+    case 'urlencode':
+      return typeof value === 'string' ? encodeURIComponent(value) : value;
+    case 'urldecode':
+      return typeof value === 'string' ? decodeURIComponent(value) : value;
     default:
       return value;
   }
 }
 
-export function resolvePath(pathStr: string, ctx: RenderContext): any {
+export function resolvePath(pathStr: string, ctx: RenderContext): unknown {
   const args = ctx.args ?? {};
   const item = ctx.item ?? {};
   const data = ctx.data;
   const index = ctx.index ?? 0;
   const parts = pathStr.split('.');
   const rootName = parts[0];
-  let obj: any; let rest: string[];
+  let obj: unknown;
+  let rest: string[];
   if (rootName === 'args') { obj = args; rest = parts.slice(1); }
   else if (rootName === 'item') { obj = item; rest = parts.slice(1); }
   else if (rootName === 'data') { obj = data; rest = parts.slice(1); }
   else if (rootName === 'index') return index;
   else { obj = item; rest = parts; }
   for (const part of rest) {
-    if (obj && typeof obj === 'object' && !Array.isArray(obj)) obj = obj[part];
+    if (isRecord(obj)) obj = obj[part];
     else if (Array.isArray(obj) && /^\d+$/.test(part)) obj = obj[parseInt(part, 10)];
     else return null;
   }
   return obj;
 }
 
+/**
+ * Evaluate arbitrary JS expressions as a last-resort fallback.
+ *
+ * ⚠️  SECURITY NOTE: Uses `new Function()` to execute the expression.
+ * This is acceptable here because:
+ *   1. YAML adapters are authored by trusted repo contributors only.
+ *   2. The expression runs in the same Node.js process (no sandbox).
+ *   3. Only a curated set of globals is exposed (no require/import/process/fs).
+ * If opencli ever loads untrusted third-party adapters, this MUST be replaced
+ * with a proper sandboxed evaluator.
+ */
+function evalJsExpr(expr: string, ctx: RenderContext): unknown {
+  // Guard against absurdly long expressions that could indicate injection.
+  if (expr.length > 2000) return undefined;
+
+  const args = ctx.args ?? {};
+  const item = ctx.item ?? {};
+  const data = ctx.data;
+  const index = ctx.index ?? 0;
+
+  try {
+    const fn = new Function(
+      'args',
+      'item',
+      'data',
+      'index',
+      'encodeURIComponent',
+      'decodeURIComponent',
+      'JSON',
+      'Math',
+      'Number',
+      'String',
+      'Boolean',
+      'Array',
+      'Object',
+      'Date',
+      `"use strict"; return (${expr});`,
+    );
+
+    return fn(
+      args,
+      item,
+      data,
+      index,
+      encodeURIComponent,
+      decodeURIComponent,
+      JSON,
+      Math,
+      Number,
+      String,
+      Boolean,
+      Array,
+      Object,
+      Date,
+    );
+  } catch {
+    return undefined;
+  }
+}
+
 /**
  * Normalize JavaScript source for browser evaluate() calls.
  */

package/src/pipeline/transform.test.ts

@@ -58,6 +58,19 @@ describe('stepMap', () => {
   it('returns null/undefined as-is', async () => {
     expect(await stepMap(null, { x: '${{ item.x }}' }, null, {})).toBeNull();
   });
+
+  it('supports inline select before mapping', async () => {
+    const result = await stepMap(null, {
+      select: 'posts',
+      title: '${{ item.title }}',
+      rank: '${{ index + 1 }}',
+    }, { posts: [{ title: 'One' }, { title: 'Two' }] }, {});
+
+    expect(result).toEqual([
+      { title: 'One', rank: 1 },
+      { title: 'Two', rank: 2 },
+    ]);
+  });
 });
 
 describe('stepFilter', () => {
@@ -75,12 +88,12 @@ describe('stepFilter', () => {
 describe('stepSort', () => {
   it('sorts ascending by key', async () => {
     const result = await stepSort(null, 'score', SAMPLE_DATA, {});
-    expect(result.map((r: any) => r.title)).toEqual(['Alpha', 'Gamma', 'Beta']);
+    expect((result as typeof SAMPLE_DATA).map((r) => r.title)).toEqual(['Alpha', 'Gamma', 'Beta']);
   });
 
   it('sorts descending', async () => {
     const result = await stepSort(null, { by: 'score', order: 'desc' }, SAMPLE_DATA, {});
-    expect(result.map((r: any) => r.title)).toEqual(['Beta', 'Gamma', 'Alpha']);
+    expect((result as typeof SAMPLE_DATA).map((r) => r.title)).toEqual(['Beta', 'Gamma', 'Alpha']);
   });
 
   it('does not mutate original', async () => {