@pikku/cli 0.12.21 → 0.12.23

package/dist/src/functions/wirings/cli/pikku-command-cli-entry.js

@@ -12,6 +12,7 @@ import { ErrorCode } from '@pikku/inspector';
 export const pikkuCLIEntry = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
+        let channelWireGenerated = false;
         // Check if CLI entrypoints are configured
         if (!config.cli?.entrypoints ||
             Object.keys(config.cli.entrypoints).length === 0) {
@@ -19,7 +20,7 @@ export const pikkuCLIEntry = pikkuSessionlessFunc({
                 message: 'No CLI entrypoints configured in config.cli.entrypoints, skipping CLI bootstrap generation',
                 type: 'skip',
             });
-            return;
+            return false;
         }
         // Generate bootstrap files for each configured entrypoint
         for (const [programName, entrypointConfigs] of Object.entries(config.cli.entrypoints)) {
@@ -56,8 +57,9 @@ export const pikkuCLIEntry = pikkuSessionlessFunc({
                             `Move it to a source directory like "src/wirings/cli-channel.gen.ts".`);
                     }
                     const channelWireFile = resolvedWirePath;
-                    const channelCode = serializeChannelCLI(programName, programMeta, channelWireFile, visitState.functions.files, config.packageMappings, config.channelsTypesFile, config.functionTypesFile, channelName, channelRoute, config.globalHTTPPrefix || '');
+                    const channelCode = serializeChannelCLI(programName, programMeta, channelWireFile, visitState.functions.files, config.packageMappings, config.channelsTypesFile, config.functionTypesFile, channelName, channelRoute, config.globalHTTPPrefix || '', visitState.rpc?.wireAddonDeclarations);
                     await writeFileInDir(logger, channelWireFile, channelCode);
+                    channelWireGenerated = true;
                     logger.debug(`Serialized CLI channel for ${programName}: ${channelWireFile}`);
                     // Generate client code if clientPath is provided
                     if (channelClientPath) {
@@ -117,6 +119,7 @@ export const pikkuCLIEntry = pikkuSessionlessFunc({
                 logger.debug(`Serialized CLI bootstrap for ${programName}: ${bootstrapFile}`);
             }
         }
+        return channelWireGenerated;
     },
     middleware: [
         logCommandInfoAndTime({

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

@@ -1 +1,5 @@
-export declare const pikkuCLITypes: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+type CLITypesCommandInput = {
+    bootstrap?: boolean;
+};
+export declare const pikkuCLITypes: import("#pikku").PikkuFunctionConfig<CLITypesCommandInput, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<CLITypesCommandInput, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<CLITypesCommandInput, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export {};

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

@@ -5,9 +5,15 @@ import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-
 import { serializeCLITypes } from './serialize-cli-types.js';
 import { checkRequiredTypes } from '../../../utils/check-required-types.js';
 export const pikkuCLITypes = pikkuSessionlessFunc({
-    func: async ({ logger, config, getInspectorState }) => {
+    func: async ({ logger, config, getInspectorState }, input) => {
         const { cliTypesFile, functionTypesFile, packageMappings } = config;
-        const visitState = await getInspectorState();
+        const bootstrap = input?.bootstrap === true;
+        // In bootstrap mode we only need filesAndMethods (userSession/singleton
+        // services types) — skip schema generation. Full mode would dynamic-import
+        // pikku-types.gen.ts, which re-exports the not-yet-written cli-types file.
+        const visitState = bootstrap
+            ? await getInspectorState(false, true, false)
+            : await getInspectorState();
         const functionTypesImportPath = getFileImportRelativePath(cliTypesFile, functionTypesFile, packageMappings);
         // Check for required types
         checkRequiredTypes(visitState.filesAndMethodsErrors, {

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

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

package/dist/src/functions/wirings/cli/serialize-channel-cli-client.js

@@ -26,16 +26,27 @@ export function collectRendererNames(programMeta) {
     }
     return rendererNames;
 }
+/**
+ * Resolve a renderer name (e.g. `cli-render:kanban:list`) to the JS identifier
+ * actually imported into the client file. Returns null when the name has no
+ * importable binding so callers can skip it rather than emit invalid JS.
+ */
+function resolveRendererBinding(renderName, renderersMeta) {
+    return renderersMeta?.[renderName]?.exportedName ?? null;
+}
 /**
  * Build a renderers map for CLI commands
  */
-function buildRenderersMap(programMeta) {
+function buildRenderersMap(programMeta, renderersMeta) {
     const entries = [];
-    // Build map entries for each command that has a renderer
+    // Build map entries for each command that has an importable renderer
     function addCommandRenderer(command, path) {
         const commandId = path.join('.');
         if (command.renderName) {
-            entries.push(`    '${commandId}': ${command.renderName}`);
+            const binding = resolveRendererBinding(command.renderName, renderersMeta);
+            if (binding) {
+                entries.push(`    '${commandId}': ${binding}`);
+            }
         }
         // Recursively process subcommands
         if (command.subcommands) {
@@ -75,7 +86,11 @@ export function serializeChannelCLIClient(programName, programMeta, clientFile,
                 if (!importsByFile.has(relativePath)) {
                     importsByFile.set(relativePath, []);
                 }
-                importsByFile.get(relativePath).push(meta.exportedName);
+                const names = importsByFile.get(relativePath);
+                // Distinct renderer names can share an exported binding — import once.
+                if (!names.includes(meta.exportedName)) {
+                    names.push(meta.exportedName);
+                }
             }
         }
         // Generate import statements
@@ -83,11 +98,14 @@ export function serializeChannelCLIClient(programName, programMeta, clientFile,
             rendererImports += `import { ${names.join(', ')} } from '${path}'\n`;
         }
     }
-    // Build renderers map
-    const renderersMap = buildRenderersMap(programMeta);
-    // Determine default renderer
-    const defaultRendererCode = programMeta.defaultRenderName
-        ? `,\n    defaultRenderer: ${programMeta.defaultRenderName}`
+    // Build renderers map (keyed by command id → imported renderer binding)
+    const renderersMap = buildRenderersMap(programMeta, renderersMeta);
+    // Determine default renderer — only when it resolves to an imported binding
+    const defaultRendererBinding = programMeta.defaultRenderName
+        ? resolveRendererBinding(programMeta.defaultRenderName, renderersMeta)
+        : null;
+    const defaultRendererCode = defaultRendererBinding
+        ? `,\n    defaultRenderer: ${defaultRendererBinding}`
         : '';
     return `
 import { executeCLIViaChannel } from '@pikku/core/cli/channel'

package/dist/src/functions/wirings/cli/serialize-channel-cli.d.ts

@@ -1,4 +1,7 @@
 import type { CLIProgramMeta } from '@pikku/core/cli';
+type WireAddonDeclarations = Map<string, {
+    package: string;
+}>;
 /**
  * Serializes a wireChannel call from CLI metadata
  * This creates a WebSocket backend for all CLI commands
@@ -6,4 +9,5 @@ import type { CLIProgramMeta } from '@pikku/core/cli';
 export declare function serializeChannelCLI(programName: string, programMeta: CLIProgramMeta, channelFile: string, functionFiles: Map<string, {
     path: string;
     exportedName: string;
-}>, packageMappings: Record<string, string>, channelTypesFile: string, functionTypesFile: string, channelName?: string, channelRoute?: string, globalHTTPPrefix?: string): string;
+}>, packageMappings: Record<string, string>, channelTypesFile: string, functionTypesFile: string, channelName?: string, channelRoute?: string, globalHTTPPrefix?: string, wireAddonDeclarations?: WireAddonDeclarations): string;
+export {};

package/dist/src/functions/wirings/cli/serialize-channel-cli.js

@@ -3,7 +3,13 @@ import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
  * Serializes a wireChannel call from CLI metadata
  * This creates a WebSocket backend for all CLI commands
  */
-export function serializeChannelCLI(programName, programMeta, channelFile, functionFiles, packageMappings, channelTypesFile, functionTypesFile, channelName, channelRoute, globalHTTPPrefix = '') {
+export function serializeChannelCLI(programName, programMeta, channelFile, functionFiles, packageMappings, channelTypesFile, functionTypesFile, channelName, channelRoute, globalHTTPPrefix = '', wireAddonDeclarations) {
+    const packageToNamespace = new Map();
+    if (wireAddonDeclarations) {
+        for (const [namespace, decl] of wireAddonDeclarations.entries()) {
+            packageToNamespace.set(decl.package, namespace);
+        }
+    }
     const finalChannelName = channelName || `${programName}-cli`;
     const finalChannelRoute = channelRoute || `${globalHTTPPrefix}/cli/${programName}`;
     // Flatten all commands into a single routing map
@@ -13,9 +19,13 @@ export function serializeChannelCLI(programName, programMeta, channelFile, funct
             const fullPath = [...path, name];
             const commandKey = fullPath.join('.');
             if (cmd.pikkuFuncId) {
+                const addonNamespace = cmd.packageName
+                    ? packageToNamespace.get(cmd.packageName)
+                    : undefined;
                 commandMap[commandKey] = {
                     pikkuFuncId: cmd.pikkuFuncId,
                     isAddon: !!cmd.packageName,
+                    addonNamespace,
                 };
             }
             // Recursively process subcommands
@@ -113,9 +123,9 @@ wireChannel({
         middleware: [cliCloseOnComplete],
       },
 ${Object.entries(commandMap)
-        .map(([commandKey, { pikkuFuncId, isAddon }]) => {
+        .map(([commandKey, { pikkuFuncId, isAddon, addonNamespace }]) => {
         const funcRef = isAddon
-            ? `ref('${pikkuFuncId}')`
+            ? `ref('${addonNamespace ? `${addonNamespace}:${pikkuFuncId}` : pikkuFuncId}')`
             : (functionFiles.get(pikkuFuncId)?.exportedName ?? pikkuFuncId);
         return `      '${commandKey}': {
         func: ${funcRef},

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

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

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

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

package/dist/src/functions/wirings/console/pikku-command-nodes-meta.d.ts

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

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

@@ -7,6 +7,7 @@ export const pikkuConsoleSetSecret = pikkuSessionlessFunc<{
 }, {
   success: boolean
 }>({
+  tags: ['pikku'],
   description: 'Set the value of a secret',
   expose: true,
   auth: false,
@@ -20,6 +21,7 @@ export const pikkuConsoleGetVariable = pikkuSessionlessFunc<
   { variableId: string },
   { exists: boolean; value: unknown | null }
 >({
+  tags: ['pikku'],
   description: 'Get the current value of a variable',
   expose: true,
   auth: false,
@@ -42,6 +44,7 @@ export const pikkuConsoleSetVariable = pikkuSessionlessFunc<
   { variableId: string; value: unknown },
   { success: boolean }
 >({
+  tags: ['pikku'],
   description: 'Set the value of a variable',
   expose: true,
   auth: false,
@@ -59,6 +62,7 @@ export const pikkuConsoleHasSecret = pikkuSessionlessFunc<
   { secretId: string },
   { exists: boolean }
 >({
+  tags: ['pikku'],
   description: 'Check if a secret exists without reading its value',
   expose: true,
   auth: false,
@@ -72,6 +76,7 @@ export const pikkuConsoleGetSecret = pikkuSessionlessFunc<
   { secretId: string },
   { exists: boolean; value: unknown | null }
 >({
+  tags: ['pikku'],
   description: 'Get the current value of a secret',
   expose: true,
   auth: false,

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

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

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

@@ -1 +1,5 @@
-export declare const pikkuAddonTypes: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+type AddonTypesCommandInput = {
+    bootstrap?: boolean;
+};
+export declare const pikkuAddonTypes: import("#pikku").PikkuFunctionConfig<AddonTypesCommandInput, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<AddonTypesCommandInput, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<AddonTypesCommandInput, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export {};

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

@@ -5,12 +5,17 @@ import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeAddonTypes } from './serialize-addon-types.js';
 export const pikkuAddonTypes = pikkuSessionlessFunc({
-    func: async ({ logger, config, getInspectorState }) => {
+    func: async ({ logger, config, getInspectorState }, input) => {
         if (!config.addon) {
             return;
         }
-        const visitState = await getInspectorState();
         const { addonTypesFile, packageMappings, servicesFile, secretsFile, credentialsFile, variablesFile, } = config;
+        const bootstrap = input?.bootstrap === true;
+        if (bootstrap) {
+            await writeFileInDir(logger, addonTypesFile, 'export {}\n');
+            return;
+        }
+        const visitState = await getInspectorState();
         checkRequiredTypes(visitState.filesAndMethodsErrors, {
             singletonServicesType: true,
         });

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

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

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

@@ -6,7 +6,7 @@ import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-
 import { serializeFunctionTypes } from './serialize-function-types.js';
 export const pikkuFunctionTypesSplit = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
-        const visitState = await getInspectorState();
+        const visitState = await getInspectorState(false, true);
         const { functionTypesFile, packageMappings, rpcInternalMapDeclarationFile, servicesFile, } = config;
         // Check for required types
         checkRequiredTypes(visitState.filesAndMethodsErrors, {

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

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

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

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

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

@@ -1,2 +1,2 @@
 export declare const serializeServicesMap: (allSingletonServices: string[], allWireServices: string[], requiredServices: Set<string>, forceRequiredServices: string[] | undefined, servicesImport: string, wireServicesImport: string, addonRequiredParentServices?: string[]) => string;
-export declare const pikkuServices: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuServices: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/functions/schemas.d.ts

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

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

@@ -15,9 +15,13 @@ export const serializeFunctionTypes = (userSessionTypeImport, userSessionTypeNam
 import type { CorePikkuMiddleware, CorePermissionGroup, ListInput, ListOutput, PikkuWire, PickRequired } from '@pikku/core'
 import type { CorePikkuFunctionConfig, CorePikkuAuth, CorePikkuAuthConfig, CorePikkuPermission } from '@pikku/core/function'
 import { pikkuAuth as pikkuAuthCore } from '@pikku/core/function'
-import { addMiddleware as addMiddlewareCore, addPermission as addPermissionCore } from '@pikku/core/middleware'
+import {
+  addTagMiddleware as addTagMiddlewareCore,
+  addGlobalMiddleware as addGlobalMiddlewareCore,
+  addTagPermission as addTagPermissionCore,
+  addGlobalPermission as addGlobalPermissionCore,
+} from '@pikku/core/middleware'
 import { pikkuState as __pikkuState, CreateWireServices } from '@pikku/core/internal'
-import { PikkuError } from '@pikku/core/errors'
 import type { NodeType } from '@pikku/core/node'
 import type { StandardSchemaV1 } from '@standard-schema/spec'
 import { CorePikkuFunction, CorePikkuFunctionSessionless } from '@pikku/core/function'
@@ -332,37 +336,36 @@ export type PikkuFunctionConfig<
  * Use this when you want to define input/output schemas using Zod.
  * Types are automatically inferred from the schemas.
  */
+type SchemaInferred<S, Fallback = unknown> = S extends StandardSchemaV1
+  ? InferSchemaOutput<S>
+  : Fallback
+
+/**
+ * Schema-overload variant for pikkuFunc. Derived from CorePikkuFunctionConfig
+ * so adding a field on the core type automatically propagates here.
+ */
 export type PikkuFunctionConfigWithSchema<
   InputSchema extends StandardSchemaV1 | undefined = undefined,
   OutputSchema extends StandardSchemaV1 | undefined = undefined,
   RequiredWires extends keyof PikkuWire = never
-> = {
-  name?: string
-  description?: string
-  tags?: string[]
-  expose?: boolean
-  mcp?: boolean
-  internal?: boolean
-  remote?: boolean
-  deploy?: 'serverless' | 'server' | 'auto'
-  approvalRequired?: boolean
-  approvalDescription?: InputSchema extends StandardSchemaV1 ? PikkuApprovalDescription<InferSchemaOutput<InputSchema>> : never
-  func: PikkuFunction<
-    InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown,
-    OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown,
-    RequiredWires
-  > | PikkuFunctionSessionless<
-    InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown,
-    OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown,
-    RequiredWires
-  >
-  auth?: boolean
-  permissions?: InputSchema extends StandardSchemaV1 ? CorePermissionGroup<PikkuPermission<InferSchemaOutput<InputSchema>>> : undefined
-  middleware?: PikkuMiddleware[]
+> = Omit<
+  CorePikkuFunctionConfig<
+    | PikkuFunction<SchemaInferred<InputSchema>, SchemaInferred<OutputSchema>, RequiredWires>
+    | PikkuFunctionSessionless<SchemaInferred<InputSchema>, SchemaInferred<OutputSchema>, RequiredWires>
+  >,
+  'func' | 'input' | 'output' | 'permissions' | 'approvalDescription'
+> & {
+  func:
+    | PikkuFunction<SchemaInferred<InputSchema>, SchemaInferred<OutputSchema>, RequiredWires>
+    | PikkuFunctionSessionless<SchemaInferred<InputSchema>, SchemaInferred<OutputSchema>, RequiredWires>
   input?: InputSchema
   output?: OutputSchema
-  node?: NodeConfig
-  errors?: Array<typeof PikkuError>
+  permissions?: InputSchema extends StandardSchemaV1
+    ? CorePermissionGroup<PikkuPermission<InferSchemaOutput<InputSchema>>>
+    : undefined
+  approvalDescription?: InputSchema extends StandardSchemaV1
+    ? PikkuApprovalDescription<InferSchemaOutput<InputSchema>>
+    : never
 }
 
 /**
@@ -447,33 +450,33 @@ export const pikkuListFunc = <
 /**
  * Configuration object for sessionless Pikku functions with Zod schema validation.
  */
+/**
+ * Schema-overload variant for pikkuSessionlessFunc. Derived from
+ * CorePikkuFunctionConfig to stay in sync with the generic-typed config.
+ */
 export type PikkuFunctionSessionlessConfigWithSchema<
   InputSchema extends StandardSchemaV1 | undefined = undefined,
   OutputSchema extends StandardSchemaV1 | undefined = undefined,
   RequiredWires extends keyof PikkuWire = never
-> = {
-  name?: string
-  description?: string
-  tags?: string[]
-  expose?: boolean
-  mcp?: boolean
-  internal?: boolean
-  remote?: boolean
-  deploy?: 'serverless' | 'server' | 'auto'
-  approvalRequired?: boolean
-  approvalDescription?: InputSchema extends StandardSchemaV1 ? PikkuApprovalDescription<InferSchemaOutput<InputSchema>> : never
+> = Omit<
+  CorePikkuFunctionConfig<
+    PikkuFunctionSessionless<SchemaInferred<InputSchema>, SchemaInferred<OutputSchema>, RequiredWires>
+  >,
+  'func' | 'input' | 'output' | 'permissions' | 'approvalDescription'
+> & {
   func: PikkuFunctionSessionless<
-    InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown,
-    OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown,
+    SchemaInferred<InputSchema>,
+    SchemaInferred<OutputSchema>,
     RequiredWires
   >
-  auth?: boolean
-  permissions?: InputSchema extends StandardSchemaV1 ? CorePermissionGroup<PikkuPermission<InferSchemaOutput<InputSchema>>> : undefined
-  middleware?: PikkuMiddleware[]
   input?: InputSchema
   output?: OutputSchema
-  node?: NodeConfig
-  errors?: Array<typeof PikkuError>
+  permissions?: InputSchema extends StandardSchemaV1
+    ? CorePermissionGroup<PikkuPermission<InferSchemaOutput<InputSchema>>>
+    : undefined
+  approvalDescription?: InputSchema extends StandardSchemaV1
+    ? PikkuApprovalDescription<InferSchemaOutput<InputSchema>>
+    : never
 }
 
 /**
@@ -664,57 +667,49 @@ export const pikkuWireServices = (
 }
 
 /**
- * Adds global middleware for a specific tag.
- *
- * This function allows you to register middleware that will be applied to
- * any wiring (HTTP, Channel, Queue, Scheduler, MCP) that includes the matching tag.
- *
- * @param tag - The tag that the middleware should apply to.
- * @param middleware - The middleware array to apply for the specified tag.
- *
- * @throws Error if middleware for the tag already exists.
+ * Tag-scoped middleware. Applies to any wiring that carries the matching tag.
  *
  * @example
- * \`\`\`typescript
- * // Add admin middleware for admin endpoints
- * addMiddleware('admin', [adminMiddleware])
- *
- * // Add authentication middleware for auth endpoints
- * addMiddleware('auth', [authMiddleware])
- *
- * // Add logging middleware for all API endpoints
- * addMiddleware('api', [loggingMiddleware])
- * \`\`\`
+ * addTagMiddleware('admin', [adminMiddleware])
  */
-export const addMiddleware = (tag: string, middleware: PikkuMiddleware[]) => {
-  addMiddlewareCore(tag, middleware as any, ${packageNameValue})
+export const addTagMiddleware = (tag: string, middleware: PikkuMiddleware[]) => {
+  addTagMiddlewareCore(tag, middleware as any, ${packageNameValue})
 }
 
 /**
- * Adds global permissions for a specific tag.
- *
- * This function allows you to register permissions that will be applied to
- * any wiring (HTTP, Channel, Queue, Scheduler, MCP) that includes the matching tag.
+ * Wire-agnostic global middleware. Runs at the top of every wiring's
+ * middleware chain — before wire-, tag-, and function-level entries.
  *
- * @param tag - The tag that the permissions should apply to.
- * @param permissions - The permissions array or object to apply for the specified tag.
+ * Resolution order: global -> wire -> tag -> function.
  *
- * @throws Error if permissions for the tag already exist.
+ * @example
+ * addGlobalMiddleware([telemetryMiddleware])
+ */
+export const addGlobalMiddleware = (middleware: PikkuMiddleware[]) => {
+  addGlobalMiddlewareCore(middleware as any, ${packageNameValue})
+}
+
+/**
+ * Tag-scoped permissions. Applies to any wiring that carries the matching tag.
  *
  * @example
- * \`\`\`typescript
- * // Add admin permissions for admin endpoints
- * addPermission('admin', [adminPermission])
+ * addTagPermission('admin', [adminPermission])
+ */
+export const addTagPermission = <In = unknown>(tag: string, permissions: CorePermissionGroup<PikkuPermission<In>> | PikkuPermission<In>[]) => {
+  addTagPermissionCore(tag, permissions as any, ${packageNameValue})
+}
+
+/**
+ * Wire-agnostic global permissions. Runs at the top of every wiring's
+ * permission resolution — before wire-, tag-, and function-level entries.
  *
- * // Add authentication permissions for auth endpoints
- * addPermission('auth', [authPermission])
+ * Resolution order: global -> wire -> tag -> function.
  *
- * // Add read permissions for all API endpoints (as object)
- * addPermission('api', { read: readPermission })
- * \`\`\`
+ * @example
+ * addGlobalPermission([signedInUser])
  */
-export const addPermission = <In = unknown>(tag: string, permissions: CorePermissionGroup<PikkuPermission<In>> | PikkuPermission<In>[]) => {
-  addPermissionCore(tag, permissions as any, ${packageNameValue})
+export const addGlobalPermission = <In = unknown>(permissions: CorePermissionGroup<PikkuPermission<In>> | PikkuPermission<In>[]) => {
+  addGlobalPermissionCore(permissions as any, ${packageNameValue})
 }
 
 export { wireAddon } from '@pikku/core/rpc'

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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