@pikku/inspector 0.12.42 → 0.12.44

package/dist/add/add-permission.js

@@ -1,34 +1,14 @@
 import * as ts from 'typescript';
-import { extractFunctionName, isNamedExport, makeContextBasedId, } from '../utils/extract-function-name.js';
+import { extractFunctionName } from '../utils/extract-function-name.js';
 import { extractServicesFromFunction, extractUsedWires, } from '../utils/extract-services.js';
-import { extractPermissionPikkuNames } from '../utils/permissions.js';
 import { getPropertyValue } from '../utils/get-property-value.js';
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
-function renameTempDefinitions(state, definitionIds, groupType, groupKey) {
-    const tempIndices = definitionIds
-        .map((name, i) => (name.startsWith('__temp_') ? i : -1))
-        .filter((i) => i >= 0);
-    for (const idx of tempIndices) {
-        const oldId = definitionIds[idx];
-        const newId = tempIndices.length === 1
-            ? makeContextBasedId(groupType, groupKey)
-            : makeContextBasedId(groupType, groupKey, String(idx));
-        const existing = state.permissions.definitions[oldId];
-        if (existing) {
-            delete state.permissions.definitions[oldId];
-            state.permissions.definitions[newId] = existing;
-        }
-        definitionIds[idx] = newId;
-    }
-}
 function isInsidePermissionContainer(node) {
     let current = node.parent;
     while (current) {
         if (ts.isCallExpression(current) &&
             ts.isIdentifier(current.expression) &&
-            (current.expression.text === 'pikkuPermissionFactory' ||
-                current.expression.text === 'addTagPermission' ||
-                current.expression.text === 'addHTTPPermission')) {
+            current.expression.text === 'pikkuPermissionFactory') {
             return true;
         }
         current = current.parent;
@@ -36,7 +16,7 @@ function isInsidePermissionContainer(node) {
     return false;
 }
 /**
- * Inspect pikkuPermission calls, addPermission calls, and addHTTPPermission calls
+ * Inspect pikkuPermission, pikkuAuth, and pikkuPermissionFactory definitions.
  */
 export const addPermission = (logger, node, checker, state) => {
     if (!ts.isCallExpression(node))
@@ -249,158 +229,4 @@ export const addPermission = (logger, node, checker, state) => {
         logger.debug(`• Found permission factory with services: ${services.services.join(', ')}`);
         return;
     }
-    // Handle addPermission('tag', [permission1, permission2])
-    // Supports two patterns:
-    // 1. export const x = () => addTagPermission('tag', [...])  (factory - tree-shakeable)
-    // 2. export const x = addTagPermission('tag', [...])  (direct - no tree-shaking)
-    if (expression.text === 'addTagPermission') {
-        const tagArg = args[0];
-        const permissionsArrayArg = args[1];
-        if (!tagArg || !permissionsArrayArg)
-            return;
-        // Extract tag name
-        let tag;
-        if (ts.isStringLiteral(tagArg)) {
-            tag = tagArg.text;
-        }
-        if (!tag) {
-            logger.warn(`• addTagPermission call without valid tag string`);
-            return;
-        }
-        // Check if permissions is a literal array or object
-        if (!ts.isArrayLiteralExpression(permissionsArrayArg) &&
-            !ts.isObjectLiteralExpression(permissionsArrayArg)) {
-            logger.error(`• addTagPermission('${tag}', ...) must have a literal array or object as second argument`);
-            return;
-        }
-        // Extract permission pikkuFuncIds from array
-        const permissionNames = extractPermissionPikkuNames(permissionsArrayArg, checker, state.rootDir);
-        if (permissionNames.length > 0) {
-            renameTempDefinitions(state, permissionNames, 'tag', tag);
-        }
-        const allServices = new Set();
-        for (const permissionName of permissionNames) {
-            const permissionMeta = state.permissions.definitions[permissionName];
-            if (permissionMeta && permissionMeta.services) {
-                for (const service of permissionMeta.services.services) {
-                    allServices.add(service);
-                }
-            }
-        }
-        let isFactory = false;
-        let exportedName = null;
-        let parent = node.parent;
-        if (parent && ts.isArrowFunction(parent)) {
-            if (parent.parameters.length === 0) {
-                isFactory = true;
-                const arrowParent = parent.parent;
-                if (arrowParent && ts.isVariableDeclaration(arrowParent)) {
-                    if (ts.isIdentifier(arrowParent.name)) {
-                        if (isNamedExport(arrowParent)) {
-                            exportedName = arrowParent.name.text;
-                        }
-                    }
-                }
-            }
-        }
-        if (!isFactory) {
-            const extracted = extractFunctionName(node, checker, state.rootDir);
-            exportedName = extracted.exportedName;
-        }
-        if (!isFactory && exportedName) {
-            logger.warn(`• Permission group '${exportedName}' for tag '${tag}' is not wrapped in a factory function. ` +
-                `For tree-shaking, use: export const ${exportedName} = () => addTagPermission('${tag}', [...])`);
-        }
-        state.permissions.tagPermissions.set(tag, {
-            exportName: exportedName,
-            sourceFile: node.getSourceFile().fileName,
-            position: node.getStart(),
-            services: {
-                optimized: false,
-                services: Array.from(allServices),
-            },
-            count: permissionNames.length,
-            instanceIds: permissionNames,
-            isFactory,
-        });
-        logger.debug(`• Found tag permission group: ${tag} -> [${permissionNames.join(', ')}] (${isFactory ? 'factory' : 'direct'})`);
-        return;
-    }
-    // Handle addHTTPPermission(pattern, [permission1, permission2])
-    // Supports two patterns:
-    // 1. export const x = () => addHTTPPermission('*', [...])  (factory - tree-shakeable)
-    // 2. export const x = addHTTPPermission('*', [...])  (direct - no tree-shaking)
-    if (expression.text === 'addHTTPPermission') {
-        const patternArg = args[0];
-        const permissionsArrayArg = args[1];
-        if (!patternArg || !permissionsArrayArg)
-            return;
-        // Extract route pattern
-        let pattern;
-        if (ts.isStringLiteral(patternArg)) {
-            pattern = patternArg.text;
-        }
-        if (!pattern) {
-            logger.warn(`• addHTTPPermission call without valid pattern string`);
-            return;
-        }
-        // Check if permissions is a literal array or object
-        if (!ts.isArrayLiteralExpression(permissionsArrayArg) &&
-            !ts.isObjectLiteralExpression(permissionsArrayArg)) {
-            logger.error(`• addHTTPPermission('${pattern}', ...) must have a literal array or object as second argument`);
-            return;
-        }
-        // Extract permission pikkuFuncIds from array
-        const permissionNames = extractPermissionPikkuNames(permissionsArrayArg, checker, state.rootDir);
-        if (permissionNames.length > 0) {
-            renameTempDefinitions(state, permissionNames, 'http', pattern);
-        }
-        const allServices = new Set();
-        for (const permissionName of permissionNames) {
-            const permissionMeta = state.permissions.definitions[permissionName];
-            if (permissionMeta && permissionMeta.services) {
-                for (const service of permissionMeta.services.services) {
-                    allServices.add(service);
-                }
-            }
-        }
-        let isFactory = false;
-        let exportedName = null;
-        let parent = node.parent;
-        if (parent && ts.isArrowFunction(parent)) {
-            if (parent.parameters.length === 0) {
-                isFactory = true;
-                const arrowParent = parent.parent;
-                if (arrowParent && ts.isVariableDeclaration(arrowParent)) {
-                    if (ts.isIdentifier(arrowParent.name)) {
-                        if (isNamedExport(arrowParent)) {
-                            exportedName = arrowParent.name.text;
-                        }
-                    }
-                }
-            }
-        }
-        if (!isFactory) {
-            const extracted = extractFunctionName(node, checker, state.rootDir);
-            exportedName = extracted.exportedName;
-        }
-        if (!isFactory && exportedName) {
-            logger.warn(`• HTTP permission group '${exportedName}' for pattern '${pattern}' is not wrapped in a factory function. ` +
-                `For tree-shaking, use: export const ${exportedName} = () => addHTTPPermission('${pattern}', [...])`);
-        }
-        state.http.routePermissions.set(pattern, {
-            exportName: exportedName,
-            sourceFile: node.getSourceFile().fileName,
-            position: node.getStart(),
-            services: {
-                optimized: false,
-                services: Array.from(allServices),
-            },
-            count: permissionNames.length,
-            instanceIds: permissionNames,
-            isFactory,
-        });
-        logger.debug(`• Found HTTP route permission group: ${pattern} -> [${permissionNames.join(', ')}] (${isFactory ? 'factory' : 'direct'})`);
-        return;
-    }
 };

package/dist/add/add-queue-worker.js

@@ -2,6 +2,7 @@ import * as ts from 'typescript';
 import { getPropertyValue, getCommonWireMetaData, } from '../utils/get-property-value.js';
 import { extractFunctionName, makeContextBasedId, } from '../utils/extract-function-name.js';
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
+import { ensureInlineWiringFunction } from '../utils/ensure-function-metadata.js';
 import { resolveMiddleware } from '../utils/middleware.js';
 import { extractWireNames } from '../utils/post-process.js';
 import { resolveAddonName } from '../utils/resolve-addon-package.js';
@@ -44,6 +45,8 @@ export const addQueueWorker = (logger, node, checker, state) => {
             logger.critical(ErrorCode.MISSING_QUEUE_NAME, `No 'name' provided for queue processor function '${pikkuFuncId}'.`);
             return;
         }
+        // Register metadata for a func inlined into the wiring (see helper).
+        ensureInlineWiringFunction(state, pikkuFuncId, name, funcInitializer, checker, extracted.isHelper);
         // --- resolve middleware ---
         const middleware = resolveMiddleware(state, obj, tags, checker);
         // --- track used functions/middleware for service aggregation ---

package/dist/add/add-schedule.js

@@ -2,6 +2,7 @@ import * as ts from 'typescript';
 import { getPropertyValue, getCommonWireMetaData, } from '../utils/get-property-value.js';
 import { extractFunctionName, makeContextBasedId, } from '../utils/extract-function-name.js';
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
+import { ensureInlineWiringFunction } from '../utils/ensure-function-metadata.js';
 import { resolveMiddleware } from '../utils/middleware.js';
 import { extractWireNames } from '../utils/post-process.js';
 import { resolveAddonName } from '../utils/resolve-addon-package.js';
@@ -43,6 +44,8 @@ export const addSchedule = (logger, node, checker, state, options) => {
         if (!nameValue || !scheduleValue) {
             return;
         }
+        // Register metadata for a func inlined into the wiring (see helper).
+        ensureInlineWiringFunction(state, pikkuFuncId, nameValue, funcInitializer, checker, extracted.isHelper);
         // --- resolve middleware ---
         const middleware = resolveMiddleware(state, obj, tags, checker);
         // --- track used functions/middleware for service aggregation ---

package/dist/add/add-scope.d.ts

@@ -0,0 +1,2 @@
+import type { AddWiring } from '../types.js';
+export declare const addScope: AddWiring;

package/dist/add/add-scope.js

@@ -0,0 +1,146 @@
+import * as ts from 'typescript';
+import { getPropertyValue } from '../utils/get-property-value.js';
+import { ErrorCode } from '../error-codes.js';
+const SEPARATOR = ':';
+const WILDCARD = '*';
+/**
+ * Validates a single scope segment, reporting rather than throwing so the
+ * inspector can surface every problem in one pass.
+ *
+ * @returns true when the segment is usable.
+ */
+const isValidSegment = (segment, scopeName, logger) => {
+    if (segment.length === 0) {
+        logger.critical(ErrorCode.INVALID_VALUE, `Scope '${scopeName}' contains an empty segment.`);
+        return false;
+    }
+    if (segment.includes(SEPARATOR)) {
+        logger.critical(ErrorCode.INVALID_VALUE, `Scope segment '${segment}' in '${scopeName}' contains the '${SEPARATOR}' separator. ` +
+            `Nest scopes with the 'scopes' property instead of embedding '${SEPARATOR}' in a name.`);
+        return false;
+    }
+    if (segment === WILDCARD) {
+        logger.critical(ErrorCode.INVALID_VALUE, `Scope segment '${segment}' in '${scopeName}' is the wildcard. ` +
+            `'${WILDCARD}' is reserved for granting a scope and its descendants, and cannot be declared.`);
+        return false;
+    }
+    return true;
+};
+/**
+ * Recursively extracts a `scopes: { ... }` object literal into nested metadata.
+ */
+const extractScopeNodes = (obj, scopeName, logger) => {
+    const nodes = {};
+    for (const prop of obj.properties) {
+        if (!ts.isPropertyAssignment(prop)) {
+            continue;
+        }
+        let segment;
+        if (ts.isIdentifier(prop.name)) {
+            segment = prop.name.text;
+        }
+        else if (ts.isStringLiteral(prop.name)) {
+            segment = prop.name.text;
+        }
+        if (segment === undefined) {
+            logger.critical(ErrorCode.NON_LITERAL_WIRE_NAME, `Scope '${scopeName}' has a nested scope whose key is not a literal.`);
+            continue;
+        }
+        if (!isValidSegment(segment, scopeName, logger)) {
+            continue;
+        }
+        if (!ts.isObjectLiteralExpression(prop.initializer)) {
+            logger.critical(ErrorCode.INVALID_VALUE, `Nested scope '${segment}' in '${scopeName}' must be an object literal.`);
+            continue;
+        }
+        const node = {};
+        const displayName = getPropertyValue(prop.initializer, 'displayName');
+        if (displayName) {
+            node.displayName = displayName;
+        }
+        const description = getPropertyValue(prop.initializer, 'description');
+        if (description) {
+            node.description = description;
+        }
+        const nestedProp = prop.initializer.properties.find((p) => ts.isPropertyAssignment(p) &&
+            ts.isIdentifier(p.name) &&
+            p.name.text === 'scopes');
+        if (nestedProp &&
+            ts.isPropertyAssignment(nestedProp) &&
+            ts.isObjectLiteralExpression(nestedProp.initializer)) {
+            const nested = extractScopeNodes(nestedProp.initializer, scopeName, logger);
+            if (nested) {
+                node.scopes = nested;
+            }
+        }
+        nodes[segment] = node;
+    }
+    return Object.keys(nodes).length > 0 ? nodes : undefined;
+};
+/**
+ * Unwraps `x as const` / `x as any` so a cast declaration is still extracted
+ * rather than silently skipped.
+ */
+const unwrapAs = (node) => ts.isAsExpression(node) || ts.isSatisfiesExpression(node)
+    ? unwrapAs(node.expression)
+    : node;
+export const addScope = (logger, node, checker, state, _options) => {
+    if (!ts.isCallExpression(node)) {
+        return;
+    }
+    const expression = node.expression;
+    if (!ts.isIdentifier(expression) || expression.text !== 'wireScope') {
+        return;
+    }
+    const firstArg = node.arguments[0];
+    if (!firstArg) {
+        return;
+    }
+    const unwrapped = unwrapAs(firstArg);
+    if (!ts.isObjectLiteralExpression(unwrapped)) {
+        return;
+    }
+    const sourceFile = node.getSourceFile().fileName;
+    // Roots are keyed exactly like the nodes beneath them, so each property of
+    // the call's single argument is one tree.
+    for (const prop of unwrapped.properties) {
+        if (!ts.isPropertyAssignment(prop)) {
+            continue;
+        }
+        let name;
+        if (ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name)) {
+            name = prop.name.text;
+        }
+        if (name === undefined) {
+            logger.critical(ErrorCode.NON_LITERAL_WIRE_NAME, 'A scope is declared with a key that is not a literal.');
+            continue;
+        }
+        if (!isValidSegment(name, name, logger)) {
+            continue;
+        }
+        if (!ts.isObjectLiteralExpression(prop.initializer)) {
+            logger.critical(ErrorCode.INVALID_VALUE, `Scope '${name}' must be an object literal.`);
+            continue;
+        }
+        const root = prop.initializer;
+        const displayNameValue = getPropertyValue(root, 'displayName');
+        const descriptionValue = getPropertyValue(root, 'description');
+        let scopes;
+        const scopesProp = root.properties.find((p) => ts.isPropertyAssignment(p) &&
+            ts.isIdentifier(p.name) &&
+            p.name.text === 'scopes');
+        if (scopesProp &&
+            ts.isPropertyAssignment(scopesProp) &&
+            ts.isObjectLiteralExpression(scopesProp.initializer)) {
+            scopes = extractScopeNodes(scopesProp.initializer, name, logger);
+        }
+        state.scopes.files.add(sourceFile);
+        state.scopes.definitions.push({
+            name,
+            displayName: displayNameValue || undefined,
+            description: descriptionValue || undefined,
+            scopes,
+            sourceFile,
+        });
+    }
+};

package/dist/add/add-trigger.js

@@ -2,6 +2,7 @@ import * as ts from 'typescript';
 import { getPropertyValue, getCommonWireMetaData, } from '../utils/get-property-value.js';
 import { extractFunctionName, makeContextBasedId, } from '../utils/extract-function-name.js';
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
+import { ensureInlineWiringFunction } from '../utils/ensure-function-metadata.js';
 import { resolveMiddleware } from '../utils/middleware.js';
 import { extractWireNames } from '../utils/post-process.js';
 import { resolveAddonName } from '../utils/resolve-addon-package.js';
@@ -45,6 +46,8 @@ const addWireTrigger = (logger, node, checker, state, firstArg) => {
     if (!nameValue) {
         return;
     }
+    // Register metadata for a func inlined into the wiring (see helper).
+    ensureInlineWiringFunction(state, pikkuFuncId, nameValue, funcInitializer, checker, extracted.isHelper);
     // --- resolve middleware ---
     const middleware = resolveMiddleware(state, obj, tags, checker);
     // --- track used functions/middleware for service aggregation ---

package/dist/add/add-wire-remote-addon.d.ts

@@ -0,0 +1,10 @@
+import * as ts from 'typescript';
+import type { InspectorState, InspectorLogger } from '../types.js';
+/**
+ * Detect wireRemoteAddon({ name: '...', package: '...' }) call expressions and
+ * record the namespace as a **remote** addon declaration. Only name + package
+ * are needed for codegen (serverUrl/auth are runtime closures resolved by the
+ * RPC runner); the `remote` marker tells the consumer's RPC-map generator to
+ * import the addon's `.remote.gen` map instead of `.internal.gen`.
+ */
+export declare function addWireRemoteAddon(node: ts.Node, state: InspectorState, logger: InspectorLogger): void;

package/dist/add/add-wire-remote-addon.js

@@ -0,0 +1,66 @@
+import * as ts from 'typescript';
+/**
+ * Detect wireRemoteAddon({ name: '...', package: '...' }) call expressions and
+ * record the namespace as a **remote** addon declaration. Only name + package
+ * are needed for codegen (serverUrl/auth are runtime closures resolved by the
+ * RPC runner); the `remote` marker tells the consumer's RPC-map generator to
+ * import the addon's `.remote.gen` map instead of `.internal.gen`.
+ */
+export function addWireRemoteAddon(node, state, logger) {
+    if (!ts.isCallExpression(node))
+        return;
+    const { expression, arguments: args } = node;
+    if (!ts.isIdentifier(expression) || expression.text !== 'wireRemoteAddon')
+        return;
+    const [firstArg] = args;
+    if (!firstArg || !ts.isObjectLiteralExpression(firstArg))
+        return;
+    let name;
+    let pkg;
+    // The auth binding is a runtime closure; we only extract the statically
+    // knowable slot names so `pikku verify` can check they exist in the
+    // consumer's own wirings. `hasAuth` distinguishes "public" (omitted) from
+    // "bound via a custom resolve()" (present but no static id).
+    let hasAuth = false;
+    let authCredentialId;
+    let authSecretId;
+    for (const prop of firstArg.properties) {
+        if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name))
+            continue;
+        const key = prop.name.text;
+        if (key === 'name' && ts.isStringLiteral(prop.initializer)) {
+            name = prop.initializer.text;
+        }
+        else if (key === 'package' && ts.isStringLiteral(prop.initializer)) {
+            pkg = prop.initializer.text;
+        }
+        else if (key === 'auth' &&
+            ts.isObjectLiteralExpression(prop.initializer)) {
+            hasAuth = true;
+            for (const authProp of prop.initializer.properties) {
+                if (!ts.isPropertyAssignment(authProp) || !ts.isIdentifier(authProp.name))
+                    continue;
+                if (authProp.name.text === 'credentialId' &&
+                    ts.isStringLiteral(authProp.initializer)) {
+                    authCredentialId = authProp.initializer.text;
+                }
+                else if (authProp.name.text === 'secretId' &&
+                    ts.isStringLiteral(authProp.initializer)) {
+                    authSecretId = authProp.initializer.text;
+                }
+            }
+        }
+    }
+    if (!name || !pkg)
+        return;
+    logger.debug(`• Found wireRemoteAddon: ${name} → ${pkg} (remote)`);
+    state.rpc.wireAddonDeclarations.set(name, {
+        package: pkg,
+        remote: true,
+        hasAuth,
+        authCredentialId,
+        authSecretId,
+    });
+    state.rpc.usedAddons.add(name);
+    state.rpc.wireAddonFiles.add(node.getSourceFile().fileName);
+}

package/dist/add/add-workflow-graph.js

@@ -2,6 +2,11 @@ import * as ts from 'typescript';
 import { ErrorCode } from '../error-codes.js';
 import { extractStringLiteral } from '../utils/extract-node-value.js';
 function extractAstValue(expr, refParamName, templateParamName) {
+    // `'GET' as const` / parenthesised values wrap the real initializer — see
+    // through them or the whole property is silently dropped from the meta.
+    while (ts.isAsExpression(expr) || ts.isParenthesizedExpression(expr)) {
+        expr = expr.expression;
+    }
     if (ts.isStringLiteral(expr)) {
         return expr.text;
     }
@@ -113,9 +118,13 @@ function extractInputMapping(node, _checker) {
     const refParamName = node.parameters.length > 0 && ts.isIdentifier(node.parameters[0].name)
         ? node.parameters[0].name.text
         : 'ref';
+    // The canonical form imports `template` from '@pikku/core/workflow' and calls
+    // it inside a single-param `(ref) => (...)` arrow; the older form passes it as
+    // a second arrow parameter. Support both — default to the imported name so a
+    // `template(...)` value is never dropped just because it isn't a 2nd param.
     const templateParamName = node.parameters.length > 1 && ts.isIdentifier(node.parameters[1].name)
         ? node.parameters[1].name.text
-        : undefined;
+        : 'template';
     const input = {};
     for (const prop of bodyObj.properties) {
         if (!ts.isPropertyAssignment(prop))
@@ -138,6 +147,12 @@ function extractInputMapping(node, _checker) {
  * Extract next config (string, array, or record)
  */
 function extractNextConfig(node, _checker) {
+    // Key-based branch `next` (`{ key: [targets] }`) is authored with an `as any`
+    // cast because the graph's NextConfig can't narrow record targets to node-id
+    // literals; see through that (and parens) so the routing survives into the meta.
+    while (ts.isAsExpression(node) || ts.isParenthesizedExpression(node)) {
+        node = node.expression;
+    }
     if (ts.isStringLiteral(node)) {
         return node.text;
     }
@@ -207,6 +222,7 @@ function extractWorkflowGraphConfig(configArg, checker) {
     let name;
     let description;
     let tags;
+    let notes;
     let disabled;
     let nodesNode;
     let configNode;
@@ -231,6 +247,12 @@ function extractWorkflowGraphConfig(configArg, checker) {
                 .filter(ts.isStringLiteral)
                 .map((el) => el.text);
         }
+        else if (propName === 'notes' &&
+            ts.isArrayLiteralExpression(prop.initializer)) {
+            notes = prop.initializer.elements
+                .filter(ts.isStringLiteral)
+                .map((el) => el.text);
+        }
         else if (propName === 'nodes' &&
             ts.isObjectLiteralExpression(prop.initializer)) {
             nodesNode = prop.initializer;
@@ -240,7 +262,7 @@ function extractWorkflowGraphConfig(configArg, checker) {
             configNode = prop.initializer;
         }
     }
-    return { name, description, tags, disabled, nodesNode, configNode };
+    return { name, description, tags, notes, disabled, nodesNode, configNode };
 }
 /**
  * Extract graph nodes from the new pikkuWorkflowGraph format
@@ -283,6 +305,7 @@ function extractGraphFromNewFormat(nodesNode, configNode, checker, state) {
             onError: undefined,
             retries: undefined,
             retryDelay: undefined,
+            notes: undefined,
         };
     }
     // Extract config for each node from 'config' property
@@ -305,6 +328,7 @@ function extractGraphFromNewFormat(nodesNode, configNode, checker, state) {
                     nodes[nodeId].input = nodeConfig.input;
                     nodes[nodeId].retries = nodeConfig.retries;
                     nodes[nodeId].retryDelay = nodeConfig.retryDelay;
+                    nodes[nodeId].notes = nodeConfig.notes;
                 }
             }
         }
@@ -320,6 +344,7 @@ function extractNodeConfigFromObject(obj, checker) {
     let input = {};
     let retries = undefined;
     let retryDelay = undefined;
+    let notes = undefined;
     for (const prop of obj.properties) {
         if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name))
             continue;
@@ -346,8 +371,11 @@ function extractNodeConfigFromObject(obj, checker) {
                 retryDelay = prop.initializer.text;
             }
         }
+        else if (propName === 'notes') {
+            notes = extractStringLiteral(prop.initializer, checker);
+        }
     }
-    return { next, onError, input, retries, retryDelay };
+    return { next, onError, input, retries, retryDelay, notes };
 }
 /**
  * Inspector for pikkuWorkflowGraph() calls
@@ -402,6 +430,7 @@ export const addWorkflowGraph = (logger, node, checker, state) => {
         source: 'graph',
         description: graphConfig.description,
         tags: graphConfig.tags,
+        notes: graphConfig.notes,
         nodes: graphNodes,
         entryNodeIds,
     };

package/dist/add/add-workflow.js

@@ -62,8 +62,8 @@ function hasInlineSteps(steps) {
             if (step.defaultSteps && hasInlineSteps(step.defaultSteps))
                 return true;
         }
-        else if (step.type === 'fanout' && step.child) {
-            if (hasInlineSteps([step.child]))
+        else if (step.type === 'fanout' && step.body) {
+            if (hasInlineSteps(step.body))
                 return true;
         }
         else if (step.type === 'parallel' && step.children) {
@@ -80,6 +80,11 @@ export function collectInvokedRPCs(steps, rpcs) {
     for (const step of steps) {
         if (step.type === 'rpc' && step.rpcName) {
             rpcs.add(step.rpcName);
+            // The compensation handler is invoked at runtime too, so it has to be
+            // wired like any other step.
+            if (step.options?.onError) {
+                rpcs.add(step.options.onError);
+            }
         }
         else if (step.type === 'branch') {
             for (const branch of step.branches) {
@@ -96,8 +101,8 @@ export function collectInvokedRPCs(steps, rpcs) {
             if (step.defaultSteps)
                 collectInvokedRPCs(step.defaultSteps, rpcs);
         }
-        else if (step.type === 'fanout' && step.child) {
-            collectInvokedRPCs([step.child], rpcs);
+        else if (step.type === 'fanout' && step.body) {
+            collectInvokedRPCs(step.body, rpcs);
         }
         else if (step.type === 'parallel' && step.children) {
             collectInvokedRPCs(step.children, rpcs);

package/dist/error-codes.d.ts

@@ -22,6 +22,9 @@ export declare enum ErrorCode {
     EXPECT_EVENTUALLY_SCENARIO_ONLY = "PKU675",
     WORKFLOW_ORCHESTRATOR_NOT_CONFIGURED = "PKU600",
     INVALID_DSL_WORKFLOW = "PKU641",
+    WORKFLOW_GRAPH_ADDON_NOT_WIRED = "PKU642",
+    REMOTE_ADDON_NOT_DEV_DEPENDENCY = "PKU338",
+    REMOTE_ADDON_AUTH_UNRESOLVED = "PKU339",
     DB_COLUMN_NAME_TYPE_CONTRADICTION = "PKU480",
     DB_JSON_COLUMN_UNTYPED = "PKU481",
     DB_FORMAT_ON_NON_STRING = "PKU482",

package/dist/error-codes.js

@@ -24,6 +24,10 @@ export var ErrorCode;
     ErrorCode["EXPECT_EVENTUALLY_SCENARIO_ONLY"] = "PKU675";
     ErrorCode["WORKFLOW_ORCHESTRATOR_NOT_CONFIGURED"] = "PKU600";
     ErrorCode["INVALID_DSL_WORKFLOW"] = "PKU641";
+    ErrorCode["WORKFLOW_GRAPH_ADDON_NOT_WIRED"] = "PKU642";
+    // Remote addon (wireRemoteAddon) validation
+    ErrorCode["REMOTE_ADDON_NOT_DEV_DEPENDENCY"] = "PKU338";
+    ErrorCode["REMOTE_ADDON_AUTH_UNRESOLVED"] = "PKU339";
     // Database schema codegen warnings
     ErrorCode["DB_COLUMN_NAME_TYPE_CONTRADICTION"] = "PKU480";
     ErrorCode["DB_JSON_COLUMN_UNTYPED"] = "PKU481";