@pikku/inspector 0.12.103 → 0.12.107

package/dist/utils/resolve-callee-name.d.ts

@@ -0,0 +1,27 @@
+import * as ts from 'typescript';
+/** The helpers that define or register middleware. */
+export declare const MIDDLEWARE_HELPERS: ReadonlySet<string>;
+/** The helpers that define or register permissions. */
+export declare const PERMISSION_HELPERS: ReadonlySet<string>;
+type NameMatcher = ReadonlySet<string> | ((name: string) => boolean);
+export declare const isNamespaceReceiver: (receiver: ts.Expression, checker: ts.TypeChecker) => boolean;
+/**
+ * Every name a callee answers to, from its spelling at the call site to the
+ * declaration it resolves to: through import and re-export aliases, members
+ * of a namespace import, and `const` bindings of another name.
+ */
+export declare const calleeNames: (expression: ts.Expression, checker: ts.TypeChecker) => readonly string[];
+/**
+ * The pikku helper a call invokes, identified by what its callee resolves to
+ * rather than how it is spelled, so `import { addTagMiddleware as guard }` and
+ * `mw.addTagMiddleware(...)` are seen for what they are.
+ *
+ * The deepest known name wins, because it is the declaration's own: an alias
+ * that happens to look like another helper (`pikkuFunc as pikkuOpenFunc`) is
+ * still the helper it imports. A call inside the body of a helper's own
+ * declaration — the generated `#pikku` wrappers forwarding to `@pikku/core` —
+ * is the helper's implementation, not a use of it, and keeps the meaning its
+ * literal spelling gives it.
+ */
+export declare const resolveCalleeName: (call: ts.CallExpression, checker: ts.TypeChecker, known: NameMatcher) => string | undefined;
+export {};

package/dist/utils/resolve-callee-name.js

@@ -0,0 +1,147 @@
+import * as ts from 'typescript';
+const MAX_DEPTH = 8;
+/** The helpers that define or register middleware. */
+export const MIDDLEWARE_HELPERS = new Set([
+    'pikkuMiddleware',
+    'pikkuMiddlewareFactory',
+    'addTagMiddleware',
+    'addGlobalMiddleware',
+    'addHTTPMiddleware',
+    'pikkuChannelMiddleware',
+    'pikkuChannelMiddlewareFactory',
+    'pikkuAgentMiddleware',
+    'addChannelMiddleware',
+]);
+/** The helpers that define or register permissions. */
+export const PERMISSION_HELPERS = new Set([
+    'pikkuPermission',
+    'pikkuAuth',
+    'pikkuPermissionFactory',
+    'addGlobalPermission',
+]);
+const matcher = (known) => typeof known === 'function' ? known : (name) => known.has(name);
+const namesCache = new WeakMap();
+const unwrap = (expression) => {
+    let current = expression;
+    while (ts.isParenthesizedExpression(current) ||
+        ts.isAsExpression(current) ||
+        ts.isSatisfiesExpression(current) ||
+        ts.isNonNullExpression(current) ||
+        ts.isTypeAssertionExpression(current)) {
+        current = current.expression;
+    }
+    return current;
+};
+export const isNamespaceReceiver = (receiver, checker) => {
+    if (!ts.isIdentifier(receiver))
+        return false;
+    const symbol = checker.getSymbolAtLocation(receiver);
+    if (!symbol)
+        return false;
+    if (symbol.declarations?.some(ts.isNamespaceImport))
+        return true;
+    const target = symbol.flags & ts.SymbolFlags.Alias
+        ? checker.getAliasedSymbol(symbol)
+        : symbol;
+    return (target.flags & ts.SymbolFlags.ValueModule) !== 0;
+};
+const followSymbol = (symbol, checker, names, depth) => {
+    if (!symbol || depth > MAX_DEPTH)
+        return;
+    let target = symbol;
+    if (symbol.flags & ts.SymbolFlags.Alias) {
+        const declaration = symbol.declarations?.[0];
+        if (declaration &&
+            (ts.isImportSpecifier(declaration) || ts.isExportSpecifier(declaration))) {
+            names.push((declaration.propertyName ?? declaration.name).text);
+        }
+        target = checker.getAliasedSymbol(symbol);
+        // An import from a module the program cannot resolve: the specifier's own
+        // exported name is the only identity there is.
+        if (!target.declarations?.length)
+            return;
+        names.push(target.getName());
+    }
+    const declaration = target.valueDeclaration;
+    if (declaration &&
+        ts.isVariableDeclaration(declaration) &&
+        declaration.initializer &&
+        ts.getCombinedNodeFlags(declaration) & ts.NodeFlags.Const) {
+        collectNames(declaration.initializer, checker, names, depth + 1);
+    }
+};
+const collectNames = (expression, checker, names, depth) => {
+    const callee = unwrap(expression);
+    if (ts.isIdentifier(callee)) {
+        names.push(callee.text);
+        followSymbol(checker.getSymbolAtLocation(callee), checker, names, depth);
+    }
+    else if (ts.isPropertyAccessExpression(callee) &&
+        isNamespaceReceiver(unwrap(callee.expression), checker)) {
+        names.push(callee.name.text);
+        followSymbol(checker.getSymbolAtLocation(callee.name), checker, names, depth);
+    }
+};
+/**
+ * Every name a callee answers to, from its spelling at the call site to the
+ * declaration it resolves to: through import and re-export aliases, members
+ * of a namespace import, and `const` bindings of another name.
+ */
+export const calleeNames = (expression, checker) => {
+    let cache = namesCache.get(checker);
+    if (!cache) {
+        cache = new WeakMap();
+        namesCache.set(checker, cache);
+    }
+    const cached = cache.get(expression);
+    if (cached)
+        return cached;
+    const names = [];
+    collectNames(expression, checker, names, 0);
+    cache.set(expression, names);
+    return names;
+};
+const isInsideDeclarationOf = (node, isKnown) => {
+    for (let current = node.parent; current; current = current.parent) {
+        if ((ts.isVariableDeclaration(current) ||
+            ts.isFunctionDeclaration(current)) &&
+            current.name &&
+            ts.isIdentifier(current.name) &&
+            isKnown(current.name.text)) {
+            return true;
+        }
+    }
+    return false;
+};
+/**
+ * The pikku helper a call invokes, identified by what its callee resolves to
+ * rather than how it is spelled, so `import { addTagMiddleware as guard }` and
+ * `mw.addTagMiddleware(...)` are seen for what they are.
+ *
+ * The deepest known name wins, because it is the declaration's own: an alias
+ * that happens to look like another helper (`pikkuFunc as pikkuOpenFunc`) is
+ * still the helper it imports. A call inside the body of a helper's own
+ * declaration — the generated `#pikku` wrappers forwarding to `@pikku/core` —
+ * is the helper's implementation, not a use of it, and keeps the meaning its
+ * literal spelling gives it.
+ */
+export const resolveCalleeName = (call, checker, known) => {
+    const isKnown = matcher(known);
+    const names = calleeNames(call.expression, checker);
+    let resolved;
+    for (let i = names.length - 1; i >= 0; i--) {
+        if (isKnown(names[i])) {
+            resolved = names[i];
+            break;
+        }
+    }
+    if (!resolved)
+        return undefined;
+    const spelled = ts.isIdentifier(call.expression)
+        ? call.expression.text
+        : undefined;
+    if (resolved !== spelled && isInsideDeclarationOf(call, isKnown)) {
+        return spelled !== undefined && isKnown(spelled) ? spelled : undefined;
+    }
+    return resolved;
+};

package/dist/utils/resolve-service-types.d.ts

@@ -0,0 +1,8 @@
+import type ts from 'typescript';
+import type { InspectorServiceTypes, InspectorState } from '../types.js';
+/**
+ * Reads the checker's view of the SingletonServices and Services types into
+ * plain names, so the shared finalize phase can aggregate services and refuse
+ * secret aliases without a `ts.Type` in hand.
+ */
+export declare const resolveServiceTypes: (state: Pick<InspectorState, "typesLookup" | "singletonServicesTypeImportMap" | "wireServicesTypeImportMap">, checker: ts.TypeChecker) => InspectorServiceTypes;

package/dist/utils/resolve-service-types.js

@@ -0,0 +1,21 @@
+import { extractTypeKeys } from './type-utils.js';
+import { resolveCoreType } from './resolve-core-type.js';
+import { findSecretAliasServices } from './secret-alias-services.js';
+/**
+ * Reads the checker's view of the SingletonServices and Services types into
+ * plain names, so the shared finalize phase can aggregate services and refuse
+ * secret aliases without a `ts.Type` in hand.
+ */
+export const resolveServiceTypes = (state, checker) => {
+    const singletonServicesType = resolveCoreType(state.typesLookup, state.singletonServicesTypeImportMap);
+    const servicesType = resolveCoreType(state.typesLookup, state.wireServicesTypeImportMap);
+    return {
+        singletonServices: singletonServicesType
+            ? extractTypeKeys(singletonServicesType).sort()
+            : null,
+        services: servicesType ? extractTypeKeys(servicesType) : null,
+        secretAliases: singletonServicesType
+            ? findSecretAliasServices(singletonServicesType, checker)
+            : [],
+    };
+};

package/dist/utils/schema-generator.js

@@ -1,13 +1,14 @@
 import * as ts from 'typescript';
 import { createHash } from 'crypto';
 import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync, } from 'fs';
-import { dirname, join, resolve } from 'path';
+import { basename, dirname, join, resolve } from 'path';
 import { createFormatter, createParser, DEFAULT_CONFIG, RootlessError, SchemaGenerator, } from 'ts-json-schema-generator';
 import { register } from 'tsx/esm/api';
 import * as z from 'zod';
 import { findZodTransform } from './find-zod-transform.js';
 import { zodToTypeText } from './zod-to-type-text.js';
 import { ErrorCode } from '../error-codes.js';
+import { getCachedSourceFile } from '../source-file-cache.js';
 import { generateCustomTypes } from './custom-types-generator.js';
 const PRIMITIVE_TYPES = new Set([
     'boolean',
@@ -212,6 +213,21 @@ const createIndexedGenerator = (program, config) => {
     const completedConfig = { ...DEFAULT_CONFIG, ...config };
     return new IndexedSchemaGenerator(program, createParser(program, completedConfig), createFormatter(completedConfig), completedConfig);
 };
+/**
+ * Parse at the inspector's target so the schema program reuses the inspector's
+ * SourceFiles instead of re-parsing the project; `target` is part of the
+ * parse cache key. The lib the project's own target implies is pinned, so type
+ * resolution is unchanged.
+ */
+const parseAtInspectorTarget = (options) => {
+    if (options.target === ts.ScriptTarget.ESNext)
+        return options;
+    return {
+        ...options,
+        target: ts.ScriptTarget.ESNext,
+        lib: options.lib ?? [basename(ts.getDefaultLibFilePath(options))],
+    };
+};
 function createProgramWithVirtualFile(logger, tsconfig, virtualFilePath, virtualFileContent) {
     const configPath = resolve(tsconfig);
     // Cache the parsed tsconfig — it doesn't change between runs
@@ -219,6 +235,7 @@ function createProgramWithVirtualFile(logger, tsconfig, virtualFilePath, virtual
         const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
         const basePath = dirname(configPath);
         cachedParsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, basePath);
+        cachedParsedConfig.options = parseAtInspectorTarget(cachedParsedConfig.options);
         cachedTsconfigPath = configPath;
         cachedSchemaProgram = undefined;
     }
@@ -235,7 +252,17 @@ function createProgramWithVirtualFile(logger, tsconfig, virtualFilePath, virtual
             if (resolve(fileName) === resolvedVirtualPath) {
                 return ts.createSourceFile(fileName, virtualFileContent, languageVersionOrOptions);
             }
-            return defaultHost.getSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
+            if (shouldCreateNewSourceFile) {
+                return defaultHost.getSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
+            }
+            // Shares the inspector's parsed files rather than parsing the project a
+            // second time.
+            const text = defaultHost.readFile(fileName);
+            if (text === undefined)
+                return undefined;
+            return getCachedSourceFile(fileName, text, languageVersionOrOptions, {
+                populate: false,
+            }).file;
         },
         fileExists(fileName) {
             if (resolve(fileName) === resolvedVirtualPath)

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

@@ -60,6 +60,8 @@ export interface SerializableInspectorState {
     addonRequiredParentServices: string[];
     addonCreatedServices: string[];
     addonServicesFactorySeen: boolean;
+    analytics?: InspectorState['analytics'];
+    outgoingWebhooks?: InspectorState['outgoingWebhooks'];
     addonServerlessIncompatible: Array<[string, string[]]>;
     configFactories: Array<[
         string,
@@ -115,6 +117,7 @@ export interface SerializableInspectorState {
             exportedName: string;
         }]>;
         approvalDescriptions: InspectorState['functions']['approvalDescriptions'];
+        dynamicImportIds?: string[];
     };
     http: {
         metaInputTypes: Array<[
@@ -260,6 +263,7 @@ export interface SerializableInspectorState {
     scopes: {
         definitions: InspectorState['scopes']['definitions'];
         files: string[];
+        declared?: Array<[string, string]>;
     };
     systemRoles: {
         definitions: InspectorState['systemRoles']['definitions'];
@@ -269,8 +273,8 @@ export interface SerializableInspectorState {
         definitions: InspectorState['featureFlags']['definitions'];
         files: string[];
     };
-    personas: {
-        definitions: InspectorState['personas']['definitions'];
+    virtualUsers: {
+        definitions: InspectorState['virtualUsers']['definitions'];
         files: string[];
     };
     variables: {
@@ -301,6 +305,7 @@ export interface SerializableInspectorState {
     permissions: {
         definitions: InspectorState['permissions']['definitions'];
         instances: InspectorState['permissions']['instances'];
+        global?: InspectorState['permissions']['global'];
     };
     serviceAggregation: {
         requiredServices: string[];
@@ -310,6 +315,7 @@ export interface SerializableInspectorState {
         allSingletonServices: string[];
         allWireServices: string[];
     };
+    serviceTypes?: InspectorState['serviceTypes'];
     resolvedIOTypes: Record<string, {
         inputType: string;
         outputType: string;
@@ -328,7 +334,7 @@ export interface SerializableInspectorState {
  * Serializes InspectorState to a JSON-compatible format
  * Omits typesLookup (not needed for filtering/generation) and converts Maps/Sets to arrays
  */
-export declare function serializeInspectorState(state: InspectorState): SerializableInspectorState;
+export declare function serializeInspectorState(state: Omit<InspectorState, 'typesLookup'>): SerializableInspectorState;
 /**
  * Deserializes JSON data back to InspectorState
  * Creates a partial state suitable for filtering/generation (without typesLookup)

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

@@ -26,6 +26,8 @@ export function serializeInspectorState(state) {
         addonRequiredParentServices: state.addonRequiredParentServices,
         addonCreatedServices: state.addonCreatedServices,
         addonServicesFactorySeen: state.addonServicesFactorySeen,
+        analytics: state.analytics,
+        outgoingWebhooks: state.outgoingWebhooks,
         addonServerlessIncompatible: Array.from(state.addonServerlessIncompatible.entries()),
         configFactories: Array.from(state.configFactories.entries()),
         serverLifecycleFactories: Array.from(state.serverLifecycleFactories.entries()),
@@ -38,6 +40,7 @@ export function serializeInspectorState(state) {
             meta: state.functions.meta,
             files: Array.from(state.functions.files.entries()),
             approvalDescriptions: state.functions.approvalDescriptions,
+            dynamicImportIds: Array.from(state.functions.dynamicImportIds ?? []),
         },
         http: {
             metaInputTypes: Array.from(state.http.metaInputTypes.entries()),
@@ -131,6 +134,9 @@ export function serializeInspectorState(state) {
         scopes: {
             definitions: state.scopes.definitions,
             files: Array.from(state.scopes.files),
+            declared: state.scopes.declared
+                ? Array.from(state.scopes.declared.entries())
+                : undefined,
         },
         systemRoles: {
             definitions: state.systemRoles.definitions,
@@ -140,9 +146,9 @@ export function serializeInspectorState(state) {
             definitions: state.featureFlags.definitions,
             files: Array.from(state.featureFlags.files),
         },
-        personas: {
-            definitions: state.personas.definitions,
-            files: Array.from(state.personas.files),
+        virtualUsers: {
+            definitions: state.virtualUsers.definitions,
+            files: Array.from(state.virtualUsers.files),
         },
         variables: {
             definitions: state.variables.definitions,
@@ -166,6 +172,7 @@ export function serializeInspectorState(state) {
         permissions: {
             definitions: state.permissions.definitions,
             instances: state.permissions.instances,
+            global: state.permissions.global,
         },
         serviceAggregation: {
             requiredServices: Array.from(state.serviceAggregation.requiredServices),
@@ -175,6 +182,7 @@ export function serializeInspectorState(state) {
             allSingletonServices: state.serviceAggregation.allSingletonServices,
             allWireServices: state.serviceAggregation.allWireServices,
         },
+        serviceTypes: state.serviceTypes,
         resolvedIOTypes: state.resolvedIOTypes,
         middlewareGroupsMeta: state.middlewareGroupsMeta,
         permissionsGroupsMeta: state.permissionsGroupsMeta,
@@ -212,6 +220,8 @@ export function deserializeInspectorState(data) {
         addonRequiredParentServices: data.addonRequiredParentServices || [],
         addonCreatedServices: data.addonCreatedServices || [],
         addonServicesFactorySeen: data.addonServicesFactorySeen ?? false,
+        analytics: data.analytics,
+        outgoingWebhooks: data.outgoingWebhooks,
         addonServerlessIncompatible: new Map(data.addonServerlessIncompatible || []),
         configFactories: new Map(data.configFactories),
         serverLifecycleFactories: new Map(data.serverLifecycleFactories),
@@ -227,7 +237,7 @@ export function deserializeInspectorState(data) {
             meta: data.functions.meta,
             files: new Map(data.functions.files),
             approvalDescriptions: data.functions.approvalDescriptions || {},
-            dynamicImportIds: new Set(),
+            dynamicImportIds: new Set(data.functions.dynamicImportIds ?? []),
         },
         http: {
             metaInputTypes: new Map(data.http.metaInputTypes),
@@ -321,6 +331,9 @@ export function deserializeInspectorState(data) {
         scopes: {
             definitions: data.scopes?.definitions || [],
             files: new Set(data.scopes?.files || []),
+            declared: data.scopes?.declared
+                ? new Map(data.scopes.declared)
+                : undefined,
         },
         systemRoles: {
             definitions: data.systemRoles?.definitions || [],
@@ -330,9 +343,9 @@ export function deserializeInspectorState(data) {
             definitions: data.featureFlags?.definitions || [],
             files: new Set(data.featureFlags?.files || []),
         },
-        personas: {
-            definitions: data.personas?.definitions || [],
-            files: new Set(data.personas?.files || []),
+        virtualUsers: {
+            definitions: data.virtualUsers?.definitions || [],
+            files: new Set(data.virtualUsers?.files || []),
         },
         variables: {
             definitions: data.variables?.definitions || [],
@@ -356,6 +369,7 @@ export function deserializeInspectorState(data) {
         permissions: {
             definitions: data.permissions.definitions,
             instances: data.permissions.instances || {},
+            global: data.permissions.global || [],
         },
         serviceAggregation: {
             requiredServices: new Set(data.serviceAggregation.requiredServices),
@@ -365,6 +379,7 @@ export function deserializeInspectorState(data) {
             allSingletonServices: data.serviceAggregation.allSingletonServices,
             allWireServices: data.serviceAggregation.allWireServices,
         },
+        serviceTypes: data.serviceTypes,
         resolvedIOTypes: data.resolvedIOTypes || {},
         middlewareGroupsMeta: data.middlewareGroupsMeta || {
             definitions: {},

package/dist/utils/single-declaration.d.ts

@@ -3,18 +3,18 @@ import type { InspectorLogger } from '../types.js';
 /**
  * Claims the one call site a single-declaration construct is allowed.
  *
- * `definePersonas` takes a keyed object, so one call already declares as many
+ * `defineVirtualUsers` takes a keyed object, so one call already declares as many
  * entries as you like. Letting the call itself repeat buys nothing and costs
  * the thing that matters: a single place to read the declared set from, and a
  * single place to add to it. The same rule `pikkuBetterAuth` has had all along.
  *
  * A second call in the SAME file is refused too — "the file" is not an answer
- * to "where do I add a persona?" when the file holds two calls, so allowing it
+ * to "where do I add a virtual user?" when the file holds two calls, so allowing it
  * would keep the ambiguity the rule exists to remove.
  *
  * A generated file is exempt, and never claims the slot either. The rule exists
  * to name the one place a person adds to, and nobody adds to a file the CLI
- * rewrites on the next run — `pikku-personas.gen.ts` would otherwise make every
+ * rewrites on the next run — `pikku-virtual-users.gen.ts` would otherwise make every
  * project that scaffolds one unbuildable, and take the app's own declaration
  * down with it.
  *

package/dist/utils/single-declaration.js

@@ -1,18 +1,18 @@
 /**
  * Claims the one call site a single-declaration construct is allowed.
  *
- * `definePersonas` takes a keyed object, so one call already declares as many
+ * `defineVirtualUsers` takes a keyed object, so one call already declares as many
  * entries as you like. Letting the call itself repeat buys nothing and costs
  * the thing that matters: a single place to read the declared set from, and a
  * single place to add to it. The same rule `pikkuBetterAuth` has had all along.
  *
  * A second call in the SAME file is refused too — "the file" is not an answer
- * to "where do I add a persona?" when the file holds two calls, so allowing it
+ * to "where do I add a virtual user?" when the file holds two calls, so allowing it
  * would keep the ambiguity the rule exists to remove.
  *
  * A generated file is exempt, and never claims the slot either. The rule exists
  * to name the one place a person adds to, and nobody adds to a file the CLI
- * rewrites on the next run — `pikku-personas.gen.ts` would otherwise make every
+ * rewrites on the next run — `pikku-virtual-users.gen.ts` would otherwise make every
  * project that scaffolds one unbuildable, and take the app's own declaration
  * down with it.
  *

package/dist/utils/validate-single-step-workflows.d.ts

@@ -0,0 +1,3 @@
+import type { InspectorLogger, InspectorState } from '../types.js';
+/** Warns about a workflow with at most one RPC step and nothing to wait on or fan out: it is a function or a queue job wearing a workflow's cost. */
+export declare function validateSingleStepWorkflows(logger: InspectorLogger, state: InspectorState): void;

package/dist/utils/validate-single-step-workflows.js

@@ -0,0 +1,32 @@
+import { ErrorCode } from '../error-codes.js';
+const DURABLE_FLOWS = new Set([
+    'sleep',
+    'suspend',
+    'approval',
+    'parallel',
+    'fanout',
+]);
+/** Warns about a workflow with at most one RPC step and nothing to wait on or fan out: it is a function or a queue job wearing a workflow's cost. */
+export function validateSingleStepWorkflows(logger, state) {
+    for (const [name, graph] of Object.entries(state.workflows.graphMeta)) {
+        if (graph.source === 'scenario')
+            continue;
+        const file = state.workflows.files.get(graph.pikkuFuncId)?.path ??
+            state.workflows.graphFiles.get(name)?.path;
+        if (!file)
+            continue;
+        const nodes = Object.values(graph.nodes);
+        const rpcSteps = nodes.filter((n) => 'rpcName' in n && n.rpcName);
+        if (rpcSteps.length > 1)
+            continue;
+        if (nodes.some((n) => 'flow' in n && DURABLE_FLOWS.has(n.flow)))
+            continue;
+        logger.diagnostic({
+            severity: 'warn',
+            code: ErrorCode.SINGLE_STEP_WORKFLOW,
+            message: `Workflow '${name}' (${file}) runs ${rpcSteps.length === 0 ? 'no RPC step' : 'a single RPC step'} ` +
+                `and never sleeps, suspends or fans out, so it buys nothing a workflow is for. ` +
+                `Call the function directly, or enqueue it on a queue worker if it must survive a restart.`,
+        });
+    }
+}

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

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import { isWorkflowDoCall, isWorkflowExpectEventuallyCall, isScenarioStepCall, isScenarioExpectationCall, getScenarioStepPhase, DYNAMIC_SCENARIO_STEP_TARGET, extractActorFromOptions, isWorkflowSleepCall, isWorkflowSuspendCall, isWorkflowMilestoneCall, isWorkflowApprovalCall, isThrowCancelException, extractCancelReason, isParallelFanout, isParallelGroup, isSequentialFanout, isArrayFilter, isArraySome, isArrayEvery, extractForOfVariable, isArrayType, getSourceText, extractSourcePath, } from './patterns.js';
+import { isWorkflowDoCall, isWorkflowExpectEventuallyCall, isScenarioStepCall, isScenarioExpectationCall, getScenarioStepPhase, DYNAMIC_SCENARIO_STEP_TARGET, extractVirtualUserFromOptions, isWorkflowSleepCall, isWorkflowSuspendCall, isWorkflowMilestoneCall, isWorkflowApprovalCall, 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';
 /**
@@ -571,7 +571,7 @@ function extractRpcStep(call, context, outputVar) {
             outputVar,
             inputs,
             options,
-            actor: extractActorFromOptions(optionsArg),
+            virtualUser: extractVirtualUserFromOptions(optionsArg),
             expectEventually: expectEventually || undefined,
         };
     }
@@ -623,7 +623,7 @@ function extractScenarioStep(call, context, outputVar) {
             outputVar,
             inputs,
             options,
-            actor: extractActorFromOptions(optionsArg),
+            virtualUser: extractVirtualUserFromOptions(optionsArg),
         };
     }
     catch (error) {

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

@@ -13,13 +13,7 @@ export declare function isWorkflowWireIdentifier(expr: ts.Expression): boolean;
  * (both are RPC steps; expectEventually is the polling variant used by scenarios)
  */
 export declare function isWorkflowDoCall(node: ts.CallExpression, checker: ts.TypeChecker): boolean;
-/**
- * Placeholder recorded when a scenario step's target isn't a static string
- * literal. The step is kept rather than dropped so post-processing can raise
- * PKU678 against it — a dropped step is the silent-failure mode this repo has
- * hit repeatedly on workflow graph round-trips.
- */
-export declare const DYNAMIC_SCENARIO_STEP_TARGET = "<dynamic>";
+export { DYNAMIC_SCENARIO_STEP_TARGET } from '../../inspector-constants.js';
 declare const SCENARIO_STEP_PHASES: readonly ["given", "when", "then"];
 export type ScenarioStepPhaseName = (typeof SCENARIO_STEP_PHASES)[number];
 /**
@@ -44,11 +38,11 @@ export declare function isScenarioExpectationCall(node: ts.CallExpression): bool
  */
 export declare function isWorkflowExpectEventuallyCall(node: ts.CallExpression): boolean;
 /**
- * Extract the actor NAME from a step options object literal:
- * `{ actor: actors.x }` → 'x' (also `actors['x']`). Undefined when absent
+ * Extract the virtual user NAME from a step options object literal:
+ * `{ virtualUser: virtualUsers.x }` → 'x' (also `virtualUsers['x']`). Undefined when absent
  * or not statically resolvable.
  */
-export declare function extractActorFromOptions(optionsArg: ts.Expression | undefined): string | undefined;
+export declare function extractVirtualUserFromOptions(optionsArg: ts.Expression | undefined): string | undefined;
 /**
  * Check if a call expression is workflow.sleep()
  */
@@ -117,4 +111,3 @@ export declare function isArrayType(type: ts.Type, checker: ts.TypeChecker): boo
  * Get the source text of a node (for condition expressions)
  */
 export declare function getSourceText(node: ts.Node): string;
-export {};

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

@@ -24,13 +24,7 @@ export function isWorkflowDoCall(node, checker) {
         propAccess.name.text === 'expectEventually') &&
         isWorkflowWireIdentifier(propAccess.expression));
 }
-/**
- * Placeholder recorded when a scenario step's target isn't a static string
- * literal. The step is kept rather than dropped so post-processing can raise
- * PKU678 against it — a dropped step is the silent-failure mode this repo has
- * hit repeatedly on workflow graph round-trips.
- */
-export const DYNAMIC_SCENARIO_STEP_TARGET = '<dynamic>';
+export { DYNAMIC_SCENARIO_STEP_TARGET } from '../../inspector-constants.js';
 const SCENARIO_STEP_PHASES = ['given', 'when', 'then'];
 /**
  * Check if a call expression is scenario.given()/when()/then() — a declared
@@ -88,17 +82,17 @@ export function isWorkflowExpectEventuallyCall(node) {
         isWorkflowWireIdentifier(node.expression.expression));
 }
 /**
- * Extract the actor NAME from a step options object literal:
- * `{ actor: actors.x }` → 'x' (also `actors['x']`). Undefined when absent
+ * Extract the virtual user NAME from a step options object literal:
+ * `{ virtualUser: virtualUsers.x }` → 'x' (also `virtualUsers['x']`). Undefined when absent
  * or not statically resolvable.
  */
-export function extractActorFromOptions(optionsArg) {
+export function extractVirtualUserFromOptions(optionsArg) {
     if (!optionsArg || !ts.isObjectLiteralExpression(optionsArg))
         return;
     for (const prop of optionsArg.properties) {
         if (ts.isPropertyAssignment(prop) &&
             ts.isIdentifier(prop.name) &&
-            prop.name.text === 'actor') {
+            prop.name.text === 'virtualUser') {
             const init = prop.initializer;
             if (ts.isPropertyAccessExpression(init)) {
                 return init.name.text;