@pikku/inspector 0.12.8 → 0.12.10

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 ## 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
+
+- 2ac6468: Fix workflow inspector crash when workflow.do() data object has a 'description' property
+- fbcf5b9: Add version awareness to RPC handler: versioned functions now appear in the exposed RPC type map (e.g. `getData@v1`, `getData@v2`), enabling type-safe `rpc.invoke('getData@v1', data)` calls. Tree-shaking respects specific version filters without pulling in all versions. HTTP wirings correctly resolve versioned function IDs.
+- Updated dependencies [fbcf5b9]
+  - @pikku/core@0.12.16
+
 ## 0.12.8
 
 ### Patch Changes

package/dist/add/add-functions.js

@@ -245,6 +245,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 +313,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) {
@@ -583,6 +585,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,
@@ -615,15 +618,14 @@ export const addFunctions = (logger, node, checker, state, options) => {
     }
     if (mcpEnabled) {
         if (!description) {
-            logger.critical(ErrorCode.MISSING_DESCRIPTION, `MCP tool '${name}' is missing a description.`);
-            return;
+            logger.warn(`MCP tool '${name}' is missing a description.`);
         }
         state.mcpEndpoints.files.add(node.getSourceFile().fileName);
         state.mcpEndpoints.toolsMeta[name] = {
             pikkuFuncId,
             name,
             title: title || undefined,
-            description,
+            description: description || undefined,
             summary,
             errors,
             tags,

package/dist/add/add-mcp-prompt.js

@@ -58,6 +58,10 @@ export const addMCPPrompt = (logger, node, checker, state, options) => {
         }
         const inputSchema = fnMeta.inputs?.[0] || null;
         const outputSchema = fnMeta.outputs?.[0] || null;
+        if (!fnMeta.outputSchemaName) {
+            fnMeta.outputSchemaName = 'MCPPromptResponse';
+            fnMeta.outputs = ['MCPPromptResponse'];
+        }
         // --- resolve middleware ---
         const middleware = resolveMiddleware(state, obj, tags, checker);
         // --- resolve permissions ---

package/dist/add/add-mcp-resource.js

@@ -67,6 +67,10 @@ export const addMCPResource = (logger, node, checker, state, options) => {
         }
         const inputSchema = fnMeta.inputs?.[0] || null;
         const outputSchema = fnMeta.outputs?.[0] || null;
+        if (!fnMeta.outputSchemaName) {
+            fnMeta.outputSchemaName = 'MCPResourceResponse';
+            fnMeta.outputs = ['MCPResourceResponse'];
+        }
         // --- resolve middleware ---
         const middleware = resolveMiddleware(state, obj, tags, checker);
         // --- resolve permissions ---

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

@@ -88,7 +88,7 @@ function getWorkflowInvocations(node, checker, state, workflowName, steps) {
                     // workflow.do(stepName, rpcName|fn, data?, options?)
                     const stepNameArg = args[0];
                     const secondArg = args[1];
-                    const optionsArg = args.length >= 3 ? args[args.length - 1] : undefined;
+                    const optionsArg = args.length >= 4 ? args[args.length - 1] : undefined;
                     const stepName = extractStringLiteral(stepNameArg, checker);
                     const description = extractDescription(optionsArg, checker) ?? undefined;
                     // Determine form by checking 2nd argument type
@@ -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/utils/extract-function-name.d.ts

@@ -6,6 +6,7 @@ export type ExtractedFunctionName = {
     exportedName: string | null;
     propertyName: string | null;
     isHelper: boolean;
+    version: number | null;
 };
 export declare function makeContextBasedId(wiringType: string, ...segments: string[]): string;
 export declare function funcIdToTypeName(id: string): string;

package/dist/utils/extract-function-name.js

@@ -1,5 +1,6 @@
 import * as ts from 'typescript';
 import { randomUUID } from 'crypto';
+import { formatVersionedId } from '@pikku/core';
 export function makeContextBasedId(wiringType, ...segments) {
     return [wiringType, ...segments].join(':');
 }
@@ -20,6 +21,7 @@ export function extractFunctionName(callExpr, checker, rootDir) {
         propertyName: null,
         explicitName: null,
         isHelper: false,
+        version: null,
     };
     const workflowHelpers = new Set([
         'workflow',
@@ -103,16 +105,7 @@ export function extractFunctionName(callExpr, checker, rootDir) {
             // Check for object with 'name' property in first argument
             const firstArg = args[0];
             if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
-                for (const prop of firstArg.properties) {
-                    if (ts.isPropertyAssignment(prop) &&
-                        ts.isIdentifier(prop.name) &&
-                        prop.name.text === 'override' &&
-                        ts.isStringLiteral(prop.initializer)) {
-                        // Priority 1: Object with override property
-                        result.explicitName = prop.initializer.text;
-                        break;
-                    }
-                }
+                extractOverrideAndVersion(firstArg, result);
             }
             // Special handling for pikkuSessionlessFunc pattern - use the arrow function directly
             if (expression.text.startsWith('pikku')) {
@@ -274,19 +267,9 @@ export function extractFunctionName(callExpr, checker, rootDir) {
                     if (ts.isCallExpression(decl.initializer) &&
                         ts.isIdentifier(decl.initializer.expression) &&
                         decl.initializer.expression.text.startsWith('pikku')) {
-                        // Check for object with 'override' property in first argument
                         const firstArg = decl.initializer.arguments[0];
                         if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
-                            for (const prop of firstArg.properties) {
-                                if (ts.isPropertyAssignment(prop) &&
-                                    ts.isIdentifier(prop.name) &&
-                                    prop.name.text === 'override' &&
-                                    ts.isStringLiteral(prop.initializer)) {
-                                    // Priority 1: Object with override property
-                                    result.explicitName = prop.initializer.text;
-                                    break;
-                                }
-                            }
+                            extractOverrideAndVersion(firstArg, result);
                         }
                         if (decl.initializer.expression.text.startsWith('pikku')) {
                             if (firstArg &&
@@ -340,17 +323,7 @@ export function extractFunctionName(callExpr, checker, rootDir) {
     else if (ts.isCallExpression(callExpr)) {
         const firstArg = callExpr.arguments[0];
         if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
-            for (const prop of firstArg.properties) {
-                if (ts.isPropertyAssignment(prop) &&
-                    ts.isIdentifier(prop.name) &&
-                    prop.name.text === 'override' &&
-                    ts.isStringLiteral(prop.initializer) &&
-                    !result.explicitName // Only set if not already set
-                ) {
-                    result.explicitName = prop.initializer.text;
-                    break;
-                }
-            }
+            extractOverrideAndVersion(firstArg, result);
         }
     }
     // Apply name priority logic
@@ -364,6 +337,9 @@ export function extractFunctionName(callExpr, checker, rootDir) {
     else {
         result.pikkuFuncId = `__temp_${randomUUID()}`;
     }
+    if (result.version !== null) {
+        result.pikkuFuncId = formatVersionedId(result.pikkuFuncId, result.version);
+    }
     return result;
 }
 /**
@@ -420,3 +396,22 @@ export function isNamedExport(declaration, checker) {
     }
     return false;
 }
+function extractOverrideAndVersion(objLiteral, result) {
+    for (const prop of objLiteral.properties) {
+        if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+            if (prop.name.text === 'override' &&
+                ts.isStringLiteral(prop.initializer) &&
+                !result.explicitName) {
+                result.explicitName = prop.initializer.text;
+            }
+            else if (prop.name.text === 'version' &&
+                ts.isNumericLiteral(prop.initializer) &&
+                result.version === null) {
+                const parsed = Number(prop.initializer.text);
+                if (Number.isInteger(parsed) && parsed >= 1) {
+                    result.version = parsed;
+                }
+            }
+        }
+    }
+}

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);
@@ -84,7 +88,12 @@ export function extractDescription(optionsNode, checker) {
     if (!optionsNode || !ts.isObjectLiteralExpression(optionsNode)) {
         return null;
     }
-    return extractPropertyString(optionsNode, 'description', checker);
+    try {
+        return extractPropertyString(optionsNode, 'description', checker);
+    }
+    catch {
+        return null;
+    }
 }
 /**
  * Extract duration value (number or string)

package/dist/utils/filter-inspector-state.js

@@ -532,11 +532,15 @@ export function filterInspectorState(state, filters, logger) {
             filteredState.serviceAggregation.usedFunctions.add(funcId);
         }
     }
-    // Post-filter version expansion: include all versions of matched functions
+    // Post-filter version expansion: when an unversioned base name is matched,
+    // include all its versions. Specific version matches (e.g. analyzeData@v1)
+    // do NOT expand to include other versions.
     const includedBaseNames = new Set();
     for (const funcId of filteredState.serviceAggregation.usedFunctions) {
-        const { baseName } = parseVersionedId(funcId);
-        includedBaseNames.add(baseName);
+        const { baseName, version } = parseVersionedId(funcId);
+        if (version === null) {
+            includedBaseNames.add(baseName);
+        }
     }
     if (includedBaseNames.size > 0) {
         for (const funcId of Object.keys(state.functions.meta)) {

package/dist/utils/resolve-versions.js

@@ -66,13 +66,43 @@ export function resolveLatestVersions(state, logger) {
             if (state.rpc.exposedMeta[baseName] === oldId) {
                 state.rpc.exposedMeta[baseName] = newId;
             }
+            updateWiringReferences(state, oldId, newId);
         }
         else {
             const latest = group.explicit.reduce((a, b) => a.version > b.version ? a : b);
             state.rpc.internalMeta[baseName] = latest.id;
         }
+        if (state.rpc.exposedMeta[baseName]) {
+            const latestId = state.rpc.internalMeta[baseName];
+            state.rpc.exposedMeta[baseName] = latestId;
+            for (const entry of group.explicit) {
+                state.rpc.exposedMeta[entry.id] = entry.id;
+                const fileEntry = state.rpc.internalFiles.get(entry.id);
+                if (fileEntry) {
+                    state.rpc.exposedFiles.set(entry.id, fileEntry);
+                }
+            }
+            if (group.unversioned) {
+                state.rpc.exposedMeta[latestId] = latestId;
+                const fileEntry = state.rpc.internalFiles.get(latestId);
+                if (fileEntry) {
+                    state.rpc.exposedFiles.set(latestId, fileEntry);
+                }
+            }
+        }
         for (const entry of group.explicit) {
             state.rpc.invokedFunctions.add(entry.id);
         }
     }
 }
+function updateWiringReferences(state, oldId, newId) {
+    if (state.http) {
+        for (const methods of Object.values(state.http.meta)) {
+            for (const meta of Object.values(methods)) {
+                if (meta.pikkuFuncId === oldId) {
+                    meta.pikkuFuncId = newId;
+                }
+            }
+        }
+    }
+}

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
  */