@pikku/inspector 0.12.106 → 0.12.108

package/dist/utils/post-process.js

@@ -1,15 +1,11 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { join } from 'node:path';
-import { extractTypeKeys } from './type-utils.js';
 import { ErrorCode } from '../error-codes.js';
-import { findSecretAliasServices } from './secret-alias-services.js';
 import { deriveOAuth2AppSecrets } from '@pikku/core/secret';
-import { resolveCoreType } from './resolve-core-type.js';
 import { relative } from 'node:path';
-import { AUTH_HANDLER_FUNC_ID } from '../add/add-auth.js';
+import { AUTH_HANDLER_FUNC_ID, DYNAMIC_SCENARIO_STEP_TARGET, } from './inspector-constants.js';
 import { flattenScopeDefinitions } from '@pikku/core/scope';
-import { DYNAMIC_SCENARIO_STEP_TARGET } from './workflow/dsl/patterns.js';
 import { addonResolutionDirs } from './addon-resolution.js';
 /**
  * Stamp the inspected authorize/callbacks service set onto the generated auth
@@ -72,26 +68,25 @@ function expandAndAddGroupServices(list, state, addServices) {
     }
 }
 /**
- * Extracts all service names from SingletonServices and Services types.
- * This provides the complete list of available services for code generation.
- * Only runs if typesLookup is available (omitted in deserialized states).
+ * Applies the service names of the SingletonServices and Services types, which
+ * `resolveServiceTypes` read off the checker during analysis. This provides the
+ * complete list of available services for code generation.
+ * Skipped when analysis did not resolve them (e.g. an older serialized state).
  */
 function extractAllServices(state) {
-    // Skip if typesLookup is not available (e.g., deserialized state)
-    if (!('typesLookup' in state)) {
+    const resolved = state.serviceTypes;
+    if (!resolved) {
         return;
     }
-    // Extract all singleton services from the SingletonServices type
-    const singletonServicesType = resolveCoreType(state.typesLookup, state.singletonServicesTypeImportMap);
-    if (singletonServicesType) {
-        state.serviceAggregation.allSingletonServices = extractTypeKeys(singletonServicesType).sort();
+    if (resolved.singletonServices) {
+        state.serviceAggregation.allSingletonServices = [
+            ...resolved.singletonServices,
+        ];
     }
-    // Extract all services from the Services type
-    const servicesType = resolveCoreType(state.typesLookup, state.wireServicesTypeImportMap);
-    if (servicesType) {
+    if (resolved.services) {
         // Wire services are those in Services but not in SingletonServices
         const singletonSet = new Set(state.serviceAggregation.allSingletonServices);
-        state.serviceAggregation.allWireServices = extractTypeKeys(servicesType)
+        state.serviceAggregation.allWireServices = resolved.services
             .filter((name) => !singletonSet.has(name))
             .sort();
         markSingletonServicesOnly(state, new Set(state.serviceAggregation.allWireServices));
@@ -170,6 +165,18 @@ export function aggregateRequiredServices(state) {
             addServices(permissionMeta.services);
         }
     });
+    // 3b. Global permissions and global middleware apply to every function, so
+    // whatever they touch is required wherever any function runs.
+    for (const registration of state.permissions?.global ?? []) {
+        for (const definitionId of registration.definitionIds) {
+            addServices(state.permissions.definitions[definitionId]?.services);
+        }
+    }
+    for (const [instanceId, instance] of Object.entries(state.middleware?.instances ?? {})) {
+        if (instanceId.startsWith('global:')) {
+            addServices(state.middleware.definitions[instance.definitionId]?.services);
+        }
+    }
     // 4. Services from middleware/permission groups used in wirings
     // We need to check all wirings and expand any tag/HTTP-pattern groups they use
     for (const method of [
@@ -1172,15 +1179,8 @@ export function validateSchemaWiringSeparation(logger, state) {
  * a name the omit does not cover. A name-based rule misses this; the type does
  * not.
  */
-export function validateNoSecretAliasServices(logger, checker, state) {
-    if (!('typesLookup' in state)) {
-        return;
-    }
-    const singletonServicesType = resolveCoreType(state.typesLookup, state.singletonServicesTypeImportMap);
-    if (!singletonServicesType) {
-        return;
-    }
-    const aliases = findSecretAliasServices(singletonServicesType, checker);
+export function validateNoSecretAliasServices(logger, state) {
+    const aliases = state.serviceTypes?.secretAliases ?? [];
     if (aliases.length === 0) {
         return;
     }

package/dist/utils/read-jsx-literal-text.js

@@ -42,6 +42,34 @@ const NON_TEXT_ATTRIBUTES = new Set([
     'value',
     'key',
 ]);
+/**
+ * Calls whose string arguments are class lists. A literal anywhere inside one —
+ * `cva('…', { variants: { size: { heading: 'font-heading text-xl' } } })` — is
+ * styling, even under a key like `heading` that would otherwise read as text.
+ */
+const CLASS_BUILDERS = new Set([
+    'cn',
+    'cva',
+    'clsx',
+    'cx',
+    'classNames',
+    'classnames',
+    'tv',
+    'twMerge',
+    'twJoin',
+]);
+const isInsideClassBuilder = (node) => {
+    for (let at = node.parent; at; at = at.parent) {
+        if (ts.isJsxElement(at) || ts.isJsxSelfClosingElement(at))
+            return false;
+        if (ts.isCallExpression(at) &&
+            ts.isIdentifier(at.expression) &&
+            CLASS_BUILDERS.has(at.expression.text)) {
+            return true;
+        }
+    }
+    return false;
+};
 const isProse = (text) => /^\p{Lu}[^\s]*(\s+[^\s]+)+/u.test(text.trim()) &&
     !/[:/[\]=_#]/.test(text.split(/\s+/)[0] ?? '');
 const isSentence = (text) => /\p{L}+\s+\p{L}+/u.test(text);
@@ -72,7 +100,9 @@ export const readJsxLiteralText = (fileName, content) => {
     const found = [];
     const seen = new Set();
     const add = (node, text) => {
-        if (!hasLetter(text) || seen.has(node.getStart(source)))
+        if (!hasLetter(text) ||
+            seen.has(node.getStart(source)) ||
+            isInsideClassBuilder(node))
             return;
         seen.add(node.getStart(source));
         const { line } = source.getLineAndCharacterOfPosition(node.getStart(source));

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'];
@@ -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,
@@ -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 || [],
@@ -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/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];
 /**
@@ -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

package/dist/visit.js

@@ -35,6 +35,7 @@ import { addAnalytics } from './add/add-analytics.js';
 import { addOutgoingWebhook } from './add/add-outgoing-webhook.js';
 import { addAgentScorer } from './add/add-agent-scorer.js';
 import { addApprovalDescription } from './add/add-approval-description.js';
+import { checkIndirectRegistrations } from './add/check-indirect-registrations.js';
 export const visitSetup = (logger, checker, node, state, options) => {
     addFileExtendsCoreType(node, checker, state.singletonServicesTypeImportMap, 'CoreSingletonServices', state);
     addFileExtendsCoreType(node, checker, state.wireServicesTypeImportMap, 'CoreServices', state);
@@ -52,6 +53,7 @@ export const visitSetup = (logger, checker, node, state, options) => {
     addWireRemoteAddon(node, state, logger);
     addMiddleware(logger, node, checker, state, options);
     addPermission(logger, node, checker, state, options);
+    checkIndirectRegistrations(logger, node, checker, state, options);
     addApprovalDescription(logger, node, checker, state, options);
     addWorkflow(logger, node, checker, state, options);
     ts.forEachChild(node, (child) => visitSetup(logger, checker, child, state, options));