@pikku/core 0.11.1 → 0.11.2

package/dist/types/core.types.d.ts

@@ -1,5 +1,6 @@
 import type { Logger, LogLevel } from '../services/logger.js';
 import { VariablesService } from '../services/variables-service.js';
+import { SecretService } from '../services/secret-service.js';
 import { SchemaService } from '../services/schema-service.js';
 import { JWTService } from '../services/jwt-service.js';
 import { PikkuHTTP } from '../wirings/http/http.types.js';
@@ -11,6 +12,8 @@ import { PikkuScheduledTask } from '../wirings/scheduler/scheduler.types.js';
 import { PikkuQueue, QueueService } from '../wirings/queue/queue.types.js';
 import { PikkuCLI } from '../wirings/cli/cli.types.js';
 import { PikkuWorkflowWire, WorkflowService, WorkflowServiceConfig, WorkflowStepWire } from '../wirings/workflow/workflow.types.js';
+import type { PikkuGraphWire } from '../wirings/workflow/graph/workflow-graph.types.js';
+import { PikkuTrigger } from '../wirings/trigger/trigger.types.js';
 import { SchedulerService } from '../services/scheduler-service.js';
 export type PikkuWiringTypes = 'http' | 'scheduler' | 'channel' | 'rpc' | 'queue' | 'mcp' | 'cli' | 'workflow';
 export interface FunctionServicesMeta {
@@ -124,6 +127,8 @@ export interface CoreSingletonServices<Config extends CoreConfig = CoreConfig> {
     logger: Logger;
     /** The variable service to be used */
     variables: VariablesService;
+    /** The secrets service to retrieve secrets */
+    secrets: SecretService;
     /** The workflow orchestrator service */
     workflowService?: WorkflowService;
     /** The queue service */
@@ -134,7 +139,7 @@ export interface CoreSingletonServices<Config extends CoreConfig = CoreConfig> {
 /**
  * Represents different forms of wire within Pikku and the outside world.
  */
-export type PikkuWire<In = unknown, Out = unknown, HasInitialSession extends boolean = false, UserSession extends CoreUserSession = CoreUserSession, TypedRPC extends PikkuRPC = PikkuRPC, IsChannel extends true | null = null, MCPTools extends string | never = never, TypedWorkflow extends PikkuWorkflowWire | never = PikkuWorkflowWire> = Partial<{
+export type PikkuWire<In = unknown, Out = unknown, HasInitialSession extends boolean = false, UserSession extends CoreUserSession = CoreUserSession, TypedRPC extends PikkuRPC = PikkuRPC, IsChannel extends true | null = null, MCPTools extends string | never = never, TypedWorkflow extends PikkuWorkflowWire | never = PikkuWorkflowWire, TriggerOutput = unknown> = Partial<{
     http: PikkuHTTP<In>;
     mcp: PikkuMCP<MCPTools>;
     rpc: TypedRPC;
@@ -144,6 +149,8 @@ export type PikkuWire<In = unknown, Out = unknown, HasInitialSession extends boo
     cli: PikkuCLI;
     workflow: TypedWorkflow;
     workflowStep: WorkflowStepWire;
+    graph: PikkuGraphWire;
+    trigger: PikkuTrigger<TriggerOutput>;
     initialSession: HasInitialSession extends true ? UserSession : UserSession | undefined;
     session: SessionService<UserSession>;
 }>;
@@ -160,8 +167,8 @@ export type CorePikkuMiddleware<SingletonServices extends CoreSingletonServices
 export type CorePikkuMiddlewareConfig<SingletonServices extends CoreSingletonServices = CoreSingletonServices, UserSession extends CoreUserSession = CoreUserSession> = {
     /** The middleware function */
     func: CorePikkuMiddleware<SingletonServices, UserSession>;
-    /** Optional human-readable name for the middleware */
-    name?: string;
+    /** Optional human-readable title for the middleware */
+    title?: string;
     /** Optional description of what the middleware does */
     description?: string;
 };
@@ -191,7 +198,7 @@ export type CorePikkuMiddlewareGroup<SingletonServices extends CoreSingletonServ
  *
  * // Configuration object syntax with metadata
  * export const logMiddleware = pikkuMiddleware({
- *   name: 'Request Logger',
+ *   title: 'Request Logger',
  *   description: 'Logs request information',
  *   func: async ({ logger }, next) => {
  *     logger.info('Request started')
@@ -241,6 +248,7 @@ export type CreateConfig<Config extends CoreConfig, RemainingArgs extends any[]
  */
 export type CommonWireMeta = {
     pikkuFuncName: string;
+    title?: string;
     tags?: string[];
     summary?: string;
     description?: string;

package/dist/types/core.types.js

@@ -14,7 +14,7 @@
  *
  * // Configuration object syntax with metadata
  * export const logMiddleware = pikkuMiddleware({
- *   name: 'Request Logger',
+ *   title: 'Request Logger',
  *   description: 'Logs request information',
  *   func: async ({ logger }, next) => {
  *     logger.info('Request started')

package/dist/types/state.types.d.ts

@@ -0,0 +1,135 @@
+import { PikkuError, ErrorDetails } from '../errors/error-handler.js';
+import { CorePikkuFunctionConfig, CorePermissionGroup, CorePikkuPermission } from '../function/functions.types.js';
+import { CoreChannel, ChannelsMeta } from '../wirings/channel/channel.types.js';
+import { CLIMeta, CLIProgramState } from '../wirings/cli/cli.types.js';
+import { HTTPMethod, CoreHTTPFunctionWiring, HTTPWiringsMeta } from '../wirings/http/http.types.js';
+import { CoreMCPResource, MCPResourceMeta, CoreMCPTool, MCPToolMeta, CoreMCPPrompt, MCPPromptMeta } from '../wirings/mcp/mcp.types.js';
+import { CoreQueueWorker, QueueWorkersMeta } from '../wirings/queue/queue.types.js';
+import { CoreScheduledTask, ScheduledTasksMeta } from '../wirings/scheduler/scheduler.types.js';
+import { CoreWorkflow, WorkflowsRuntimeMeta, WorkflowWires } from '../wirings/workflow/workflow.types.js';
+import type { WorkflowGraphDefinition, GraphNodeConfig } from '../wirings/workflow/graph/workflow-graph.types.js';
+import { CoreTrigger, TriggerMeta } from '../wirings/trigger/trigger.types.js';
+import { FunctionsMeta, CorePikkuMiddleware, CorePikkuMiddlewareGroup, FunctionServicesMeta, CreateConfig, CreateSingletonServices, CreateWireServices, CoreConfig, CoreSingletonServices, CoreServices, CoreUserSession } from './core.types.js';
+/**
+ * State structure for an individual package
+ */
+export interface PikkuPackageState {
+    function: {
+        meta: FunctionsMeta;
+        functions: Map<string, CorePikkuFunctionConfig<any, any>>;
+    };
+    rpc: {
+        meta: Record<string, string>;
+        files: Map<string, {
+            exportedName: string;
+            path: string;
+        }>;
+        /** Maps namespace aliases to package names (e.g., 'ext' -> '@pikku/templates-function-external') */
+        externalPackages: Map<string, 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>;
+        graphRegistrations: Map<string, WorkflowGraphDefinition<any>>;
+        /** DSL workflow wirings (from wireWorkflow({ func: ... })) */
+        wirings: Map<any, {
+            wires: WorkflowWires;
+            func: any;
+        }>;
+        /** Graph workflow wirings (from wireWorkflow({ graph: ... })) */
+        graphWirings: Map<any, {
+            wires: WorkflowWires;
+            graph: Record<string, GraphNodeConfig<string>>;
+        }>;
+        meta: WorkflowsRuntimeMeta;
+    };
+    trigger: {
+        triggers: Map<string, CoreTrigger>;
+        meta: TriggerMeta;
+    };
+    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[]>;
+    };
+    package: {
+        /** Service factory functions for external packages */
+        factories: {
+            createConfig?: CreateConfig<CoreConfig>;
+            createSingletonServices?: CreateSingletonServices<CoreConfig, CoreSingletonServices>;
+            createWireServices?: CreateWireServices<CoreSingletonServices, CoreServices, CoreUserSession>;
+        } | null;
+        /** Cached singleton services for this package */
+        singletonServices: CoreSingletonServices | null;
+    };
+}

package/dist/types/state.types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils.d.ts

@@ -1,5 +1,13 @@
 import { Logger } from './services/logger.js';
+import { CoreSingletonServices } from './types/core.types.js';
 export declare const closeWireServices: (logger: Logger, wireServices: Record<string, any>) => Promise<void>;
 export declare const createWeakUID: () => string;
 export declare const isSerializable: (data: any) => boolean;
 export declare const freezeDedupe: <T>(arr?: readonly T[] | T[] | undefined) => readonly T[];
+/**
+ * Stop all singleton services, including external package services.
+ * External package services are stopped first, then the parent services.
+ *
+ * @param singletonServices - The parent singleton services to stop
+ */
+export declare const stopSingletonServices: (singletonServices: CoreSingletonServices) => Promise<void>;

package/dist/utils.js

@@ -45,3 +45,48 @@ export const freezeDedupe = (arr) => {
     }
     return Object.freeze(out);
 };
+/**
+ * Stop a single service by calling its stop method if it exists
+ */
+const stopService = async (logger, name, service) => {
+    const stop = service?.stop;
+    if (stop) {
+        logger.info(`Stopping singleton service: ${name}`);
+        try {
+            await stop.call(service);
+        }
+        catch (e) {
+            logger.error(`Error stopping service ${name}:`, e);
+        }
+    }
+};
+/**
+ * Stop all singleton services, including external package services.
+ * External package services are stopped first, then the parent services.
+ *
+ * @param singletonServices - The parent singleton services to stop
+ */
+export const stopSingletonServices = async (singletonServices) => {
+    const logger = singletonServices.logger;
+    // First, stop all external package singleton services
+    if (globalThis.pikkuState) {
+        for (const [packageName, packageState] of globalThis.pikkuState) {
+            // Skip main package - we handle it separately
+            if (packageName === '__main__')
+                continue;
+            const packageServices = packageState.package?.singletonServices;
+            if (packageServices) {
+                logger.info(`Stopping singleton services for package: ${packageName}`);
+                for (const [name, service] of Object.entries(packageServices)) {
+                    await stopService(logger, `${packageName}/${name}`, service);
+                }
+                // Clear the cached services
+                packageState.package.singletonServices = null;
+            }
+        }
+    }
+    // Then stop the parent singleton services
+    for (const [name, service] of Object.entries(singletonServices)) {
+        await stopService(logger, name, service);
+    }
+};

package/dist/wirings/channel/channel-handler.js

@@ -1,7 +1,7 @@
 import { pikkuState } from '../../pikku-state.js';
 import { runPikkuFunc } from '../../function/function-runner.js';
 const getRouteMeta = (channelName, routingProperty, routerValue) => {
-    const channelMeta = pikkuState('channel', 'meta')[channelName];
+    const channelMeta = pikkuState(null, 'channel', 'meta')[channelName];
     if (!channelMeta) {
         throw new Error(`Channel ${channelName} not found`);
     }

package/dist/wirings/channel/channel-runner.js

@@ -9,12 +9,12 @@ import { httpRouter } from '../http/routers/http-router.js';
  */
 export const wireChannel = (channel) => {
     // Get the channel metadata
-    const channelsMeta = pikkuState('channel', 'meta');
+    const channelsMeta = pikkuState(null, 'channel', 'meta');
     const channelMeta = channelsMeta[channel.name];
     if (!channelMeta) {
         throw new Error(`Channel metadata not found for channel: ${channel.name}`);
     }
-    pikkuState('channel', 'channels').set(channel.name, channel);
+    pikkuState(null, 'channel', 'channels').set(channel.name, channel);
     // Register onConnect function if provided
     if (channel.onConnect && channelMeta.connect) {
         addFunction(channelMeta.connect.pikkuFuncName, channel.onConnect);
@@ -50,19 +50,19 @@ export const wireChannel = (channel) => {
         });
     }
     // Store the channel configuration
-    pikkuState('channel', 'channels').set(channel.name, channel);
+    pikkuState(null, 'channel', 'channels').set(channel.name, channel);
 };
 const getMatchingChannelConfig = (path) => {
     const matchedPath = httpRouter.match('get', path);
     if (!matchedPath) {
         return null;
     }
-    const meta = pikkuState('channel', 'meta');
+    const meta = pikkuState(null, 'channel', 'meta');
     const channelMeta = Object.values(meta).find((channelConfig) => channelConfig.route === matchedPath.route);
     if (!channelMeta) {
         return null;
     }
-    const channels = pikkuState('channel', 'channels');
+    const channels = pikkuState(null, 'channel', 'channels');
     const channelConfig = channels.get(channelMeta.name);
     if (!channelConfig) {
         return null;

package/dist/wirings/channel/log-channels.js

@@ -4,7 +4,7 @@ import { pikkuState } from '../../pikku-state.js';
  * @param logger - A logger for logging information.
  */
 export const logChannels = (logger) => {
-    const channels = pikkuState('channel', 'channels');
+    const channels = pikkuState(null, 'channel', 'channels');
     if (channels.size === 0) {
         logger.info('No channels added');
         return;

package/dist/wirings/channel/serverless/serverless-channel-runner.js

@@ -8,9 +8,9 @@ import { pikkuState } from '../../../pikku-state.js';
 import { PikkuFetchHTTPRequest } from '../../http/pikku-fetch-http-request.js';
 import { runChannelLifecycleWithMiddleware } from '../channel-common.js';
 const getVariablesForChannel = ({ channelId, channelName, channelHandlerFactory, openingData, }) => {
-    const channels = pikkuState('channel', 'channels');
+    const channels = pikkuState(null, 'channel', 'channels');
     const channelConfig = channels.get(channelName);
-    const channelsMeta = pikkuState('channel', 'meta');
+    const channelsMeta = pikkuState(null, 'channel', 'meta');
     const meta = channelsMeta[channelName];
     if (!channelConfig) {
         throw new Error(`Channel not found: ${channelName}`);

package/dist/wirings/cli/channel/cli-channel-runner.js

@@ -12,10 +12,11 @@ const defaultJSONRenderer = (_services, data) => {
  */
 export async function executeCLIViaChannel({ programName, pikkuWS, args = process.argv.slice(2), renderers = {}, defaultRenderer, }) {
     // Get CLI metadata from state
-    const allCLIMeta = pikkuState('cli', 'meta');
-    if (!allCLIMeta) {
+    const cliMeta = pikkuState(null, 'cli', 'meta');
+    if (!cliMeta || !('programs' in cliMeta)) {
         throw new Error('[PKU342] CLI metadata not found. No CLI wirings were registered. See https://pikku.dev/docs/pikku-cli/errors/pku342 for more information.');
     }
+    const allCLIMeta = cliMeta;
     const programMeta = allCLIMeta.programs[programName];
     if (!programMeta) {
         console.error(`Error: CLI program "${programName}" not found`);

package/dist/wirings/cli/cli-runner.js

@@ -27,12 +27,12 @@ const defaultJSONRenderer = (_services, data) => {
  */
 export const wireCLI = (cli) => {
     // Get the existing metadata that was generated during inspection
-    const cliMeta = pikkuState('cli', 'meta') || {};
+    const cliMeta = pikkuState(null, 'cli', 'meta') || {};
     if (!cliMeta.programs?.[cli.program]) {
         throw new Error(`CLI metadata not found for program '${cli.program}'. Did you run 'pikku all'?`);
     }
     // Get existing programs state and add this program
-    const programs = pikkuState('cli', 'programs') || {};
+    const programs = pikkuState(null, 'cli', 'programs') || {};
     programs[cli.program] = {
         defaultRenderer: (cli.render ||
             defaultJSONRenderer),
@@ -40,7 +40,7 @@ export const wireCLI = (cli) => {
         renderers: {},
         tags: cli.tags,
     };
-    pikkuState('cli', 'programs', programs);
+    pikkuState(null, 'cli', 'programs', programs);
     // Register all command functions recursively
     registerCLICommands(cli.commands, [], cli.options || {}, cli.program);
 };
@@ -72,7 +72,7 @@ function unwrapFunc(command) {
  */
 function registerCLICommands(commands, path = [], inheritedOptions = {}, program) {
     // Get the CLI metadata to find actual function names
-    const cliMeta = pikkuState('cli', 'meta').programs[program];
+    const cliMeta = pikkuState(null, 'cli', 'meta').programs[program];
     for (const [name, command] of Object.entries(commands)) {
         const fullPath = [...path, name];
         const commandId = fullPath.join('.');
@@ -96,7 +96,7 @@ function registerCLICommands(commands, path = [], inheritedOptions = {}, program
         const commandOptions = typeof command === 'object' ? command.options || {} : {};
         const mergedOptions = { ...inheritedOptions, ...commandOptions };
         // Store the options and middleware in program state for use during execution
-        const programs = pikkuState('cli', 'programs');
+        const programs = pikkuState(null, 'cli', 'programs');
         if (programs[program]) {
             if (!programs[program].commandOptions) {
                 programs[program].commandOptions = {};
@@ -127,10 +127,10 @@ function registerCLICommands(commands, path = [], inheritedOptions = {}, program
  * Plucks only the data that the function expects based on its schema
  */
 function pluckCLIData(mergedData, funcName, availableOptions) {
-    const funcMeta = pikkuState('function', 'meta')[funcName];
+    const funcMeta = pikkuState(null, 'function', 'meta')[funcName];
     const schemaName = funcMeta?.inputSchemaName;
     const schema = schemaName
-        ? pikkuState('misc', 'schemas').get(schemaName)
+        ? pikkuState(null, 'misc', 'schemas').get(schemaName)
         : null;
     if (schema && schema.properties) {
         // If we have a schema, only include fields that are in the schema
@@ -156,7 +156,7 @@ function pluckCLIData(mergedData, funcName, availableOptions) {
  */
 export async function runCLICommand({ program, commandPath, data, singletonServices, createWireServices, }) {
     // Get the command metadata to find the function name
-    const cliMeta = pikkuState('cli', 'meta');
+    const cliMeta = pikkuState(null, 'cli', 'meta');
     const programMeta = cliMeta.programs?.[program];
     if (!programMeta) {
         throw new NotFoundError(`Program not found: ${program}`);
@@ -175,7 +175,7 @@ export async function runCLICommand({ program, commandPath, data, singletonServi
     }
     const funcName = currentCommand.pikkuFuncName;
     // Get program-specific data
-    const programs = pikkuState('cli', 'programs') || {};
+    const programs = pikkuState(null, 'cli', 'programs') || {};
     const programData = programs[program];
     // Combine program middleware + command middleware from the hierarchy
     const allWireMiddleware = [
@@ -266,7 +266,7 @@ export async function executeCLI({ programName, args, createConfig, createSingle
     }
     try {
         // Get CLI metadata from state
-        const allCLIMeta = pikkuState('cli', 'meta');
+        const allCLIMeta = pikkuState(null, 'cli', 'meta');
         if (!allCLIMeta) {
             throw new Error('[PKU342] CLI metadata not found. No CLI wirings were registered. See https://pikku.dev/docs/pikku-cli/errors/pku342 for more information.');
         }

package/dist/wirings/cli/cli.types.d.ts

@@ -140,6 +140,7 @@ export type ExtractFunctionOutput<Func> = Func extends CorePikkuFunctionConfig<i
 export type CoreCLICommandConfig<FuncConfig, PikkuMiddleware extends CorePikkuMiddleware<any, any> = CorePikkuMiddleware<any, any>, PikkuCLIRender extends CorePikkuCLIRender<any, any, any> = CorePikkuCLIRender<any, any>, Params extends string = string> = {
     parameters?: ValidateParameters<Params, ExtractFunctionInput<FuncConfig>>;
     func?: FuncConfig;
+    title?: string;
     description?: string;
     render?: PikkuCLIRender;
     options?: {

package/dist/wirings/forge-node/forge-node.types.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Forge node types for workflow builder visualization.
+ * wireForgeNode is metadata-only - no runtime behavior.
+ * The CLI extracts this via AST and generates JSON metadata.
+ */
+/**
+ * The type of forge node.
+ * - trigger: Starts workflows (webhooks, schedules, events)
+ * - action: Operations that do something (API calls, send email, database ops)
+ * - end: Terminal nodes with no outputs (logging, notifications)
+ */
+export type ForgeNodeType = 'trigger' | 'action' | 'end';
+/**
+ * Configuration for wireForgeNode.
+ * This is the input type that developers use when defining nodes.
+ */
+export type CoreForgeNode = {
+    /** Unique identifier for this node */
+    name: string;
+    /** Human-readable name for UI display */
+    displayName: string;
+    /** Grouping category (validated against forge.node.categories in config) */
+    category: string;
+    /** Node type determining behavior and outputs */
+    type: ForgeNodeType;
+    /** RPC name to call when node executes (local name, Forge handles package aliasing) */
+    rpc: string;
+    /** Optional description for UI */
+    description?: string;
+    /** Whether to add an error output port alongside the default output */
+    errorOutput?: boolean;
+    /** Optional tags for filtering/categorization */
+    tags?: string[];
+};
+/**
+ * Metadata generated for each forge node.
+ * This is the output type that the CLI generates.
+ */
+export type ForgeNodeMeta = {
+    name: string;
+    displayName: string;
+    category: string;
+    type: ForgeNodeType;
+    /** RPC name (local, remapped by Forge for external packages) */
+    rpc: string;
+    description?: string;
+    /** Whether node has error output port */
+    errorOutput: boolean;
+    /** Input schema name extracted from RPC */
+    inputSchemaName: string | null;
+    /** Output schema name extracted from RPC */
+    outputSchemaName: string | null;
+    tags?: string[];
+};
+/**
+ * Record of all forge node metadata, keyed by node name.
+ */
+export type ForgeNodesMeta = Record<string, ForgeNodeMeta>;
+/**
+ * No-op function for wireForgeNode.
+ * This exists purely for TypeScript type checking and will be tree-shaken.
+ * The CLI extracts metadata via AST parsing.
+ */
+export declare const wireForgeNode: (_config: CoreForgeNode) => void;
+/**
+ * Configuration for wireForgeCredential.
+ * Declares credentials/secrets required by a Forge package.
+ * Uses Zod for schema definition - converted to JSON Schema at build time.
+ */
+export type CoreForgeCredential<T = unknown> = {
+    /** Unique identifier for this credential */
+    name: string;
+    /** Human-readable name for UI display */
+    displayName: string;
+    /** Optional description for UI */
+    description?: string;
+    /** Key used with SecretService.getSecret() to retrieve the credential */
+    secretId: string;
+    /** Zod schema defining the structure of the credential */
+    schema: T;
+};
+/**
+ * Metadata generated for each forge credential.
+ * Schema is converted from Zod to JSON Schema at build time.
+ */
+export type ForgeCredentialMeta = {
+    name: string;
+    displayName: string;
+    description?: string;
+    secretId: string;
+    /** JSON Schema (converted from Zod at build time) or zodLookup reference name */
+    schema: Record<string, unknown> | string;
+};
+/**
+ * Record of all forge credential metadata, keyed by credential name.
+ */
+export type ForgeCredentialsMeta = Record<string, ForgeCredentialMeta>;
+/**
+ * No-op function for wireForgeCredential.
+ * This exists purely for TypeScript type checking and will be tree-shaken.
+ * The CLI extracts metadata via AST parsing.
+ *
+ * @example
+ * ```typescript
+ * import { z } from 'zod'
+ *
+ * const slackCredentials = z.object({
+ *   botToken: z.string().describe('Bot OAuth token'),
+ *   signingSecret: z.string().describe('Request signing secret')
+ * })
+ *
+ * wireForgeCredential({
+ *   name: 'slack',
+ *   displayName: 'Slack Credentials',
+ *   secretId: 'SLACK_CREDENTIALS',
+ *   schema: slackCredentials
+ * })
+ * ```
+ */
+export declare const wireForgeCredential: <T>(_config: CoreForgeCredential<T>) => void;

package/dist/wirings/forge-node/forge-node.types.js

@@ -0,0 +1,38 @@
+/**
+ * Forge node types for workflow builder visualization.
+ * wireForgeNode is metadata-only - no runtime behavior.
+ * The CLI extracts this via AST and generates JSON metadata.
+ */
+/**
+ * No-op function for wireForgeNode.
+ * This exists purely for TypeScript type checking and will be tree-shaken.
+ * The CLI extracts metadata via AST parsing.
+ */
+export const wireForgeNode = (_config) => {
+    // No-op - metadata only, extracted by CLI via AST
+};
+/**
+ * No-op function for wireForgeCredential.
+ * This exists purely for TypeScript type checking and will be tree-shaken.
+ * The CLI extracts metadata via AST parsing.
+ *
+ * @example
+ * ```typescript
+ * import { z } from 'zod'
+ *
+ * const slackCredentials = z.object({
+ *   botToken: z.string().describe('Bot OAuth token'),
+ *   signingSecret: z.string().describe('Request signing secret')
+ * })
+ *
+ * wireForgeCredential({
+ *   name: 'slack',
+ *   displayName: 'Slack Credentials',
+ *   secretId: 'SLACK_CREDENTIALS',
+ *   schema: slackCredentials
+ * })
+ * ```
+ */
+export const wireForgeCredential = (_config) => {
+    // No-op - metadata only, extracted by CLI via AST
+};

package/dist/wirings/forge-node/index.d.ts

@@ -0,0 +1 @@
+export * from './forge-node.types.js';

package/dist/wirings/forge-node/index.js

@@ -0,0 +1 @@
+export * from './forge-node.types.js';

package/dist/wirings/http/http-runner.d.ts

@@ -31,7 +31,7 @@ import { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js';
  * ])
  * ```
  */
-export declare const addHTTPMiddleware: <PikkuMiddleware extends CorePikkuMiddleware>(pattern: string, middleware: CorePikkuMiddlewareGroup) => CorePikkuMiddlewareGroup;
+export declare const addHTTPMiddleware: <PikkuMiddleware extends CorePikkuMiddleware>(pattern: string, middleware: CorePikkuMiddlewareGroup, packageName?: string | null) => CorePikkuMiddlewareGroup;
 /**
  * Registers HTTP permissions for a specific route pattern.
  *
@@ -61,7 +61,7 @@ export declare const addHTTPMiddleware: <PikkuMiddleware extends CorePikkuMiddle
  * ])
  * ```
  */
-export declare const addHTTPPermission: <PikkuPermission extends CorePikkuPermission>(pattern: string, permissions: CorePermissionGroup | CorePikkuPermission[]) => CorePermissionGroup | CorePikkuPermission[];
+export declare const addHTTPPermission: <PikkuPermission extends CorePikkuPermission>(pattern: string, permissions: CorePermissionGroup | CorePikkuPermission[], packageName?: string | null) => CorePermissionGroup | CorePikkuPermission[];
 /**
  * Adds a new route to the global HTTP route registry.
  *