@pikku/cli 0.11.3 → 0.12.1

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

@@ -1,13 +1,22 @@
 /**
  * Generates core function, middleware, and permission type definitions
  */
-export const serializeFunctionTypes = (userSessionTypeImport, userSessionTypeName, singletonServicesTypeImport, singletonServicesTypeName, wireServicesTypeImport, wireServicesTypeName, rpcMapTypeImport, requiredServicesTypeImport, configTypeImport, packageName) => {
+export const serializeFunctionTypes = (userSessionTypeImport, userSessionTypeName, singletonServicesTypeImport, singletonServicesTypeName, wireServicesTypeImport, wireServicesTypeName, rpcMapTypeImport, requiredServicesTypeImport, configTypeImport, packageName, workflowTypesImport, nodeCategories) => {
     const packageNameValue = packageName ? `'${packageName}'` : 'null';
+    const nodeCategoryType = nodeCategories?.length
+        ? nodeCategories.map((c) => `'${c}'`).join(' | ')
+        : 'string';
+    const workflowImport = workflowTypesImport ||
+        `import type { TypedWorkflow } from '../workflow/pikku-workflow-types.gen.js'`;
     return `/**
  * Core function, middleware, and permission types for all wirings
  */
 
-import { CorePikkuFunctionConfig, CorePikkuPermission, CorePikkuMiddleware, CorePermissionGroup, addMiddleware as addMiddlewareCore, addPermission as addPermissionCore, PikkuWire, PickRequired, ZodLike, CreateWireServices } from '@pikku/core'
+import { CorePikkuFunctionConfig, CorePikkuAuth, CorePikkuAuthConfig, CorePikkuPermission, CorePikkuMiddleware, CorePermissionGroup, addMiddleware as addMiddlewareCore, addPermission as addPermissionCore, PikkuWire, PickRequired } from '@pikku/core'
+import { pikkuState as __pikkuState, CreateWireServices } from '@pikku/core/internal'
+import { pikkuAuth as pikkuAuthCore } from '@pikku/core'
+import type { NodeType } from '@pikku/core/node'
+import type { StandardSchemaV1 } from '@standard-schema/spec'
 import { CorePikkuFunction, CorePikkuFunctionSessionless } from '@pikku/core/function'
 
 ${userSessionTypeImport}
@@ -16,11 +25,22 @@ ${wireServicesTypeImport}
 ${configTypeImport}
 ${rpcMapTypeImport}
 ${requiredServicesTypeImport}
+${workflowImport}
 
-${singletonServicesTypeName !== 'SingletonServices' ? `type SingletonServices = ${singletonServicesTypeName}` : ''}
-${wireServicesTypeName !== 'Services' ? `type Services = ${wireServicesTypeName}` : ''}
-${userSessionTypeName !== 'Session' ? `type Session = ${userSessionTypeName}` : ''}
-${configTypeImport.includes('Config type not found') ? 'type Config = any' : ''}
+${singletonServicesTypeName !== 'SingletonServices' ? `export type SingletonServices = ${singletonServicesTypeName}` : `export type { ${singletonServicesTypeName} as SingletonServices }`}
+${wireServicesTypeName !== 'Services' ? `export type Services = ${wireServicesTypeName}` : `export type { ${wireServicesTypeName} as Services }`}
+${userSessionTypeName !== 'Session' ? `export type Session = ${userSessionTypeName}` : `export type { ${userSessionTypeName} as Session }`}
+${configTypeImport.includes('Config type not found') ? 'export type Config = any' : ''}
+
+/**
+ * Inline node configuration for function definitions.
+ */
+export type NodeConfig = {
+  displayName: string
+  category: ${nodeCategoryType}
+  type: NodeType
+  errorOutput?: boolean
+}
 
 /**
  * Type-safe API permission definition that integrates with your application's session type.
@@ -80,6 +100,46 @@ export const pikkuPermission = <In>(
   return typeof permission === 'function' ? permission : permission.func
 }
 
+/**
+ * Type-safe auth-only permission that only needs services and session.
+ * Use this for upfront authorization gates (MCP tools, AI agents, workflows)
+ * where request data isn't available yet.
+ *
+ * @template RequiredServices - The services required for this auth check
+ */
+export type PikkuAuth<RequiredServices extends SingletonServices = SingletonServices> = CorePikkuAuth<RequiredServices, Session>
+
+/**
+ * Configuration object for creating an auth permission with metadata
+ */
+export type PikkuAuthConfig<RequiredServices extends SingletonServices = SingletonServices> = CorePikkuAuthConfig<RequiredServices, Session>
+
+/**
+ * Factory function for creating auth-only permissions with tree-shaking support.
+ * Auth permissions only receive services and session (no request data),
+ * making them evaluable before request data is available.
+ *
+ * @example
+ * \\\`\\\`\\\`typescript
+ * const isAuthenticated = pikkuAuth(async ({ logger }, session) => {
+ *   return !!session
+ * })
+ *
+ * const isAdmin = pikkuAuth({
+ *   name: 'Admin Auth',
+ *   description: 'Checks if user is an admin',
+ *   func: async ({ logger }, session) => {
+ *     return session?.role === 'admin'
+ *   }
+ * })
+ * \\\`\\\`\\\`
+ */
+export const pikkuAuth = <RequiredServices extends SingletonServices = SingletonServices>(
+  auth: PikkuAuth<RequiredServices> | PikkuAuthConfig<RequiredServices>
+): PikkuPermission<any, any> => {
+  return pikkuAuthCore(auth as any) as any
+}
+
 /**
  * Configuration object for creating middleware with metadata
  */
@@ -153,8 +213,8 @@ export const pikkuMiddlewareFactory = <In = any>(
  * export const requireRole = pikkuPermissionFactory<{ role: string }>(({
  *   role
  * }) => {
- *   return pikkuPermission(async ({ logger }, data, { initialSession }) => {
- *     if (!initialSession || initialSession.role !== role) {
+ *   return pikkuPermission(async ({ logger }, data, { session }) => {
+ *     if (!session || session.role !== role) {
  *       logger.warn(\`Permission denied: required role '\${role}'\`)
  *       return false
  *     }
@@ -186,7 +246,8 @@ export type PikkuFunctionSessionless<
     In,
     Out,
     RequiredServices,
-    PickRequired<PikkuWire<In, Out, false, Session, TypedPikkuRPC, null, any>, RequiredWires>
+    Session,
+    PickRequired<PikkuWire<In, Out, false, Session, TypedPikkuRPC, null, any, TypedWorkflow>, RequiredWires>
   >
 
 /**
@@ -206,13 +267,14 @@ export type PikkuFunction<
     In,
     Out,
     RequiredServices,
-    PickRequired<PikkuWire<In, Out, true, Session, TypedPikkuRPC, null, any>, RequiredWires>
+    Session,
+    PickRequired<PikkuWire<In, Out, true, Session, TypedPikkuRPC, null, any, TypedWorkflow>, RequiredWires>
   >
 
 /**
- * Helper type to infer the output type from a Zod schema
+ * Helper type to infer the output type from a Standard Schema
  */
-export type InferZodOutput<T> = T extends ZodLike<infer U> ? U : never
+export type InferSchemaOutput<T> = T extends StandardSchemaV1<any, infer Output> ? Output : never
 
 /**
  * Configuration object for Pikku functions with optional middleware, permissions, tags, and documentation.
@@ -227,8 +289,8 @@ export type PikkuFunctionConfig<
   Out = unknown,
   RequiredWires extends keyof PikkuWire = never,
   PikkuFunc extends PikkuFunction<In, Out, RequiredWires> | PikkuFunctionSessionless<In, Out, RequiredWires> = PikkuFunction<In, Out, RequiredWires> | PikkuFunctionSessionless<In, Out, RequiredWires>,
-  InputSchema extends ZodLike | undefined = undefined,
-  OutputSchema extends ZodLike | undefined = undefined
+  InputSchema extends StandardSchemaV1 | undefined = undefined,
+  OutputSchema extends StandardSchemaV1 | undefined = undefined
 > = CorePikkuFunctionConfig<PikkuFunc, PikkuPermission<In>, PikkuMiddleware, InputSchema, OutputSchema>
 
 /**
@@ -237,28 +299,30 @@ export type PikkuFunctionConfig<
  * Types are automatically inferred from the schemas.
  */
 export type PikkuFunctionConfigWithSchema<
-  InputSchema extends ZodLike,
-  OutputSchema extends ZodLike | undefined = undefined,
+  InputSchema extends StandardSchemaV1,
+  OutputSchema extends StandardSchemaV1 | undefined = undefined,
   RequiredWires extends keyof PikkuWire = never
 > = {
   name?: string
   tags?: string[]
   expose?: boolean
+  mcp?: boolean
   internal?: boolean
   func: PikkuFunction<
-    InferZodOutput<InputSchema>,
-    OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown,
+    InferSchemaOutput<InputSchema>,
+    OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown,
     RequiredWires
   > | PikkuFunctionSessionless<
-    InferZodOutput<InputSchema>,
-    OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown,
+    InferSchemaOutput<InputSchema>,
+    OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown,
     RequiredWires
   >
   auth?: boolean
-  permissions?: CorePermissionGroup<PikkuPermission<InferZodOutput<InputSchema>>>
+  permissions?: CorePermissionGroup<PikkuPermission<InferSchemaOutput<InputSchema>>>
   middleware?: PikkuMiddleware[]
   input: InputSchema
   output?: OutputSchema
+  node?: NodeConfig
 }
 
 /**
@@ -300,11 +364,11 @@ export type PikkuFunctionConfigWithSchema<
  * \`\`\`
  */
 export function pikkuFunc<
-  InputSchema extends ZodLike,
-  OutputSchema extends ZodLike | undefined = undefined
+  InputSchema extends StandardSchemaV1,
+  OutputSchema extends StandardSchemaV1 | undefined = undefined
 >(
   config: PikkuFunctionConfigWithSchema<InputSchema, OutputSchema, 'session' | 'rpc'>
-): PikkuFunctionConfig<InferZodOutput<InputSchema>, OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown, 'session' | 'rpc'>
+): PikkuFunctionConfig<InferSchemaOutput<InputSchema>, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, 'session' | 'rpc'>
 export function pikkuFunc<In, Out = unknown>(
   func:
     | PikkuFunction<In, Out, 'session' | 'rpc'>
@@ -318,25 +382,28 @@ export function pikkuFunc(func: any) {
  * Configuration object for sessionless Pikku functions with Zod schema validation.
  */
 export type PikkuFunctionSessionlessConfigWithSchema<
-  InputSchema extends ZodLike,
-  OutputSchema extends ZodLike | undefined = undefined,
+  InputSchema extends StandardSchemaV1,
+  OutputSchema extends StandardSchemaV1 | undefined = undefined,
   RequiredWires extends keyof PikkuWire = never
 > = {
   name?: string
   description?: string
   tags?: string[]
   expose?: boolean
+  mcp?: boolean
   internal?: boolean
+  remote?: boolean
   func: PikkuFunctionSessionless<
-    InferZodOutput<InputSchema>,
-    OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown,
+    InferSchemaOutput<InputSchema>,
+    OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown,
     RequiredWires
   >
   auth?: boolean
-  permissions?: CorePermissionGroup<PikkuPermission<InferZodOutput<InputSchema>>>
+  permissions?: CorePermissionGroup<PikkuPermission<InferSchemaOutput<InputSchema>>>
   middleware?: PikkuMiddleware[]
   input: InputSchema
   output?: OutputSchema
+  node?: NodeConfig
 }
 
 /**
@@ -375,11 +442,11 @@ export type PikkuFunctionSessionlessConfigWithSchema<
  * \`\`\`
  */
 export function pikkuSessionlessFunc<
-  InputSchema extends ZodLike,
-  OutputSchema extends ZodLike | undefined = undefined
+  InputSchema extends StandardSchemaV1,
+  OutputSchema extends StandardSchemaV1 | undefined = undefined
 >(
   config: PikkuFunctionSessionlessConfigWithSchema<InputSchema, OutputSchema, 'session' | 'rpc'>
-): PikkuFunctionConfig<InferZodOutput<InputSchema>, OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown, 'session' | 'rpc'>
+): PikkuFunctionConfig<InferSchemaOutput<InputSchema>, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, 'session' | 'rpc'>
 export function pikkuSessionlessFunc<In, Out = unknown>(
   func:
     | PikkuFunctionSessionless<In, Out, 'session' | 'rpc'>
@@ -414,27 +481,27 @@ export const pikkuVoidFunc = (
 }
 
 /**
- * Creates a wrapper function for external package functions that are exposed via RPC.
- * This allows you to wire external functions to any wiring type (HTTP, queue, etc.)
+ * Creates a wrapper function for addon package functions that are exposed via RPC.
+ * This allows you to wire addon functions to any wiring type (HTTP, queue, etc.)
  * without type compatibility issues.
  *
  * @template Name - The RPC method name (must be a key in FlattenedRPCMap)
  * @param rpcName - The name of the RPC method to invoke
- * @returns A Pikku function that proxies calls to the external RPC method
+ * @returns A Pikku function that proxies calls to the addon RPC method
  *
  * @example
  * \`\`\`typescript
- * // Wire an external function via HTTP
+ * // Wire an addon function via HTTP
  * wireHTTP({
  *   auth: false,
  *   method: 'get',
- *   route: '/external/hello',
- *   func: external('ext:hello'),
- *   tags: ['external'],
+ *   route: '/addon/hello',
+ *   func: addon('ext:hello'),
+ *   tags: ['addon'],
  * })
  * \`\`\`
  */
-export const external = <Name extends keyof FlattenedRPCMap>(
+export const addon = <Name extends keyof FlattenedRPCMap>(
   rpcName: Name
 ): PikkuFunctionConfig<
   FlattenedRPCMap[Name]['input'],
@@ -442,9 +509,9 @@ export const external = <Name extends keyof FlattenedRPCMap>(
   'session' | 'rpc'
 > => {
   return {
-    func: (async (_services: any, data: any, { rpc }: any) => {
+    func: async (_services: any, data: FlattenedRPCMap[Name]['input'], { rpc }: any) => {
       return rpc.invoke(rpcName, data)
-    }) as any
+    }
   } as PikkuFunctionConfig<
     FlattenedRPCMap[Name]['input'],
     FlattenedRPCMap[Name]['output'],
@@ -473,6 +540,7 @@ export const pikkuConfig = (
   func: (variables?: any, ...args: any[]) => Promise<Config>
 ) => func
 
+
 /**
  * Creates a Pikku singleton services factory.
  * Use this to define services that are created once and shared across all requests.
@@ -492,8 +560,14 @@ export const pikkuConfig = (
  * \`\`\`
  */
 export const pikkuServices = (
-  func: (config: Config, existingServices?: Partial<SingletonServices>) => Promise<RequiredSingletonServices>
-) => func
+  func: (config: Config, existingServices: Partial<SingletonServices>) => Promise<RequiredSingletonServices>
+) => {
+  return async (config: Config, existingServices: Partial<SingletonServices> = {}) => {
+    const services = await func(config, existingServices)
+    __pikkuState(null, 'package', 'singletonServices', services as any)
+    return services
+  }
+}
 
 /**
  * Creates a Pikku wire services factory.
@@ -517,7 +591,11 @@ export const pikkuWireServices = (
     services: SingletonServices,
     wire: any
   ) => Promise<RequiredWireServices>
-): CreateWireServices => func as unknown as CreateWireServices
+): CreateWireServices => {
+  const factories = __pikkuState(null, 'package', 'factories')
+  __pikkuState(null, 'package', 'factories', { ...factories, createWireServices: func as any })
+  return func as unknown as CreateWireServices
+}
 
 /**
  * Adds global middleware for a specific tag.
@@ -572,5 +650,8 @@ export const addMiddleware = (tag: string, middleware: PikkuMiddleware[]) => {
 export const addPermission = <In = unknown>(tag: string, permissions: CorePermissionGroup<PikkuPermission<In>> | PikkuPermission<In>[]) => {
   addPermissionCore(tag, permissions as any, ${packageNameValue})
 }
+
+export { wireAddon } from '@pikku/core'
+export type { WireAddonConfig } from '@pikku/core'
 `;
 };

package/dist/src/functions/wirings/functions/serialize-pikku-types-hub.d.ts

@@ -1,4 +1,4 @@
 /**
  * Generates the main pikku-types.gen.ts file as a re-export hub
  */
-export declare const serializePikkuTypesHub: (functionTypesImportPath: string, httpTypesImportPath: string | null, channelTypesImportPath: string | null, schedulerTypesImportPath: string | null, queueTypesImportPath: string | null, mcpTypesImportPath: string | null, cliTypesImportPath: string | null, forgeTypesImportPath: string | null) => string;
+export declare const serializePikkuTypesHub: (functionTypesImportPath: string, httpTypesImportPath: string | null, channelTypesImportPath: string | null, triggerTypesImportPath: string | null, schedulerTypesImportPath: string | null, queueTypesImportPath: string | null, mcpTypesImportPath: string | null, cliTypesImportPath: string | null, nodeTypesImportPath: string | null, secretTypesImportPath: string | null, addonTypesImportPath: string | null) => string;

package/dist/src/functions/wirings/functions/serialize-pikku-types-hub.js

@@ -1,7 +1,7 @@
 /**
  * Generates the main pikku-types.gen.ts file as a re-export hub
  */
-export const serializePikkuTypesHub = (functionTypesImportPath, httpTypesImportPath, channelTypesImportPath, schedulerTypesImportPath, queueTypesImportPath, mcpTypesImportPath, cliTypesImportPath, forgeTypesImportPath) => {
+export const serializePikkuTypesHub = (functionTypesImportPath, httpTypesImportPath, channelTypesImportPath, triggerTypesImportPath, schedulerTypesImportPath, queueTypesImportPath, mcpTypesImportPath, cliTypesImportPath, nodeTypesImportPath, secretTypesImportPath, addonTypesImportPath) => {
     const exports = [
         {
             comment: 'Core function, middleware, and permission types',
@@ -9,11 +9,14 @@ export const serializePikkuTypesHub = (functionTypesImportPath, httpTypesImportP
         },
         { comment: 'HTTP wiring types', path: httpTypesImportPath },
         { comment: 'Channel wiring types', path: channelTypesImportPath },
+        { comment: 'Trigger wiring types', path: triggerTypesImportPath },
         { comment: 'Scheduler wiring types', path: schedulerTypesImportPath },
         { comment: 'Queue wiring types', path: queueTypesImportPath },
         { comment: 'MCP wiring types', path: mcpTypesImportPath },
         { comment: 'CLI wiring types', path: cliTypesImportPath },
-        { comment: 'Forge wiring types', path: forgeTypesImportPath },
+        { comment: 'Node wiring types', path: nodeTypesImportPath },
+        { comment: 'Secret definition types', path: secretTypesImportPath },
+        { comment: 'Addon types', path: addonTypesImportPath },
     ];
     const exportStatements = exports
         .filter((e) => e.path)

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

@@ -1 +1 @@
-export declare const pikkuHTTPMap: any;
+export declare const pikkuHTTPMap: 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/http/pikku-command-http-map.js

@@ -1,12 +1,12 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeTypedHTTPWiringsMap } from './serialize-typed-http-map.js';
 export const pikkuHTTPMap = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
-        const { http, functions } = await getInspectorState();
-        const { httpMapDeclarationFile, packageMappings } = config;
-        const content = serializeTypedHTTPWiringsMap(httpMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, http.meta, http.metaInputTypes);
+        const { http, functions, resolvedIOTypes } = await getInspectorState();
+        const { httpMapDeclarationFile, rpcInternalMapDeclarationFile, packageMappings, } = config;
+        const content = serializeTypedHTTPWiringsMap(logger, httpMapDeclarationFile, packageMappings, functions.typesMap, http.meta, http.metaInputTypes, resolvedIOTypes, rpcInternalMapDeclarationFile);
         await writeFileInDir(logger, httpMapDeclarationFile, content);
     },
     middleware: [

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

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

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

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { serializeFileImports } from '../../../utils/file-imports-serializer.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
@@ -24,7 +24,7 @@ export const pikkuHTTP = pikkuSessionlessFunc({
         const importStatement = supportsImportAttributes
             ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
             : `import metaData from '${jsonImportPath}'`;
-        await writeFileInDir(logger, httpWiringMetaFile, `import { pikkuState } from '@pikku/core'\nimport type { HTTPWiringsMeta } from '@pikku/core/http'\n${importStatement}\npikkuState(null, 'http', 'meta', metaData as HTTPWiringsMeta)`);
+        await writeFileInDir(logger, httpWiringMetaFile, `import { pikkuState } from '@pikku/core/internal'\nimport type { HTTPWiringsMeta } from '@pikku/core/http'\n${importStatement}\npikkuState(null, 'http', 'meta', metaData as HTTPWiringsMeta)`);
         return true;
     },
     middleware: [

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

@@ -1 +1 @@
-export declare const pikkuHTTPTypes: any;
+export declare const pikkuHTTPTypes: 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/http/pikku-command-http-types.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';

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

@@ -1 +1 @@
-export declare const pikkuOpenAPI: any;
+export declare const pikkuOpenAPI: 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/http/pikku-command-openapi.js

@@ -1,23 +1,25 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
-import { generateSchemas } from '../../../utils/schema-generator.js';
-import { generateOpenAPISpec } from './openapi-spec-generator.js';
 import { stringify } from 'yaml';
 export const pikkuOpenAPI = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
-        const { tsconfig, openAPI, schemasFromTypes } = config;
-        // If openAPI outputFile is not defined, clean up any existing file and return
+        const { openAPI } = config;
         if (!openAPI?.outputFile) {
-            logger.info({
+            logger.debug({
                 message: 'Skipping creating OpenAPI spec since openAPI outfile is not defined.',
                 type: 'skip',
             });
             return;
         }
-        const { http, functions, zodLookup } = await getInspectorState();
-        const schemas = await generateSchemas(logger, tsconfig, functions.typesMap, functions.meta, http.meta, schemasFromTypes, config.schema?.additionalProperties, zodLookup);
-        const openAPISpec = await generateOpenAPISpec(logger, functions.meta, http.meta, schemas, openAPI.additionalInfo);
+        const { openAPISpec } = await getInspectorState();
+        if (!openAPISpec) {
+            logger.debug({
+                message: 'Skipping creating OpenAPI spec since no spec was generated.',
+                type: 'skip',
+            });
+            return;
+        }
         if (openAPI.outputFile.endsWith('.json')) {
             await writeFileInDir(logger, openAPI.outputFile, JSON.stringify(openAPISpec, null, 2), { ignoreModifyComment: true });
         }

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

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

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

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { serializeFileImports } from '../../../utils/file-imports-serializer.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
@@ -15,7 +15,7 @@ export const pikkuHTTP = pikkuSessionlessFunc({
         const importStatement = supportsImportAttributes
             ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
             : `import metaData from '${jsonImportPath}'`;
-        await writeFileInDir(logger, httpWiringMetaFile, `import { pikkuState, HTTPWiringsMeta } from '@pikku/core'\n${importStatement}\npikkuState(null, 'http', 'meta', metaData as HTTPWiringsMeta)`);
+        await writeFileInDir(logger, httpWiringMetaFile, `import { pikkuState } from '@pikku/core/internal'\nimport type { HTTPWiringsMeta } from '@pikku/core/http'\n${importStatement}\npikkuState(null, 'http', 'meta', metaData as HTTPWiringsMeta)`);
         return true;
     },
     middleware: [

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

@@ -6,9 +6,9 @@ export const serializeHTTPTypes = (functionTypesImportPath) => {
  * HTTP-specific type definitions for tree-shaking optimization
  */
 
-import { AssertHTTPWiringParams, wireHTTP as wireHTTPCore, addHTTPMiddleware as addHTTPMiddlewareCore, addHTTPPermission as addHTTPPermissionCore } from '@pikku/core/http'
-import type { PikkuFunction, PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware } from '${functionTypesImportPath}'
-import type { CoreHTTPFunctionWiring, HTTPMethod } from '@pikku/core/http'
+import { AssertHTTPWiringParams, wireHTTP as wireHTTPCore, addHTTPMiddleware as addHTTPMiddlewareCore, addHTTPPermission as addHTTPPermissionCore, wireHTTPRoutes as wireHTTPRoutesCore, defineHTTPRoutes as defineHTTPRoutesCore } from '@pikku/core/http'
+import type { PikkuFunction, PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware, PikkuFunctionConfig } from '${functionTypesImportPath}'
+import type { CoreHTTPFunctionWiring, HTTPMethod, HTTPRouteBaseConfig } from '@pikku/core/http'
 
 /**
  * Type definition for HTTP API wirings with type-safe path parameters.
@@ -20,22 +20,6 @@ import type { CoreHTTPFunctionWiring, HTTPMethod } from '@pikku/core/http'
  */
 type HTTPWiring<In, Out, Route extends string> = CoreHTTPFunctionWiring<In, Out, Route, PikkuFunction<In, Out, 'rpc' | 'session'>, PikkuFunctionSessionless<In, Out, 'rpc' | 'session'>, PikkuPermission<In>, PikkuMiddleware>
 
-/**
- * HTTP wiring for workflow triggers (no function needed)
- */
-type HTTPWorkflowWiring<Route extends string> = {
-  route: Route
-  method: HTTPMethod
-  workflow: true
-  func?: undefined
-  permissions?: undefined
-  auth?: undefined
-  tags?: undefined
-  middleware?: undefined
-  returnsJSON?: undefined
-  sse?: boolean
-}
-
 /**
  * Registers an HTTP wiring with the Pikku framework.
  *
@@ -45,7 +29,7 @@ type HTTPWorkflowWiring<Route extends string> = {
  * @param httpWiring - HTTP wiring definition with handler, method, and optional middleware
  */
 export const wireHTTP = <In, Out, Route extends string>(
-  httpWiring: (HTTPWiring<In, Out, Route> & AssertHTTPWiringParams<In, Route>) | HTTPWorkflowWiring<Route>
+  httpWiring: HTTPWiring<In, Out, Route> & AssertHTTPWiringParams<In, Route>
 ) => {
   wireHTTPCore(httpWiring as any)
 }
@@ -101,5 +85,66 @@ export const addHTTPPermission = <In = unknown>(
 ) => {
   addHTTPPermissionCore(pattern, permissions as any)
 }
+
+/**
+ * Route configuration for wireHTTPRoutes with proper typing
+ */
+type HTTPRouteConfig = HTTPRouteBaseConfig & {
+  method: HTTPMethod
+  route: string
+  func: PikkuFunctionConfig<any, any, any, any, any, any>
+  auth?: boolean
+  permissions?: Record<string, PikkuPermission | PikkuPermission[]>
+  middleware?: PikkuMiddleware[]
+  sse?: boolean
+}
+
+/**
+ * Typed route map for wireHTTPRoutes
+ */
+type TypedHTTPRouteMap = {
+  [key: string]: HTTPRouteConfig | TypedHTTPRouteMap | TypedHTTPRouteContract
+}
+
+/**
+ * Typed route contract for defineHTTPRoutes
+ */
+type TypedHTTPRouteContract<T extends TypedHTTPRouteMap = TypedHTTPRouteMap> = TypedHTTPRoutesGroupConfig & {
+  routes: T
+}
+
+/**
+ * Group config with typed middleware/permissions
+ */
+type TypedHTTPRoutesGroupConfig = {
+  basePath?: string
+  tags?: string[]
+  auth?: boolean
+  middleware?: PikkuMiddleware[]
+  permissions?: Record<string, PikkuPermission | PikkuPermission[]>
+}
+
+/**
+ * Full config for wireHTTPRoutes
+ */
+type TypedWireHTTPRoutesConfig = TypedHTTPRoutesGroupConfig & {
+  routes: TypedHTTPRouteMap | HTTPRouteConfig[]
+}
+
+/**
+ * Type-safe helper for defining route contracts that can be composed.
+ */
+export function defineHTTPRoutes<T extends TypedHTTPRouteMap>(routes: T): TypedHTTPRouteContract<T>
+export function defineHTTPRoutes<T extends TypedHTTPRouteMap>(config: TypedHTTPRoutesGroupConfig & { routes: T }): TypedHTTPRouteContract<T>
+export function defineHTTPRoutes<T extends TypedHTTPRouteMap>(configOrRoutes: T | (TypedHTTPRoutesGroupConfig & { routes: T })): TypedHTTPRouteContract<T> {
+  return defineHTTPRoutesCore(configOrRoutes as any) as unknown as TypedHTTPRouteContract<T>
+}
+
+/**
+ * Wires multiple HTTP routes from a nested map or array configuration.
+ */
+export const wireHTTPRoutes = (config: TypedWireHTTPRoutesConfig): void => {
+  wireHTTPRoutesCore(config as any)
+}
 `;
 };

package/dist/src/functions/wirings/http/serialize-typed-http-map.d.ts

@@ -1,4 +1,7 @@
-import { HTTPWiringsMeta } from '@pikku/core/http';
-import { MetaInputTypes, TypesMap } from '@pikku/inspector';
-import { FunctionsMeta } from '@pikku/core';
-export declare const serializeTypedHTTPWiringsMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, wiringsMeta: HTTPWiringsMeta, metaTypes: MetaInputTypes) => string;
+import type { HTTPWiringsMeta } from '@pikku/core/http';
+import type { MetaInputTypes, TypesMap } from '@pikku/inspector';
+import type { Logger } from '@pikku/core/services';
+export declare const serializeTypedHTTPWiringsMap: (logger: Logger, relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, wiringsMeta: HTTPWiringsMeta, metaTypes: MetaInputTypes, resolvedIOTypes: Record<string, {
+    inputType: string;
+    outputType: string;
+}>, rpcInternalMapDeclarationFile: string) => string;