@pikku/cli 0.12.19 → 0.12.21

package/dist/src/functions/commands/deploy-apply.js

@@ -94,7 +94,6 @@ export async function resolveProvider(config, providerName) {
 }
 const ANSI = {
     green: '\x1b[32m',
-    red: '\x1b[31m',
     bold: '\x1b[1m',
     reset: '\x1b[0m',
 };
@@ -119,8 +118,12 @@ async function runDeploy(provider, providerDir, logger, resultFile) {
         deployResult = await provider.deploy({
             buildDir: providerDir,
             logger,
-            onProgress: (_step, _detail) => {
-                process.stdout.write(` ${ANSI.green}done${ANSI.reset}\n`);
+            onProgress: (step, detail) => {
+                logger.info({
+                    message: `[${step}] ${detail}`,
+                    type: 'progress',
+                    data: { progress: { step, detail } },
+                });
             },
         });
     }
@@ -132,7 +135,6 @@ async function runDeploy(provider, providerDir, logger, resultFile) {
         };
     }
     await writeResultFile(resultFile, deployResult);
-    console.log('');
     if (deployResult.success) {
         logger.info(`${ANSI.green}${ANSI.bold}Deployment complete.${ANSI.reset}`);
         logger.info(`  ${deployResult.workersDeployed?.length ?? 0} units deployed, ${deployResult.resourcesCreated?.length ?? 0} resources created`);

package/dist/src/functions/commands/deploy-plan.js

@@ -89,7 +89,13 @@ export const deployPlan = pikkuSessionlessFunc({
                 unitCount: result.bundled.length,
                 totalSizeBytes: totalSize,
                 errors: result.bundleErrors,
-                manifest: result.manifest,
+                codegenErrors: result.codegenErrors,
+                summary: plan.summary,
+                changeCount: plan.changes.length,
+                artifacts: {
+                    deploymentManifestPath: result.deploymentManifestPath,
+                    infraPath: result.infraPath,
+                },
             }, null, 2), 'utf-8');
         }
     },

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

@@ -0,0 +1,13 @@
+export declare const dev: import("#pikku").PikkuFunctionConfig<{
+    port?: string;
+    watch?: boolean;
+    hmr?: boolean;
+}, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<{
+    port?: string;
+    watch?: boolean;
+    hmr?: boolean;
+}, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+    port?: string;
+    watch?: boolean;
+    hmr?: boolean;
+}, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/commands/dev.js

@@ -0,0 +1,187 @@
+import { createServer } from 'http';
+import { join, resolve } from 'path';
+import { Readable } from 'stream';
+import { pikkuSessionlessFunc } from '#pikku';
+import chokidar from 'chokidar';
+import { pikkuDevReloader } from '@pikku/core/dev';
+import { ConsoleLogger, InMemoryQueueService, InMemoryWorkflowService, InMemoryTriggerService, InMemoryAIRunStateService, } from '@pikku/core/services';
+import { stopSingletonServices } from '@pikku/core';
+import { pikkuState } from '@pikku/core/internal';
+import { fetchData, PikkuFetchHTTPResponse, logRoutes, } from '@pikku/core/http';
+import { compileAllSchemas } from '@pikku/core/schema';
+import { pikkuWebsocketHandler } from '@pikku/ws';
+import { WebSocketServer } from 'ws';
+import { InMemorySchedulerService } from '@pikku/schedule';
+function incomingMessageToRequest(req) {
+    const url = new URL(req.url || '/', 'http://localhost');
+    const method = req.method ? req.method.toUpperCase() : 'GET';
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(req.headers)) {
+        if (value) {
+            headers.set(key, Array.isArray(value) ? value.join(', ') : value);
+        }
+    }
+    let body = null;
+    if (method !== 'GET' && method !== 'HEAD') {
+        body = Readable.toWeb(req);
+    }
+    return new Request(url.toString(), {
+        method,
+        headers,
+        body,
+        // @ts-ignore - duplex is needed for streaming body in Node.js
+        duplex: 'half',
+    });
+}
+async function writeResponse(nodeRes, webResponse) {
+    const headers = {};
+    webResponse.headers.forEach((value, name) => {
+        const lower = name.toLowerCase();
+        if (lower === 'set-cookie') {
+            const existing = headers[lower];
+            if (Array.isArray(existing)) {
+                existing.push(value);
+            }
+            else {
+                headers[lower] = [value];
+            }
+        }
+        else {
+            headers[lower] = value;
+        }
+    });
+    nodeRes.writeHead(webResponse.status, headers);
+    if (webResponse.body) {
+        const reader = webResponse.body.getReader();
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                nodeRes.write(value);
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    nodeRes.end();
+}
+export const dev = pikkuSessionlessFunc({
+    remote: true,
+    func: async ({ logger, config, getInspectorState }, { port, watch, hmr }, { rpc }) => {
+        const resolvedPort = parseInt(port || '3000', 10);
+        const hostname = 'localhost';
+        const enableWatch = watch !== false;
+        const enableHmr = hmr !== false;
+        await rpc.invoke('all');
+        const inspectorState = await getInspectorState(true);
+        const { pikkuConfigFactory, singletonServicesFactory } = inspectorState.filesAndMethods;
+        if (!pikkuConfigFactory || !singletonServicesFactory) {
+            logger.error('createConfig and createSingletonServices must be defined in your project');
+            return;
+        }
+        const pikkuDir = resolve(config.rootDir, config.outDir);
+        const bootstrapPath = join(pikkuDir, 'pikku-bootstrap.gen.js');
+        await import(bootstrapPath);
+        const configModule = await import(pikkuConfigFactory.file);
+        const servicesModule = await import(singletonServicesFactory.file);
+        const userCreateConfig = configModule[pikkuConfigFactory.variable];
+        const userCreateSingletonServices = servicesModule[singletonServicesFactory.variable];
+        const userConfig = await userCreateConfig();
+        const schedulerService = new InMemorySchedulerService();
+        const inMemoryServices = {
+            logger: new ConsoleLogger(),
+            schedulerService,
+            queueService: new InMemoryQueueService(),
+            workflowService: new InMemoryWorkflowService(),
+            triggerService: new InMemoryTriggerService(),
+            aiRunStateService: new InMemoryAIRunStateService(),
+        };
+        const singletonServices = await userCreateSingletonServices(userConfig, inMemoryServices);
+        pikkuState(null, 'package', 'singletonServices', singletonServices);
+        compileAllSchemas(logger);
+        logRoutes(logger);
+        const server = createServer(async (req, res) => {
+            const request = incomingMessageToRequest(req);
+            const pikkuResponse = new PikkuFetchHTTPResponse();
+            await fetchData(request, pikkuResponse, { respondWith404: true });
+            const response = pikkuResponse.toResponse();
+            await writeResponse(res, response);
+        });
+        const wss = new WebSocketServer({ noServer: true });
+        pikkuWebsocketHandler({ server, wss, logger });
+        await schedulerService.start();
+        await new Promise((resolve) => {
+            server.listen(resolvedPort, hostname, () => {
+                logger.info(`Dev server running at http://${hostname}:${resolvedPort}`);
+                resolve();
+            });
+        });
+        let configWatcher;
+        let watcher;
+        process.once('SIGINT', async () => {
+            logger.info('Stopping dev server...');
+            try {
+                await stopSingletonServices();
+                await configWatcher?.close();
+                await watcher?.close();
+                await new Promise((resolve, reject) => wss.close((err) => (err ? reject(err) : resolve())));
+                await new Promise((resolve, reject) => server.close((err) => (err ? reject(err) : resolve())));
+            }
+            finally {
+                process.exit(0);
+            }
+        });
+        if (enableHmr) {
+            await pikkuDevReloader({
+                srcDirectories: config.srcDirectories,
+                logger,
+            });
+        }
+        if (enableWatch) {
+            const genIgnore = /\.gen\.tsx?$/;
+            configWatcher = chokidar.watch(config.srcDirectories, {
+                ignoreInitial: true,
+                ignored: genIgnore,
+            });
+            const generatorWatcher = () => {
+                watcher?.close();
+                logger.info(`• Watching directories: \n  - ${config.srcDirectories.join('\n  - ')}`);
+                watcher = chokidar.watch(config.srcDirectories, {
+                    ignoreInitial: true,
+                    ignored: genIgnore,
+                });
+                watcher.on('ready', async () => {
+                    const handle = async () => {
+                        try {
+                            const start = Date.now();
+                            await rpc.invoke('all');
+                            logger.info({
+                                message: `✓ Generated in ${Date.now() - start}ms`,
+                                type: 'timing',
+                            });
+                        }
+                        catch (err) {
+                            logger.error(`Error running watch: ${err}`);
+                        }
+                    };
+                    await handle();
+                    let timeout;
+                    const deduped = (_file) => {
+                        if (timeout) {
+                            clearTimeout(timeout);
+                        }
+                        timeout = setTimeout(handle, 10);
+                    };
+                    watcher?.on('change', deduped);
+                    watcher?.on('add', deduped);
+                    watcher?.on('unlink', deduped);
+                });
+            };
+            configWatcher.on('ready', generatorWatcher);
+            configWatcher.on('change', generatorWatcher);
+        }
+        await new Promise(() => { });
+    },
+});

package/dist/src/functions/commands/pikku-command-summary.js

@@ -49,7 +49,10 @@ export const pikkuSummary = pikkuSessionlessFunc({
                 summary.set('workflowGraphs', workflowGraphsCount);
         }
         if (!logger.isSilent()) {
-            console.log(summary.format());
+            // Route through the logger so JSON mode emits a single NDJSON
+            // record instead of raw chalk-coloured text written directly to
+            // stdout (which would break NDJSON consumers).
+            logger.info({ message: summary.format(), type: 'summary' });
         }
     },
 });

package/dist/src/functions/commands/versions-update.js

@@ -7,12 +7,18 @@ export const pikkuVersionsUpdate = pikkuSessionlessFunc({
         const manifestPath = join(config.rootDir, 'versions.pikku.json');
         const visitState = await getInspectorState();
         if (!visitState.manifest.initial) {
-            throw new Error(`Version manifest not found at ${manifestPath}. Run 'pikku versions init' to create one.`);
+            logger.warn(`Run 'pikku versions init' to enable contract versioning.`);
+            return;
         }
         const immutabilityErrors = visitState.manifest.errors.filter((e) => e.code === ErrorCode.FUNCTION_VERSION_MODIFIED);
         if (immutabilityErrors.length > 0) {
-            const messages = immutabilityErrors.map((e) => `[${e.code}] ${e.message}`);
-            throw new Error(messages.join('\n'));
+            for (const e of immutabilityErrors) {
+                logger.critical(ErrorCode.FUNCTION_VERSION_MODIFIED, e.message);
+            }
+            if (logger.hasCriticalErrors()) {
+                process.exit(1);
+            }
+            return;
         }
         await saveManifest(manifestPath, visitState.manifest.current);
         logger.debug(`Version manifest updated at ${manifestPath}`);

package/dist/src/functions/wirings/channels/pikku-command-channels.d.ts

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

package/dist/src/functions/wirings/channels/pikku-command-channels.js

@@ -4,7 +4,7 @@ import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
-export const pikkuChannels = pikkuSessionlessFunc({
+export const pikkuCommandChannels = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
         const { channelsWiringFile, channelsWiringMetaFile, channelsWiringMetaJsonFile, packageMappings, schema, } = config;

package/dist/src/functions/wirings/console/pikku-command-console-functions.js

@@ -4,7 +4,11 @@ import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeConsoleFunctions } from './serialize-console-functions.js';
 export const pikkuConsoleFunctions = pikkuSessionlessFunc({
-    func: async ({ logger, config }) => {
+    func: async ({ logger, config, variables }) => {
+        const deployCodegenFlag = await variables.get('PIKKU_DEPLOY_CODEGEN');
+        if (deployCodegenFlag === '1') {
+            return false;
+        }
         if (config.scaffold?.console) {
             const pathToPikkuTypes = getFileImportRelativePath(config.consoleFunctionsFile, config.typesDeclarationFile, config.packageMappings);
             const pathToAgentTypes = getFileImportRelativePath(config.consoleFunctionsFile, config.agentTypesFile, config.packageMappings);

package/dist/src/functions/wirings/functions/serialize-function-types.js

@@ -12,7 +12,7 @@ export const serializeFunctionTypes = (userSessionTypeImport, userSessionTypeNam
  * Core function, middleware, and permission types for all wirings
  */
 
-import type { CorePikkuMiddleware, CorePermissionGroup, PikkuWire, PickRequired } from '@pikku/core'
+import type { CorePikkuMiddleware, CorePermissionGroup, ListInput, ListOutput, PikkuWire, PickRequired } from '@pikku/core'
 import type { CorePikkuFunctionConfig, CorePikkuAuth, CorePikkuAuthConfig, CorePikkuPermission } from '@pikku/core/function'
 import { pikkuAuth as pikkuAuthCore } from '@pikku/core/function'
 import { addMiddleware as addMiddlewareCore, addPermission as addPermissionCore } from '@pikku/core/middleware'
@@ -338,10 +338,13 @@ export type PikkuFunctionConfigWithSchema<
   RequiredWires extends keyof PikkuWire = never
 > = {
   name?: string
+  description?: string
   tags?: string[]
   expose?: boolean
   mcp?: boolean
   internal?: boolean
+  remote?: boolean
+  deploy?: 'serverless' | 'server' | 'auto'
   approvalRequired?: boolean
   approvalDescription?: InputSchema extends StandardSchemaV1 ? PikkuApprovalDescription<InferSchemaOutput<InputSchema>> : never
   func: PikkuFunction<
@@ -415,6 +418,32 @@ export function pikkuFunc(func: any) {
   return typeof func === 'function' ? { func } : func
 }
 
+export type PikkuListFunction<
+  F extends Record<string, unknown> = {},
+  Row = unknown,
+  S extends string = never
+> =
+  | PikkuFunction<ListInput<F, S>, ListOutput<Row>, 'session' | 'rpc'>
+  | PikkuFunctionSessionless<
+      ListInput<F, S>,
+      ListOutput<Row>,
+      'session' | 'rpc'
+    >
+
+export const pikkuListFunc = <
+  F extends Record<string, unknown> = {},
+  Row = unknown,
+  S extends string = never
+>(
+  config: PikkuFunctionConfig<
+    ListInput<F, S>,
+    ListOutput<Row>,
+    'session' | 'rpc'
+  >
+): PikkuFunctionConfig<ListInput<F, S>, ListOutput<Row>, 'session' | 'rpc'> => {
+  return pikkuFunc(config)
+}
+
 /**
  * Configuration object for sessionless Pikku functions with Zod schema validation.
  */
@@ -430,6 +459,7 @@ export type PikkuFunctionSessionlessConfigWithSchema<
   mcp?: boolean
   internal?: boolean
   remote?: boolean
+  deploy?: 'serverless' | 'server' | 'auto'
   approvalRequired?: boolean
   approvalDescription?: InputSchema extends StandardSchemaV1 ? PikkuApprovalDescription<InferSchemaOutput<InputSchema>> : never
   func: PikkuFunctionSessionless<

package/dist/src/functions/wirings/http/pikku-command-http-routes.d.ts

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

package/dist/src/functions/wirings/http/pikku-command-http-routes.js

@@ -4,7 +4,7 @@ import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
-export const pikkuHTTP = pikkuSessionlessFunc({
+export const pikkuCommandHTTP = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
         const { httpWiringsFile, httpWiringMetaFile, httpWiringMetaJsonFile, packageMappings, schema, } = config;

package/dist/src/functions/wirings/queue/pikku-command-queue-map.d.ts

@@ -1 +1 @@
-export declare const pikkuQueueMap: 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>;
+export declare const pikkuCommandQueueMap: 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>;

package/dist/src/functions/wirings/queue/pikku-command-queue-map.js

@@ -2,7 +2,7 @@ import { pikkuSessionlessFunc } from '#pikku';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeQueueMap } from './serialize-queue-map.js';
-export const pikkuQueueMap = pikkuSessionlessFunc({
+export const pikkuCommandQueueMap = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const { queueWorkers, functions, resolvedIOTypes } = await getInspectorState();
         const { queueMapDeclarationFile, packageMappings } = config;

package/dist/src/functions/wirings/queue/pikku-command-queue.d.ts

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

package/dist/src/functions/wirings/queue/pikku-command-queue.js

@@ -5,7 +5,7 @@ import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-
 import { serializeQueueMeta, serializeQueueMetaTS, } from './serialize-queue-meta.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
-export const pikkuQueue = pikkuSessionlessFunc({
+export const pikkuCommandQueue = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
         const { queueWorkersWiringFile, queueWorkersWiringMetaFile, queueWorkersWiringMetaJsonFile, packageMappings, schema, } = config;

package/dist/src/functions/wirings/rpc/pikku-command-public-rpc.js

@@ -4,7 +4,11 @@ import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializePublicRPC } from './serialize-public-rpc.js';
 export const pikkuPublicRPC = pikkuSessionlessFunc({
-    func: async ({ logger, config }) => {
+    func: async ({ logger, config, variables }) => {
+        const deployCodegenFlag = await variables.get('PIKKU_DEPLOY_CODEGEN');
+        if (deployCodegenFlag === '1') {
+            return false;
+        }
         if (config.scaffold?.rpc) {
             const pathToPikkuTypes = getFileImportRelativePath(config.publicRpcFile, config.typesDeclarationFile, config.packageMappings);
             await writeFileInDir(logger, config.publicRpcFile, serializePublicRPC(pathToPikkuTypes, config.scaffold.rpc === 'auth', config.globalHTTPPrefix || ''));

package/dist/src/functions/wirings/rpc/pikku-command-remote-rpc.js

@@ -4,7 +4,11 @@ import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeRemoteRPC } from './serialize-remote-rpc.js';
 export const pikkuRemoteRPC = pikkuSessionlessFunc({
-    func: async ({ logger, config }) => {
+    func: async ({ logger, config, variables }) => {
+        const deployCodegenFlag = await variables.get('PIKKU_DEPLOY_CODEGEN');
+        if (deployCodegenFlag === '1') {
+            return false;
+        }
         if (config.remoteRpcWorkersFile) {
             const pathToPikkuTypes = getFileImportRelativePath(config.remoteRpcWorkersFile, config.typesDeclarationFile, config.packageMappings);
             await writeFileInDir(logger, config.remoteRpcWorkersFile, serializeRemoteRPC(pathToPikkuTypes));

package/dist/src/functions/wirings/rpc/serialize-typed-rpc-map.js

@@ -41,13 +41,13 @@ ${addonImports}
 ${mergedRPCMap}
 
 export type RPCInvoke = <Name extends keyof FlattenedRPCMap>(
-  ...args: FlattenedRPCMap[Name]['input'] extends void | null
+  ...args: IsVoidishInput<FlattenedRPCMap[Name]['input']> extends true
     ? [name: Name]
     : [name: Name, data: FlattenedRPCMap[Name]['input']]
 ) => Promise<FlattenedRPCMap[Name]['output']>
 
 export type RPCRemote = <Name extends keyof FlattenedRPCMap>(
-  ...args: FlattenedRPCMap[Name]['input'] extends void | null
+  ...args: IsVoidishInput<FlattenedRPCMap[Name]['input']> extends true
     ? [name: Name]
     : [name: Name, data: FlattenedRPCMap[Name]['input']]
 ) => Promise<FlattenedRPCMap[Name]['output']>
@@ -117,6 +117,13 @@ function generateMergedRPCMap(wireAddonDeclarations) {
         return `
 // No addon packages, use RPCMap directly
 export type FlattenedRPCMap = RPCMap
+
+type IsAny<T> = 0 extends (1 & T) ? true : false
+type IsVoidishInput<T> = IsAny<T> extends true
+  ? false
+  : [T] extends [void | null | undefined]
+    ? true
+    : false
 `;
     }
     // TypeScript utility to flatten namespaced RPC maps
@@ -131,6 +138,13 @@ export type FlattenedRPCMap =
   RPCMap${Array.from(wireAddonDeclarations.keys())
         .map((namespace) => ` & PrefixKeys<${toPascalCase(namespace)}RPCMap, '${namespace}'>`)
         .join('')}
+
+type IsAny<T> = 0 extends (1 & T) ? true : false
+type IsVoidishInput<T> = IsAny<T> extends true
+  ? false
+  : [T] extends [void | null | undefined]
+    ? true
+    : false
 `;
     return utilityTypes;
 }

package/dist/src/functions/wirings/workflow/serialize-workflow-routes.js

@@ -25,7 +25,7 @@ export const workflowStarter = pikkuSessionlessFunc<
 >({
   auth: ${authFlag},
   func: async (_services, { workflowName, data }, { rpc }) => {
-    return await rpc.startWorkflow(workflowName as any, data ?? {})
+    return await rpc.startWorkflow(workflowName as any, (data ?? {}) as any)
   },
 })
 
@@ -68,6 +68,7 @@ export const workflowStatusStream = pikkuSessionlessFunc<
 
     const terminalStatuses = new Set(['completed', 'failed', 'cancelled'])
     let lastHash = ''
+    let initSent = false
 
     const poll = async () => {
       const run = await workflowRunService.getRun(runId)
@@ -78,6 +79,26 @@ export const workflowStatusStream = pikkuSessionlessFunc<
 
       const steps = await workflowRunService.getRunSteps(runId)
 
+      if (!initSent && run.deterministic) {
+        const statusByStep = new Map(
+          steps.map((s: { stepName: string; status: string }) => [
+            s.stepName,
+            s.status,
+          ])
+        )
+        channel.send({
+          type: 'init',
+          deterministic: true,
+          steps: (run.plannedSteps ?? []).map(
+            (s: { stepName: string }) => ({
+              stepName: s.stepName,
+              status: statusByStep.get(s.stepName) ?? 'pending',
+            })
+          ),
+        })
+        initSent = true
+      }
+
       const hash = JSON.stringify({
         s: run.status,
         steps: steps.map((s: { stepName: string; status: string }) => [s.stepName, s.status]),
@@ -133,6 +154,7 @@ export const workflowStatusStreamFull = pikkuSessionlessFunc<
 
     const terminalStatuses = new Set(['completed', 'failed', 'cancelled'])
     let lastHash = ''
+    let initSent = false
 
     const poll = async () => {
       const run = await workflowRunService.getRun(runId)
@@ -143,6 +165,26 @@ export const workflowStatusStreamFull = pikkuSessionlessFunc<
 
       const steps = await workflowRunService.getRunSteps(runId)
 
+      if (!initSent && run.deterministic) {
+        const statusByStep = new Map(
+          steps.map((s: { stepName: string; status: string }) => [
+            s.stepName,
+            s.status,
+          ])
+        )
+        channel.send({
+          type: 'init',
+          deterministic: true,
+          steps: (run.plannedSteps ?? []).map(
+            (s: { stepName: string }) => ({
+              stepName: s.stepName,
+              status: statusByStep.get(s.stepName) ?? 'pending',
+            })
+          ),
+        })
+        initSent = true
+      }
+
       const hash = JSON.stringify({
         s: run.status,
         o: run.output,
@@ -193,7 +235,7 @@ export const graphStarter = pikkuSessionlessFunc<
 >({
   auth: ${authFlag},
   func: async (_services, { workflowName, nodeId, data }, { rpc }) => {
-    return await rpc.startWorkflow(workflowName as any, data ?? {}, { startNode: nodeId })
+    return await rpc.startWorkflow(workflowName as any, (data ?? {}) as any, { startNode: nodeId })
   },
 })
 

package/dist/src/functions/workflows/all.workflow.js

@@ -128,7 +128,7 @@ export const allWorkflow = pikkuWorkflowComplexFunc({
         }
         if (!config.addon) {
             const [http, scheduler, triggers] = await Promise.all([
-                workflow.do('HTTP', 'pikkuHTTP', null),
+                workflow.do('HTTP', 'pikkuCommandHTTP', null),
                 workflow.do('Scheduler', 'pikkuScheduler', null),
                 workflow.do('Trigger', 'pikkuTrigger', null),
             ]);
@@ -158,15 +158,15 @@ export const allWorkflow = pikkuWorkflowComplexFunc({
         }
         if (!config.addon) {
             const [queues, channels, gateways, mcp, cli] = await Promise.all([
-                workflow.do('Queue', 'pikkuQueue', null),
-                workflow.do('Channels', 'pikkuChannels', null),
+                workflow.do('Queue', 'pikkuCommandQueue', null),
+                workflow.do('Channels', 'pikkuCommandChannels', null),
                 workflow.do('Gateway', 'pikkuGateway', null),
                 workflow.do('MCP', 'pikkuMCP', null),
                 workflow.do('CLI', 'pikkuCLI', null),
             ]);
             if (queues) {
                 await Promise.all([
-                    workflow.do('Queue map', 'pikkuQueueMap', null),
+                    workflow.do('Queue map', 'pikkuCommandQueueMap', null),
                     workflow.do('Queue service', 'pikkuQueueService', null),
                 ]);
                 allImports.push(config.queueWorkersWiringMetaFile, config.queueWorkersWiringFile);
@@ -200,12 +200,7 @@ export const allWorkflow = pikkuWorkflowComplexFunc({
             await workflow.do('OpenAPI re-inspect', async () => getInspectorState(true));
             await workflow.do('OpenAPI', 'pikkuOpenAPI', null);
         }
-        try {
-            await workflow.do('Versions update', 'pikkuVersionsUpdate', null);
-        }
-        catch {
-            logger.warn(`Run 'pikku versions init' to enable contract versioning.`);
-        }
+        await workflow.do('Versions update', 'pikkuVersionsUpdate', null);
         await workflow.do('Bootstrap', 'pikkuBootstrap', { allImports });
         await workflow.do('Summary', 'pikkuSummary', null);
     },

package/dist/src/scaffold/rpc-remote.gen.js

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.19
+ * This file was generated by @pikku/cli@0.12.21
  */
 /**
  * Auto-generated remote internal RPC queue worker and HTTP endpoint