@pikku/cli 0.11.3 → 0.12.0

package/dist/.pikku/variables/pikku-variable-types.gen.js

@@ -0,0 +1,4 @@
+/**
+ * This file was generated by @pikku/cli@0.12.0
+ */
+export { wireVariable } from '@pikku/core/variable';

package/dist/.pikku/variables/pikku-variables.gen.d.ts

@@ -0,0 +1,11 @@
+/**
+ * This file was generated by @pikku/cli@0.12.0
+ */
+import { TypedVariablesService as CoreTypedVariablesService } from '@pikku/core/services';
+import type { VariablesService } from '@pikku/core/services';
+export interface VariablesMap {
+}
+export type VariableId = keyof VariablesMap;
+export declare class TypedVariablesService extends CoreTypedVariablesService<VariablesMap> {
+    constructor(variables: VariablesService);
+}

package/dist/.pikku/variables/pikku-variables.gen.js

@@ -0,0 +1,10 @@
+/**
+ * This file was generated by @pikku/cli@0.12.0
+ */
+import { TypedVariablesService as CoreTypedVariablesService } from '@pikku/core/services';
+const VARIABLES_META = {};
+export class TypedVariablesService extends CoreTypedVariablesService {
+    constructor(variables) {
+        super(variables, VARIABLES_META);
+    }
+}

package/dist/.pikku/workflow/pikku-workflow-types.gen.d.ts

@@ -1,146 +1,28 @@
 /**
- * This file was generated by @pikku/cli@0.11.3
+ * This file was generated by @pikku/cli@0.12.0
  */
-/**
- * Workflow type definitions and helpers
- * Used for authoring both DSL and graph-based workflows
- */
-import { PikkuWorkflowWire, WorkflowStepOptions, WorkflowCancelledException } from '@pikku/core/workflow';
+import { WorkflowCancelledException } from '@pikku/core/workflow';
+import { template } from '@pikku/core/workflow';
+import { type PikkuWorkflowGraphConfig, type PikkuWorkflowGraphResult } from '@pikku/core/workflow';
+import type { PikkuWorkflowWire, WorkflowStepOptions } from '@pikku/core/workflow';
 export { WorkflowCancelledException };
 import type { PikkuFunctionSessionless, PikkuFunctionConfig } from '../function/pikku-function-types.gen.js';
 import type { RPCMap, FlattenedRPCMap } from '../rpc/pikku-rpc-wirings-map.internal.gen.d.js';
-import type { GraphNodeConfig, HTTPMethod } from '@pikku/core';
-/**
- * Typed workflow wire with RPC awareness
- * Provides type-safe workflow.do() for RPC steps
- */
+import type { WorkflowMap, GraphsMap } from './pikku-workflow-map.gen.d.js';
+export { template };
 export interface TypedWorkflow extends PikkuWorkflowWire {
     do<K extends keyof RPCMap>(stepName: string, rpcName: K, data: RPCMap[K]['input'], options?: WorkflowStepOptions): Promise<RPCMap[K]['output']>;
     do<T>(stepName: string, fn: () => T | Promise<T>, options?: WorkflowStepOptions): Promise<T>;
 }
-/**
- * Workflow function type with typed workflow service
- */
 export type PikkuFunctionWorkflow<In = unknown, Out = never> = PikkuFunctionSessionless<In, Out, 'workflow'>;
-/**
- * Creates a DSL-compatible workflow function (serializable, shows in Forge UI)
- */
 export declare const pikkuWorkflowFunc: <In, Out = unknown>(func: PikkuFunctionWorkflow<In, Out> | PikkuFunctionConfig<In, Out, "workflow", PikkuFunctionWorkflow<In, Out>>) => PikkuFunctionConfig<In, Out, "workflow", PikkuFunctionWorkflow<In, Out>>;
-/**
- * Creates a complex workflow function (arbitrary code, hidden from Forge UI)
- */
 export declare const pikkuWorkflowComplexFunc: <In, Out = unknown>(func: PikkuFunctionWorkflow<In, Out> | PikkuFunctionConfig<In, Out, "workflow", PikkuFunctionWorkflow<In, Out>>) => PikkuFunctionConfig<In, Out, "workflow", PikkuFunctionWorkflow<In, Out>>;
-/** HTTP wire configuration for graph workflows */
-interface GraphHttpWire<NodeIds extends string> {
-    route: string;
-    method: HTTPMethod;
-    startNode: NodeIds;
-}
-/** Channel wire configuration for graph workflows */
-interface GraphChannelWire<NodeIds extends string> {
-    name: string;
-    onConnect?: NodeIds;
-    onDisconnect?: NodeIds;
-    onMessage?: NodeIds;
-}
-/** Queue wire configuration for graph workflows */
-interface GraphQueueWire<NodeIds extends string> {
-    name: string;
-    startNode: NodeIds;
-}
-/** CLI wire configuration for graph workflows */
-interface GraphCliWire<NodeIds extends string> {
-    command: string;
-    startNode: NodeIds;
-}
-/** MCP wire configurations for graph workflows */
-interface GraphMcpWires<NodeIds extends string> {
-    tool?: Array<{
-        name: string;
-        startNode: NodeIds;
-    }>;
-    prompt?: Array<{
-        name: string;
-        startNode: NodeIds;
-    }>;
-    resource?: Array<{
-        uri: string;
-        startNode: NodeIds;
-    }>;
-}
-/** Schedule wire configuration for graph workflows */
-interface GraphScheduleWire<NodeIds extends string> {
-    cron?: string;
-    interval?: string;
-    startNode: NodeIds;
-}
-/** Trigger wire configuration for graph workflows */
-interface GraphTriggerWire<NodeIds extends string> {
-    name: string;
-    startNode: NodeIds;
-}
-/** All wire configurations for graph workflows */
-interface GraphWiresConfig<NodeIds extends string> {
-    http?: Array<GraphHttpWire<NodeIds>>;
-    channel?: Array<GraphChannelWire<NodeIds>>;
-    queue?: Array<GraphQueueWire<NodeIds>>;
-    cli?: Array<GraphCliWire<NodeIds>>;
-    mcp?: GraphMcpWires<NodeIds>;
-    schedule?: Array<GraphScheduleWire<NodeIds>>;
-    trigger?: Array<GraphTriggerWire<NodeIds>>;
-}
-/** Configuration for graph-based workflow */
-export interface PikkuWorkflowGraphConfig<FuncMap extends Record<string, keyof FlattenedRPCMap & string>, T> {
-    /** Workflow name (optional - defaults to exported variable name) */
-    name?: string;
-    /** Optional description */
-    description?: string;
-    /** Optional tags for organization */
-    tags?: string[];
-    /** Node to RPC function mapping */
-    nodes: FuncMap;
-    /** Wire configurations - how this workflow can be triggered */
-    wires?: GraphWiresConfig<Extract<keyof FuncMap, string>>;
-    /** Node configurations (next, input, onError) */
-    config?: T;
-}
-/** Result of pikkuWorkflowGraph - includes metadata for wiring */
-export interface PikkuWorkflowGraphResult<T, NodeIds extends string = string> {
-    __type: 'pikkuWorkflowGraph';
-    name?: string;
-    description?: string;
-    tags?: string[];
-    wires?: GraphWiresConfig<NodeIds>;
-    graph: T;
-}
-/**
- * Creates a graph-based workflow definition with metadata
- * Name defaults to the exported variable name if not provided.
- *
- * @example
- * // Name inferred from exported variable name
- * export const myWorkflow = pikkuWorkflowGraph({
- *   description: 'Handles user onboarding',
- *   tags: ['onboarding'],
- *   nodes: {
- *     entry: 'createUser',
- *     sendEmail: 'sendWelcomeEmail',
- *   },
- *   config: {
- *     entry: { next: 'sendEmail' },
- *     sendEmail: { input: (ref) => ({ to: ref('entry', 'email') }) },
- *   },
- * })
- */
-export declare function pikkuWorkflowGraph<const FuncMap extends Record<string, keyof FlattenedRPCMap & string>>(config: PikkuWorkflowGraphConfig<FuncMap, GraphNodeConfigMap<FuncMap>>): PikkuWorkflowGraphResult<Record<Extract<keyof FuncMap, string>, GraphNodeConfig<Extract<keyof FuncMap, string>>>, Extract<keyof FuncMap, string>>;
-/** Typed ref value */
 type TypedRef<T> = {
     $ref: string;
     path?: string;
 } & {
     __phantomType?: T;
 };
-/** Template string type - assignable to string fields */
 type TemplateString = {
     $template: {
         parts: string[];
@@ -152,30 +34,16 @@ type TemplateString = {
 } & {
     __brand: 'TemplateString';
 };
-/**
- * Creates a template string with variable interpolation
- * Uses indexed placeholders $0, $1, etc. with refs array
- *
- * @example
- * template('Hello $0, your order $1 is ready', [ref('trigger', 'name'), ref('step_0', 'orderId')])
- */
-export declare function template(templateStr: string, refs: TypedRef<unknown>[]): TemplateString;
-/** Map input type fields to allow TypedRef or TemplateString for any field */
 type InputWithRefs<T> = {
     [K in keyof T]?: T[K] | TypedRef<T[K]> | TypedRef<unknown> | TemplateString;
 };
-/** Get the input type for a node based on its RPC mapping */
 type NodeInputType<FuncMap extends Record<string, string>, K extends keyof FuncMap> = FuncMap[K] extends keyof FlattenedRPCMap ? InputWithRefs<FlattenedRPCMap[FuncMap[K]]['input']> : Record<string, unknown>;
-/** Get the output type keys for a node based on its RPC mapping */
 type NodeOutputKeys<FuncMap extends Record<string, string>, N extends string> = N extends keyof FuncMap ? FuncMap[N] extends keyof FlattenedRPCMap ? keyof FlattenedRPCMap[FuncMap[N]]['output'] & string : string : string;
-/** Ref function type with path validation */
 type RefFunction<FuncMap extends Record<string, string>> = {
     <N extends Extract<keyof FuncMap, string>>(nodeId: N, path: NodeOutputKeys<FuncMap, N>): TypedRef<unknown>;
     (nodeId: 'trigger' | '$item', path?: string): TypedRef<unknown>;
 };
-/** Template function type */
 type TemplateFunction = (templateStr: string, refs: TypedRef<unknown>[]) => TemplateString;
-/** Type helper for node configuration */
 type GraphNodeConfigMap<FuncMap extends Record<string, string>> = {
     [K in Extract<keyof FuncMap, string>]?: {
         next?: NextConfig<Extract<keyof FuncMap, string>>;
@@ -188,45 +56,25 @@ type NextConfig<NodeIds extends string> = NodeIds | NodeIds[] | {
     then: NodeIds;
     else?: NodeIds;
 };
-/** Workflow definition with DSL function */
-interface WorkflowDefinitionFunc {
-    /** Whether this workflow wiring is enabled (default: true) */
-    enabled?: boolean;
-    /** Wire configurations for the workflow */
-    wires: {
-        http?: {
-            route: string;
-            method: HTTPMethod;
-        };
-        channel?: string;
-        queue?: string;
+export declare function pikkuWorkflowGraph<const FuncMap extends Record<string, keyof FlattenedRPCMap & string>>(config: PikkuWorkflowGraphConfig<FuncMap, GraphNodeConfigMap<FuncMap>>): PikkuWorkflowGraphResult;
+export declare const workflow: <Name extends keyof WorkflowMap>(workflowName: Name, options?: {
+    pollIntervalMs?: number;
+}) => PikkuFunctionConfig<WorkflowMap[Name]["input"], WorkflowMap[Name]["output"], "session" | "rpc">;
+export declare const workflowStart: <Name extends keyof WorkflowMap>(workflowName: Name) => PikkuFunctionConfig<WorkflowMap[Name]["input"], {
+    runId: string;
+}, "session" | "rpc">;
+export declare const workflowStatus: <Name extends keyof WorkflowMap>(_workflowName: Name) => PikkuFunctionConfig<{
+    runId: string;
+}, {
+    id: string;
+    status: "running" | "completed" | "failed" | "cancelled";
+    output?: WorkflowMap[Name]["output"];
+    error?: {
+        message?: string;
     };
-    /** DSL workflow function */
-    func: PikkuFunctionConfig<any, any, 'workflow', PikkuFunctionWorkflow<any, any>>;
-}
-/** Workflow definition with graph */
-interface WorkflowDefinitionGraph<T, NodeIds extends string = string> {
-    /** Whether this workflow wiring is enabled (default: true) */
-    enabled?: boolean;
-    /** Graph workflow definition - wires are defined in the graph itself */
-    graph: PikkuWorkflowGraphResult<T, NodeIds>;
-}
-/**
- * Wire a workflow with wires
- * Accepts either a DSL function (func) or a graph definition (graph)
- *
- * @example
- * // DSL workflow
- * wireWorkflow({
- *   wires: { http: { route: '/start', method: 'post' } },
- *   func: myWorkflowFunc,
- * })
- *
- * @example
- * // Graph workflow - wires are defined in the graph itself
- * wireWorkflow({
- *   enabled: true,  // default: true
- *   graph: myGraphWorkflow,
- * })
- */
-export declare function wireWorkflow<T extends Record<string, GraphNodeConfig<Extract<keyof T, string>>>, NodeIds extends string = string>(definition: WorkflowDefinitionFunc | WorkflowDefinitionGraph<T, NodeIds>): void;
+}, "session" | "rpc">;
+export declare const graphStart: <Name extends keyof GraphsMap, Node extends string & keyof GraphsMap[Name]>(graphName: Name, startNode: Node) => PikkuFunctionConfig<GraphsMap[Name][Node] extends {
+    input: infer I;
+} ? I : never, {
+    runId: string;
+}, "session" | "rpc">;

package/dist/.pikku/workflow/pikku-workflow-types.gen.js

@@ -1,118 +1,30 @@
 /**
- * This file was generated by @pikku/cli@0.11.3
- */
-/**
- * Workflow type definitions and helpers
- * Used for authoring both DSL and graph-based workflows
+ * This file was generated by @pikku/cli@0.12.0
  */
 import { WorkflowCancelledException } from '@pikku/core/workflow';
-// Re-export WorkflowCancelledException for use in workflow functions
+import { workflow as coreWorkflow, workflowStart as coreWorkflowStart, workflowStatus as coreWorkflowStatus, graphStart as coreGraphStart, } from '@pikku/core/workflow';
+import { template } from '@pikku/core/workflow';
+import { pikkuWorkflowGraph as corePikkuWorkflowGraph, } from '@pikku/core/workflow';
 export { WorkflowCancelledException };
-import { createGraph, wireWorkflow as coreWireWorkflow } from '@pikku/core';
-/**
- * Creates a DSL-compatible workflow function (serializable, shows in Forge UI)
- */
+export { template };
 export const pikkuWorkflowFunc = (func) => {
     return typeof func === 'function' ? { func } : func;
 };
-/**
- * Creates a complex workflow function (arbitrary code, hidden from Forge UI)
- */
 export const pikkuWorkflowComplexFunc = (func) => {
     return typeof func === 'function' ? { func } : func;
 };
-// ============================================================================
-// Graph Workflow Types (pikkuWorkflowGraph)
-// ============================================================================
-/**
- * Type-safe graph builder with full RPC autocomplete
- */
-const graphBuilder = createGraph();
-/**
- * Creates a graph-based workflow definition with metadata
- * Name defaults to the exported variable name if not provided.
- *
- * @example
- * // Name inferred from exported variable name
- * export const myWorkflow = pikkuWorkflowGraph({
- *   description: 'Handles user onboarding',
- *   tags: ['onboarding'],
- *   nodes: {
- *     entry: 'createUser',
- *     sendEmail: 'sendWelcomeEmail',
- *   },
- *   config: {
- *     entry: { next: 'sendEmail' },
- *     sendEmail: { input: (ref) => ({ to: ref('entry', 'email') }) },
- *   },
- * })
- */
 export function pikkuWorkflowGraph(config) {
-    return {
-        __type: 'pikkuWorkflowGraph',
-        name: config.name,
-        description: config.description,
-        tags: config.tags,
-        wires: config.wires,
-        graph: graphBuilder(config.nodes, config.config),
-    };
-}
-/**
- * Creates a template string with variable interpolation
- * Uses indexed placeholders $0, $1, etc. with refs array
- *
- * @example
- * template('Hello $0, your order $1 is ready', [ref('trigger', 'name'), ref('step_0', 'orderId')])
- */
-export function template(templateStr, refs) {
-    const parts = [];
-    const expressions = [];
-    // Parse template string: "Hello $0" -> parts: ["Hello ", ""], use refs[0] for expression
-    const regex = /$(d+)/g;
-    let lastIndex = 0;
-    let match;
-    while ((match = regex.exec(templateStr)) !== null) {
-        // Add the part before this match
-        parts.push(templateStr.slice(lastIndex, match.index));
-        // Get the ref by index
-        const refIndex = parseInt(match[1], 10);
-        const refValue = refs[refIndex];
-        if (refValue) {
-            const expr = { $ref: refValue.$ref };
-            if (refValue.path) {
-                expr.path = refValue.path;
-            }
-            expressions.push(expr);
-        }
-        else {
-            expressions.push({ $ref: 'unknown' });
-        }
-        lastIndex = regex.lastIndex;
-    }
-    // Add the remaining part
-    parts.push(templateStr.slice(lastIndex));
-    return {
-        $template: { parts, expressions }
-    };
-}
-/**
- * Wire a workflow with wires
- * Accepts either a DSL function (func) or a graph definition (graph)
- *
- * @example
- * // DSL workflow
- * wireWorkflow({
- *   wires: { http: { route: '/start', method: 'post' } },
- *   func: myWorkflowFunc,
- * })
- *
- * @example
- * // Graph workflow - wires are defined in the graph itself
- * wireWorkflow({
- *   enabled: true,  // default: true
- *   graph: myGraphWorkflow,
- * })
- */
-export function wireWorkflow(definition) {
-    coreWireWorkflow(definition);
+    return corePikkuWorkflowGraph(config);
 }
+export const workflow = (workflowName, options) => {
+    return coreWorkflow(workflowName, options);
+};
+export const workflowStart = (workflowName) => {
+    return coreWorkflowStart(workflowName);
+};
+export const workflowStatus = (_workflowName) => {
+    return coreWorkflowStatus(_workflowName);
+};
+export const graphStart = (graphName, startNode) => {
+    return coreGraphStart(graphName, startNode);
+};

package/dist/.pikku/workflow/pikku-workflow-wirings-meta.gen.js

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.11.3
+ * This file was generated by @pikku/cli@0.12.0
  */
 import { pikkuState } from '@pikku/core';
 const workflowsMeta = {};

package/dist/.pikku/workflow/pikku-workflow-wirings.gen.d.ts

@@ -1,4 +1,4 @@
 export {};
 /**
- * This file was generated by @pikku/cli@0.11.3
+ * This file was generated by @pikku/cli@0.12.0
  */

package/dist/.pikku/workflow/pikku-workflow-wirings.gen.js

@@ -1,4 +1,4 @@
 export {};
 /**
- * This file was generated by @pikku/cli@0.11.3
+ * This file was generated by @pikku/cli@0.12.0
  */

package/dist/bin/pikku.js

@@ -1,50 +1,23 @@
 #!/usr/bin/env node
-import { Command } from 'commander';
-import { createConfig, createSingletonServices } from '../src/services.js';
-import { LocalVariablesService } from '@pikku/core/services';
-import { all as allCommand } from '../src/functions/commands/all.js';
-import { watch as watchCommand } from '../src/functions/commands/watch.js';
-// Import bootstrap if it exists
-try {
-    await import('../.pikku/pikku-bootstrap.gen.js');
-}
-catch {
-    // Bootstrap doesn't exist yet, continue anyway
-}
-const action = async (command, cliConfig) => {
-    const config = await createConfig(new LocalVariablesService(), cliConfig);
-    const services = await createSingletonServices(config);
-    if (command === 'watch') {
-        await watchCommand.func(services);
+import { existsSync } from 'fs';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { dirname, join } from 'path';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// Use the generated Pikku CLI
+const pikkuCliPath = join(__dirname, '../.pikku/cli/pikku-cli.gen.js');
+if (existsSync(pikkuCliPath)) {
+    try {
+        const { PikkuCLI } = await import(pathToFileURL(pikkuCliPath).href);
+        await PikkuCLI(process.argv.slice(2));
+        process.exit(0);
     }
-    else {
-        await allCommand.func(services);
+    catch (error) {
+        console.error('Failed to run Pikku CLI:', error.message);
+        process.exit(1);
     }
-};
-const all = (program, name, description) => {
-    program
-        .command(name, { isDefault: name === 'all' })
-        .description(description)
-        .option('--pikku-config-type', 'The type of your pikku config object')
-        .option('--singleton-services-factory-type', 'The type of your singleton services factory')
-        .option('--session-services-factory-type', 'The type of your wire services factory')
-        .option('-c, --config <string>', 'The path to pikku cli config file')
-        .option('-t, --tags <tags...>', 'Which tags to filter by')
-        .option('--types <types...>', 'Which types to filter by (http, channel, queue, scheduler, rpc, mcp)')
-        .option('-d, --directories <directories...>', 'Which directories to filter by')
-        .option('-n, --names <names...>', 'Filter functions by name patterns (supports wildcards)')
-        .option('--httpMethods <methods...>', 'Filter HTTP routes by methods (comma-separated)')
-        .option('--httpRoutes <routes...>', 'Filter HTTP routes by route patterns (comma-separated)')
-        .option('-s, --silent', 'Silent mode - only show critical errors')
-        .option('--info', 'Show info messages and above (info, warn, error, critical)')
-        .option('--verbose', 'Show all debug messages (most detailed)')
-        .option('--loglevel <level>', 'Set explicit log level (trace, debug, info, warn, error, critical)')
-        .option('--state-output <path>', 'Save inspector state to JSON file for reuse')
-        .option('--state-input <path>', 'Load inspector state from JSON file (skips inspection)')
-        .action((c) => action(name, c));
-};
-const program = new Command('pikku');
-program.usage('[command]');
-all(program, 'all', 'Generate all pikku wirings and files');
-all(program, 'watch', 'Watch for changes in pikku files');
-program.parse(process.argv);
+}
+else {
+    console.error('Pikku CLI not found. Run build.sh first.');
+    process.exit(1);
+}

package/dist/src/cli.wiring.js

@@ -1,6 +1,6 @@
 import { pikkuSchemas } from './functions/wirings/functions/schemas.js';
-import { pikkuFetch } from './functions/wirings/fetch/index.js';
-import { pikkuWebSocketTyped } from './functions/wirings/channels/pikku-command-websocket-typed.js';
+import { pikkuFetch } from './functions/runtimes/fetch/index.js';
+import { pikkuWebSocketTyped } from './functions/runtimes/websocket/pikku-command-websocket-typed.js';
 import { pikkuRPCClient } from './functions/wirings/rpc/pikku-command-rpc-client.js';
 import { pikkuQueueService } from './functions/wirings/queue/pikku-command-queue-service.js';
 import { pikkuOpenAPI } from './functions/wirings/http/pikku-command-openapi.js';
@@ -9,6 +9,9 @@ import { pikkuCLICommand, wireCLI } from '../.pikku/cli/pikku-cli-types.gen.js';
 import { all } from './functions/commands/all.js';
 import { bootstrap } from './functions/commands/bootstrap.js';
 import { watch } from './functions/commands/watch.js';
+import { consoleCommand } from './functions/commands/console.js';
+import { pikkuVersionsInit } from './functions/commands/versions-init.js';
+import { pikkuVersionsCheck } from './functions/commands/versions-check.js';
 // import { clientCLIRenderer } from './services.js'
 wireCLI({
     program: 'pikku',
@@ -77,6 +80,17 @@ wireCLI({
             func: watch,
             description: 'Watch for file changes and regenerate automatically',
         }),
+        console: pikkuCLICommand({
+            func: consoleCommand,
+            description: 'Start the Pikku Console UI with live file watching',
+            options: {
+                port: {
+                    description: 'Port for the console server',
+                    default: '51442',
+                    short: 'p',
+                },
+            },
+        }),
         schemas: pikkuCLICommand({
             func: pikkuSchemas,
             description: 'Generate JSON schemas for function input/output types',
@@ -105,5 +119,18 @@ wireCLI({
             func: pikkuNext,
             description: 'Generate Next.js backend and HTTP wrappers',
         }),
+        init: pikkuCLICommand({
+            func: pikkuVersionsInit,
+            description: 'Initialize project',
+            options: {
+                force: {
+                    description: 'Overwrite existing manifest',
+                },
+            },
+        }),
+        'versions-check': pikkuCLICommand({
+            func: pikkuVersionsCheck,
+            description: 'Validate function contracts against the version manifest',
+        }),
     },
 });

package/dist/src/functions/commands/all.d.ts

@@ -1 +1 @@
-export declare const all: any;
+export declare const all: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;