@pikku/inspector 0.12.27 → 0.12.28

package/CHANGELOG.md

@@ -1,3 +1,37 @@
+## 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-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/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;

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/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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/inspector",
-  "version": "0.12.27",
+  "version": "0.12.28",
   "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.40",
     "openapi-types": "^12.1.3",
     "path-to-regexp": "^8.3.0",
     "ts-json-schema-generator": "^2.5.0",

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)) {

package/src/add/rpc-type-cast.test.ts

@@ -0,0 +1,123 @@
+import { strict as assert } from 'assert'
+import { describe, test } from 'node:test'
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { inspect } from '../inspector.js'
+import { ErrorCode } from '../error-codes.js'
+import type { InspectorLogger } from '../types.js'
+
+function makeLogger() {
+  const criticals: Array<{ code: ErrorCode; message: string }> = []
+  const logger: InspectorLogger = {
+    debug: () => {},
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    diagnostic: ({ code, message }) => criticals.push({ code, message }),
+    critical: (code, message) => criticals.push({ code, message }),
+    hasCriticalErrors: () => criticals.length > 0,
+  }
+  return { logger, criticals }
+}
+
+async function runInspect(sourceCode: string) {
+  const tmpDir = await mkdtemp(join(tmpdir(), 'pikku-rpc-cast-test-'))
+  const file = join(tmpDir, 'funcs.ts')
+  await writeFile(file, sourceCode)
+  const { logger, criticals } = makeLogger()
+  try {
+    await inspect(logger, [file], { rootDir: tmpDir })
+  } finally {
+    await rm(tmpDir, { recursive: true, force: true })
+  }
+  return criticals
+}
+
+describe('RPC type-cast check — PKU940', () => {
+  test('flags rpc.invoke() with an as-cast on an argument', async () => {
+    const criticals = await runInspect(`
+declare const rpc: { invoke: (name: string, data: unknown) => Promise<unknown> }
+export async function doWork() {
+  return rpc.invoke('someFunction', { id: 1 } as any)
+}
+`)
+    const hit = criticals.find(
+      (c) => c.code === ErrorCode.RPC_INVOCATION_TYPE_CAST
+    )
+    assert.ok(hit, `Expected PKU940 but got: ${JSON.stringify(criticals)}`)
+  })
+
+  test('flags rpc.invoke() with an angle-bracket cast on an argument', async () => {
+    const criticals = await runInspect(`
+declare const rpc: { invoke: (name: string, data: unknown) => Promise<unknown> }
+export async function doWork() {
+  return rpc.invoke('someFunction', <any>{ id: 1 })
+}
+`)
+    const hit = criticals.find(
+      (c) => c.code === ErrorCode.RPC_INVOCATION_TYPE_CAST
+    )
+    assert.ok(hit, `Expected PKU940 but got: ${JSON.stringify(criticals)}`)
+  })
+
+  test('flags rpc.invoke() result cast with as any', async () => {
+    const criticals = await runInspect(`
+declare const rpc: { invoke: (name: string, data: unknown) => Promise<unknown> }
+export async function doWork() {
+  return (rpc.invoke('someFunction', { id: 1 }) as any)
+}
+`)
+    const hit = criticals.find(
+      (c) => c.code === ErrorCode.RPC_INVOCATION_TYPE_CAST
+    )
+    assert.ok(hit, `Expected PKU940 but got: ${JSON.stringify(criticals)}`)
+  })
+
+  test('flags rpc.invoke() result cast with as never', async () => {
+    const criticals = await runInspect(`
+declare const rpc: { invoke: (name: string, data: unknown) => Promise<unknown> }
+export async function doWork() {
+  return (rpc.invoke('someFunction', { id: 1 }) as never)
+}
+`)
+    const hit = criticals.find(
+      (c) => c.code === ErrorCode.RPC_INVOCATION_TYPE_CAST
+    )
+    assert.ok(hit, `Expected PKU940 but got: ${JSON.stringify(criticals)}`)
+  })
+
+  test('does not flag a clean rpc.invoke() call', async () => {
+    const criticals = await runInspect(`
+declare const rpc: { invoke: (name: string, data: unknown) => Promise<unknown> }
+export async function doWork() {
+  return rpc.invoke('someFunction', { id: 1 })
+}
+`)
+    const hit = criticals.find(
+      (c) => c.code === ErrorCode.RPC_INVOCATION_TYPE_CAST
+    )
+    assert.equal(
+      hit,
+      undefined,
+      `Expected no PKU940 but got: ${JSON.stringify(hit)}`
+    )
+  })
+
+  test('does not flag as-casts on unrelated calls', async () => {
+    const criticals = await runInspect(`
+declare function otherFn(data: unknown): Promise<unknown>
+export async function doWork() {
+  return otherFn({ id: 1 } as any)
+}
+`)
+    const hit = criticals.find(
+      (c) => c.code === ErrorCode.RPC_INVOCATION_TYPE_CAST
+    )
+    assert.equal(
+      hit,
+      undefined,
+      `Expected no PKU940 but got: ${JSON.stringify(hit)}`
+    )
+  })
+})

package/src/error-codes.ts

@@ -88,6 +88,8 @@ export enum ErrorCode {
   // Addon authoring errors
   ADDON_WIRING_NOT_ALLOWED = 'PKU920',
   ADDON_CONTRACT_HANDLERS_NOT_ALLOWED = 'PKU921',
+
+  RPC_INVOCATION_TYPE_CAST = 'PKU940',
 }
 
 /**

package/src/types.ts

@@ -263,6 +263,10 @@ export type InspectorFilters = {
   // to 'server'. Sourced from `pikku.config.json` →
   // `deploy.serverlessIncompatible`. Used only when deploy filters are set.
   serverlessIncompatible?: string[]
+  // Default deploy target for functions without an explicit `deploy` flag.
+  // Sourced from `pikku.config.json` → `deploy.defaultTarget`. Used only
+  // when deploy filters are set. Defaults to 'serverless'.
+  defaultTarget?: 'serverless' | 'server'
 }
 
 export type AddonConfig = {

package/src/utils/filter-inspector-state.ts

@@ -340,9 +340,15 @@ export function filterInspectorState(
       ? new Set(filters.excludeTarget)
       : null
     const incompatible = new Set(filters.serverlessIncompatible ?? [])
+    const defaultTarget = filters.defaultTarget ?? 'serverless'
     keptByDeploy = new Set<string>()
     for (const [funcId, funcMeta] of Object.entries(state.functions.meta)) {
-      const target = resolveDeployTarget(funcMeta as any, incompatible, funcId)
+      const target = resolveDeployTarget(
+        funcMeta as any,
+        incompatible,
+        funcId,
+        defaultTarget
+      )
       if (allowed && !allowed.has(target)) continue
       if (excluded && excluded.has(target)) continue
       keptByDeploy.add(funcId)
@@ -1062,10 +1068,10 @@ export function filterInspectorState(
   }
 
   // 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: string): string =>
     filteredState.rpc.internalMeta[rpcName] ??
@@ -1081,8 +1087,8 @@ export function filterInspectorState(
       if (!survivingFuncIds.has(funcId) && !survivingFuncIds.has(rpcName))
         continue
       const funcMeta = (filteredState.functions.meta[funcId] ??
-        filteredState.functions.meta[rpcName]) as { inline?: boolean }
-      if (funcMeta?.inline === false) {
+        filteredState.functions.meta[rpcName]) as { workflowQueued?: boolean }
+      if (funcMeta?.workflowQueued === true) {
         filteredState.serviceAggregation.requiredServices.add('workflowService')
         filteredState.serviceAggregation.requiredServices.add('queueService')
       }

package/src/utils/post-process.ts

@@ -290,10 +290,17 @@ export function aggregateRequiredServices(
       }
     }
 
-    // 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 as string
+      const funcId =
+        state.rpc?.internalMeta?.[rpcName] ??
+        state.rpc?.exposedMeta?.[rpcName] ??
+        rpcName
+      const funcMeta = (state.functions.meta[funcId] ??
+        state.functions.meta[rpcName]) as { workflowQueued?: boolean }
+      if (funcMeta?.workflowQueued !== true) continue
       const stepQueueName = `wf-step-${toKebab(rpcName)}`
       if (!state.queueWorkers.meta[stepQueueName]) {
         state.queueWorkers.meta[stepQueueName] = {

package/src/utils/resolve-deploy-target.test.ts

@@ -102,4 +102,34 @@ describe('resolveDeployTarget', () => {
       'server'
     )
   })
+
+  test('defaultTarget: server overrides the serverless default', () => {
+    assert.strictEqual(
+      resolveDeployTarget({}, new Set(), '<unknown>', 'server'),
+      'server'
+    )
+  })
+
+  test('explicit deploy flag wins over defaultTarget', () => {
+    assert.strictEqual(
+      resolveDeployTarget({ deploy: 'serverless' }, new Set(), 'fn', 'server'),
+      'serverless'
+    )
+    assert.strictEqual(
+      resolveDeployTarget({ deploy: 'server' }, new Set(), 'fn', 'serverless'),
+      'server'
+    )
+  })
+
+  test('serverlessIncompatible still forces server regardless of defaultTarget', () => {
+    assert.strictEqual(
+      resolveDeployTarget(
+        { services: { services: ['metaService'] } as any },
+        new Set(['metaService']),
+        'fn',
+        'serverless'
+      ),
+      'server'
+    )
+  })
 })

package/src/utils/resolve-deploy-target.ts

@@ -29,7 +29,8 @@ 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
@@ -39,7 +40,8 @@ export class IncompatibleDeployTargetError extends Error {
 export function resolveDeployTarget(
   funcMeta: Pick<FunctionMeta, 'deploy' | 'services'>,
   serverlessIncompatible: Set<string>,
-  functionName = '<unknown>'
+  functionName = '<unknown>',
+  defaultTarget: 'serverless' | 'server' = 'serverless'
 ): 'serverless' | 'server' {
   // Service compatibility wins over the explicit flag — a serverless
   // bundle of a function that needs (e.g.) node:fs would crash at runtime.
@@ -59,5 +61,5 @@ export function resolveDeployTarget(
 
   if (funcMeta.deploy === 'server') return 'server'
   if (funcMeta.deploy === 'serverless') return 'serverless'
-  return 'serverless'
+  return defaultTarget
 }

package/src/utils/workflow/graph/workflow-graph.types.ts

@@ -87,8 +87,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
 }
 
 /**