@pikku/core 0.11.1 → 0.12.0

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>;

package/dist/permissions.js

@@ -1,6 +1,6 @@
 import { pikkuState } from './pikku-state.js';
 import { ForbiddenError } from './errors/errors.js';
-import { freezeDedupe } from './utils.js';
+import { freezeDedupe, getTagGroups } from './utils.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.
@@ -8,7 +8,7 @@ import { freezeDedupe } from './utils.js';
  * @param wire - The wire object containing request/response context and session.
  * @returns A promise that resolves to void.
  */
-export const verifyPermissions = async (permissions, services, data, wire) => {
+const verifyPermissions = async (permissions, services, data, wire) => {
     if (!permissions) {
         return true;
     }
@@ -33,40 +33,19 @@ export const verifyPermissions = async (permissions, services, data, wire) => {
     }
     return false;
 };
-/**
- * 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 const registerPermission = (name, permission) => {
-    const permissionStore = pikkuState('misc', 'permissions');
-    permissionStore[name] = [permission];
-};
 /**
  * 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.
+ * @param {string} name - The unique name (pikkuFuncId) of the permission function.
  * @returns {CorePikkuPermission | undefined} The permission function, or undefined if not found.
  *
  * @internal
  */
-export const getPermissionByName = (name) => {
-    const permissionStore = pikkuState('misc', 'permissions');
+const getPermissionByName = (name) => {
+    const permissionStore = pikkuState(null, 'misc', 'permissions');
     const permission = permissionStore[name];
     if (Array.isArray(permission) && permission.length === 1) {
         return permission[0];
@@ -101,57 +80,23 @@ export const getPermissionByName = (name) => {
  * ])
  * ```
  */
-export const addPermission = (tag, permissions) => {
-    const tagGroups = pikkuState('permissions', 'tagGroup');
+export const addPermission = (tag, permissions, packageName = null) => {
+    const tagGroups = pikkuState(packageName, 'permissions', 'tagGroup');
     if (tagGroups[tag]) {
         throw new Error(`Permissions for tag '${tag}' already exist. Use a different tag or remove the existing permissions first.`);
     }
     tagGroups[tag] = permissions;
     return permissions;
 };
-const EMPTY = [];
-/**
- * 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 const getPermissionsForTags = (tags) => {
-    if (!tags || tags.length === 0) {
-        return EMPTY;
-    }
-    const permissionsStore = pikkuState('permissions', 'tagGroup');
-    const applicablePermissions = [];
-    // Collect permissions for all matching tags
-    for (const tag of new Set(tags)) {
-        const tagPermissions = permissionsStore[tag];
-        if (tagPermissions) {
-            if (Array.isArray(tagPermissions)) {
-                applicablePermissions.push(...tagPermissions);
-            }
-            else {
-                applicablePermissions.push(tagPermissions);
-            }
-        }
-    }
-    return applicablePermissions;
-};
 const combinedPermissionsCache = {
     http: {},
     rpc: {},
     channel: {},
     queue: {},
     scheduler: {},
+    trigger: {},
     mcp: {},
+    agent: {},
     cli: {},
     workflow: {},
 };
@@ -179,7 +124,7 @@ const combinedPermissionsCache = {
  * })
  * ```
  */
-export const combinePermissions = (wireType, uid, { wireInheritedPermissions, wirePermissions, funcInheritedPermissions, funcPermissions, } = {}) => {
+const combinePermissions = (wireType, uid, { wireInheritedPermissions, wirePermissions, funcInheritedPermissions, funcPermissions, packageName = null, } = {}) => {
     if (combinedPermissionsCache[wireType][uid]) {
         return combinedPermissionsCache[wireType][uid];
     }
@@ -189,7 +134,7 @@ export const combinePermissions = (wireType, uid, { wireInheritedPermissions, wi
         for (const meta of wireInheritedPermissions) {
             if (meta.type === 'http') {
                 // Look up HTTP permission group from pikkuState
-                const group = pikkuState('permissions', 'httpGroup')[meta.route];
+                const group = pikkuState(packageName, 'permissions', 'httpGroup')[meta.route];
                 if (group) {
                     if (Array.isArray(group)) {
                         resolved.push(...group);
@@ -200,9 +145,8 @@ export const combinePermissions = (wireType, uid, { wireInheritedPermissions, wi
                 }
             }
             else if (meta.type === 'tag') {
-                // Look up tag permission group from pikkuState
-                const group = pikkuState('permissions', 'tagGroup')[meta.tag];
-                if (group) {
+                const groups = getTagGroups(pikkuState(packageName, 'permissions', 'tagGroup'), meta.tag);
+                for (const group of groups) {
                     if (Array.isArray(group)) {
                         resolved.push(...group);
                     }
@@ -233,9 +177,8 @@ export const combinePermissions = (wireType, uid, { wireInheritedPermissions, wi
     if (funcInheritedPermissions) {
         for (const meta of funcInheritedPermissions) {
             if (meta.type === 'tag') {
-                // Look up tag permission group from pikkuState
-                const group = pikkuState('permissions', 'tagGroup')[meta.tag];
-                if (group) {
+                const groups = getTagGroups(pikkuState(packageName, 'permissions', 'tagGroup'), meta.tag);
+                for (const group of groups) {
                     if (Array.isArray(group)) {
                         resolved.push(...group);
                     }
@@ -264,27 +207,24 @@ export const combinePermissions = (wireType, uid, { wireInheritedPermissions, wi
  * Runs permission checks using combined permissions from all sources.
  * Combines permissions from wire and function levels, then validates them.
  */
-export const runPermissions = async (wireType, uid, { wireInheritedPermissions, wirePermissions, funcInheritedPermissions, funcPermissions, services, wire, data, }) => {
+export const runPermissions = async (wireType, uid, { wireInheritedPermissions, wirePermissions, funcInheritedPermissions, funcPermissions, services, wire, data, packageName = null, }) => {
     // Combine all permissions: wireInheritedPermissions → wirePermissions → funcInheritedPermissions → funcPermissions
     const allPermissions = combinePermissions(wireType, uid, {
         wireInheritedPermissions,
         wirePermissions,
         funcInheritedPermissions,
         funcPermissions,
+        packageName,
     });
     // Check all combined permissions - at least one must pass if any exist
     if (allPermissions.length > 0) {
-        let permissioned = false;
         for (const permission of allPermissions) {
             const result = await verifyPermissions(typeof permission === 'function' ? { permission } : permission, services, data, wire);
             if (result) {
-                permissioned = true;
-                // Continue executing all permissions (don't break early)
+                return;
             }
         }
-        if (!permissioned) {
-            services.logger.debug('Permission denied - combined permissions');
-            throw new ForbiddenError('Permission denied');
-        }
+        services.logger.debug('Permission denied - combined permissions');
+        throw new ForbiddenError('Permission denied');
     }
 };

package/dist/pikku-state.d.ts

@@ -1,106 +1,35 @@
-import { ChannelsMeta, CoreChannel } from './wirings/channel/channel.types.js';
-import { CoreHTTPFunctionWiring, HTTPMethod, HTTPWiringsMeta } from './wirings/http/http.types.js';
-import { FunctionsMeta, CorePikkuMiddleware, CorePikkuMiddlewareGroup, FunctionServicesMeta } from './types/core.types.js';
-import { CoreScheduledTask, ScheduledTasksMeta } from './wirings/scheduler/scheduler.types.js';
-import { ErrorDetails, PikkuError } from './errors/error-handler.js';
-import { CorePermissionGroup, CorePikkuFunctionConfig, CorePikkuPermission } from './function/functions.types.js';
-import { QueueWorkersMeta, CoreQueueWorker } from './wirings/queue/queue.types.js';
-import { CoreMCPResource, CoreMCPTool, CoreMCPPrompt, MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from './wirings/mcp/mcp.types.js';
-import { CLIMeta, CLIProgramState } from './wirings/cli/cli.types.js';
-import { CoreWorkflow, WorkflowsMeta } from './wirings/workflow/workflow.types.js';
-interface PikkuState {
-    function: {
-        meta: FunctionsMeta;
-        functions: Map<string, CorePikkuFunctionConfig<any, any>>;
-    };
-    rpc: {
-        meta: Record<string, string>;
-        files: Map<string, {
-            exportedName: string;
-            path: string;
-        }>;
-    };
-    http: {
-        middleware: Map<string, CorePikkuMiddleware<any, any>[]>;
-        permissions: Map<string, CorePermissionGroup | CorePikkuPermission[]>;
-        routes: Map<HTTPMethod, Map<string, CoreHTTPFunctionWiring<any, any, any>>>;
-        meta: HTTPWiringsMeta;
-    };
-    channel: {
-        channels: Map<string, CoreChannel<any, any>>;
-        meta: ChannelsMeta;
-    };
-    scheduler: {
-        tasks: Map<string, CoreScheduledTask>;
-        meta: ScheduledTasksMeta;
-    };
-    queue: {
-        registrations: Map<string, CoreQueueWorker>;
-        meta: QueueWorkersMeta;
-    };
-    workflows: {
-        registrations: Map<string, CoreWorkflow>;
-        meta: WorkflowsMeta;
-    };
-    mcp: {
-        resources: Map<string, CoreMCPResource>;
-        resourcesMeta: MCPResourceMeta;
-        tools: Map<string, CoreMCPTool>;
-        toolsMeta: MCPToolMeta;
-        prompts: Map<string, CoreMCPPrompt>;
-        promptsMeta: MCPPromptMeta;
-    };
-    cli: {
-        meta: CLIMeta | Record<string, any>;
-        programs: Record<string, CLIProgramState>;
-    };
-    middleware: {
-        tagGroup: Record<string, CorePikkuMiddlewareGroup>;
-        httpGroup: Record<string, CorePikkuMiddlewareGroup>;
-        tagGroupMeta: Record<string, {
-            exportName: string | null;
-            sourceFile: string;
-            position: number;
-            services: FunctionServicesMeta;
-            middlewareCount: number;
-            isFactory: boolean;
-        }>;
-        httpGroupMeta: Record<string, {
-            exportName: string | null;
-            sourceFile: string;
-            position: number;
-            services: FunctionServicesMeta;
-            middlewareCount: number;
-            isFactory: boolean;
-        }>;
-    };
-    permissions: {
-        tagGroup: Record<string, CorePermissionGroup | CorePikkuPermission[]>;
-        httpGroup: Record<string, CorePermissionGroup | CorePikkuPermission[]>;
-        tagGroupMeta: Record<string, {
-            exportName: string | null;
-            sourceFile: string;
-            position: number;
-            services: FunctionServicesMeta;
-            permissionCount: number;
-            isFactory: boolean;
-        }>;
-        httpGroupMeta: Record<string, {
-            exportName: string | null;
-            sourceFile: string;
-            position: number;
-            services: FunctionServicesMeta;
-            permissionCount: number;
-            isFactory: boolean;
-        }>;
-    };
-    misc: {
-        errors: Map<PikkuError, ErrorDetails>;
-        schemas: Map<string, any>;
-        middleware: Record<string, CorePikkuMiddleware[]>;
-        permissions: Record<string, CorePermissionGroup | CorePikkuPermission[]>;
-    };
+import { PikkuPackageState } from './index.js';
+declare global {
+    var pikkuState: Map<string, PikkuPackageState> | undefined;
 }
+/**
+ * Get or set package-scoped pikku state
+ *
+ * @param packageName - Package name (null for main package, '@scope/package' for external packages)
+ * @param type - State category (function, rpc, http, etc.)
+ * @param content - Content key within the category
+ * @param value - Optional value to set
+ * @returns The current value of the state
+ *
+ * @example
+ * // Main package
+ * pikkuState(null, 'function', 'functions').get(funcName)
+ *
+ * // External package
+ * pikkuState('@acme/stripe-functions', 'rpc', 'meta')
+ */
+export declare const pikkuState: <Type extends keyof PikkuPackageState, Content extends keyof PikkuPackageState[Type]>(packageName: string | null, type: Type, content: Content, value?: PikkuPackageState[Type][Content]) => PikkuPackageState[Type][Content];
+/**
+ * Initialize state for a new package
+ */
+export declare const initializePikkuState: (packageName: string) => void;
 export declare const resetPikkuState: () => void;
-export declare const pikkuState: <Type extends keyof PikkuState, Content extends keyof PikkuState[Type]>(type: Type, content: Content, value?: PikkuState[Type][Content]) => PikkuState[Type][Content];
-export {};
+export declare const getPikkuMetaDir: (packageName?: string | null) => string | null;
+/**
+ * Register service factories for an external package.
+ * These factories are used to create services when the package's functions are invoked.
+ *
+ * @param packageName - The package name (e.g., '@pikku/templates-function-external')
+ * @param factories - The service factory functions
+ */
+export declare const addPackageServiceFactories: (packageName: string, factories: NonNullable<PikkuPackageState["package"]["factories"]>) => void;

package/dist/pikku-state.js

@@ -1,72 +1,156 @@
-export const resetPikkuState = () => {
-    globalThis.pikkuState = {
-        function: {
-            meta: {},
-            functions: new Map(),
-        },
-        rpc: {
-            meta: {},
-            files: new Map(),
-        },
-        http: {
-            permissions: new Map(),
-            routes: new Map(),
-            meta: {},
-        },
-        channel: {
-            channels: new Map(),
-            meta: {},
-        },
-        scheduler: {
-            tasks: new Map(),
-            meta: [],
-        },
-        queue: {
-            registrations: new Map(),
-            meta: {},
-        },
-        workflows: {
-            registrations: new Map(),
-            meta: {},
-        },
-        mcp: {
-            resources: new Map(),
-            resourcesMeta: {},
-            tools: new Map(),
-            toolsMeta: {},
-            prompts: new Map(),
-            promptsMeta: {},
-        },
-        cli: {
-            meta: { programs: {}, renderers: {} },
-            programs: {},
-        },
-        middleware: {
-            tagGroup: {},
-            httpGroup: {},
-            tagGroupMeta: {},
-            httpGroupMeta: {},
-        },
-        permissions: {
-            tagGroup: {},
-            httpGroup: {},
-            tagGroupMeta: {},
-            httpGroupMeta: {},
-        },
-        misc: {
-            errors: globalThis.pikkuState?.misc?.errors || new Map(),
-            schemas: new Map(),
-            middleware: {},
-            permissions: {},
+/**
+ * Get or set package-scoped pikku state
+ *
+ * @param packageName - Package name (null for main package, '@scope/package' for external packages)
+ * @param type - State category (function, rpc, http, etc.)
+ * @param content - Content key within the category
+ * @param value - Optional value to set
+ * @returns The current value of the state
+ *
+ * @example
+ * // Main package
+ * pikkuState(null, 'function', 'functions').get(funcName)
+ *
+ * // External package
+ * pikkuState('@acme/stripe-functions', 'rpc', 'meta')
+ */
+export const pikkuState = (packageName, type, content, value) => {
+    const resolvedPackageName = packageName ?? '__main__';
+    // Initialize package state if it doesn't exist
+    if (!globalThis.pikkuState ||
+        !globalThis.pikkuState.has(resolvedPackageName)) {
+        initializePikkuState(resolvedPackageName);
+    }
+    const packageState = globalThis.pikkuState.get(resolvedPackageName);
+    if (value !== undefined) {
+        packageState[type][content] = value;
+    }
+    return packageState[type][content];
+};
+const createEmptyPackageState = () => ({
+    function: {
+        meta: {},
+        functions: new Map(),
+    },
+    rpc: {
+        meta: {},
+        files: new Map(),
+        externalPackages: new Map(),
+    },
+    http: {
+        middleware: new Map(),
+        permissions: new Map(),
+        routes: new Map(),
+        meta: {
+            post: {},
+            get: {},
+            delete: {},
+            patch: {},
+            head: {},
+            put: {},
+            options: {},
         },
-    };
+    },
+    channel: {
+        channels: new Map(),
+        meta: {},
+    },
+    scheduler: {
+        tasks: new Map(),
+        meta: [],
+    },
+    queue: {
+        registrations: new Map(),
+        meta: {},
+    },
+    workflows: {
+        registrations: new Map(),
+        meta: {},
+    },
+    trigger: {
+        functions: new Map(),
+        triggers: new Map(),
+        triggerSources: new Map(),
+        meta: {},
+        sourceMeta: {},
+    },
+    mcp: {
+        resources: new Map(),
+        resourcesMeta: {},
+        toolsMeta: {},
+        prompts: new Map(),
+        promptsMeta: {},
+    },
+    agent: {
+        agents: new Map(),
+        agentsMeta: {},
+    },
+    cli: {
+        meta: { programs: {}, renderers: {} },
+        programs: {},
+    },
+    middleware: {
+        tagGroup: {},
+        httpGroup: {},
+    },
+    channelMiddleware: {
+        tagGroup: {},
+    },
+    permissions: {
+        tagGroup: {},
+        httpGroup: {},
+    },
+    misc: {
+        errors: new Map(),
+        schemas: new Map(),
+        middleware: {},
+        channelMiddleware: {},
+        permissions: {},
+    },
+    models: {
+        config: null,
+    },
+    package: {
+        factories: null,
+        singletonServices: null,
+        metaDir: null,
+    },
+});
+/**
+ * Initialize state for a new package
+ */
+export const initializePikkuState = (packageName) => {
+    if (!globalThis.pikkuState) {
+        globalThis.pikkuState = new Map();
+    }
+    if (!globalThis.pikkuState.has(packageName)) {
+        globalThis.pikkuState.set(packageName, createEmptyPackageState());
+    }
+};
+export const resetPikkuState = () => {
+    // Preserve the errors map before resetting
+    const existingErrors = globalThis.pikkuState?.get('__main__')?.misc.errors;
+    globalThis.pikkuState = new Map();
+    initializePikkuState('__main__');
+    // Restore the errors map if it existed
+    if (existingErrors) {
+        const mainState = globalThis.pikkuState.get('__main__');
+        mainState.misc.errors = existingErrors;
+    }
 };
 if (!globalThis.pikkuState) {
     resetPikkuState();
 }
-export const pikkuState = (type, content, value) => {
-    if (value) {
-        globalThis.pikkuState[type][content] = value;
-    }
-    return globalThis.pikkuState[type][content];
+export const getPikkuMetaDir = (packageName) => {
+    return pikkuState(packageName ?? null, 'package', 'metaDir');
+};
+/**
+ * Register service factories for an external package.
+ * These factories are used to create services when the package's functions are invoked.
+ *
+ * @param packageName - The package name (e.g., '@pikku/templates-function-external')
+ * @param factories - The service factory functions
+ */
+export const addPackageServiceFactories = (packageName, factories) => {
+    pikkuState(packageName, 'package', 'factories', factories);
 };