@pikku/inspector 0.12.16 → 0.12.18

package/src/utils/custom-types-generator.ts

@@ -11,6 +11,61 @@ export function sanitizeTypeName(name: string): string {
   return name.replace(/[^a-zA-Z0-9_$]/g, '_')
 }
 
+const CLASSIFICATION_WRAPPERS = new Set(['Private', 'Pii', 'Secret'])
+
+function findMatchingAngleBracket(type: string, startIndex: number): number {
+  let depth = 0
+  for (let i = startIndex; i < type.length; i += 1) {
+    const char = type[i]
+    if (char === '<') {
+      depth += 1
+      continue
+    }
+    if (char === '>' && (i === 0 || type[i - 1] !== '=')) {
+      depth -= 1
+      if (depth === 0) {
+        return i
+      }
+    }
+  }
+  return -1
+}
+
+function stripClassificationWrappers(type: string): string {
+  let output = ''
+  let index = 0
+
+  while (index < type.length) {
+    const char = type[index]
+    if (!/[A-Za-z_$]/.test(char)) {
+      output += char
+      index += 1
+      continue
+    }
+
+    let end = index + 1
+    while (end < type.length && /[A-Za-z0-9_$]/.test(type[end])) {
+      end += 1
+    }
+
+    const identifier = type.slice(index, end)
+    if (CLASSIFICATION_WRAPPERS.has(identifier) && type[end] === '<') {
+      const closingIndex = findMatchingAngleBracket(type, end)
+      if (closingIndex !== -1) {
+        const inner = type.slice(end + 1, closingIndex)
+        output += stripClassificationWrappers(inner)
+        index = closingIndex + 1
+        continue
+      }
+    }
+
+    output += identifier
+    index = end
+  }
+
+  return output
+}
+
 export function generateCustomTypes(
   typesMap: TypesMap,
   requiredTypes: Set<string>
@@ -25,12 +80,16 @@ export function generateCustomTypes(
     .map(([originalName, { type, references }]) => {
       const name = sanitizeTypeName(originalName)
       references.forEach((refName) => {
-        if (refName !== '__object' && !refName.startsWith('__object_')) {
+        if (
+          refName !== '__object' &&
+          !refName.startsWith('__object_') &&
+          !CLASSIFICATION_WRAPPERS.has(refName)
+        ) {
           requiredTypes.add(refName)
         }
       })
 
-      const typeString = type
+      const typeString = stripClassificationWrappers(type)
       const typeNameRegex = /\b[A-Z][a-zA-Z0-9]*\b/g
       const potentialTypes = typeString.match(typeNameRegex) || []
 
@@ -59,12 +118,13 @@ export function generateCustomTypes(
         }
       })
 
-      if (name === type) return null
-      return `export type ${name} = ${type}`
+      if (name === typeString) return null
+      return `export type ${name} = ${typeString}`
     })
 
   const importsByPath = new Map<string, Set<string>>()
   for (const typeName of requiredTypes) {
+    if (CLASSIFICATION_WRAPPERS.has(typeName)) continue
     try {
       const typeMeta = typesMap.getTypeMeta(typeName)
       if (typeMeta.path) {

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

@@ -1061,21 +1061,28 @@ export function filterInspectorState(
     filteredState.requiredSchemas = prunedSchemas
   }
 
-  // If any surviving function is a non-inline workflow step, the unit needs
-  // workflowService + queueService even though the function doesn't use them.
-  // Check the ORIGINAL graph meta (before filtering pruned it).
+  // 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).
   const survivingFuncIds = new Set(Object.keys(filteredState.functions.meta))
+  const resolveFuncId = (rpcName: string): string =>
+    filteredState.rpc.internalMeta[rpcName] ??
+    filteredState.rpc.exposedMeta[rpcName] ??
+    rpcName
   // Use the snapshot taken before filtering
   for (const graph of Object.values(originalGraphMeta)) {
     if (!graph.nodes) continue
     for (const node of Object.values(graph.nodes)) {
       if (!('rpcName' in node) || !node.rpcName) continue
       const rpcName = node.rpcName as string
-      if (!survivingFuncIds.has(rpcName)) continue
-      const isInline =
-        (node as { options?: { async?: boolean } }).options?.async !== true &&
-        graph.inline === true
-      if (!isInline) {
+      const funcId = resolveFuncId(rpcName)
+      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.serviceAggregation.requiredServices.add('workflowService')
         filteredState.serviceAggregation.requiredServices.add('queueService')
       }

package/src/utils/schema-generator.ts

@@ -297,7 +297,9 @@ async function batchImportWithRegister(
     logger.debug(`tsx register() batch import failed: ${(e as Error).message}`)
     return null
   } finally {
-    await unregister?.()
+    void Promise.resolve(unregister?.()).catch((e) => {
+      logger.debug(`tsx unregister() failed: ${(e as Error).message}`)
+    })
   }
 }
 
@@ -308,7 +310,7 @@ async function importWithRegister(
   try {
     return await import(sourceFile)
   } finally {
-    await unregister()
+    void Promise.resolve(unregister()).catch(() => {})
   }
 }
 

package/src/utils/workflow/dsl/extract-dsl-workflow.ts

@@ -6,7 +6,6 @@ import type {
   BranchStepMeta,
   ParallelGroupStepMeta,
   FanoutStepMeta,
-  ReturnStepMeta,
   CancelStepMeta,
   SetStepMeta,
   SwitchStepMeta,
@@ -1340,11 +1339,38 @@ function extractOutputBinding(
 function extractReturn(
   statement: ts.ReturnStatement,
   context: ExtractionContext
-): ReturnStepMeta | null {
+): WorkflowStepMeta | null {
   if (!statement.expression) {
     return null
   }
 
+  if (
+    ts.isAwaitExpression(statement.expression) &&
+    ts.isCallExpression(statement.expression.expression)
+  ) {
+    const call = statement.expression.expression
+    if (isWorkflowDoCall(call, context.checker)) {
+      return isInlineDoCall(call)
+        ? extractInlineStep(call, context)
+        : extractRpcStep(call, context)
+    }
+    if (isWorkflowSleepCall(call, context.checker)) {
+      return extractSleepStep(call, context)
+    }
+  }
+
+  if (ts.isCallExpression(statement.expression)) {
+    const call = statement.expression
+    if (isWorkflowDoCall(call, context.checker)) {
+      return isInlineDoCall(call)
+        ? extractInlineStep(call, context)
+        : extractRpcStep(call, context)
+    }
+    if (isWorkflowSleepCall(call, context.checker)) {
+      return extractSleepStep(call, context)
+    }
+  }
+
   if (!ts.isObjectLiteralExpression(statement.expression)) {
     return null
   }

package/src/utils/workflow/graph/convert-dsl-to-graph.ts

@@ -400,7 +400,6 @@ export function convertDslToGraph(
     source,
     description: meta.description,
     tags: meta.tags,
-    inline: meta.inline,
     context: meta.context,
     nodes: nodesRecord,
     entryNodeIds,