@pikku/cli 0.12.104 → 0.12.107

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

@@ -0,0 +1,55 @@
+/**
+ * Generates type definitions for gateway wirings
+ */
+export const serializeGatewayTypes = (singletonServicesTypeImport, singletonServicesTypeName, { addon = false } = {}) => {
+    return `/**
+ * Gateway-specific type definitions for tree-shaking optimization
+ */
+
+${addon ? '' : `import { wireGateway as wireGatewayCore } from '@pikku/core/gateway'\n`}import type { CoreGateway, GatewayAdapter, GatewayInboundMessage, GatewayOutboundMessage, GatewayTransportType, WebhookVerificationResult } from '@pikku/core/gateway'
+${singletonServicesTypeImport}
+
+${singletonServicesTypeName !== 'SingletonServices' ? `type SingletonServices = ${singletonServicesTypeName}` : ''}
+
+export type { GatewayAdapter, GatewayInboundMessage, GatewayOutboundMessage, GatewayTransportType, WebhookVerificationResult }
+
+/**
+ * Builds a {@link GatewayAdapter} from your application's services.
+ * The core factory type is handed \`CoreSingletonServices\`; this one receives
+ * the services your project actually registered.
+ */
+export type PikkuGatewayAdapterFactory = (
+  services: SingletonServices
+) => GatewayAdapter | Promise<GatewayAdapter>
+
+/**
+ * Type definition for gateway wirings.
+ * Declares a gateway name, its transport and its target pikku function.
+ */
+export type GatewayWiring = CoreGateway
+
+${addon
+        ? ''
+        : `
+/**
+ * Registers a gateway with the Pikku framework.
+ * Runs everywhere — inspector extracts at build time.
+ *
+ * @param gateway - Gateway definition with name, transport type and function
+ *
+ * @example
+ * \`\`\`typescript
+ * wireGateway({
+ *   name: 'stripe',
+ *   type: 'webhook',
+ *   func: handleStripeEvent
+ * })
+ * \`\`\`
+ */
+export const wireGateway = (
+  gateway: GatewayWiring
+) => {
+  wireGatewayCore(gateway as any)
+}
+`}`;
+};

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

@@ -1 +1 @@
-export declare const pikkuGraphWirings: import("#pikku").PikkuFunctionConfig<void, boolean, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, boolean, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<void, boolean, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuGraphWirings: import("#pikku/function").PikkuFunctionConfig<void, boolean, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, boolean, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, boolean, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

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

@@ -1,5 +1,5 @@
-import { pikkuSessionlessFunc } from '#pikku';
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { pikkuSessionlessFunc } from '#pikku/function';
+import { getLeafImportPath } from '../../../utils/leaf-import-path.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { removeLegacyScaffoldFile } from '../../../utils/remove-legacy-scaffold-file.js';
@@ -7,8 +7,7 @@ import { serializeGraphWirings } from './serialize-graph-wirings.js';
 export const pikkuGraphWirings = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
         if (config.scaffold?.graph && config.graphWiringsFile) {
-            const pathToPikkuTypes = getFileImportRelativePath(config.graphWiringsFile, config.typesDeclarationFile, config.packageMappings);
-            await writeFileInDir(logger, config.graphWiringsFile, serializeGraphWirings(pathToPikkuTypes));
+            await writeFileInDir(logger, config.graphWiringsFile, serializeGraphWirings((leaf) => getLeafImportPath(config.graphWiringsFile, leaf, config)));
             await removeLegacyScaffoldFile(config.graphWiringsFile);
             return true;
         }

package/dist/src/functions/wirings/graph/serialize-graph-wirings.d.ts

@@ -2,4 +2,4 @@
  * Wire @pikku/addon-graph so `pikkuWorkflowGraph` nodes can reference its native
  * transform functions (e.g. `graph:editFields`).
  */
-export declare const serializeGraphWirings: (pathToPikkuTypes: string) => string;
+export declare const serializeGraphWirings: (leaf: (name: string) => string) => string;

package/dist/src/functions/wirings/graph/serialize-graph-wirings.js

@@ -2,12 +2,12 @@
  * Wire @pikku/addon-graph so `pikkuWorkflowGraph` nodes can reference its native
  * transform functions (e.g. `graph:editFields`).
  */
-export const serializeGraphWirings = (pathToPikkuTypes) => {
+export const serializeGraphWirings = (leaf) => {
     return `/**
  * @pikku/addon-graph wiring
  * Do not edit manually - regenerate with 'npx pikku'
  */
-import { wireAddon } from '${pathToPikkuTypes}'
+import { wireAddon } from '${leaf('addon')}'
 
 wireAddon({ name: 'graph', package: '@pikku/addon-graph' })
 `;

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

@@ -1 +1 @@
-export declare const pikkuHTTPMap: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuHTTPMap: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

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

@@ -1,12 +1,12 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 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, resolvedIOTypes } = await getInspectorState();
+        const { http, functions, resolvedIOTypes, rpc } = await getInspectorState();
         const { httpMapDeclarationFile, rpcInternalMapDeclarationFile, packageMappings, } = config;
-        const content = serializeTypedHTTPWiringsMap(logger, httpMapDeclarationFile, packageMappings, functions.typesMap, http.meta, http.metaInputTypes, resolvedIOTypes, rpcInternalMapDeclarationFile);
+        const content = serializeTypedHTTPWiringsMap(logger, httpMapDeclarationFile, packageMappings, functions.typesMap, http.meta, http.metaInputTypes, resolvedIOTypes, rpcInternalMapDeclarationFile, rpc?.wireAddonDeclarations);
         await writeFileInDir(logger, httpMapDeclarationFile, content);
     },
     middleware: [

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

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

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

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 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';
@@ -42,7 +42,7 @@ export const pikkuCommandHTTP = pikkuSessionlessFunc({
         const importStatement = supportsImportAttributes
             ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
             : `import metaData from '${jsonImportPath}'`;
-        await writeFileInDir(logger, httpWiringMetaFile, `import { pikkuState } from '@pikku/core/ecosystem'\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/state'\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: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuHTTPTypes: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

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

@@ -1,13 +1,17 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 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';
 import { serializeHTTPTypes } from './serialize-http-types.js';
 export const pikkuHTTPTypes = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
-        const { httpTypesFile, functionTypesFile, packageMappings } = config;
+        const { httpTypesFile, functionTypesFile, middlewareTypesFile, packageMappings, } = config;
         const functionTypesImportPath = getFileImportRelativePath(httpTypesFile, functionTypesFile, packageMappings);
-        const content = serializeHTTPTypes(functionTypesImportPath);
+        const middlewareTypesImportPath = getFileImportRelativePath(httpTypesFile, middlewareTypesFile, packageMappings);
+        const authTypesImportPath = getFileImportRelativePath(httpTypesFile, config.authGuardsFile, packageMappings);
+        const content = serializeHTTPTypes(functionTypesImportPath, middlewareTypesImportPath, authTypesImportPath, {
+            addon: !!config.addon,
+        });
         await writeFileInDir(logger, httpTypesFile, content);
     },
     middleware: [

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

@@ -1 +1 @@
-export declare const pikkuOpenAPI: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuOpenAPI: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

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

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

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

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

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

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 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';
@@ -18,7 +18,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/ecosystem'\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/state'\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.d.ts

@@ -1,4 +1,6 @@
 /**
  * Generates type definitions for HTTP wirings
  */
-export declare const serializeHTTPTypes: (functionTypesImportPath: string) => string;
+export declare const serializeHTTPTypes: (functionTypesImportPath: string, middlewareTypesImportPath: string, authTypesImportPath: string, { addon }?: {
+    addon?: boolean;
+}) => string;

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

@@ -1,16 +1,22 @@
 /**
  * Generates type definitions for HTTP wirings
  */
-export const serializeHTTPTypes = (functionTypesImportPath) => {
+export const serializeHTTPTypes = (functionTypesImportPath, middlewareTypesImportPath, authTypesImportPath, { addon = false } = {}) => {
     return `/**
  * HTTP-specific type definitions for tree-shaking optimization
  */
 
-import { AssertHTTPWiringParams, wireHTTP as wireHTTPCore, addHTTPMiddleware as addHTTPMiddlewareCore, 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'
+import { ${addon ? '' : 'wireHTTP as wireHTTPCore, '}${addon ? '' : 'wireHTTPRoutes as wireHTTPRoutesCore, '}defineHTTPRoutes as defineHTTPRoutesCore } from '@pikku/core/http'
+${addon ? '' : `import { AssertHTTPWiringParams } from '@pikku/core/http'\n`}import type { ${addon ? '' : 'PikkuFunction, PikkuFunctionSessionless, '}PikkuFunctionConfig } from '${functionTypesImportPath}'
+${addon ? '' : `import type { PikkuPermission } from '${authTypesImportPath}'\n`}import type { PikkuMiddleware } from '${middlewareTypesImportPath}'
+import type {
+${addon ? '' : '  CoreHTTPFunctionWiring,\n'}  HTTPMethod,
+  HTTPRouteBaseConfig,
+} from '@pikku/core/http'
 
-/**
+${addon
+        ? ''
+        : `/**
  * Type definition for HTTP API wirings with type-safe path parameters.
  * Supports both authenticated and unauthenticated functions.
  *
@@ -33,33 +39,7 @@ export const wireHTTP = <In, Out, Route extends string>(
 ) => {
   wireHTTPCore(httpWiring as any)
 }
-
-/**
- * Registers HTTP middleware either globally or for a specific route pattern.
- *
- * When a string route pattern is provided along with middleware, the middleware
- * is applied only to that route. Otherwise, if an array is provided, it is treated
- * as global middleware (applied to all routes).
- *
- * @param routeOrMiddleware - Either a global middleware array or a route pattern string
- * @param middleware - The middleware array to apply when a route pattern is specified
- *
- * @example
- * \`\`\`typescript
- * // Add global HTTP middleware
- * addHTTPMiddleware([authMiddleware, loggingMiddleware])
- *
- * // Add route-specific middleware
- * addHTTPMiddleware('/api/admin/*', [adminAuthMiddleware])
- * \`\`\`
- */
-export const addHTTPMiddleware = (
-  routeOrMiddleware: PikkuMiddleware[] | string,
-  middleware?: PikkuMiddleware[]
-) => {
-  addHTTPMiddlewareCore(routeOrMiddleware as any, middleware as any)
-}
-
+`}
 /**
  * Route configuration for wireHTTPRoutes with proper typing
  */
@@ -96,13 +76,15 @@ type TypedHTTPRoutesGroupConfig = {
   middleware?: PikkuMiddleware[]
 }
 
-/**
+${addon
+        ? ''
+        : `/**
  * Full config for wireHTTPRoutes
  */
 type TypedWireHTTPRoutesConfig = TypedHTTPRoutesGroupConfig & {
   routes: TypedHTTPRouteMap | HTTPRouteConfig[]
 }
-
+`}
 /**
  * Type-safe helper for defining route contracts that can be composed.
  */
@@ -112,11 +94,14 @@ export function defineHTTPRoutes<T extends TypedHTTPRouteMap>(configOrRoutes: T
   return defineHTTPRoutesCore(configOrRoutes as any) as unknown as TypedHTTPRouteContract<T>
 }
 
+${addon
+        ? ''
+        : `
 /**
  * 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,7 +1,11 @@
 import type { HTTPWiringsMeta } from '@pikku/core/http';
 import type { MetaInputTypes, TypesMap } from '@pikku/inspector';
 import type { Logger } from '@pikku/core/services';
+type WireAddonDeclarations = Map<string, {
+    package: string;
+}>;
 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;
+}>, rpcInternalMapDeclarationFile: string, wireAddonDeclarations?: WireAddonDeclarations) => string;
+export {};

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

@@ -1,11 +1,11 @@
 import { serializeImportMap } from '../../../utils/serialize-import-map.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { generateCustomTypes } from '@pikku/inspector';
-export const serializeTypedHTTPWiringsMap = (logger, relativeToPath, packageMappings, typesMap, wiringsMeta, metaTypes, resolvedIOTypes, rpcInternalMapDeclarationFile) => {
+export const serializeTypedHTTPWiringsMap = (logger, relativeToPath, packageMappings, typesMap, wiringsMeta, metaTypes, resolvedIOTypes, rpcInternalMapDeclarationFile, wireAddonDeclarations) => {
     const requiredTypes = new Set();
     const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
     const serializedMetaTypes = generateMetaTypes(metaTypes, typesMap, requiredTypes);
-    const serializedHTTPWirings = generateHTTPWirings(wiringsMeta, resolvedIOTypes, requiredTypes);
+    const serializedHTTPWirings = generateHTTPWirings(wiringsMeta, resolvedIOTypes, requiredTypes, wireAddonDeclarations);
     const needsFlattenedRPCMap = Array.from(requiredTypes).some((t) => t.includes('FlattenedRPCMap'));
     if (needsFlattenedRPCMap) {
         for (const t of Array.from(requiredTypes)) {
@@ -48,7 +48,7 @@ export type HTTPWiringsWithMethod<Method extends string> = {
 }[keyof HTTPWiringsMap];
   `;
 };
-function generateHTTPWirings(routesMeta, resolvedIOTypes, requiredTypes) {
+function generateHTTPWirings(routesMeta, resolvedIOTypes, requiredTypes, wireAddonDeclarations) {
     const routesObj = {};
     for (const methods of Object.values(routesMeta)) {
         for (const meta of Object.values(methods)) {
@@ -58,7 +58,8 @@ function generateHTTPWirings(routesMeta, resolvedIOTypes, requiredTypes) {
             }
             const resolved = resolvedIOTypes[pikkuFuncId];
             if (!resolved) {
-                if (meta.packageName) {
+                const namespace = pikkuFuncId.slice(0, pikkuFuncId.indexOf(':'));
+                if (namespace && wireAddonDeclarations?.has(namespace)) {
                     // Addon functions aren't in the consumer's local resolvedIOTypes, but
                     // their real types are reachable through the generated FlattenedRPCMap
                     // (the addon's RPC map is merged in under its namespace). Adding these

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

@@ -1 +1 @@
-export declare const pikkuMCPJSON: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuMCPJSON: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

package/dist/src/functions/wirings/mcp/pikku-command-mcp-json.js

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

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

@@ -1 +1 @@
-export declare const pikkuMCPTypes: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuMCPTypes: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

package/dist/src/functions/wirings/mcp/pikku-command-mcp-types.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 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';
@@ -7,7 +7,10 @@ export const pikkuMCPTypes = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
         const { mcpTypesFile, functionTypesFile, packageMappings } = config;
         const functionTypesImportPath = getFileImportRelativePath(mcpTypesFile, functionTypesFile, packageMappings);
-        const content = serializeMCPTypes(functionTypesImportPath);
+        const middlewareTypesImportPath = getFileImportRelativePath(mcpTypesFile, config.middlewareTypesFile, packageMappings);
+        const content = serializeMCPTypes(functionTypesImportPath, middlewareTypesImportPath, getFileImportRelativePath(mcpTypesFile, config.authGuardsFile, packageMappings), {
+            addon: !!config.addon,
+        });
         await writeFileInDir(logger, mcpTypesFile, content);
     },
     middleware: [

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

@@ -1 +1 @@
-export declare const pikkuMCP: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<void, boolean | undefined, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuMCP: import("#pikku/function").PikkuFunctionConfig<void, boolean | undefined, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, boolean | undefined, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, boolean | undefined, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

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

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 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';
@@ -87,8 +87,12 @@ export const pikkuMCP = pikkuSessionlessFunc({
         const importStatement = supportsImportAttributes
             ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
             : `import metaData from '${jsonImportPath}'`;
-        await writeFileInDir(logger, mcpWiringsMetaFile, `import { pikkuState } from '@pikku/core/ecosystem'
-import type { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core/mcp'
+        await writeFileInDir(logger, mcpWiringsMetaFile, `import { pikkuState } from '@pikku/core/state'
+import type {
+  MCPResourceMeta,
+  MCPToolMeta,
+  MCPPromptMeta,
+} from '@pikku/core/mcp'
 ${importStatement}
 pikkuState(null, 'mcp', 'resourcesMeta', metaData.resourcesMeta as MCPResourceMeta)
 pikkuState(null, 'mcp', 'toolsMeta', metaData.toolsMeta as MCPToolMeta)

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

@@ -1,4 +1,6 @@
 /**
  * Generates type definitions for MCP wirings
  */
-export declare const serializeMCPTypes: (functionTypesImportPath: string) => string;
+export declare const serializeMCPTypes: (functionTypesImportPath: string, middlewareTypesImportPath: string, authTypesImportPath: string, { addon }?: {
+    addon?: boolean;
+}) => string;

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

@@ -1,27 +1,25 @@
 /**
  * Generates type definitions for MCP wirings
  */
-export const serializeMCPTypes = (functionTypesImportPath) => {
+export const serializeMCPTypes = (functionTypesImportPath, middlewareTypesImportPath, authTypesImportPath, { addon = false } = {}) => {
     return `/**
  * MCP-specific type definitions for tree-shaking optimization
  */
 
+import { ${addon ? '' : 'wireMCPResource as wireMCPResourceCore, wireMCPPrompt as wireMCPPromptCore, '}MCPResourceResponse, MCPPromptResponse } from '@pikku/core/mcp'
 import {
-  CoreMCPResource,
-  CoreMCPPrompt,
-  wireMCPResource as wireMCPResourceCore,
-  wireMCPPrompt as wireMCPPromptCore,
-  MCPResourceResponse,
-  MCPToolResponse,
-  MCPPromptResponse,
-  AssertMCPResourceURIParams
+${addon ? '' : `  CoreMCPResource,\n  CoreMCPPrompt,\n`}  MCPToolResponse,${addon ? '' : `\n  AssertMCPResourceURIParams,`}
 } from '@pikku/core/mcp'
 
-import type { PikkuFunctionConfig, PikkuFunctionSessionless, PikkuMiddleware, PikkuPermission, InferSchemaOutput } from '${functionTypesImportPath}'
-import type { CorePermissionGroup } from '@pikku/core'
+import type { PikkuFunctionConfig, PikkuFunctionSessionless, InferSchemaOutput } from '${functionTypesImportPath}'
+import type { PikkuPermission } from '${authTypesImportPath}'
+import type { PikkuMiddleware } from '${middlewareTypesImportPath}'
+import type { CorePermissionGroup } from '@pikku/core/function'
 import type { StandardSchemaV1 } from '@standard-schema/spec'
 
-/**
+${addon
+        ? ''
+        : `/**
  * Type definition for MCP resources that provide data to AI models.
  *
  * @template In - Input type for the resource request
@@ -35,8 +33,10 @@ type MCPResourceWiring<In, URI extends string> = CoreMCPResource<PikkuFunctionCo
  * @template In - Input type for the prompt parameters
  */
 type MCPPromptWiring<In> = CoreMCPPrompt<PikkuFunctionConfig<In, MCPPromptResponse, 'rpc' | 'session' | 'mcp'>>
-
-/**
+`}
+${addon
+        ? ''
+        : `/**
  * Registers an MCP resource with the Pikku framework.
  * Resources provide data that AI models can access.
  *
@@ -62,7 +62,7 @@ export const wireMCPPrompt = <In>(
 ) => {
   wireMCPPromptCore(mcpPrompt as any)
 }
-
+`}
 /**
  * Configuration for MCP prompt with Zod schema input validation.
  */

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

@@ -1 +1 @@
-export declare const pikkuMiddleware: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<void, boolean | undefined, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuMiddleware: import("#pikku/function").PikkuFunctionConfig<void, boolean | undefined, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, boolean | undefined, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, boolean | undefined, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

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

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeMiddlewareImports } from './serialize-middleware-imports.js';

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

@@ -0,0 +1,9 @@
+/**
+ * Generates the middleware authoring surface — every way a project declares or
+ * registers middleware, whatever wiring it ends up attached to.
+ *
+ * Middleware is one concept, so it is one leaf. `PikkuMiddleware` is declared
+ * here rather than alongside the function types that consume it; those types
+ * import it back, which is a type-only edge and carries no runtime cycle.
+ */
+export declare const serializeMiddlewareTypes: (functionTypesImportPath: string, packageName?: string) => string;