@pikku/inspector 0.12.27 → 0.12.29

package/CHANGELOG.md

@@ -1,3 +1,63 @@
+## 0.12.29
+
+### Patch Changes
+
+- 7b5b10a: fix(workflow): include suspend steps in plannedSteps with readable displayName
+
+  `workflow.suspend(reason)` calls now appear in the static `plannedSteps` ladder
+  produced by `deriveWorkflowPlan`. Previously the inspector ignored them, so the
+  runtime's `__workflow_suspend:<reason>` steps had no planned counterpart and
+  the UI appended them as orphans at the bottom of the step list instead of
+  showing them at the correct position.
+
+  Changes:
+  - `WorkflowPlannedStep` gains an optional `displayName` field — the human-
+    readable label to show in the UI (falls back to `stepName` when absent).
+  - New `SuspendStepMeta` type added to `WorkflowStepMeta`.
+  - Inspector extracts `workflow.suspend('reason')` calls and emits a
+    `SuspendStepMeta` step with `type: 'suspend'` and `reason`.
+  - `collectNamedSteps` maps a suspend step to
+    `{ stepName: '__workflow_suspend:<reason>', displayName: '<reason>' }`,
+    matching the key the runtime stores so the UI can overlay live status
+    onto the planned position.
+
+- Updated dependencies [7b5b10a]
+  - @pikku/core@0.12.42
+
+## 0.12.28
+
+### Patch Changes
+
+- 66d43d1: Add `deploy.defaultTarget` to `pikku.config.json` to override the default deploy target ('serverless') for functions without an explicit `deploy` flag.
+- a8c9e6d: feat(inspector): add PKU940 — block type casts on rpc.invoke() calls
+
+  The inspector now emits a critical PKU940 error when `rpc.invoke()` is called
+  with an `as` cast on an argument (`rpc.invoke('fn', data as any)`) or when its
+  result is cast (`rpc.invoke('fn', data) as any`). Both patterns defeat Pikku's
+  generated type safety and are rejected at build time.
+
+- ba1ab08: refactor(workflow): replace `inline: false` with `workflowQueued: true` on function meta
+
+  The per-function workflow dispatch flag has been renamed from the confusing
+  negative `inline: false` to the explicit positive `workflowQueued: true`.
+  Two companion fields are also added: `workflowRetries` and `workflowTimeout`
+  as function-level equivalents of the per-call-site `NodeOptions` fields.
+
+  **Breaking change (patch — flag was undocumented):** rename `inline: false`
+  to `workflowQueued: true` on any `pikkuSessionlessFunc` / `pikkuFunc` that
+  dispatches its workflow steps via the queue.
+
+  **Behaviour change:** a step marked `workflowQueued: true` now throws if no
+  queue service is configured, instead of silently falling back to inline
+  execution.
+
+  **Bug fix:** `post-process.ts` was registering `wf-step-*` queues for every
+  workflow step node; it now only registers them for steps that are actually
+  `workflowQueued: true`, avoiding spurious queue resource allocation.
+
+- Updated dependencies [ba1ab08]
+  - @pikku/core@0.12.40
+
 ## 0.12.27
 
 ### Patch Changes

package/dist/add/add-file-with-factory.js

@@ -8,6 +8,7 @@ const wrapperFunctionMap = {
     pikkuAddonServices: 'CreateSingletonServices',
     pikkuWireServices: 'CreateWireServices',
     pikkuAddonWireServices: 'CreateWireServices',
+    pikkuServerLifecycle: 'ServerLifecycle',
 };
 export const addFileWithFactory = (node, checker, methods = new Map(), expectedTypeName, state) => {
     if (ts.isVariableDeclaration(node)) {

package/dist/add/add-functions.js

@@ -277,7 +277,9 @@ export const addFunctions = (logger, node, checker, state, options) => {
     let deploy;
     let approvalRequired;
     let approvalDescription;
-    let inline;
+    let workflowQueued;
+    let workflowRetries;
+    let workflowTimeout;
     let version;
     let objectNode;
     let nodeDisplayName = null;
@@ -345,7 +347,9 @@ export const addFunctions = (logger, node, checker, state, options) => {
         readonly_ = getPropertyValue(firstArg, 'readonly');
         deploy = getPropertyValue(firstArg, 'deploy');
         approvalRequired = getPropertyValue(firstArg, 'approvalRequired');
-        inline = getPropertyValue(firstArg, 'inline');
+        workflowQueued = getPropertyValue(firstArg, 'workflowQueued');
+        workflowRetries = getPropertyValue(firstArg, 'workflowRetries');
+        workflowTimeout = getPropertyValue(firstArg, 'workflowTimeout');
         // Extract approvalDescription identifier reference
         for (const prop of firstArg.properties) {
             if (ts.isPropertyAssignment(prop) &&
@@ -740,7 +744,9 @@ export const addFunctions = (logger, node, checker, state, options) => {
         deploy: deploy || undefined,
         approvalRequired: approvalRequired || undefined,
         approvalDescription: approvalDescription || undefined,
-        inline: inline === false ? false : undefined,
+        workflowQueued: workflowQueued === true ? true : undefined,
+        workflowRetries: workflowRetries ?? undefined,
+        workflowTimeout: workflowTimeout ?? undefined,
         implementationHash,
         version,
         title,

package/dist/add/add-rpc-invocations.js

@@ -1,4 +1,18 @@
 import * as ts from 'typescript';
+import { ErrorCode } from '../error-codes.js';
+function hasTypeCast(node) {
+    return ts.isAsExpression(node) || ts.isTypeAssertionExpression(node);
+}
+function outerParent(node) {
+    let p = node.parent;
+    while (p && (ts.isAwaitExpression(p) || ts.isParenthesizedExpression(p))) {
+        p = p.parent;
+    }
+    return p;
+}
+function findCastArg(args) {
+    return args.find(hasTypeCast);
+}
 /**
  * Helper to extract namespace from a namespaced function reference like 'ext:hello'
  */
@@ -52,6 +66,19 @@ export function addRPCInvocations(node, state, logger) {
             expression.name.text === 'invoke' &&
             ts.isIdentifier(expression.expression) &&
             expression.expression.text === 'rpc') {
+            // Skip PKU940 for generated files — they may contain intentional casts
+            // (e.g. the paginated useInfiniteQuery hook in pikku-react-query.gen.ts).
+            const sourceFileName = node.getSourceFile().fileName;
+            const isGenerated = sourceFileName.endsWith('.gen.ts') || sourceFileName.endsWith('.gen.js');
+            if (!isGenerated) {
+                if (hasTypeCast(outerParent(node))) {
+                    logger.critical(ErrorCode.RPC_INVOCATION_TYPE_CAST, `rpc.invoke() result is type-cast — remove the 'as' expression and rely on Pikku's generated types`);
+                }
+                const castArg = findCastArg(args);
+                if (castArg) {
+                    logger.critical(ErrorCode.RPC_INVOCATION_TYPE_CAST, `rpc.invoke() has a type cast on an argument — remove the 'as' expression and rely on Pikku's generated types`);
+                }
+            }
             const [firstArg] = args;
             if (firstArg) {
                 if (ts.isStringLiteral(firstArg)) {

package/dist/error-codes.d.ts

@@ -59,7 +59,8 @@ export declare enum ErrorCode {
     WORKFLOW_MULTI_QUEUE_NOT_SUPPORTED = "PKU901",
     PII_IN_OUTPUT = "PKU910",
     ADDON_WIRING_NOT_ALLOWED = "PKU920",
-    ADDON_CONTRACT_HANDLERS_NOT_ALLOWED = "PKU921"
+    ADDON_CONTRACT_HANDLERS_NOT_ALLOWED = "PKU921",
+    RPC_INVOCATION_TYPE_CAST = "PKU940"
 }
 /**
  * Severity of a tracked, coded diagnostic. `critical` always blocks the build;

package/dist/error-codes.js

@@ -75,4 +75,5 @@ export var ErrorCode;
     // Addon authoring errors
     ErrorCode["ADDON_WIRING_NOT_ALLOWED"] = "PKU920";
     ErrorCode["ADDON_CONTRACT_HANDLERS_NOT_ALLOWED"] = "PKU921";
+    ErrorCode["RPC_INVOCATION_TYPE_CAST"] = "PKU940";
 })(ErrorCode || (ErrorCode = {}));

package/dist/inspector.js

@@ -30,7 +30,9 @@ export function getInitialInspectorState(rootDir) {
         wireServicesFactories: new Map(),
         wireServicesMeta: new Map(),
         addonRequiredParentServices: [],
+        addonServerlessIncompatible: new Map(),
         configFactories: new Map(),
+        serverLifecycleFactories: new Map(),
         filesAndMethods: {},
         filesAndMethodsErrors: new Map(),
         typesLookup: new Map(),

package/dist/types.d.ts

@@ -196,6 +196,7 @@ export type InspectorFilters = {
     target?: Array<'serverless' | 'server'>;
     excludeTarget?: Array<'serverless' | 'server'>;
     serverlessIncompatible?: string[];
+    defaultTarget?: 'serverless' | 'server';
 };
 export type AddonConfig = {
     package: string;
@@ -302,6 +303,12 @@ export interface InspectorFilesAndMethods {
         type: string;
         typePath: string;
     };
+    serverLifecycleFactory?: {
+        file: string;
+        variable: string;
+        type: string;
+        typePath: string;
+    };
 }
 export interface InspectorDiagnostic {
     code: string;
@@ -353,7 +360,9 @@ export interface InspectorState {
     wireServicesFactories: PathToNameAndType;
     wireServicesMeta: Map<string, string[]>;
     addonRequiredParentServices: string[];
+    addonServerlessIncompatible: Map<string, string[]>;
     configFactories: PathToNameAndType;
+    serverLifecycleFactories: PathToNameAndType;
     filesAndMethods: InspectorFilesAndMethods;
     filesAndMethodsErrors: Map<string, PathToNameAndType>;
     typesLookup: Map<string, ts.Type[]>;

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

@@ -256,9 +256,10 @@ export function filterInspectorState(state, filters, logger) {
             ? new Set(filters.excludeTarget)
             : null;
         const incompatible = new Set(filters.serverlessIncompatible ?? []);
+        const defaultTarget = filters.defaultTarget ?? 'serverless';
         keptByDeploy = new Set();
         for (const [funcId, funcMeta] of Object.entries(state.functions.meta)) {
-            const target = resolveDeployTarget(funcMeta, incompatible, funcId);
+            const target = resolveDeployTarget(funcMeta, incompatible, funcId, defaultTarget);
             if (allowed && !allowed.has(target))
                 continue;
             if (excluded && excluded.has(target))
@@ -761,10 +762,10 @@ export function filterInspectorState(state, filters, logger) {
         filteredState.requiredSchemas = prunedSchemas;
     }
     // Step dispatch is decided purely per-function: a workflow step runs via the
-    // queue only when its function opts out of inline execution (inline: false).
-    // Such a unit needs workflowService + queueService injected even though the
-    // function itself doesn't reference them. Check the ORIGINAL graph meta
-    // (before filtering pruned it).
+    // queue only when its function is marked `workflowQueued: true`. Such a unit
+    // needs workflowService + queueService injected even though the function
+    // itself doesn't reference them. Check the ORIGINAL graph meta (before
+    // filtering pruned it).
     const survivingFuncIds = new Set(Object.keys(filteredState.functions.meta));
     const resolveFuncId = (rpcName) => filteredState.rpc.internalMeta[rpcName] ??
         filteredState.rpc.exposedMeta[rpcName] ??
@@ -782,7 +783,7 @@ export function filterInspectorState(state, filters, logger) {
                 continue;
             const funcMeta = (filteredState.functions.meta[funcId] ??
                 filteredState.functions.meta[rpcName]);
-            if (funcMeta?.inline === false) {
+            if (funcMeta?.workflowQueued === true) {
                 filteredState.serviceAggregation.requiredServices.add('workflowService');
                 filteredState.serviceAggregation.requiredServices.add('queueService');
             }

package/dist/utils/get-files-and-methods.d.ts

@@ -13,9 +13,10 @@ export type FilesAndMethods = {
     pikkuConfigFactory: Meta;
     singletonServicesFactory: Meta;
     wireServicesFactory: Meta;
+    serverLifecycleFactory: Meta;
 };
 export type FilesAndMethodsErrors = Map<string, PathToNameAndType>;
-export declare const getFilesAndMethods: ({ singletonServicesTypeImportMap, wireServicesTypeImportMap, userSessionTypeImportMap, configTypeImportMap, wireServicesFactories, singletonServicesFactories, configFactories, }: InspectorState, { configFileType, userSessionType, singletonServicesFactoryType, wireServicesFactoryType, }?: InspectorOptions["types"]) => {
+export declare const getFilesAndMethods: ({ singletonServicesTypeImportMap, wireServicesTypeImportMap, userSessionTypeImportMap, configTypeImportMap, wireServicesFactories, singletonServicesFactories, configFactories, serverLifecycleFactories, }: InspectorState, { configFileType, userSessionType, singletonServicesFactoryType, wireServicesFactoryType, }?: InspectorOptions["types"]) => {
     result: Partial<FilesAndMethods>;
     errors: FilesAndMethodsErrors;
 };

package/dist/utils/get-files-and-methods.js

@@ -46,7 +46,7 @@ const getMetaTypes = (type, map, desiredType, errors) => {
     }
     return;
 };
-export const getFilesAndMethods = ({ singletonServicesTypeImportMap, wireServicesTypeImportMap, userSessionTypeImportMap, configTypeImportMap, wireServicesFactories, singletonServicesFactories, configFactories, }, { configFileType, userSessionType, singletonServicesFactoryType, wireServicesFactoryType, } = {}) => {
+export const getFilesAndMethods = ({ singletonServicesTypeImportMap, wireServicesTypeImportMap, userSessionTypeImportMap, configTypeImportMap, wireServicesFactories, singletonServicesFactories, configFactories, serverLifecycleFactories, }, { configFileType, userSessionType, singletonServicesFactoryType, wireServicesFactoryType, } = {}) => {
     const errors = new Map();
     const result = {
         userSessionType: getMetaTypes('CoreUserSession', userSessionTypeImportMap, userSessionType, errors),
@@ -56,6 +56,7 @@ export const getFilesAndMethods = ({ singletonServicesTypeImportMap, wireService
         pikkuConfigFactory: getMetaTypes('CoreConfig', configFactories, configFileType, errors),
         singletonServicesFactory: getMetaTypes('CreateSingletonServices', singletonServicesFactories, singletonServicesFactoryType, errors),
         wireServicesFactory: getMetaTypes('CreateWireServices', wireServicesFactories, wireServicesFactoryType, errors),
+        serverLifecycleFactory: getMetaTypes('ServerLifecycle', serverLifecycleFactories),
     };
     return { result, errors };
 };

package/dist/utils/load-addon-functions-meta.js

@@ -134,6 +134,20 @@ export async function loadAddonFunctionsMeta(logger, state) {
             catch {
                 // No variables meta — that's fine
             }
+            // Load addon serverlessIncompatible service names from pikku-addon-meta.gen.json
+            try {
+                const addonMetaPath = require.resolve(`${decl.package}/.pikku/console/pikku-addon-meta.gen.json`);
+                const addonMetaRaw = await readFile(addonMetaPath, 'utf-8');
+                const addonMeta = JSON.parse(addonMetaRaw);
+                if (Array.isArray(addonMeta.serverlessIncompatible) &&
+                    addonMeta.serverlessIncompatible.length > 0) {
+                    state.addonServerlessIncompatible.set(namespace, addonMeta.serverlessIncompatible);
+                    logger.debug(`Addon '${namespace}' marks [${addonMeta.serverlessIncompatible.join(', ')}] as serverless-incompatible`);
+                }
+            }
+            catch {
+                // No addon meta or no serverlessIncompatible declared — that's fine
+            }
             // Load addon required parent services from pikku-services.gen
             try {
                 const servicesGenPath = require.resolve(`${decl.package}/.pikku/pikku-services.gen.js`);

package/dist/utils/post-process.js

@@ -220,11 +220,18 @@ export function aggregateRequiredServices(state) {
                 pikkuFuncId: `pikkuWorkflowOrchestrator:${graph.name}`,
             };
         }
-        // Per-step queues
+        // Per-step queues — only for steps explicitly marked workflowQueued: true
         for (const node of Object.values(graph.nodes)) {
             if (!('rpcName' in node) || !node.rpcName)
                 continue;
             const rpcName = node.rpcName;
+            const funcId = state.rpc?.internalMeta?.[rpcName] ??
+                state.rpc?.exposedMeta?.[rpcName] ??
+                rpcName;
+            const funcMeta = (state.functions.meta[funcId] ??
+                state.functions.meta[rpcName]);
+            if (funcMeta?.workflowQueued !== true)
+                continue;
             const stepQueueName = `wf-step-${toKebab(rpcName)}`;
             if (!state.queueWorkers.meta[stepQueueName]) {
                 state.queueWorkers.meta[stepQueueName] = {

package/dist/utils/resolve-deploy-target.d.ts

@@ -18,11 +18,12 @@ export declare class IncompatibleDeployTargetError extends Error {
  *      - throw if the function explicitly declares `deploy: 'serverless'`
  *      - otherwise target is 'server'
  *   2. Explicit `funcMeta.deploy: 'serverless' | 'server'`
- *   3. Default 'serverless'
+ *   3. `defaultTarget` (sourced from `pikku.config.json` →
+ *      `deploy.defaultTarget`, falling back to 'serverless')
  *
  * Used both by the per-unit deploy analyzer (when bucketing functions
  * into deployment units) and by `filterInspectorState` (when
  * `pikku all --deploy <target>` is used to emit a target-scoped set
  * of gen files).
  */
-export declare function resolveDeployTarget(funcMeta: Pick<FunctionMeta, 'deploy' | 'services'>, serverlessIncompatible: Set<string>, functionName?: string): 'serverless' | 'server';
+export declare function resolveDeployTarget(funcMeta: Pick<FunctionMeta, 'deploy' | 'services'>, serverlessIncompatible: Set<string>, functionName?: string, defaultTarget?: 'serverless' | 'server'): 'serverless' | 'server';

package/dist/utils/resolve-deploy-target.js

@@ -25,14 +25,15 @@ export class IncompatibleDeployTargetError extends Error {
  *      - throw if the function explicitly declares `deploy: 'serverless'`
  *      - otherwise target is 'server'
  *   2. Explicit `funcMeta.deploy: 'serverless' | 'server'`
- *   3. Default 'serverless'
+ *   3. `defaultTarget` (sourced from `pikku.config.json` →
+ *      `deploy.defaultTarget`, falling back to 'serverless')
  *
  * Used both by the per-unit deploy analyzer (when bucketing functions
  * into deployment units) and by `filterInspectorState` (when
  * `pikku all --deploy <target>` is used to emit a target-scoped set
  * of gen files).
  */
-export function resolveDeployTarget(funcMeta, serverlessIncompatible, functionName = '<unknown>') {
+export function resolveDeployTarget(funcMeta, serverlessIncompatible, functionName = '<unknown>', defaultTarget = 'serverless') {
     // Service compatibility wins over the explicit flag — a serverless
     // bundle of a function that needs (e.g.) node:fs would crash at runtime.
     const incompatibleHits = [];
@@ -52,5 +53,5 @@ export function resolveDeployTarget(funcMeta, serverlessIncompatible, functionNa
         return 'server';
     if (funcMeta.deploy === 'serverless')
         return 'serverless';
-    return 'serverless';
+    return defaultTarget;
 }

package/dist/utils/serialize-inspector-state.d.ts

@@ -56,6 +56,7 @@ export interface SerializableInspectorState {
     ]>;
     wireServicesMeta: Array<[string, string[]]>;
     addonRequiredParentServices: string[];
+    addonServerlessIncompatible: Array<[string, string[]]>;
     configFactories: Array<[
         string,
         {
@@ -64,6 +65,14 @@ export interface SerializableInspectorState {
             typePath: string | null;
         }[]
     ]>;
+    serverLifecycleFactories: Array<[
+        string,
+        {
+            variable: string;
+            type: string | null;
+            typePath: string | null;
+        }[]
+    ]>;
     filesAndMethods: InspectorState['filesAndMethods'];
     filesAndMethodsErrors: Array<[
         string,

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

@@ -24,7 +24,9 @@ export function serializeInspectorState(state) {
         wireServicesFactories: Array.from(state.wireServicesFactories.entries()),
         wireServicesMeta: Array.from(state.wireServicesMeta.entries()),
         addonRequiredParentServices: state.addonRequiredParentServices,
+        addonServerlessIncompatible: Array.from(state.addonServerlessIncompatible.entries()),
         configFactories: Array.from(state.configFactories.entries()),
+        serverLifecycleFactories: Array.from(state.serverLifecycleFactories.entries()),
         filesAndMethods: state.filesAndMethods,
         filesAndMethodsErrors: Array.from(state.filesAndMethodsErrors.entries()).map(([key, mapValue]) => [key, Array.from(mapValue.entries())]),
         schemaLookup: Array.from(state.schemaLookup.entries()),
@@ -176,7 +178,9 @@ export function deserializeInspectorState(data) {
         wireServicesFactories: new Map(data.wireServicesFactories),
         wireServicesMeta: new Map(data.wireServicesMeta),
         addonRequiredParentServices: data.addonRequiredParentServices || [],
+        addonServerlessIncompatible: new Map(data.addonServerlessIncompatible || []),
         configFactories: new Map(data.configFactories),
+        serverLifecycleFactories: new Map(data.serverLifecycleFactories),
         filesAndMethods: data.filesAndMethods,
         filesAndMethodsErrors: new Map(data.filesAndMethodsErrors.map(([key, entries]) => [
             key,

package/dist/utils/workflow/derive-workflow-plan.js

@@ -43,6 +43,15 @@ function containsLoop(steps) {
 function containsConditional(steps) {
     return steps.some((step) => step.type === 'branch' || step.type === 'switch');
 }
+/**
+ * Turn an internal snake/kebab reason key into a sentence-case display label.
+ * e.g. "awaiting_approval" → "Awaiting approval", "building-image" → "Building image"
+ */
+function reasonToLabel(reason) {
+    return reason
+        .replace(/[-_]/g, ' ')
+        .replace(/^(.)/, (c) => c.toUpperCase());
+}
 /** Flatten named steps (rpc/inline/sleep/parallel children) in source order. */
 function collectNamedSteps(steps) {
     const planned = [];
@@ -53,6 +62,16 @@ function collectNamedSteps(steps) {
             case 'sleep':
                 planned.push({ stepName: step.stepName });
                 break;
+            case 'suspend':
+                // Runtime stores the suspend step as `__workflow_suspend:${reason}`.
+                // We surface it in the planned ladder with a readable displayName so
+                // the UI shows it in the right position instead of appending it at the
+                // bottom as an unrecognised orphan.
+                planned.push({
+                    stepName: `__workflow_suspend:${step.reason}`,
+                    displayName: reasonToLabel(step.reason),
+                });
+                break;
             case 'parallel':
                 for (const child of step.children) {
                     planned.push({ stepName: child.stepName });

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

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import { isWorkflowDoCall, isWorkflowSleepCall, isThrowCancelException, extractCancelReason, isParallelFanout, isParallelGroup, isSequentialFanout, isArrayFilter, isArraySome, isArrayEvery, extractForOfVariable, isArrayType, getSourceText, extractSourcePath, } from './patterns.js';
+import { isWorkflowDoCall, isWorkflowSleepCall, isWorkflowSuspendCall, 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';
 /**
@@ -360,6 +360,9 @@ function extractExpressionStatement(statement, context) {
         if (isWorkflowSleepCall(call, context.checker)) {
             return extractSleepStep(call, context);
         }
+        if (isWorkflowSuspendCall(call, context.checker)) {
+            return extractSuspendStep(call, context);
+        }
         // Check for parallel group or fanout
         if (isParallelFanout(call)) {
             return extractParallelFanout(call, context);
@@ -513,6 +516,28 @@ function extractSleepStep(call, context) {
         return null;
     }
 }
+/**
+ * Extract suspend step from workflow.suspend() call
+ */
+function extractSuspendStep(call, context) {
+    const args = call.arguments;
+    if (args.length < 1)
+        return null;
+    try {
+        const reason = extractStringLiteral(args[0], context.checker);
+        return {
+            type: 'suspend',
+            reason,
+        };
+    }
+    catch (error) {
+        context.errors.push({
+            message: `Failed to extract suspend step: ${error instanceof Error ? error.message : String(error)}`,
+            node: call,
+        });
+        return null;
+    }
+}
 /**
  * Extract cancel step from throw WorkflowCancelledException statement
  */

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

@@ -10,6 +10,10 @@ export declare function isWorkflowDoCall(node: ts.CallExpression, checker: ts.Ty
  * Check if a call expression is workflow.sleep()
  */
 export declare function isWorkflowSleepCall(node: ts.CallExpression, checker: ts.TypeChecker): boolean;
+/**
+ * Check if a call expression is workflow.suspend()
+ */
+export declare function isWorkflowSuspendCall(node: ts.CallExpression, _checker: ts.TypeChecker): boolean;
 /**
  * Check if a throw statement throws WorkflowCancelledException
  * Matches: throw new WorkflowCancelledException(...) or throw WorkflowCancelledException(...)

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

@@ -26,6 +26,18 @@ export function isWorkflowSleepCall(node, checker) {
         ts.isIdentifier(propAccess.expression) &&
         propAccess.expression.text === 'workflow');
 }
+/**
+ * Check if a call expression is workflow.suspend()
+ */
+export function isWorkflowSuspendCall(node, _checker) {
+    if (!ts.isPropertyAccessExpression(node.expression)) {
+        return false;
+    }
+    const propAccess = node.expression;
+    return (propAccess.name.text === 'suspend' &&
+        ts.isIdentifier(propAccess.expression) &&
+        propAccess.expression.text === 'workflow');
+}
 /**
  * Check if a throw statement throws WorkflowCancelledException
  * Matches: throw new WorkflowCancelledException(...) or throw WorkflowCancelledException(...)

package/dist/utils/workflow/graph/workflow-graph.types.d.ts

@@ -62,8 +62,6 @@ export interface NodeOptions {
     retryDelay?: string;
     /** Timeout for node execution (e.g., '30s', '5m') */
     timeout?: string;
-    /** If true, execute via queue (async). Default: false (inline) */
-    async?: boolean;
 }
 /**
  * Flow node types for control flow (no RPC call)

package/dist/visit.js

@@ -33,6 +33,7 @@ export const visitSetup = (logger, checker, node, state, options) => {
     addFileWithFactory(node, checker, state.singletonServicesFactories, 'CreateSingletonServices', state);
     addFileWithFactory(node, checker, state.wireServicesFactories, 'CreateWireServices', state);
     addFileWithFactory(node, checker, state.configFactories, 'CreateConfig');
+    addFileWithFactory(node, checker, state.serverLifecycleFactories, 'ServerLifecycle');
     addRPCInvocations(node, state, logger);
     addWireAddon(node, state, logger);
     addMiddleware(logger, node, checker, state, options);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/inspector",
-  "version": "0.12.27",
+  "version": "0.12.29",
   "author": "yasser.fadl@gmail.com",
   "license": "BUSL-1.1",
   "type": "module",
@@ -35,7 +35,7 @@
   },
   "dependencies": {
     "@openapi-contrib/json-schema-to-openapi-schema": "^4.3.1",
-    "@pikku/core": "^0.12.39",
+    "@pikku/core": "^0.12.42",
     "openapi-types": "^12.1.3",
     "path-to-regexp": "^8.3.0",
     "ts-json-schema-generator": "^2.5.0",

package/src/add/add-file-with-factory.ts

@@ -10,6 +10,7 @@ const wrapperFunctionMap: Record<string, string> = {
   pikkuAddonServices: 'CreateSingletonServices',
   pikkuWireServices: 'CreateWireServices',
   pikkuAddonWireServices: 'CreateWireServices',
+  pikkuServerLifecycle: 'ServerLifecycle',
 }
 
 export const addFileWithFactory = (

package/src/add/add-functions.ts

@@ -392,7 +392,9 @@ export const addFunctions: AddWiring = (
   let deploy: 'serverless' | 'server' | 'auto' | undefined
   let approvalRequired: boolean | undefined
   let approvalDescription: string | undefined
-  let inline: boolean | undefined
+  let workflowQueued: boolean | undefined
+  let workflowRetries: number | undefined
+  let workflowTimeout: string | undefined
   let version: number | undefined
   let objectNode: ts.ObjectLiteralExpression | undefined
   let nodeDisplayName: string | null = null
@@ -488,7 +490,9 @@ export const addFunctions: AddWiring = (
     approvalRequired = getPropertyValue(firstArg, 'approvalRequired') as
       | boolean
       | undefined
-    inline = getPropertyValue(firstArg, 'inline') as boolean | undefined
+    workflowQueued = getPropertyValue(firstArg, 'workflowQueued') as boolean | undefined
+    workflowRetries = getPropertyValue(firstArg, 'workflowRetries') as number | undefined
+    workflowTimeout = getPropertyValue(firstArg, 'workflowTimeout') as string | undefined
 
     // Extract approvalDescription identifier reference
     for (const prop of firstArg.properties) {
@@ -1027,7 +1031,9 @@ export const addFunctions: AddWiring = (
     deploy: deploy || undefined,
     approvalRequired: approvalRequired || undefined,
     approvalDescription: approvalDescription || undefined,
-    inline: inline === false ? false : undefined,
+    workflowQueued: workflowQueued === true ? true : undefined,
+    workflowRetries: workflowRetries ?? undefined,
+    workflowTimeout: workflowTimeout ?? undefined,
     implementationHash,
     version,
     title,

package/src/add/add-rpc-invocations.ts

@@ -1,5 +1,24 @@
 import * as ts from 'typescript'
 import type { InspectorState, InspectorLogger } from '../types.js'
+import { ErrorCode } from '../error-codes.js'
+
+function hasTypeCast(node: ts.Node): boolean {
+  return ts.isAsExpression(node) || ts.isTypeAssertionExpression(node)
+}
+
+function outerParent(node: ts.Node): ts.Node {
+  let p = node.parent
+  while (p && (ts.isAwaitExpression(p) || ts.isParenthesizedExpression(p))) {
+    p = p.parent
+  }
+  return p
+}
+
+function findCastArg(
+  args: ts.NodeArray<ts.Expression>
+): ts.Expression | undefined {
+  return args.find(hasTypeCast)
+}
 
 /**
  * Helper to extract namespace from a namespaced function reference like 'ext:hello'
@@ -67,6 +86,28 @@ export function addRPCInvocations(
       ts.isIdentifier(expression.expression) &&
       expression.expression.text === 'rpc'
     ) {
+      // Skip PKU940 for generated files — they may contain intentional casts
+      // (e.g. the paginated useInfiniteQuery hook in pikku-react-query.gen.ts).
+      const sourceFileName = node.getSourceFile().fileName
+      const isGenerated =
+        sourceFileName.endsWith('.gen.ts') || sourceFileName.endsWith('.gen.js')
+      if (!isGenerated) {
+        if (hasTypeCast(outerParent(node))) {
+          logger.critical(
+            ErrorCode.RPC_INVOCATION_TYPE_CAST,
+            `rpc.invoke() result is type-cast — remove the 'as' expression and rely on Pikku's generated types`
+          )
+        }
+
+        const castArg = findCastArg(args)
+        if (castArg) {
+          logger.critical(
+            ErrorCode.RPC_INVOCATION_TYPE_CAST,
+            `rpc.invoke() has a type cast on an argument — remove the 'as' expression and rely on Pikku's generated types`
+          )
+        }
+      }
+
       const [firstArg] = args
       if (firstArg) {
         if (ts.isStringLiteral(firstArg)) {