@pikku/inspector 0.12.47 → 0.12.48

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

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import { isWorkflowDoCall, isWorkflowExpectEventuallyCall, extractActorFromOptions, isWorkflowSleepCall, isWorkflowSuspendCall, isWorkflowApprovalCall, isThrowCancelException, extractCancelReason, isParallelFanout, isParallelGroup, isSequentialFanout, isArrayFilter, isArraySome, isArrayEvery, extractForOfVariable, isArrayType, getSourceText, extractSourcePath, } from './patterns.js';
+import { isWorkflowDoCall, isWorkflowExpectEventuallyCall, isScenarioStepCall, getScenarioStepPhase, DYNAMIC_SCENARIO_STEP_TARGET, extractActorFromOptions, isWorkflowSleepCall, isWorkflowSuspendCall, 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';
 /**
@@ -17,7 +17,7 @@ export function extractDSLWorkflow(funcNode, checker, options) {
         }
         // Extract input parameter name (second parameter)
         const inputParamName = extractInputParamName(arrowFunc);
-        if (!inputParamName) {
+        if (inputParamName === undefined) {
             return {
                 status: 'error',
                 reason: 'Could not determine input parameter name',
@@ -121,7 +121,13 @@ function findWorkflowFunction(node) {
     return null;
 }
 /**
- * Extract the input parameter name from the arrow function
+ * Extract the input parameter name from the arrow function.
+ *
+ * Returns `null` when no input parameter is declared at all. That is
+ * legitimate — a workflow may ignore its input — and nothing in the body can
+ * reference it, so every name comparison against `null` correctly fails.
+ * Returns `undefined` when an input parameter is declared but is not a plain
+ * identifier (destructured), which the extractor cannot track by name.
  */
 function extractInputParamName(arrowFunc) {
     if (arrowFunc.parameters.length < 2) {
@@ -131,7 +137,7 @@ function extractInputParamName(arrowFunc) {
     if (ts.isIdentifier(secondParam.name)) {
         return secondParam.name.text;
     }
-    return null;
+    return undefined;
 }
 /**
  * Extract steps from the function body
@@ -179,7 +185,33 @@ function extractStep(statement, context) {
     }
     // For-of statement (sequential fanout)
     if (ts.isForOfStatement(statement)) {
-        return extractSequentialFanout(statement, context);
+        const reason = {};
+        const fanout = extractSequentialFanout(statement, context, reason);
+        if (!fanout && containsWorkflowCall(statement.statement, context.checker)) {
+            // A for-of the DSL can't model as a sequential fanout (its iterable is not
+            // a data-array identifier/field — e.g. a counting loop
+            // `for (const i of [...Array(N).keys()])`). Silently returning null here
+            // used to drop the loop AND every `workflow.do` inside it, so the workflow
+            // serialized with zero steps and its step functions were never registered
+            // (→ runtime "Function not found"). Fail loudly instead: pikkuWorkflowFunc
+            // reports INVALID_DSL_WORKFLOW; pikkuWorkflowComplexFunc falls back to the
+            // basic AST walk (which DOES register loop-invoked functions), so a genuine
+            // control-flow loop belongs in a complex workflow.
+            //
+            // Guarded on the body actually containing a workflow call: a loop that only
+            // massages locals (building a lookup, summing a total) has no step to lose,
+            // and erroring on it would be a false positive — the whole hazard is a
+            // dropped `workflow.do`, not a dropped `for`.
+            context.errors.push({
+                message: `The for-of loop '${statement.getText().slice(0, 60)}' can't be expressed in a DSL workflow — ` +
+                    (reason.message ??
+                        `its iterable must be a data array (an identifier or field like 'data.items'), not a computed/inline ` +
+                            `iterable such as '[...Array(n).keys()]'. Use pikkuWorkflowComplexFunc for a control-flow/counting loop, ` +
+                            `or iterate over a real input array.`),
+                node: statement,
+            });
+        }
+        return fanout;
     }
     // Return statement
     if (ts.isReturnStatement(statement)) {
@@ -231,10 +263,12 @@ function extractVariableDeclaration(statement, context) {
     // Check for await workflow.do(...)
     if (ts.isAwaitExpression(init) && ts.isCallExpression(init.expression)) {
         const call = init.expression;
-        if (isWorkflowDoCall(call, context.checker)) {
-            const step = isInlineDoCall(call)
-                ? extractInlineStep(call, context)
-                : extractRpcStep(call, context, varName);
+        if (isWorkflowDoCall(call, context.checker) || isScenarioStepCall(call)) {
+            const step = isScenarioStepCall(call)
+                ? extractScenarioStep(call, context, varName)
+                : isInlineDoCall(call)
+                    ? extractInlineStep(call, context)
+                    : extractRpcStep(call, context, varName);
             if (step) {
                 // Track output variable
                 const type = context.checker.getTypeAtLocation(decl);
@@ -356,6 +390,7 @@ function extractDestructuredDeclaration(statement, decl, context) {
         : null;
     const destructuresAStep = stepCall !== null &&
         (isWorkflowDoCall(stepCall, context.checker) ||
+            isScenarioStepCall(stepCall) ||
             isParallelGroup(stepCall) ||
             isParallelFanout(stepCall));
     if (!destructuresAStep)
@@ -413,10 +448,12 @@ function extractExpressionStatement(statement, context) {
     // await workflow.do(...)
     if (ts.isAwaitExpression(expr) && ts.isCallExpression(expr.expression)) {
         const call = expr.expression;
-        if (isWorkflowDoCall(call, context.checker)) {
-            const step = isInlineDoCall(call)
-                ? extractInlineStep(call, context)
-                : extractRpcStep(call, context, outputVar);
+        if (isWorkflowDoCall(call, context.checker) || isScenarioStepCall(call)) {
+            const step = isScenarioStepCall(call)
+                ? extractScenarioStep(call, context, outputVar)
+                : isInlineDoCall(call)
+                    ? extractInlineStep(call, context)
+                    : extractRpcStep(call, context, outputVar);
             // Track output variable if this is an assignment
             if (outputVar && step) {
                 const type = context.checker.getTypeAtLocation(expr);
@@ -496,6 +533,57 @@ function extractRpcStep(call, context, outputVar) {
         return null;
     }
 }
+/**
+ * Extract a scenario step from scenario.step/given/when/then(stepName,
+ * stepFunc, data?, options?).
+ *
+ * The step target must be a static string literal so it can be bundled, typed
+ * and drawn. When it isn't, the step is still recorded — with a `<dynamic>`
+ * target — so post-processing can raise PKU678 rather than the call silently
+ * vanishing from the graph.
+ */
+function extractScenarioStep(call, context, outputVar) {
+    const phase = getScenarioStepPhase(call);
+    if (!phase) {
+        return null;
+    }
+    const args = call.arguments;
+    if (args.length < 2) {
+        return null;
+    }
+    try {
+        const stepName = extractStringLiteral(args[0], context.checker);
+        let stepFunc = DYNAMIC_SCENARIO_STEP_TARGET;
+        try {
+            stepFunc = extractStringLiteral(args[1], context.checker);
+        }
+        catch {
+            // Left as '<dynamic>' — validated in post-processing (PKU678).
+        }
+        const inputs = args.length >= 3 ? extractInputSources(args[2], context) : undefined;
+        const optionsArg = args.length >= 4 ? args[3] : undefined;
+        const options = optionsArg && ts.isObjectLiteralExpression(optionsArg)
+            ? extractStepOptions(optionsArg, context)
+            : undefined;
+        return {
+            type: 'scenarioStep',
+            stepName,
+            stepFunc,
+            phase,
+            outputVar,
+            inputs,
+            options,
+            actor: extractActorFromOptions(optionsArg),
+        };
+    }
+    catch (error) {
+        context.errors.push({
+            message: `Failed to extract scenario step: ${error instanceof Error ? error.message : String(error)}`,
+            node: call,
+        });
+        return null;
+    }
+}
 /**
  * Extract inline step from workflow.do() call with a function argument
  */
@@ -952,11 +1040,14 @@ function extractFanoutBodyStep(stmt, childContext, body) {
             return;
         }
         const call = init.expression;
-        if (!isWorkflowDoCall(call, childContext.checker)) {
+        if (!isWorkflowDoCall(call, childContext.checker) &&
+            !isScenarioStepCall(call)) {
             return;
         }
         const varName = ts.isIdentifier(decl.name) ? decl.name.text : undefined;
-        const step = extractRpcStep(call, childContext, varName);
+        const step = isScenarioStepCall(call)
+            ? extractScenarioStep(call, childContext, varName)
+            : extractRpcStep(call, childContext, varName);
         if (!step) {
             return;
         }
@@ -999,6 +1090,13 @@ function extractFanoutBodyStep(stmt, childContext, body) {
             }
             return;
         }
+        if (isScenarioStepCall(call)) {
+            const scenarioStep = extractScenarioStep(call, childContext);
+            if (scenarioStep) {
+                body.push(scenarioStep);
+            }
+            return;
+        }
         if (!isWorkflowDoCall(call, childContext.checker)) {
             return;
         }
@@ -1059,7 +1157,13 @@ function extractParallelFanout(call, context) {
             : ts.isCallExpression(expr)
                 ? expr
                 : null;
-        if (doCall && isWorkflowDoCall(doCall, context.checker)) {
+        if (doCall && isScenarioStepCall(doCall)) {
+            const step = extractScenarioStep(doCall, childContext);
+            if (step) {
+                body.push(step);
+            }
+        }
+        else if (doCall && isWorkflowDoCall(doCall, context.checker)) {
             const step = extractRpcStep(doCall, childContext);
             if (step) {
                 body.push(step);
@@ -1087,7 +1191,16 @@ function extractParallelGroup(call, context) {
     }
     const children = [];
     for (const elem of arrayArg.elements) {
-        if (ts.isCallExpression(elem) && isWorkflowDoCall(elem, context.checker)) {
+        if (!ts.isCallExpression(elem)) {
+            continue;
+        }
+        if (isScenarioStepCall(elem)) {
+            const step = extractScenarioStep(elem, context);
+            if (step) {
+                children.push(step);
+            }
+        }
+        else if (isWorkflowDoCall(elem, context.checker)) {
             const step = extractRpcStep(elem, context);
             if (step) {
                 children.push(step);
@@ -1105,7 +1218,35 @@ function extractParallelGroup(call, context) {
 /**
  * Extract sequential fanout from for-of loop
  */
-function extractSequentialFanout(statement, context) {
+/**
+ * Does this subtree call the workflow wire at all?
+ *
+ * Used to tell "the DSL can't model this loop, and a step would be silently
+ * lost" from "the DSL can't model this loop, and there is nothing in it to
+ * lose". Only the first is worth failing a build over.
+ */
+function containsWorkflowCall(node, checker) {
+    let found = false;
+    const visit = (child) => {
+        if (found)
+            return;
+        if (ts.isCallExpression(child)) {
+            if (isWorkflowDoCall(child, checker) ||
+                isScenarioStepCall(child) ||
+                isWorkflowSleepCall(child, checker) ||
+                isWorkflowSuspendCall(child, checker) ||
+                isWorkflowApprovalCall(child, checker) ||
+                isWorkflowExpectEventuallyCall(child)) {
+                found = true;
+                return;
+            }
+        }
+        ts.forEachChild(child, visit);
+    };
+    visit(node);
+    return found;
+}
+function extractSequentialFanout(statement, context, reason) {
     if (!isSequentialFanout(statement)) {
         return null;
     }
@@ -1189,6 +1330,16 @@ function extractSequentialFanout(statement, context) {
         }
     }
     if (body.length === 0) {
+        // The iterable was fine — the body yielded nothing the DSL can model. The
+        // usual cause is a `workflow.do` nested inside an `if`/`switch`, because
+        // `FanoutStepMeta['body']` is a flat list of steps with no branch member:
+        // the DSL has no way to say "conditionally run this step per item".
+        const branching = bodyStatements.some((stmt) => ts.isIfStatement(stmt) || ts.isSwitchStatement(stmt));
+        if (reason) {
+            reason.message = branching
+                ? `its body only calls 'workflow.do' inside an if/switch, and a DSL fanout body is a flat list of steps with no branch member — the DSL cannot express a per-item condition. Use pikkuWorkflowComplexFunc, or lift the condition out of the loop.`
+                : `its body contains no 'workflow.do' call the DSL can model. Use pikkuWorkflowComplexFunc for a loop that does other work.`;
+        }
         return null;
     }
     return {
@@ -1374,7 +1525,11 @@ function extractInputSources(node, context) {
                     source = { from: 'outputVar', name: varName };
                 }
                 else {
-                    source = { from: 'input', path: varName };
+                    const constant = resolveConstantValue(prop.name, context.checker);
+                    source =
+                        constant !== undefined
+                            ? { from: 'literal', value: constant }
+                            : { from: 'input', path: varName };
                 }
             }
             else if (ts.isPropertyAssignment(prop)) {
@@ -1449,6 +1604,10 @@ function extractInputSource(node, context) {
         if (context.outputVars.has(varName)) {
             return { from: 'outputVar', name: varName };
         }
+        const constant = resolveConstantValue(node, context.checker);
+        if (constant !== undefined) {
+            return { from: 'literal', value: constant };
+        }
         // Assume it's from input
         return { from: 'input', path: varName };
     }
@@ -1528,6 +1687,31 @@ function extractInputSource(node, context) {
     }
     return null;
 }
+/**
+ * Resolve an identifier that names a constant to the value it was declared with.
+ *
+ * Without this, a name the extractor does not recognise falls through to
+ * `{ from: 'input' }` and is serialized as `{ $ref: 'trigger', path: <name> }` —
+ * so a module-level `const RESOURCE_ID = 'x'` used as step input silently
+ * becomes a read of a trigger field that does not exist. Only `const`
+ * declarations with a fully literal initializer resolve; anything else (a name
+ * bound out of the trigger, a computed value) falls through unchanged.
+ */
+function resolveConstantValue(node, checker) {
+    const symbol = checker.getSymbolAtLocation(node);
+    const declaration = symbol?.valueDeclaration ?? symbol?.declarations?.[0];
+    if (!declaration || !ts.isVariableDeclaration(declaration)) {
+        return undefined;
+    }
+    const declarationList = declaration.parent;
+    if (!ts.isVariableDeclarationList(declarationList) ||
+        !(declarationList.flags & ts.NodeFlags.Const)) {
+        return undefined;
+    }
+    return declaration.initializer
+        ? extractLiteralValue(declaration.initializer)
+        : undefined;
+}
 /**
  * Extract a literal value from an expression
  */

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

@@ -13,6 +13,26 @@ 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>";
+declare const SCENARIO_STEP_PHASES: readonly ["step", "given", "when", "then"];
+export type ScenarioStepPhaseName = (typeof SCENARIO_STEP_PHASES)[number];
+/**
+ * Check if a call expression is scenario.step()/given()/when()/then() — a
+ * declared `pikkuScenarioStep` invoked by name. `given`/`when`/`then` are pure
+ * sugar over `step`: the phase only changes the prose a reporter renders.
+ */
+export declare function isScenarioStepCall(node: ts.CallExpression): boolean;
+/**
+ * The Gherkin-style phase of a scenario step call, or undefined when the call
+ * isn't one.
+ */
+export declare function getScenarioStepPhase(node: ts.CallExpression): ScenarioStepPhaseName | undefined;
 /**
  * Check if a call expression is workflow.expectEventually()
  */
@@ -87,3 +107,4 @@ 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,6 +24,36 @@ 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>';
+const SCENARIO_STEP_PHASES = ['step', 'given', 'when', 'then'];
+/**
+ * Check if a call expression is scenario.step()/given()/when()/then() — a
+ * declared `pikkuScenarioStep` invoked by name. `given`/`when`/`then` are pure
+ * sugar over `step`: the phase only changes the prose a reporter renders.
+ */
+export function isScenarioStepCall(node) {
+    return getScenarioStepPhase(node) !== undefined;
+}
+/**
+ * The Gherkin-style phase of a scenario step call, or undefined when the call
+ * isn't one.
+ */
+export function getScenarioStepPhase(node) {
+    if (!ts.isPropertyAccessExpression(node.expression)) {
+        return;
+    }
+    const propAccess = node.expression;
+    if (!isWorkflowWireIdentifier(propAccess.expression)) {
+        return;
+    }
+    return SCENARIO_STEP_PHASES.find((phase) => phase === propAccess.name.text);
+}
 /**
  * Check if a call expression is workflow.expectEventually()
  */

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

@@ -18,6 +18,11 @@ export interface ValidationError {
  * - ReturnStatement
  * - ThrowStatement (for WorkflowCancelledException)
  * - Block (containers)
+ *
+ * When `allowInline` is set (complex workflows and scenarios), the bodies of
+ * closures are skipped: a callback is ordinary TypeScript, not DSL, so holding
+ * it to the statement whitelist would reject valid code. Plain DSL workflows
+ * still descend into callbacks, which is what validates fanout bodies.
  */
 export declare function validateNoDisallowedPatterns(node: ts.Node, options?: {
     allowInline?: boolean;

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

@@ -12,6 +12,11 @@ import { isWorkflowWireIdentifier } from './patterns.js';
  * - ReturnStatement
  * - ThrowStatement (for WorkflowCancelledException)
  * - Block (containers)
+ *
+ * When `allowInline` is set (complex workflows and scenarios), the bodies of
+ * closures are skipped: a callback is ordinary TypeScript, not DSL, so holding
+ * it to the statement whitelist would reject valid code. Plain DSL workflows
+ * still descend into callbacks, which is what validates fanout bodies.
  */
 export function validateNoDisallowedPatterns(node, options) {
     const errors = [];
@@ -38,6 +43,10 @@ export function validateNoDisallowedPatterns(node, options) {
         }
     }
     function visitNode(node) {
+        if (options?.allowInline &&
+            (ts.isArrowFunction(node) || ts.isFunctionExpression(node))) {
+            return;
+        }
         // Disallow while and do-while
         if (ts.isWhileStatement(node) || ts.isDoStatement(node)) {
             errors.push({

package/dist/utils/workflow/graph/convert-dsl-to-graph.js

@@ -103,6 +103,41 @@ function convertStepToNode(step, index, steps, nodeIdPrefix = 'step') {
             }
             return [node];
         }
+        // A declared step is a function node like any other — the console draws it
+        // the same way, with the phase available for the "Given/When/Then" prose.
+        case 'scenarioStep': {
+            const node = {
+                nodeId,
+                rpcName: step.stepFunc,
+                stepName: step.stepName,
+                scenarioStepPhase: step.phase,
+                next: nextNodeId,
+            };
+            if (step.actor) {
+                node.actor = step.actor;
+            }
+            if (step.inputs) {
+                if (step.inputs === 'passthrough') {
+                    node.input = { $passthrough: { $ref: 'trigger' } };
+                }
+                else {
+                    node.input = {};
+                    for (const [key, source] of Object.entries(step.inputs)) {
+                        node.input[key] = convertInputSource(source);
+                    }
+                }
+            }
+            if (step.outputVar) {
+                node.outputVar = step.outputVar;
+            }
+            if (step.options) {
+                node.options = {
+                    retries: step.options.retries,
+                    retryDelay: step.options.retryDelay,
+                };
+            }
+            return [node];
+        }
         case 'sleep': {
             const node = {
                 nodeId,
@@ -384,6 +419,7 @@ export function convertDslToGraph(workflowName, meta) {
         title: meta.title,
         description: meta.description,
         tags: meta.tags,
+        skip: meta.skip,
         actors: meta.actors,
         context: meta.context,
         nodes: nodesRecord,

package/dist/utils/workflow/graph/workflow-graph.types.d.ts

@@ -67,7 +67,7 @@ export interface NodeOptions {
  * Flow node types for control flow (no RPC call)
  */
 export type FlowType = 'sleep' | 'suspend' | 'approval' | 'branch' | 'parallel' | 'fanout' | 'inline' | 'switch' | 'filter' | 'arrayPredicate' | 'return' | 'cancel' | 'set';
-import type { ContextVariable, WorkflowContext, WorkflowPlannedStep } from '@pikku/core/workflow';
+import type { ContextVariable, ScenarioStepPhase, WorkflowContext, WorkflowPlannedStep } from '@pikku/core/workflow';
 export type { ContextVariable, WorkflowContext };
 /**
  * Base node properties shared by all node types
@@ -102,6 +102,8 @@ export interface FunctionNode extends BaseNode {
     actor?: string;
     /** True for workflow.expectEventually polling steps (scenarios) */
     expectEventually?: boolean;
+    /** Gherkin-style phase for a declared scenario step (scenario.given/when/then) */
+    scenarioStepPhase?: ScenarioStepPhase;
 }
 /**
  * Flow node - control flow only, no RPC call
@@ -150,6 +152,8 @@ export interface SerializedWorkflowGraph {
     tags?: string[];
     /** Actor names a scenario's steps run as */
     actors?: string[];
+    /** Why a scenario is held out of a default run, stated where it is declared */
+    skip?: string;
     /** If true, workflow always executes inline without queues */
     inline?: boolean;
     /** Workflow context/state variables (from Zod schema) */

package/dist/visit.js

@@ -25,6 +25,7 @@ import { addCredential } from './add/add-credential.js';
 import { addScope } from './add/add-scope.js';
 import { addVariable } from './add/add-variable.js';
 import { addWorkflowGraph } from './add/add-workflow-graph.js';
+import { addFeature } from './add/add-feature.js';
 import { addAIAgent } from './add/add-ai-agent.js';
 import { addApprovalDescription } from './add/add-approval-description.js';
 export const visitSetup = (logger, checker, node, state, options) => {
@@ -81,6 +82,7 @@ export const visitRoutes = (logger, checker, node, state, options) => {
     addMCPResource(logger, node, checker, state, nextOptions);
     addMCPPrompt(logger, node, checker, state, nextOptions);
     addWorkflowGraph(logger, node, checker, state, nextOptions);
+    addFeature(logger, node, checker, state, nextOptions);
     addAIAgent(logger, node, checker, state, nextOptions);
     ts.forEachChild(node, (child) => visitRoutes(logger, checker, child, state, nextOptions));
 };

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@pikku/inspector",
-  "version": "0.12.47",
+  "version": "0.12.48",
+  "description": "TypeScript inspector for Pikku — discovers functions and wirings to drive code generation",
   "author": "yasser.fadl@gmail.com",
   "license": "BUSL-1.1",
   "type": "module",
@@ -44,10 +45,10 @@
     "zod-to-ts": "^2.1.0"
   },
   "peerDependencies": {
-    "@pikku/core": "^0.12.68"
+    "@pikku/core": "^0.12.70"
   },
   "devDependencies": {
-    "@pikku/core": "^0.12.68",
+    "@pikku/core": "^0.12.70",
     "@types/node": "^24.11.0"
   },
   "engines": {