@pikku/inspector 0.12.9 → 0.12.11

package/CHANGELOG.md

@@ -1,5 +1,31 @@
+## 0.12.11
+
+### Patch Changes
+
+- 033d172: Log a critical inspector error when multiple functions resolve to the same `pikku` function name, instead of silently allowing routing map collisions. This may cause builds to fail if multiple functions previously resolved to the same `pikku` function name.
+- Updated dependencies [b9ed73e]
+  - @pikku/core@0.12.19
+
 ## 0.12.0
 
+## 0.12.10
+
+### Patch Changes
+
+- ba8d6ff: Support inline functions in pikkuWorkflowComplexFunc with full DSL extraction
+- d3ace0e: Inspector now captures the `deploy: 'serverless' | 'server' | 'auto'` option
+  from `pikkuFunc` / `pikkuSessionlessFunc` calls, alongside the other runtime
+  metadata (`expose`, `remote`, `mcp`, `readonly`, `approvalRequired`).
+
+  Previously this field was defined on `FunctionRuntimeMeta` but never read
+  from the user's source, so `deploy: 'server'` was silently dropped. That
+  left downstream consumers — notably `@pikku/cli`'s deployment analyzer,
+  which routes server-targeted functions to a container unit — treating
+  every function as `serverless` regardless of its declared intent.
+
+- Updated dependencies [311c0c4]
+  - @pikku/core@0.12.18
+
 ## 0.12.9
 
 ### Patch Changes
@@ -14,7 +40,6 @@
 ### Patch Changes
 
 - 624097e: Add deploy pipeline with provider-agnostic architecture
-
   - Add MetaService with explicit typed API, absorb WiringService reads
   - Add deployment service, traceId propagation, scoped logger
   - Rewrite analyzer: one function = one worker, gateways dispatch via RPC
@@ -61,7 +86,6 @@
 
 - 5866b66: Add critical error (PKU490) when Zod schemas and wiring calls (wireHTTPRoutes, addPermission, addHTTPMiddleware) coexist in the same file. The CLI uses tsImport to extract Zod schemas at runtime, which executes all top-level code — wiring side-effects crash in this context because pikku state metadata doesn't exist. Schemas and wirings must be in separate files.
 - e412b4d: Optimize CLI codegen performance: 12x faster `pikku all`
-
   - Reuse schemas across re-inspections (skip redundant `ts-json-schema-generator` runs)
   - Cache TS schemas to disk (`.pikku/schema-cache.json`) for cross-run reuse
   - Pass `oldProgram` to `ts.createProgram` for incremental TS compilation
@@ -190,14 +214,12 @@
 - 1967172: Update code generation to support channel middleware enhancements
 
   **Code Generation Updates:**
-
   - Update channel type serialization to include middleware support
   - Improve WebSocket wrapper generation for middleware handling
   - Update CLI channel client generation with better type support
   - Enhance services and schema generation for channel configurations
 
   **Inspector Updates:**
-
   - Improve channel metadata extraction for middleware
   - Better type analysis for channel lifecycle functions
   - Enhanced post-processing for channel configurations
@@ -205,19 +227,16 @@
 - 753481a: Add bootstrap command, performance optimizations, and CLI improvements
 
   **New Features:**
-
   - Add `pikku bootstrap` command for type-only generation (~13.5% faster than `pikku all`)
   - Add configurable `ignoreFiles` option to pikku.config.json with sensible defaults (_.gen.ts, _.test.ts, \*.spec.ts)
   - Export pikkuCLIRender helper from serialize-cli-types.ts with JSDoc documentation
 
   **Performance Improvements:**
-
   - Add aggressive TypeScript compiler options (skipDefaultLibCheck, types: []) - ~37% faster TypeScript setup
   - Add detailed performance timing to inspector phases (--logLevel=debug)
   - Optimize file inspection with ignore patterns - ~10-20% faster overall
 
   **Enhancements:**
-
   - Fix --logLevel flag to properly apply log level to logger
   - Update middleware logging to use structured log format
   - Improve CLI renderers to consistently use destructured logger service
@@ -318,7 +337,6 @@ For complete details, see https://pikku.dev/changelogs/0_10_0.md
 ### Patch Changes
 
 - 44e3ff4: feat: enhance CLI filtering with type and directory filters
-
   - Add --types filter to filter by PikkuEventTypes (http, channel, queue, scheduler, rpc, mcp)
   - Add --directories filter to filter by file paths/directories
   - All filters (tags, types, directories) now work together with AND logic
@@ -329,7 +347,6 @@ For complete details, see https://pikku.dev/changelogs/0_10_0.md
 - 7c592b8: feat: support for required services and improved service configuration
 
   This release includes several enhancements to service management and configuration:
-
   - Added support for required services configuration
   - Improved service discovery and registration
   - Added typed RPC clients for service communication

package/dist/add/add-functions.js

@@ -3,7 +3,7 @@ import { detectSchemaVendorOrError } from '../utils/detect-schema-vendor.js';
 import { extractFunctionName, funcIdToTypeName, } from '../utils/extract-function-name.js';
 import { extractFunctionNode } from '../utils/extract-function-node.js';
 import { extractUsedWires } from '../utils/extract-services.js';
-import { formatVersionedId } from '@pikku/core';
+import { formatVersionedId, parseVersionedId } from '@pikku/core';
 import { getPropertyValue, getCommonWireMetaData, } from '../utils/get-property-value.js';
 import { resolveMiddleware } from '../utils/middleware.js';
 import { resolvePermissions } from '../utils/permissions.js';
@@ -209,6 +209,19 @@ function unwrapPromise(checker, type) {
     }
     return type;
 }
+const resolveExistingFunctionSource = (state, pikkuFuncId) => {
+    return (state.functions.meta[pikkuFuncId]?.sourceFile ||
+        state.rpc.internalFiles.get(pikkuFuncId)?.path ||
+        null);
+};
+const areCompatibleFunctionIds = (existingId, incomingId) => {
+    if (existingId === incomingId) {
+        return true;
+    }
+    const existingParsed = parseVersionedId(existingId);
+    const incomingParsed = parseVersionedId(incomingId);
+    return existingParsed.baseName === incomingParsed.baseName;
+};
 /**
  * Inspect pikkuFunc calls, extract input/output and first-arg destructuring,
  * then push into state.functions.meta.
@@ -245,6 +258,7 @@ export const addFunctions = (logger, node, checker, state, options) => {
     let remote;
     let mcp;
     let readonly_;
+    let deploy;
     let approvalRequired;
     let approvalDescription;
     let version;
@@ -312,6 +326,7 @@ export const addFunctions = (logger, node, checker, state, options) => {
         remote = getPropertyValue(firstArg, 'remote');
         mcp = getPropertyValue(firstArg, 'mcp');
         readonly_ = getPropertyValue(firstArg, 'readonly');
+        deploy = getPropertyValue(firstArg, 'deploy');
         approvalRequired = getPropertyValue(firstArg, 'approvalRequired');
         // Extract approvalDescription identifier reference
         for (const prop of firstArg.properties) {
@@ -398,6 +413,7 @@ export const addFunctions = (logger, node, checker, state, options) => {
         pikkuFuncId = formatVersionedId(baseName, version);
     }
     const isMCPToolFunc = expression.text === 'pikkuMCPToolFunc';
+    const isListFunc = expression.text === 'pikkuListFunc';
     const mcpEnabled = mcp || isMCPToolFunc;
     // Pick the handler: use resolvedFunc when it exists and is a function, otherwise fall back to handlerNode
     const handler = resolvedFunc &&
@@ -459,7 +475,22 @@ export const addFunctions = (logger, node, checker, state, options) => {
         state.schemaLookup.set(schemaName, inputSchemaRef);
         state.functions.typesMap.addCustomType(schemaName, 'unknown', []);
     }
-    else if (genericTypes.length >= 1 && genericTypes[0]) {
+    else if (isListFunc && genericTypes.length >= 1 && genericTypes[0]) {
+        const inputAliasName = `${capitalizedName}Input`;
+        const filterType = genericTypes[0];
+        const filterTypeText = checker.typeToString(filterType, undefined, ts.TypeFormatFlags.NoTruncation);
+        const refs = resolveTypeImports(filterType, state.functions.typesMap, true, checker);
+        state.functions.typesMap.addCustomType(inputAliasName, `{ cursor?: string; limit?: number; sort?: Array<{ column: string; direction: 'asc' | 'desc' }>; filter?: unknown; search?: string; } & ${filterTypeText}`, [...new Set(refs)]);
+        inputNames = [inputAliasName];
+        const secondParam = handler.parameters[1];
+        if (secondParam) {
+            inputTypes = [checker.getTypeAtLocation(secondParam)];
+        }
+        else {
+            inputTypes = [filterType];
+        }
+    }
+    else if (!isListFunc && genericTypes.length >= 1 && genericTypes[0]) {
         // Fall back to extracting from generic type arguments
         const result = getNamesAndTypes(checker, state.functions.typesMap, 'Input', name, genericTypes[0]);
         inputNames = result.names;
@@ -483,7 +514,15 @@ export const addFunctions = (logger, node, checker, state, options) => {
         state.schemaLookup.set(schemaName, outputSchemaRef);
         state.functions.typesMap.addCustomType(schemaName, 'unknown', []);
     }
-    else if (genericTypes.length >= 2) {
+    else if (isListFunc && genericTypes.length >= 2 && genericTypes[1]) {
+        const outputAliasName = `${capitalizedName}Output`;
+        const rowType = genericTypes[1];
+        const rowTypeText = checker.typeToString(rowType, undefined, ts.TypeFormatFlags.NoTruncation);
+        const refs = resolveTypeImports(rowType, state.functions.typesMap, true, checker);
+        state.functions.typesMap.addCustomType(outputAliasName, `{ rows: Array<${rowTypeText}>; nextCursor: string | null; totalCount?: number; }`, [...new Set(refs)]);
+        outputNames = [outputAliasName];
+    }
+    else if (!isListFunc && genericTypes.length >= 2) {
         outputNames = getNamesAndTypes(checker, state.functions.typesMap, 'Output', name, genericTypes[1]).names;
     }
     else {
@@ -537,6 +576,36 @@ export const addFunctions = (logger, node, checker, state, options) => {
     if (inputTypes.length > 0) {
         state.typesLookup.set(pikkuFuncId, inputTypes);
     }
+    const sourceFile = node.getSourceFile().fileName;
+    const existingFunction = state.functions.meta[pikkuFuncId];
+    if (existingFunction &&
+        existingFunction.sourceFile &&
+        existingFunction.sourceFile !== sourceFile) {
+        logger.critical(ErrorCode.DUPLICATE_FUNCTION_NAME, `Function name '${name}' is not unique. ` +
+            `'${pikkuFuncId}' is already defined in '${existingFunction.sourceFile}' and cannot be redefined in '${sourceFile}'.`);
+        return;
+    }
+    if (exportedName || explicitName) {
+        const existingInternal = state.rpc.internalMeta[name];
+        if (existingInternal &&
+            !areCompatibleFunctionIds(existingInternal, pikkuFuncId)) {
+            const existingSource = resolveExistingFunctionSource(state, existingInternal) || 'unknown file';
+            logger.critical(ErrorCode.DUPLICATE_FUNCTION_NAME, `Function name '${name}' is not unique. ` +
+                `It already points to '${existingInternal}' in '${existingSource}', but '${pikkuFuncId}' in '${sourceFile}' tried to use the same name.`);
+            return;
+        }
+        if (expose) {
+            const existingExposed = state.rpc.exposedMeta[name];
+            if (existingExposed &&
+                !areCompatibleFunctionIds(existingExposed, pikkuFuncId)) {
+                const existingSource = resolveExistingFunctionSource(state, existingExposed) ||
+                    'unknown file';
+                logger.critical(ErrorCode.DUPLICATE_FUNCTION_NAME, `Exposed function name '${name}' is not unique. ` +
+                    `It already points to '${existingExposed}' in '${existingSource}', but '${pikkuFuncId}' in '${sourceFile}' tried to use the same name.`);
+                return;
+            }
+        }
+    }
     // --- resolve middleware ---
     let middleware = objectNode
         ? resolveMiddleware(state, objectNode, tags, checker)
@@ -583,6 +652,7 @@ export const addFunctions = (logger, node, checker, state, options) => {
         remote: remote || undefined,
         mcp: mcpEnabled || undefined,
         readonly: readonly_ || undefined,
+        deploy: deploy || undefined,
         approvalRequired: approvalRequired || undefined,
         approvalDescription: approvalDescription || undefined,
         version,
@@ -594,7 +664,7 @@ export const addFunctions = (logger, node, checker, state, options) => {
         middleware,
         permissions,
         isDirectFunction,
-        sourceFile: node.getSourceFile().fileName,
+        sourceFile,
         exportedName: exportedName || undefined,
     };
     // Populate node metadata if node config is present

package/dist/add/add-http-route.js

@@ -7,6 +7,7 @@ import { resolveHTTPMiddlewareFromObject } from '../utils/middleware.js';
 import { resolveHTTPPermissionsFromObject } from '../utils/permissions.js';
 import { extractWireNames } from '../utils/post-process.js';
 import { ensureFunctionMetadata } from '../utils/ensure-function-metadata.js';
+import { resolveFunctionMeta } from '../utils/resolve-function-meta.js';
 import { ErrorCode } from '../error-codes.js';
 import { validateAuthSessionless } from '../utils/validate-auth-sessionless.js';
 import { detectSchemaVendorOrError } from '../utils/detect-schema-vendor.js';
@@ -113,12 +114,30 @@ export function registerHTTPRoute({ obj, state, checker, logger, sourceFile, bas
     if (funcName.startsWith('__temp_')) {
         funcName = makeContextBasedId('http', method, fullRoute);
     }
+    let refAddonTarget = null;
+    if (ts.isCallExpression(funcInitializer) &&
+        ts.isIdentifier(funcInitializer.expression) &&
+        funcInitializer.expression.text === 'ref') {
+        const [firstArg] = funcInitializer.arguments;
+        if (firstArg &&
+            ts.isStringLiteral(firstArg) &&
+            firstArg.text.includes(':')) {
+            refAddonTarget = firstArg.text;
+        }
+    }
     const packageName = ts.isIdentifier(funcInitializer)
         ? resolveAddonName(funcInitializer, checker, state.rpc.wireAddonDeclarations)
         : null;
+    if (refAddonTarget) {
+        const targetMeta = resolveFunctionMeta(state, refAddonTarget);
+        if (!targetMeta) {
+            logger.warn(`Skipping route '${fullRoute}': addon function metadata for '${refAddonTarget}' is not available yet.`);
+            return;
+        }
+    }
     ensureFunctionMetadata(state, funcName, fullRoute, funcInitializer, checker, extracted.isHelper);
     // Lookup existing function metadata
-    const fnMeta = state.functions.meta[funcName];
+    const fnMeta = resolveFunctionMeta(state, funcName);
     if (!fnMeta) {
         logger.critical(ErrorCode.FUNCTION_METADATA_NOT_FOUND, `No function metadata found for '${funcName}'.`);
         return;

package/dist/add/add-workflow.d.ts

@@ -5,7 +5,7 @@ import type { WorkflowStepMeta } from '@pikku/core/workflow';
  */
 export declare function collectInvokedRPCs(steps: WorkflowStepMeta[], rpcs: Set<string>): void;
 /**
- * Inspector for pikkuWorkflow() and pikkuSimpleWorkflow() calls
+ * Inspector for pikkuWorkflowFunc() and pikkuWorkflowComplexFunc() calls
  * Detects workflow registration and extracts metadata
  */
 export declare const addWorkflow: AddWiring;

package/dist/add/add-workflow.js

@@ -142,7 +142,7 @@ function getWorkflowInvocations(node, checker, state, workflowName, steps) {
     });
 }
 /**
- * Inspector for pikkuWorkflow() and pikkuSimpleWorkflow() calls
+ * Inspector for pikkuWorkflowFunc() and pikkuWorkflowComplexFunc() calls
  * Detects workflow registration and extracts metadata
  */
 export const addWorkflow = (logger, node, checker, state) => {
@@ -160,7 +160,7 @@ export const addWorkflow = (logger, node, checker, state) => {
         wrapperType = 'dsl';
     }
     else if (expression.text === 'pikkuWorkflowComplexFunc') {
-        wrapperType = 'regular';
+        wrapperType = 'complex';
     }
     else {
         return;
@@ -220,7 +220,9 @@ export const addWorkflow = (logger, node, checker, state) => {
     let dsl = undefined;
     // Try DSL workflow extraction first
     // Pass the whole CallExpression node so findWorkflowFunction can find the arrow function
-    const result = extractDSLWorkflow(node, checker);
+    const result = extractDSLWorkflow(node, checker, {
+        allowInline: wrapperType === 'complex',
+    });
     if (result.status === 'ok' && result.steps) {
         // Extraction succeeded
         steps = result.steps;
@@ -252,7 +254,7 @@ export const addWorkflow = (logger, node, checker, state) => {
             // For pikkuWorkflowFunc, this is a critical error
             // But still track RPC invocations for function registration
             getWorkflowInvocations(resolvedFunc, checker, state, workflowName, steps);
-            logger.critical(ErrorCode.INVALID_DSL_WORKFLOW, `Workflow '${workflowName}' uses pikkuWorkflowFunc but does not conform to DSL workflow rules:\n${result.reason || 'Unknown error'}`);
+            logger.critical(ErrorCode.INVALID_DSL_WORKFLOW, `Workflow '${workflowName}' does not conform to DSL workflow rules:\n${result.reason || 'Unknown error'}`);
             return;
         }
         else {
@@ -261,12 +263,10 @@ export const addWorkflow = (logger, node, checker, state) => {
             dsl = false;
         }
     }
-    /**
-     * For non-dsl workflows or pikkuWorkflowComplexFunc, run basic extraction
-     * to ensure all RPC invocations are tracked for function registration.
-     * This catches RPCs in Promise.all callbacks and other patterns DSL can't extract.
-     */
-    if (!dsl || wrapperType === 'regular') {
+    // For pikkuWorkflowComplexFunc, also run basic extraction so RPCs in
+    // patterns the DSL extractor doesn't handle (array+push, nested Promise.all
+    // with identifier args, etc.) are still registered as invoked functions.
+    if (wrapperType === 'complex') {
         getWorkflowInvocations(resolvedFunc, checker, state, workflowName, steps);
     }
     state.workflows.meta[workflowName] = {

package/dist/error-codes.d.ts

@@ -41,6 +41,7 @@ export declare enum ErrorCode {
     PERMISSION_EMPTY_ARRAY = "PKU937",
     PERMISSION_PATTERN_INVALID = "PKU975",
     DUPLICATE_FUNCTION_VERSION = "PKU850",
+    DUPLICATE_FUNCTION_NAME = "PKU851",
     MANIFEST_MISSING = "PKU860",
     FUNCTION_VERSION_MODIFIED = "PKU861",
     CONTRACT_CHANGED_REQUIRES_BUMP = "PKU862",

package/dist/error-codes.js

@@ -48,6 +48,7 @@ export var ErrorCode;
     ErrorCode["PERMISSION_PATTERN_INVALID"] = "PKU975";
     // Versioning errors
     ErrorCode["DUPLICATE_FUNCTION_VERSION"] = "PKU850";
+    ErrorCode["DUPLICATE_FUNCTION_NAME"] = "PKU851";
     // Contract versioning errors
     ErrorCode["MANIFEST_MISSING"] = "PKU860";
     ErrorCode["FUNCTION_VERSION_MODIFIED"] = "PKU861";

package/dist/utils/extract-node-value.js

@@ -20,6 +20,10 @@ export function extractStringLiteral(node, checker) {
         }
         return result;
     }
+    // Unwrap type assertions: `expr as Type` or `<Type>expr`
+    if (ts.isAsExpression(node) || ts.isTypeAssertionExpression(node)) {
+        return extractStringLiteral(node.expression, checker);
+    }
     // Try to evaluate constant identifiers
     if (ts.isIdentifier(node)) {
         const symbol = checker.getSymbolAtLocation(node);

package/dist/utils/schema-generator.js

@@ -258,10 +258,10 @@ async function generateZodSchemas(logger, schemaLookup, typesMap) {
     const uniqueSourceFiles = [
         ...new Set([...schemaLookup.values()].map((ref) => ref.sourceFile)),
     ];
-    console.log(`[TIMING] Zod schemas: ${schemaLookup.size} schemas from ${uniqueSourceFiles.length} files`);
+    logger.info(`[TIMING] Zod schemas: ${schemaLookup.size} schemas from ${uniqueSourceFiles.length} files`);
     const importStart = performance.now();
     const importedModules = await batchImportWithRegister(logger, uniqueSourceFiles);
-    console.log(`[TIMING] Batch import: ${(performance.now() - importStart).toFixed(0)}ms`);
+    logger.info(`[TIMING] Batch import: ${(performance.now() - importStart).toFixed(0)}ms`);
     const processStart = performance.now();
     // Track schemas that need per-file tsImport fallback
     const fallbackSchemas = [];
@@ -302,7 +302,7 @@ async function generateZodSchemas(logger, schemaLookup, typesMap) {
             }
         }
     }
-    console.log(`[TIMING] Process schemas: ${(performance.now() - processStart).toFixed(0)}ms (${Object.keys(schemas).length} generated)`);
+    logger.info(`[TIMING] Process schemas: ${(performance.now() - processStart).toFixed(0)}ms (${Object.keys(schemas).length} generated)`);
     return schemas;
 }
 export async function generateAllSchemas(logger, config, state) {

package/dist/utils/validate-auth-sessionless.d.ts

@@ -1,3 +1,3 @@
-import * as ts from 'typescript';
+import type * as ts from 'typescript';
 import type { InspectorLogger, InspectorState } from '../types.js';
 export declare function validateAuthSessionless(logger: InspectorLogger, obj: ts.ObjectLiteralExpression, state: InspectorState, funcName: string, wireDescription: string, inheritedAuth?: boolean): boolean;

package/dist/utils/workflow/dsl/extract-dsl-workflow.d.ts

@@ -1,7 +1,7 @@
 import * as ts from 'typescript';
 import type { WorkflowStepMeta, WorkflowContext } from '@pikku/core/workflow';
 /**
- * Result of simple workflow extraction
+ * Result of DSL workflow extraction
  */
 export interface ExtractionResult {
     status: 'ok' | 'error';
@@ -9,9 +9,10 @@ export interface ExtractionResult {
     /** Workflow context (top-level variables) */
     context?: WorkflowContext;
     reason?: string;
-    simple?: boolean;
 }
 /**
- * Extract simple workflow metadata from a function declaration
+ * Extract DSL workflow metadata from a function declaration
  */
-export declare function extractDSLWorkflow(funcNode: ts.Node, checker: ts.TypeChecker): ExtractionResult;
+export declare function extractDSLWorkflow(funcNode: ts.Node, checker: ts.TypeChecker, options?: {
+    allowInline?: boolean;
+}): ExtractionResult;

package/dist/utils/workflow/dsl/extract-dsl-workflow.js

@@ -1,26 +1,11 @@
 import * as ts from 'typescript';
-import { isWorkflowDoCall, isWorkflowSleepCall, isThrowCancelException, extractCancelReason, isParallelFanout, isParallelGroup, isSequentialFanout, isArrayFilter, isArraySome, isArrayEvery, extractForOfVariable, isArrayType, getSourceText, } from './patterns.js';
+import { isWorkflowDoCall, isWorkflowSleepCall, isThrowCancelException, extractCancelReason, isParallelFanout, isParallelGroup, isSequentialFanout, isArrayFilter, isArraySome, isArrayEvery, extractForOfVariable, isArrayType, getSourceText, extractSourcePath, } from './patterns.js';
 import { validateNoDisallowedPatterns, validateAwaitedCalls, formatValidationErrors, } from './validation.js';
 import { extractStringLiteral, extractNumberLiteral, } from '../../extract-node-value.js';
 /**
- * Extract full source path from an expression (e.g., data.memberEmails)
+ * Extract DSL workflow metadata from a function declaration
  */
-function extractSourcePath(expr) {
-    if (ts.isIdentifier(expr)) {
-        return expr.text;
-    }
-    if (ts.isPropertyAccessExpression(expr)) {
-        const base = extractSourcePath(expr.expression);
-        if (base) {
-            return `${base}.${expr.name.text}`;
-        }
-    }
-    return null;
-}
-/**
- * Extract simple workflow metadata from a function declaration
- */
-export function extractDSLWorkflow(funcNode, checker) {
+export function extractDSLWorkflow(funcNode, checker, options) {
     try {
         // Find the async arrow function
         const arrowFunc = findWorkflowFunction(funcNode);
@@ -28,7 +13,6 @@ export function extractDSLWorkflow(funcNode, checker) {
             return {
                 status: 'error',
                 reason: 'Could not find async arrow function in workflow definition',
-                simple: false,
             };
         }
         // Extract input parameter name (second parameter)
@@ -37,7 +21,6 @@ export function extractDSLWorkflow(funcNode, checker) {
             return {
                 status: 'error',
                 reason: 'Could not determine input parameter name',
-                simple: false,
             };
         }
         // Initialize extraction context
@@ -53,12 +36,13 @@ export function extractDSLWorkflow(funcNode, checker) {
             depth: 0,
         };
         // Validate no disallowed patterns
-        const patternErrors = validateNoDisallowedPatterns(arrowFunc.body);
+        const patternErrors = validateNoDisallowedPatterns(arrowFunc.body, {
+            allowInline: options?.allowInline,
+        });
         if (patternErrors.length > 0) {
             return {
                 status: 'error',
                 reason: formatValidationErrors(patternErrors),
-                simple: false,
             };
         }
         // Validate all workflow calls are awaited
@@ -67,7 +51,6 @@ export function extractDSLWorkflow(funcNode, checker) {
             return {
                 status: 'error',
                 reason: formatValidationErrors(awaitErrors),
-                simple: false,
             };
         }
         // Extract steps from function body
@@ -77,7 +60,6 @@ export function extractDSLWorkflow(funcNode, checker) {
             return {
                 status: 'error',
                 reason: formatValidationErrors(context.errors),
-                simple: false,
             };
         }
         // Build workflow context from extracted context variables
@@ -92,14 +74,12 @@ export function extractDSLWorkflow(funcNode, checker) {
             status: 'ok',
             steps,
             context: Object.keys(workflowContext).length > 0 ? workflowContext : undefined,
-            simple: true,
         };
     }
     catch (error) {
         return {
             status: 'error',
             reason: error instanceof Error ? error.message : String(error),
-            simple: false,
         };
     }
 }
@@ -248,7 +228,9 @@ function extractVariableDeclaration(statement, context) {
     if (ts.isAwaitExpression(init) && ts.isCallExpression(init.expression)) {
         const call = init.expression;
         if (isWorkflowDoCall(call, context.checker)) {
-            const step = extractRpcStep(call, context, varName);
+            const step = isInlineDoCall(call)
+                ? extractInlineStep(call, context)
+                : extractRpcStep(call, context, varName);
             if (step) {
                 // Track output variable
                 const type = context.checker.getTypeAtLocation(decl);
@@ -335,7 +317,9 @@ function extractExpressionStatement(statement, context) {
     if (ts.isAwaitExpression(expr) && ts.isCallExpression(expr.expression)) {
         const call = expr.expression;
         if (isWorkflowDoCall(call, context.checker)) {
-            const step = extractRpcStep(call, context, outputVar);
+            const step = isInlineDoCall(call)
+                ? extractInlineStep(call, context)
+                : extractRpcStep(call, context, outputVar);
             // Track output variable if this is an assignment
             if (outputVar && step) {
                 const type = context.checker.getTypeAtLocation(expr);
@@ -394,6 +378,41 @@ function extractRpcStep(call, context, outputVar) {
         return null;
     }
 }
+/**
+ * Extract inline step from workflow.do() call with a function argument
+ */
+function extractInlineStep(call, context) {
+    const args = call.arguments;
+    if (args.length < 2)
+        return null;
+    try {
+        const stepName = extractStringLiteral(args[0], context.checker);
+        const optionsArg = args.length >= 3 ? args[args.length - 1] : undefined;
+        const options = optionsArg && ts.isObjectLiteralExpression(optionsArg)
+            ? extractStepOptions(optionsArg, context)
+            : undefined;
+        return {
+            type: 'inline',
+            stepName,
+            options,
+        };
+    }
+    catch (error) {
+        context.errors.push({
+            message: `Failed to extract inline step: ${error instanceof Error ? error.message : String(error)}`,
+            node: call,
+        });
+        return null;
+    }
+}
+/**
+ * Check if the second argument of a workflow.do() call is a function
+ */
+function isInlineDoCall(call) {
+    const secondArg = call.arguments[1];
+    return (!!secondArg &&
+        (ts.isArrowFunction(secondArg) || ts.isFunctionExpression(secondArg)));
+}
 /**
  * Extract step options from options object
  */

package/dist/utils/workflow/dsl/patterns.d.ts

@@ -1,6 +1,6 @@
 import * as ts from 'typescript';
 /**
- * Pattern detection helpers for simple workflow extraction
+ * Pattern detection helpers for DSL workflow extraction
  */
 /**
  * Check if a call expression is workflow.do()
@@ -43,6 +43,10 @@ export declare function isParallelGroup(node: ts.CallExpression): boolean;
  * Check if a for statement is a valid sequential fanout (for..of)
  */
 export declare function isSequentialFanout(node: ts.ForOfStatement): boolean;
+/**
+ * Extract full source path from an expression (e.g., data.memberEmails)
+ */
+export declare function extractSourcePath(expr: ts.Expression): string | null;
 /**
  * Extract the variable name from a for..of statement
  */

package/dist/utils/workflow/dsl/patterns.js

@@ -1,6 +1,6 @@
 import * as ts from 'typescript';
 /**
- * Pattern detection helpers for simple workflow extraction
+ * Pattern detection helpers for DSL workflow extraction
  */
 /**
  * Check if a call expression is workflow.do()
@@ -162,7 +162,7 @@ export function isSequentialFanout(node) {
 /**
  * Extract full source path from an expression (e.g., data.memberEmails)
  */
-function extractSourcePath(expr) {
+export function extractSourcePath(expr) {
     if (ts.isIdentifier(expr)) {
         return expr.text;
     }

package/dist/utils/workflow/dsl/validation.d.ts

@@ -1,6 +1,6 @@
 import * as ts from 'typescript';
 /**
- * Validation rules for simple workflows
+ * Validation rules for DSL workflows
  */
 export interface ValidationError {
     message: string;
@@ -19,7 +19,9 @@ export interface ValidationError {
  * - ThrowStatement (for WorkflowCancelledException)
  * - Block (containers)
  */
-export declare function validateNoDisallowedPatterns(node: ts.Node): ValidationError[];
+export declare function validateNoDisallowedPatterns(node: ts.Node, options?: {
+    allowInline?: boolean;
+}): ValidationError[];
 /**
  * Validate that all workflow.do calls are awaited
  */