@pikku/core 0.11.1 → 0.11.2

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 ## 0.11.0
 
+## 0.11.2
+
+### Patch Changes
+
+- db9c7bf: Add workflow graph system with type-safe builder
+
+## 0.11.2
+
+### Features
+
+- f35e89da: Add workflow graph system with type-safe builder
+  - `createGraph<RPCMap>()` for building workflow graphs with full type safety
+  - `wireWorkflowGraph()` for registering workflow graphs
+  - `graphNode()` helper for type-safe node creation
+  - Graph scheduler for execution (continueGraph, startWorkflowGraph)
+  - TypedRef for type-safe input refs in workflow graphs
+  - `setBranchTaken` added to WorkflowService interface
+  - Trigger runner for workflow triggers
+
+### Breaking Changes
+
+- Rename `pikkuWorkflowFunc` to `pikkuWorkflowComplexFunc`
+- Rename `pikkuWorkflowDSTFunc` to `pikkuWorkflowFunc`
+
 ## 0.11.1
 
 ### Patch Changes

package/dist/errors/error-handler.js

@@ -19,7 +19,7 @@ export class PikkuError extends Error {
  * @param details - The details of the error.
  */
 export const addError = (error, { status, message }) => {
-    pikkuState('misc', 'errors').set(error, { status, message });
+    pikkuState(null, 'misc', 'errors').set(error, { status, message });
 };
 /**
  * Adds multiple errors to the API errors map.
@@ -36,10 +36,10 @@ export const addErrors = (errors) => {
  * @returns An object containing the status and message, or undefined if the error is not found.
  */
 export const getErrorResponse = (error) => {
-    const errors = Array.from(pikkuState('misc', 'errors').entries());
+    const errors = Array.from(pikkuState(null, 'misc', 'errors').entries());
     const foundError = errors.find(([e]) => e.name === error.constructor.name);
     if (foundError) {
         return foundError[1];
     }
-    return pikkuState('misc', 'errors').get(error);
+    return pikkuState(null, 'misc', 'errors').get(error);
 };

package/dist/function/function-runner.d.ts

@@ -1,9 +1,9 @@
 import { CoreServices, CoreUserSession, CorePikkuMiddleware, PikkuWiringTypes, PikkuWire, MiddlewareMetadata, PermissionMetadata, CoreSingletonServices, CreateWireServices } from '../types/core.types.js';
 import { CorePermissionGroup, CorePikkuFunctionConfig, CorePikkuPermission } from './functions.types.js';
 import { SessionService } from '../services/user-session-service.js';
-export declare const addFunction: (funcName: string, funcConfig: CorePikkuFunctionConfig<any, any>) => void;
-export declare const runPikkuFuncDirectly: <In, Out>(funcName: string, allServices: CoreServices, wire: PikkuWire, data: In, userSession?: SessionService<CoreUserSession>) => Promise<Out>;
-export declare const runPikkuFunc: <In = any, Out = any>(wireType: PikkuWiringTypes, wireId: string, funcName: string, { singletonServices, createWireServices, data, auth: wiringAuth, inheritedMiddleware, wireMiddleware, inheritedPermissions, wirePermissions, coerceDataFromSchema, tags, wire, }: {
+export declare const addFunction: (funcName: string, funcConfig: CorePikkuFunctionConfig<any, any>, packageName?: string | null) => void;
+export declare const runPikkuFuncDirectly: <In, Out>(funcName: string, allServices: CoreServices, wire: PikkuWire, data: In, userSession?: SessionService<CoreUserSession>, packageName?: string | null) => Promise<Out>;
+export declare const runPikkuFunc: <In = any, Out = any>(wireType: PikkuWiringTypes, wireId: string, funcName: string, { singletonServices, createWireServices, data, auth: wiringAuth, inheritedMiddleware, wireMiddleware, inheritedPermissions, wirePermissions, coerceDataFromSchema, tags, wire, packageName, }: {
     singletonServices: CoreSingletonServices;
     createWireServices?: CreateWireServices;
     data: () => Promise<In> | In;
@@ -15,4 +15,5 @@ export declare const runPikkuFunc: <In = any, Out = any>(wireType: PikkuWiringTy
     coerceDataFromSchema?: boolean;
     tags?: string[];
     wire: PikkuWire;
+    packageName?: string | null;
 }) => Promise<Out>;

package/dist/function/function-runner.js

@@ -5,11 +5,42 @@ import { coerceTopLevelDataFromSchema, validateSchema } from '../schema.js';
 import { ForbiddenError } from '../errors/errors.js';
 import { rpcService } from '../wirings/rpc/rpc-runner.js';
 import { closeWireServices } from '../utils.js';
-export const addFunction = (funcName, funcConfig) => {
-    pikkuState('function', 'functions').set(funcName, funcConfig);
+/**
+ * Get or create singleton services for an external package.
+ * Services are cached in pikkuState to avoid recreation on each call.
+ *
+ * @param packageName - The external package name
+ * @param parentServices - The parent/caller's singleton services (used as base)
+ * @returns The package's singleton services
+ */
+const getOrCreatePackageSingletonServices = async (packageName, parentServices) => {
+    // Check if we already have cached singleton services for this package
+    const cachedServices = pikkuState(packageName, 'package', 'singletonServices');
+    if (cachedServices) {
+        return cachedServices;
+    }
+    // Get the package's service factories
+    const factories = pikkuState(packageName, 'package', 'factories');
+    if (!factories || !factories.createSingletonServices) {
+        // No factories registered, use parent services
+        return parentServices;
+    }
+    // Create config for the package (use parent config if no factory)
+    let config = parentServices.config;
+    if (factories.createConfig) {
+        config = await factories.createConfig(parentServices.variables);
+    }
+    // Create singleton services for the package, passing parent services as existing
+    const packageServices = await factories.createSingletonServices(config, parentServices);
+    // Cache the services
+    pikkuState(packageName, 'package', 'singletonServices', packageServices);
+    return packageServices;
 };
-export const runPikkuFuncDirectly = async (funcName, allServices, wire, data, userSession) => {
-    const funcConfig = pikkuState('function', 'functions').get(funcName);
+export const addFunction = (funcName, funcConfig, packageName = null) => {
+    pikkuState(packageName, 'function', 'functions').set(funcName, funcConfig);
+};
+export const runPikkuFuncDirectly = async (funcName, allServices, wire, data, userSession, packageName = null) => {
+    const funcConfig = pikkuState(packageName, 'function', 'functions').get(funcName);
     if (!funcConfig) {
         throw new Error(`Function not found: ${funcName}`);
     }
@@ -20,15 +51,28 @@ export const runPikkuFuncDirectly = async (funcName, allServices, wire, data, us
     };
     return (await funcConfig.func(allServices, data, wireWithSession));
 };
-export const runPikkuFunc = async (wireType, wireId, funcName, { singletonServices, createWireServices, data, auth: wiringAuth, inheritedMiddleware, wireMiddleware, inheritedPermissions, wirePermissions, coerceDataFromSchema, tags = [], wire, }) => {
-    const funcConfig = pikkuState('function', 'functions').get(funcName);
+export const runPikkuFunc = async (wireType, wireId, funcName, { singletonServices, createWireServices, data, auth: wiringAuth, inheritedMiddleware, wireMiddleware, inheritedPermissions, wirePermissions, coerceDataFromSchema, tags = [], wire, packageName = null, }) => {
+    const funcConfig = pikkuState(packageName, 'function', 'functions').get(funcName);
     if (!funcConfig) {
         throw new Error(`Function not found: ${funcName}`);
     }
-    const funcMeta = pikkuState('function', 'meta')[funcName];
+    const allMeta = pikkuState(packageName, 'function', 'meta');
+    const funcMeta = allMeta[funcName];
     if (!funcMeta) {
         throw new Error(`Function meta not found: ${funcName}`);
     }
+    // For external packages, get or create their singleton services
+    const resolvedSingletonServices = packageName
+        ? await getOrCreatePackageSingletonServices(packageName, singletonServices)
+        : singletonServices;
+    // Get the package's createWireServices if available
+    let resolvedCreateWireServices = createWireServices;
+    if (packageName) {
+        const factories = pikkuState(packageName, 'package', 'factories');
+        if (factories?.createWireServices) {
+            resolvedCreateWireServices = factories.createWireServices;
+        }
+    }
     // Convert tags to PermissionMetadata and merge with inheritedPermissions
     const mergedInheritedPermissions = [
         ...(inheritedPermissions || []),
@@ -60,10 +104,10 @@ export const runPikkuFunc = async (wireType, wireId, funcName, { singletonServic
         const inputSchemaName = funcMeta.inputSchemaName;
         if (inputSchemaName) {
             // Validate request data against the defined schema, if any
-            await validateSchema(singletonServices.logger, singletonServices.schema, inputSchemaName, actualData);
+            await validateSchema(resolvedSingletonServices.logger, resolvedSingletonServices.schema, inputSchemaName, actualData, packageName);
             // Coerce (top level) query string parameters or date objects if specified by the schema
             if (coerceDataFromSchema) {
-                coerceTopLevelDataFromSchema(inputSchemaName, actualData);
+                coerceTopLevelDataFromSchema(inputSchemaName, actualData, packageName);
             }
         }
         await runPermissions(wireType, wireId, {
@@ -71,13 +115,14 @@ export const runPikkuFunc = async (wireType, wireId, funcName, { singletonServic
             wirePermissions: wirePermissions,
             funcInheritedPermissions: funcMeta.permissions,
             funcPermissions: funcConfig.permissions,
-            services: singletonServices,
+            services: resolvedSingletonServices,
             wire: { ...wireWithInitialSession, rpc: undefined },
             data: actualData,
+            packageName,
         });
-        const wireServices = await createWireServices?.(singletonServices, wireWithInitialSession);
+        const wireServices = await resolvedCreateWireServices?.(resolvedSingletonServices, wireWithInitialSession);
         try {
-            const services = { ...singletonServices, ...wireServices };
+            const services = { ...resolvedSingletonServices, ...wireServices };
             const rpc = rpcService.getContextRPCService(services, wireWithInitialSession);
             return await funcConfig.func(services, actualData, {
                 ...wireWithInitialSession,
@@ -86,7 +131,7 @@ export const runPikkuFunc = async (wireType, wireId, funcName, { singletonServic
         }
         finally {
             if (wireServices) {
-                await closeWireServices(singletonServices.logger, wireServices);
+                await closeWireServices(resolvedSingletonServices.logger, wireServices);
             }
         }
     };
@@ -95,9 +140,10 @@ export const runPikkuFunc = async (wireType, wireId, funcName, { singletonServic
         wireMiddleware,
         funcInheritedMiddleware: funcMeta.middleware,
         funcMiddleware: funcConfig.middleware,
+        packageName,
     });
     if (allMiddleware.length > 0) {
-        return (await runMiddleware(singletonServices, wire, allMiddleware, executeFunction));
+        return (await runMiddleware(resolvedSingletonServices, wire, allMiddleware, executeFunction));
     }
     return (await executeFunction());
 };

package/dist/function/functions.types.d.ts

@@ -36,8 +36,8 @@ export type CorePikkuPermission<In = any, Services extends CoreSingletonServices
 export type CorePikkuPermissionConfig<In = any, Services extends CoreSingletonServices = CoreServices, Wire extends PikkuWire<In, never, false, CoreUserSession> = PikkuWire<In, never, false, CoreUserSession>> = {
     /** The permission function */
     func: CorePikkuPermission<In, Services, Wire>;
-    /** Optional human-readable name for the permission */
-    name?: string;
+    /** Optional human-readable title for the permission */
+    title?: string;
     /** Optional description of what the permission checks */
     description?: string;
 };
@@ -57,7 +57,7 @@ export type CorePikkuPermissionConfig<In = any, Services extends CoreSingletonSe
  *
  * // Configuration object syntax with metadata
  * export const adminPermission = pikkuPermission({
- *   name: 'Admin Permission',
+ *   title: 'Admin Permission',
  *   description: 'Checks if user has admin role',
  *   func: async ({ logger }, _data, { session }) => {
  *     const currentSession = await session.get()
@@ -98,8 +98,20 @@ export type CorePikkuPermissionFactory<In = any, Services extends CoreSingletonS
  */
 export declare const pikkuPermissionFactory: <In = any>(factory: CorePikkuPermissionFactory<In>) => CorePikkuPermissionFactory<In>;
 export type CorePermissionGroup<PikkuPermission = CorePikkuPermission<any>> = Record<string, PikkuPermission | PikkuPermission[]> | undefined;
-export type CorePikkuFunctionConfig<PikkuFunction extends CorePikkuFunction<any, any, any, any> | CorePikkuFunctionSessionless<any, any, any, any>, PikkuPermission extends CorePikkuPermission<any, any, any> = CorePikkuPermission<any>, PikkuMiddleware extends CorePikkuMiddleware<any, any> = CorePikkuMiddleware<any, any>> = {
-    name?: string;
+/**
+ * Zod schema type - matches z.ZodType shape for type inference
+ * This avoids requiring zod as a dependency while allowing schema inference
+ */
+export type ZodLike<T = any> = {
+    _input: T;
+    _output: T;
+};
+export type CorePikkuFunctionConfig<PikkuFunction extends CorePikkuFunction<any, any, any, any> | CorePikkuFunctionSessionless<any, any, any, any>, PikkuPermission extends CorePikkuPermission<any, any, any> = CorePikkuPermission<any>, PikkuMiddleware extends CorePikkuMiddleware<any, any> = CorePikkuMiddleware<any, any>, InputSchema extends ZodLike | undefined = undefined, OutputSchema extends ZodLike | undefined = undefined> = {
+    /** Optional human-readable title for the function */
+    title?: string;
+    /** Optional description of what the function does */
+    description?: string;
+    override?: string;
     tags?: string[];
     expose?: boolean;
     internal?: boolean;
@@ -107,4 +119,71 @@ export type CorePikkuFunctionConfig<PikkuFunction extends CorePikkuFunction<any,
     auth?: boolean;
     permissions?: CorePermissionGroup<PikkuPermission>;
     middleware?: PikkuMiddleware[];
+    input?: InputSchema;
+    output?: OutputSchema;
 };
+/**
+ * A trigger function that sets up a subscription and returns a teardown function.
+ * The trigger is fired via wire.trigger.trigger(data).
+ *
+ * @template TConfig - Configuration type (hardcoded when wired)
+ * @template TOutput - Output type produced when trigger fires
+ * @template Services - Services available to the trigger
+ */
+export type CorePikkuTriggerFunction<TConfig = unknown, TOutput = unknown, Services extends CoreSingletonServices = CoreSingletonServices> = (services: Services, config: TConfig, wire: {
+    trigger: {
+        trigger: (data: TOutput) => void;
+    };
+}) => Promise<() => void | Promise<void>>;
+/**
+ * Configuration object for creating a trigger function with metadata
+ */
+export type CorePikkuTriggerFunctionConfig<TConfig = unknown, TOutput = unknown, Services extends CoreSingletonServices = CoreSingletonServices, ConfigSchema extends ZodLike | undefined = undefined, OutputSchema extends ZodLike | undefined = undefined> = {
+    /** Optional human-readable title for the trigger */
+    title?: string;
+    /** Optional description of what the trigger does */
+    description?: string;
+    /** Optional tags for categorization */
+    tags?: string[];
+    /** The trigger function */
+    func: CorePikkuTriggerFunction<TConfig, TOutput, Services>;
+    /** Optional Zod schema for config validation */
+    config?: ConfigSchema;
+    /** Optional Zod schema for output validation */
+    output?: OutputSchema;
+};
+/**
+ * Factory function for creating trigger functions
+ * Supports both direct function and configuration object syntax
+ *
+ * @example
+ * ```typescript
+ * // Direct function syntax
+ * export const redisSubscribeTrigger = pikkuTriggerFunc<
+ *   { channel: string },
+ *   { message: string }
+ * >(async ({ redis }, { channel }, { trigger }) => {
+ *   const subscriber = redis.duplicate()
+ *   await subscriber.subscribe(channel, (msg) => {
+ *     trigger.trigger({ message: msg })
+ *   })
+ *   return () => subscriber.unsubscribe()
+ * })
+ *
+ * // Configuration object syntax with metadata
+ * export const redisSubscribeTrigger = pikkuTriggerFunc({
+ *   title: 'Redis Subscribe Trigger',
+ *   description: 'Listens to Redis pub/sub channel',
+ *   config: z.object({ channel: z.string() }),
+ *   output: z.object({ message: z.string() }),
+ *   func: async ({ redis }, { channel }, { trigger }) => {
+ *     const subscriber = redis.duplicate()
+ *     await subscriber.subscribe(channel, (msg) => {
+ *       trigger.trigger({ message: msg })
+ *     })
+ *     return () => subscriber.unsubscribe()
+ *   }
+ * })
+ * ```
+ */
+export declare const pikkuTriggerFunc: <TConfig = unknown, TOutput = unknown, Services extends CoreSingletonServices = CoreSingletonServices, ConfigSchema extends ZodLike | undefined = undefined, OutputSchema extends ZodLike | undefined = undefined>(triggerOrConfig: CorePikkuTriggerFunction<TConfig, TOutput, Services> | CorePikkuTriggerFunctionConfig<TConfig, TOutput, Services, ConfigSchema, OutputSchema>) => CorePikkuTriggerFunctionConfig<TConfig, TOutput, Services, ConfigSchema, OutputSchema>;

package/dist/function/functions.types.js

@@ -14,7 +14,7 @@
  *
  * // Configuration object syntax with metadata
  * export const adminPermission = pikkuPermission({
- *   name: 'Admin Permission',
+ *   title: 'Admin Permission',
  *   description: 'Checks if user has admin role',
  *   func: async ({ logger }, _data, { session }) => {
  *     const currentSession = await session.get()
@@ -49,3 +49,43 @@ export const pikkuPermission = (permission) => {
 export const pikkuPermissionFactory = (factory) => {
     return factory;
 };
+/**
+ * Factory function for creating trigger functions
+ * Supports both direct function and configuration object syntax
+ *
+ * @example
+ * ```typescript
+ * // Direct function syntax
+ * export const redisSubscribeTrigger = pikkuTriggerFunc<
+ *   { channel: string },
+ *   { message: string }
+ * >(async ({ redis }, { channel }, { trigger }) => {
+ *   const subscriber = redis.duplicate()
+ *   await subscriber.subscribe(channel, (msg) => {
+ *     trigger.trigger({ message: msg })
+ *   })
+ *   return () => subscriber.unsubscribe()
+ * })
+ *
+ * // Configuration object syntax with metadata
+ * export const redisSubscribeTrigger = pikkuTriggerFunc({
+ *   title: 'Redis Subscribe Trigger',
+ *   description: 'Listens to Redis pub/sub channel',
+ *   config: z.object({ channel: z.string() }),
+ *   output: z.object({ message: z.string() }),
+ *   func: async ({ redis }, { channel }, { trigger }) => {
+ *     const subscriber = redis.duplicate()
+ *     await subscriber.subscribe(channel, (msg) => {
+ *       trigger.trigger({ message: msg })
+ *     })
+ *     return () => subscriber.unsubscribe()
+ *   }
+ * })
+ * ```
+ */
+export const pikkuTriggerFunc = (triggerOrConfig) => {
+    if (typeof triggerOrConfig === 'function') {
+        return { func: triggerOrConfig };
+    }
+    return triggerOrConfig;
+};

package/dist/index.d.ts

@@ -17,12 +17,16 @@ export * from './wirings/scheduler/index.js';
 export * from './wirings/rpc/index.js';
 export * from './wirings/queue/index.js';
 export * from './wirings/workflow/index.js';
+export * from './wirings/workflow/graph/index.js';
 export * from './wirings/mcp/index.js';
 export * from './wirings/cli/index.js';
+export * from './wirings/forge-node/index.js';
+export * from './wirings/trigger/index.js';
 export * from './errors/index.js';
 export * from './middleware/index.js';
 export * from './utils.js';
 export * from './time-utils.js';
-export { pikkuState } from './pikku-state.js';
-export { runMiddleware, addMiddleware, getMiddlewareByName, } from './middleware-runner.js';
+export { pikkuState, initializePikkuState, resetPikkuState, addPackageServiceFactories, } from './pikku-state.js';
+export type { PikkuPackageState } from './types/state.types.js';
+export { runMiddleware, addMiddleware } from './middleware-runner.js';
 export { addPermission } from './permissions.js';

package/dist/index.js

@@ -17,12 +17,15 @@ export * from './wirings/scheduler/index.js';
 export * from './wirings/rpc/index.js';
 export * from './wirings/queue/index.js';
 export * from './wirings/workflow/index.js';
+export * from './wirings/workflow/graph/index.js';
 export * from './wirings/mcp/index.js';
 export * from './wirings/cli/index.js';
+export * from './wirings/forge-node/index.js';
+export * from './wirings/trigger/index.js';
 export * from './errors/index.js';
 export * from './middleware/index.js';
 export * from './utils.js';
 export * from './time-utils.js';
-export { pikkuState } from './pikku-state.js';
-export { runMiddleware, addMiddleware, getMiddlewareByName, } from './middleware-runner.js';
+export { pikkuState, initializePikkuState, resetPikkuState, addPackageServiceFactories, } from './pikku-state.js';
+export { runMiddleware, addMiddleware } from './middleware-runner.js';
 export { addPermission } from './permissions.js';

package/dist/middleware/auth-apikey.d.ts

@@ -20,5 +20,5 @@ export declare const authAPIKey: import("../types/core.types.js").CorePikkuMiddl
 }, import("../types/core.types.js").CoreSingletonServices<{
     logLevel?: import("../index.js").LogLevel;
     secrets?: {};
-    workflow?: import("../wirings/workflow/workflow.types.js").WorkflowServiceConfig;
+    workflow?: import("../index.js").WorkflowServiceConfig;
 }>, import("../types/core.types.js").CoreUserSession>;

package/dist/middleware/auth-bearer.d.ts

@@ -36,5 +36,5 @@ export declare const authBearer: import("../types/core.types.js").CorePikkuMiddl
 }, import("../types/core.types.js").CoreSingletonServices<{
     logLevel?: import("../index.js").LogLevel;
     secrets?: {};
-    workflow?: import("../wirings/workflow/workflow.types.js").WorkflowServiceConfig;
+    workflow?: import("../index.js").WorkflowServiceConfig;
 }>, CoreUserSession>;

package/dist/middleware/auth-cookie.d.ts

@@ -35,5 +35,5 @@ export declare const authCookie: import("../types/core.types.js").CorePikkuMiddl
 }, import("../types/core.types.js").CoreSingletonServices<{
     logLevel?: import("../index.js").LogLevel;
     secrets?: {};
-    workflow?: import("../wirings/workflow/workflow.types.js").WorkflowServiceConfig;
+    workflow?: import("../index.js").WorkflowServiceConfig;
 }>, import("../types/core.types.js").CoreUserSession>;

package/dist/middleware/timeout.d.ts

@@ -3,5 +3,5 @@ export declare const timeout: () => import("../types/core.types.js").CorePikkuMi
 }, import("../types/core.types.js").CoreSingletonServices<{
     logLevel?: import("../index.js").LogLevel;
     secrets?: {};
-    workflow?: import("../wirings/workflow/workflow.types.js").WorkflowServiceConfig;
+    workflow?: import("../index.js").WorkflowServiceConfig;
 }>, import("../types/core.types.js").CoreUserSession>;

package/dist/middleware-runner.d.ts

@@ -50,19 +50,7 @@ export declare const runMiddleware: <Middleware extends CorePikkuMiddleware>(ser
  * ])
  * ```
  */
-export declare const addMiddleware: <PikkuMiddleware extends CorePikkuMiddleware>(tag: string, middleware: CorePikkuMiddlewareGroup) => CorePikkuMiddlewareGroup;
-/**
- * Retrieves a registered middleware function by its name.
- *
- * This function looks up middleware that was registered with registerMiddleware.
- * It's used internally by the framework to resolve middleware references in metadata.
- *
- * @param {string} name - The unique name (pikkuFuncName) of the middleware function.
- * @returns {CorePikkuMiddleware | undefined} The middleware function, or undefined if not found.
- *
- * @internal
- */
-export declare const getMiddlewareByName: (name: string) => CorePikkuMiddleware | undefined;
+export declare const addMiddleware: <PikkuMiddleware extends CorePikkuMiddleware>(tag: string, middleware: CorePikkuMiddlewareGroup, packageName?: string | null) => CorePikkuMiddlewareGroup;
 /**
  * Combines wiring-specific middleware with function-level middleware.
  *
@@ -85,9 +73,10 @@ export declare const getMiddlewareByName: (name: string) => CorePikkuMiddleware
  * })
  * ```
  */
-export declare const combineMiddleware: (wireType: PikkuWiringTypes, uid: string, { wireInheritedMiddleware, wireMiddleware, funcInheritedMiddleware, funcMiddleware, }?: {
+export declare const combineMiddleware: (wireType: PikkuWiringTypes, uid: string, { wireInheritedMiddleware, wireMiddleware, funcInheritedMiddleware, funcMiddleware, packageName, }?: {
     wireInheritedMiddleware?: MiddlewareMetadata[];
     wireMiddleware?: CorePikkuMiddleware[];
     funcInheritedMiddleware?: MiddlewareMetadata[];
     funcMiddleware?: CorePikkuMiddleware[];
+    packageName?: string | null;
 }) => readonly CorePikkuMiddleware[];

package/dist/middleware-runner.js

@@ -64,8 +64,8 @@ export const runMiddleware = async (services, wire, middlewares, main) => {
  * ])
  * ```
  */
-export const addMiddleware = (tag, middleware) => {
-    const tagGroups = pikkuState('middleware', 'tagGroup');
+export const addMiddleware = (tag, middleware, packageName = null) => {
+    const tagGroups = pikkuState(packageName, 'middleware', 'tagGroup');
     tagGroups[tag] = middleware;
     return middleware;
 };
@@ -80,8 +80,8 @@ export const addMiddleware = (tag, middleware) => {
  *
  * @internal
  */
-export const getMiddlewareByName = (name) => {
-    const middlewareStore = pikkuState('misc', 'middleware');
+const getMiddlewareByName = (name) => {
+    const middlewareStore = pikkuState(null, 'misc', 'middleware');
     const middleware = middlewareStore[name];
     return middleware?.[0];
 };
@@ -117,7 +117,7 @@ const middlewareCache = {
  * })
  * ```
  */
-export const combineMiddleware = (wireType, uid, { wireInheritedMiddleware, wireMiddleware, funcInheritedMiddleware, funcMiddleware, } = {}) => {
+export const combineMiddleware = (wireType, uid, { wireInheritedMiddleware, wireMiddleware, funcInheritedMiddleware, funcMiddleware, packageName = null, } = {}) => {
     if (middlewareCache[wireType][uid]) {
         return middlewareCache[wireType][uid];
     }
@@ -127,7 +127,7 @@ export const combineMiddleware = (wireType, uid, { wireInheritedMiddleware, wire
         for (const meta of wireInheritedMiddleware) {
             if (meta.type === 'http') {
                 // Look up HTTP middleware group from pikkuState
-                const group = pikkuState('middleware', 'httpGroup')[meta.route];
+                const group = pikkuState(packageName, 'middleware', 'httpGroup')[meta.route];
                 if (group) {
                     // At runtime, all factories should be resolved to middleware
                     resolved.push(...group);
@@ -135,7 +135,7 @@ export const combineMiddleware = (wireType, uid, { wireInheritedMiddleware, wire
             }
             else if (meta.type === 'tag') {
                 // Look up tag middleware group from pikkuState
-                const group = pikkuState('middleware', 'tagGroup')[meta.tag];
+                const group = pikkuState(packageName, 'middleware', 'tagGroup')[meta.tag];
                 if (group) {
                     // At runtime, all factories should be resolved to middleware
                     resolved.push(...group);
@@ -159,7 +159,7 @@ export const combineMiddleware = (wireType, uid, { wireInheritedMiddleware, wire
         for (const meta of funcInheritedMiddleware) {
             if (meta.type === 'tag') {
                 // Look up tag middleware group from pikkuState
-                const group = pikkuState('middleware', 'tagGroup')[meta.tag];
+                const group = pikkuState(packageName, 'middleware', 'tagGroup')[meta.tag];
                 if (group) {
                     // At runtime, all factories should be resolved to middleware
                     resolved.push(...group);

package/dist/permissions.d.ts

@@ -1,43 +1,5 @@
 import { CoreServices, PikkuWiringTypes, PermissionMetadata, PikkuWire } from './types/core.types.js';
 import { CorePermissionGroup, CorePikkuPermission } from './function/functions.types.js';
-/**
- * This function validates permissions by iterating over permission groups and executing the corresponding permission functions. If all functions in at least one group return true, the permission is considered valid.
- * @param services - The core services required for permission validation.
- * @param data - The data to be used in the permission validation functions.
- * @param wire - The wire object containing request/response context and session.
- * @returns A promise that resolves to void.
- */
-export declare const verifyPermissions: <Out = any>(permissions: CorePermissionGroup, services: CoreServices, data: any, wire: PikkuWire<any, never, any, never, never, never>) => Promise<boolean>;
-/**
- * Registers a single permission function by name in the global permission store.
- *
- * This function is used by CLI-generated code to register permission functions
- * that can be referenced by name in metadata. It stores permissions in a special
- * namespace to avoid conflicts with tag-based permissions.
- *
- * @param {string} name - The unique name (pikkuFuncName) of the permission function.
- * @param {CorePikkuPermission} permission - The permission function to register.
- *
- * @example
- * ```typescript
- * // Called by CLI-generated pikku-permissions.gen.ts
- * registerPermission('adminPermission_src_permissions_ts_10_5', adminPermission)
- * registerPermission('readPermission_src_permissions_ts_20_10', readPermission)
- * ```
- */
-export declare const registerPermission: (name: string, permission: CorePikkuPermission<any>) => void;
-/**
- * Retrieves a registered permission function by its name.
- *
- * This function looks up permissions that was registered with registerPermission.
- * It's used internally by the framework to resolve permission references in metadata.
- *
- * @param {string} name - The unique name (pikkuFuncName) of the permission function.
- * @returns {CorePikkuPermission | undefined} The permission function, or undefined if not found.
- *
- * @internal
- */
-export declare const getPermissionByName: (name: string) => CorePikkuPermission | undefined;
 /**
  * Adds global permissions for a specific tag.
  *
@@ -66,58 +28,12 @@ export declare const getPermissionByName: (name: string) => CorePikkuPermission
  * ])
  * ```
  */
-export declare const addPermission: (tag: string, permissions: CorePermissionGroup | CorePikkuPermission[]) => CorePermissionGroup | CorePikkuPermission[];
-/**
- * Retrieves permissions for a given set of tags.
- *
- * This function looks up all permissions registered for any of the provided tags
- * and returns them as a flattened array.
- *
- * @param {string[]} tags - Array of tags to look up permissions for.
- * @returns {any[]} Array of permission functions that apply to the given tags.
- *
- * @example
- * ```typescript
- * // Get all permissions for tags 'api' and 'auth'
- * const permissions = getPermissionsForTags(['api', 'auth'])
- * ```
- */
-export declare const getPermissionsForTags: (tags?: string[]) => readonly (CorePermissionGroup | CorePikkuPermission)[];
-/**
- * Combines wiring-specific permissions with function-level permissions.
- *
- * This function resolves permission metadata into actual permission functions and combines them.
- * It filters out wire permissions without tags from inheritedPermissions to avoid duplication
- * (those are passed separately as wirePermissions).
- *
- * @param {object} options - Configuration object for combining permissions.
- * @param {PermissionMetadata[] | undefined} options.wireInheritedPermissions - Metadata from wiring (HTTP + tags + wire with tags).
- * @param {CorePermissionGroup | CorePikkuPermission[] | undefined} options.wirePermissions - Inline wire permissions.
- * @param {PermissionMetadata[] | undefined} options.funcInheritedPermissions - Function permissions metadata (only tags).
- * @param {CorePermissionGroup | CorePikkuPermission[] | undefined} options.funcPermissions - Inline function permissions.
- * @returns {(CorePermissionGroup | CorePikkuPermission)[]} Combined array of resolved permissions.
- *
- * @example
- * ```typescript
- * const combined = combinePermissions(wireType, wireId, {
- *   wireInheritedPermissions: meta.permissions,
- *   wirePermissions: inlinePermissions,
- *   funcInheritedPermissions: funcMeta.permissions,
- *   funcPermissions: funcConfig.permissions
- * })
- * ```
- */
-export declare const combinePermissions: (wireType: PikkuWiringTypes, uid: string, { wireInheritedPermissions, wirePermissions, funcInheritedPermissions, funcPermissions, }?: {
-    wireInheritedPermissions?: PermissionMetadata[];
-    wirePermissions?: CorePermissionGroup | CorePikkuPermission[];
-    funcInheritedPermissions?: PermissionMetadata[];
-    funcPermissions?: CorePermissionGroup | CorePikkuPermission[];
-}) => readonly (CorePermissionGroup | CorePikkuPermission)[];
+export declare const addPermission: (tag: string, permissions: CorePermissionGroup | CorePikkuPermission[], packageName?: string | null) => CorePermissionGroup | CorePikkuPermission[];
 /**
  * Runs permission checks using combined permissions from all sources.
  * Combines permissions from wire and function levels, then validates them.
  */
-export declare const runPermissions: (wireType: PikkuWiringTypes, uid: string, { wireInheritedPermissions, wirePermissions, funcInheritedPermissions, funcPermissions, services, wire, data, }: {
+export declare const runPermissions: (wireType: PikkuWiringTypes, uid: string, { wireInheritedPermissions, wirePermissions, funcInheritedPermissions, funcPermissions, services, wire, data, packageName, }: {
     wireInheritedPermissions?: PermissionMetadata[];
     wirePermissions?: CorePermissionGroup | CorePikkuPermission[];
     funcInheritedPermissions?: PermissionMetadata[];
@@ -125,4 +41,5 @@ export declare const runPermissions: (wireType: PikkuWiringTypes, uid: string, {
     services: CoreServices;
     wire: PikkuWire<any, never, any, never, never, never>;
     data: any;
+    packageName?: string | null;
 }) => Promise<void>;