@pikku/core 0.11.2 → 0.12.0

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

@@ -4,10 +4,11 @@ import { closeWireServices } from '../../../utils.js';
 import { processMessageHandlers } from '../channel-handler.js';
 import { PikkuLocalChannelHandler } from './local-channel-handler.js';
 import { handleHTTPError } from '../../../handle-error.js';
-import { PikkuSessionService } from '../../../services/user-session-service.js';
+import { PikkuSessionService, createMiddlewareSessionWireProps, } from '../../../services/user-session-service.js';
 import { runChannelLifecycleWithMiddleware } from '../channel-common.js';
 export const runLocalChannel = async ({ singletonServices, channelId, request, response, route, createWireServices, skipUserSession = false, respondWith404 = true, coerceDataFromSchema = true, logWarningsForStatusCodes = [], bubbleErrors = false, }) => {
     let wireServices;
+    let closedWireServices = false;
     let channelHandler;
     const userSession = new PikkuSessionService();
     let http;
@@ -39,10 +40,20 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
         try {
             channelHandler = new PikkuLocalChannelHandler(channelId, channelConfig.name, openingData);
             const channel = channelHandler.getChannel();
-            const wire = { channel, session: userSession };
+            const wire = {
+                channel,
+                ...createMiddlewareSessionWireProps(userSession),
+            };
             if (createWireServices) {
                 wireServices = await createWireServices(singletonServices, wire);
             }
+            const closeServices = async () => {
+                if (!wireServices || closedWireServices) {
+                    return;
+                }
+                closedWireServices = true;
+                await closeWireServices(singletonServices.logger, wireServices);
+            };
             const services = { ...singletonServices, ...wireServices };
             channelHandler.registerOnOpen(async () => {
                 if (channelConfig.onConnect && meta.connect) {
@@ -55,6 +66,7 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
                             services,
                             channel,
                             data: openingData,
+                            channelMiddlewareMeta: meta.channelMiddleware,
                         });
                         if (result !== undefined) {
                             await channel.send(result);
@@ -76,6 +88,7 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
                             lifecycleType: 'disconnect',
                             services,
                             channel,
+                            channelMiddlewareMeta: meta.channelMiddleware,
                         });
                     }
                     catch (e) {
@@ -83,9 +96,7 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
                         channel.send({ error: e.message || 'Unknown error' });
                     }
                 }
-                if (wireServices) {
-                    await closeWireServices(singletonServices.logger, wireServices);
-                }
+                await closeServices();
             });
             const onMessage = processMessageHandlers(services, channelConfig, channelHandler, userSession);
             channelHandler.registerOnMessage(async (data) => {
@@ -103,7 +114,8 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
             handleHTTPError(e, http, channelId, singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors);
         }
         finally {
-            if (wireServices) {
+            if (!channelHandler && wireServices && !closedWireServices) {
+                closedWireServices = true;
                 await closeWireServices(singletonServices.logger, wireServices);
             }
         }

package/dist/wirings/channel/serverless/index.d.ts

@@ -1 +1 @@
-export * from './serverless-channel-runner.js';
+export { runChannelConnect, runChannelDisconnect, runChannelMessage, } from './serverless-channel-runner.js';

package/dist/wirings/channel/serverless/index.js

@@ -1 +1 @@
-export * from './serverless-channel-runner.js';
+export { runChannelConnect, runChannelDisconnect, runChannelMessage, } from './serverless-channel-runner.js';

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

@@ -3,7 +3,7 @@ import { processMessageHandlers } from '../channel-handler.js';
 import { openChannel } from '../channel-runner.js';
 import { createHTTPWire } from '../../http/http-runner.js';
 import { handleHTTPError } from '../../../handle-error.js';
-import { PikkuSessionService } from '../../../services/user-session-service.js';
+import { PikkuSessionService, createMiddlewareSessionWireProps, } from '../../../services/user-session-service.js';
 import { pikkuState } from '../../../pikku-state.js';
 import { PikkuFetchHTTPRequest } from '../../http/pikku-fetch-http-request.js';
 import { runChannelLifecycleWithMiddleware } from '../channel-common.js';
@@ -54,7 +54,10 @@ export const runChannelConnect = async ({ singletonServices, channelId, channelO
             channelHandlerFactory,
             channelName: channelConfig.name,
         });
-        const wire = { channel, session: userSession };
+        const wire = {
+            channel,
+            ...createMiddlewareSessionWireProps(userSession),
+        };
         if (createWireServices) {
             wireServices = await createWireServices(singletonServices, wire);
         }
@@ -71,6 +74,7 @@ export const runChannelConnect = async ({ singletonServices, channelId, channelO
                 services,
                 channel,
                 data: openingData,
+                channelMiddlewareMeta: meta.channelMiddleware,
             });
         }
         http?.response?.status(101);
@@ -106,7 +110,10 @@ export const runChannelDisconnect = async ({ singletonServices, ...params }) =>
     });
     const userSession = new PikkuSessionService(params.channelStore, params.channelId);
     userSession.setInitial(session);
-    const wire = { channel, session: userSession };
+    const wire = {
+        channel,
+        ...createMiddlewareSessionWireProps(userSession),
+    };
     if (!wireServices && params.createWireServices) {
         wireServices = await params.createWireServices(singletonServices, wire);
     }
@@ -123,6 +130,7 @@ export const runChannelDisconnect = async ({ singletonServices, ...params }) =>
                 lifecycleType: 'disconnect',
                 services,
                 channel,
+                channelMiddlewareMeta: meta.channelMiddleware,
             });
         }
         catch (e) {
@@ -144,7 +152,10 @@ export const runChannelMessage = async ({ singletonServices, ...params }, data)
     });
     const userSession = new PikkuSessionService(params.channelStore, params.channelId);
     userSession.setInitial(session);
-    const wire = { channel, session: userSession };
+    const wire = {
+        channel,
+        ...createMiddlewareSessionWireProps(userSession),
+    };
     if (params.createWireServices) {
         wireServices = await params.createWireServices(singletonServices, wire);
     }

package/dist/wirings/cli/channel/index.d.ts

@@ -1 +1 @@
-export * from './cli-channel-runner.js';
+export { executeCLIViaChannel } from './cli-channel-runner.js';

package/dist/wirings/cli/channel/index.js

@@ -1 +1 @@
-export * from './cli-channel-runner.js';
+export { executeCLIViaChannel } from './cli-channel-runner.js';

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

@@ -36,7 +36,7 @@ export declare const pikkuCLIRender: <Data, Services extends CoreSingletonServic
 export declare function executeCLI({ programName, args, createConfig, createSingletonServices, createWireServices, }: {
     programName: string;
     args?: string[];
-    createConfig: CreateConfig<any, any>;
+    createConfig?: CreateConfig<any, any>;
     createSingletonServices: CreateSingletonServices<any, any>;
     createWireServices?: CreateWireServices<any, any, any>;
 }): Promise<void>;

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

@@ -1,7 +1,7 @@
-import { NotFoundError } from '../../errors/errors.js';
+import { NotFoundError, PikkuMissingMetaError } from '../../errors/errors.js';
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
 import { pikkuState } from '../../pikku-state.js';
-import { PikkuSessionService } from '../../services/user-session-service.js';
+import { PikkuSessionService, createMiddlewareSessionWireProps, } from '../../services/user-session-service.js';
 import { LocalVariablesService } from '../../services/local-variables.js';
 import { generateCommandHelp, parseCLIArguments } from './command-parser.js';
 /**
@@ -29,7 +29,7 @@ export const wireCLI = (cli) => {
     // Get the existing metadata that was generated during inspection
     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'?`);
+        throw new PikkuMissingMetaError(`CLI metadata not found for program '${cli.program}'`);
     }
     // Get existing programs state and add this program
     const programs = pikkuState(null, 'cli', 'programs') || {};
@@ -81,7 +81,7 @@ function registerCLICommands(commands, path = [], inheritedOptions = {}, program
         for (let i = 1; i < fullPath.length; i++) {
             currentMeta = currentMeta?.subcommands?.[fullPath[i]];
         }
-        const funcName = currentMeta?.pikkuFuncName;
+        const funcName = currentMeta?.pikkuFuncId;
         // Skip if no function name (could be a command group)
         if (!funcName) {
             // Recursively register subcommands if they exist
@@ -173,7 +173,7 @@ export async function runCLICommand({ program, commandPath, data, singletonServi
         }
         currentCommand = currentCommand.subcommands[commandPath[i]];
     }
-    const funcName = currentCommand.pikkuFuncName;
+    const funcName = currentCommand.pikkuFuncId;
     // Get program-specific data
     const programs = pikkuState(null, 'cli', 'programs') || {};
     const programData = programs[program];
@@ -222,7 +222,7 @@ export async function runCLICommand({ program, commandPath, data, singletonServi
             data: pluckedData,
             channel,
         },
-        session: userSession,
+        ...createMiddlewareSessionWireProps(userSession),
     };
     try {
         const result = await runPikkuFunc('cli', commandId, funcName, {
@@ -236,9 +236,11 @@ export async function runCLICommand({ program, commandPath, data, singletonServi
             wirePermissions: undefined,
             tags: programData?.tags,
             wire,
+            sessionService: userSession,
         });
         // Apply renderer one final time with the final output (if renderer exists)
-        if (renderer) {
+        // Skip if result is undefined (void functions handle their own output)
+        if (renderer && result !== undefined) {
             await Promise.resolve(renderer(singletonServices, result, userSession.get()));
         }
         return result;
@@ -306,7 +308,9 @@ export async function executeCLI({ programName, args, createConfig, createSingle
         // Merge positionals and options into single data object
         const data = { ...parsed.positionals, ...parsed.options };
         // Create config (pass data in case it needs to use any parsed options)
-        const config = await createConfig(new LocalVariablesService(), data);
+        const config = createConfig
+            ? await createConfig(new LocalVariablesService(), data)
+            : {};
         // Create services with config
         const singletonServices = await createSingletonServices(config);
         // Execute the command

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

@@ -51,7 +51,7 @@ export interface CLIProgramState {
  */
 export interface CLICommandMeta {
     parameters?: string;
-    pikkuFuncName: string;
+    pikkuFuncId: string;
     positionals: CLIPositional[];
     options: Record<string, CLIOption>;
     renderName?: string;
@@ -100,7 +100,7 @@ export type CorePikkuCLIRender<Data, Services extends CoreSingletonServices = Co
 /**
  * Extract input parameters from a Pikku function config type
  */
-export type ExtractFunctionInput<Func> = Func extends CorePikkuFunctionConfig<infer FuncType, any, any> ? FuncType extends CorePikkuFunction<infer Input, any, any, any> | CorePikkuFunctionSessionless<infer Input, any, any, any> ? Input : never : never;
+export type ExtractFunctionInput<Func> = Func extends CorePikkuFunctionConfig<infer FuncType, any, any> ? FuncType extends CorePikkuFunction<infer Input, any, any, any, any> | CorePikkuFunctionSessionless<infer Input, any, any, any, any> ? Input : never : never;
 /**
  * Strip < > [ ] characters from a string
  */
@@ -132,7 +132,7 @@ export type ValidateParameters<Params extends string, Input> = AllParamsValid<Ex
 /**
  * Extract output type from a Pikku function config type
  */
-export type ExtractFunctionOutput<Func> = Func extends CorePikkuFunctionConfig<infer FuncType, any, any> ? FuncType extends CorePikkuFunction<any, infer Output, any, any> | CorePikkuFunctionSessionless<any, infer Output, any, any> ? Output : never : never;
+export type ExtractFunctionOutput<Func> = Func extends CorePikkuFunctionConfig<infer FuncType, any, any> ? FuncType extends CorePikkuFunction<any, infer Output, any, any, any> | CorePikkuFunctionSessionless<any, infer Output, any, any, any> ? Output : never : never;
 /**
  * CLI command configuration that infers options from function input type.
  * This is a helper type for creating type-safe CLI commands.
@@ -159,7 +159,7 @@ export type CoreCLICommandConfig<FuncConfig, PikkuMiddleware extends CorePikkuMi
 /**
  * CLI command definition
  */
-export interface CoreCLICommand<In, Out, PikkuFunctionConfig extends CorePikkuFunctionConfig<CorePikkuFunction<In, Out, any, any> | CorePikkuFunctionSessionless<In, Out, any, any>>, PikkuPermission extends CorePikkuPermission<any, any, any>, PikkuMiddleware extends CorePikkuMiddleware, Options = any, Subcommands extends Record<string, CoreCLICommandConfig<any, any, any>> = Record<string, CoreCLICommandConfig<any, any, any>>> {
+export interface CoreCLICommand<In, Out, PikkuFunctionConfig extends CorePikkuFunctionConfig<CorePikkuFunction<In, Out, any, any, any> | CorePikkuFunctionSessionless<In, Out, any, any, any>>, PikkuPermission extends CorePikkuPermission<any, any, any>, PikkuMiddleware extends CorePikkuMiddleware, Options = any, Subcommands extends Record<string, CoreCLICommandConfig<any, any, any>> = Record<string, CoreCLICommandConfig<any, any, any>>> {
     parameters?: string;
     func: PikkuFunctionConfig;
     render?: CorePikkuCLIRender<Out>;
@@ -177,11 +177,11 @@ export interface CoreCLICommand<In, Out, PikkuFunctionConfig extends CorePikkuFu
 /**
  * Shorthand command definition (just a function)
  */
-export type CLICommandShorthand<In, Out, PikkuFunctionConfig extends CorePikkuFunctionConfig<CorePikkuFunction<In, Out, any, any> | CorePikkuFunctionSessionless<In, Out, any, any>>> = PikkuFunctionConfig;
+export type CLICommandShorthand<In, Out, PikkuFunctionConfig extends CorePikkuFunctionConfig<CorePikkuFunction<In, Out, any, any, any> | CorePikkuFunctionSessionless<In, Out, any, any, any>>> = PikkuFunctionConfig;
 /**
  * Command definition (either full or shorthand)
  */
-export type CLICommandDefinition<In, Out, PikkuFunctionConfig extends CorePikkuFunctionConfig<CorePikkuFunction<In, Out, any, any> | CorePikkuFunctionSessionless<In, Out, any, any>>, PikkuPermission extends CorePikkuPermission<any, any, any>, PikkuMiddleware extends CorePikkuMiddleware, Options = any, Subcommands extends Record<string, CoreCLICommandConfig<any, any, any>> = Record<string, CoreCLICommandConfig<any, any, any>>> = CoreCLICommand<In, Out, PikkuFunctionConfig, PikkuPermission, PikkuMiddleware, Options, Subcommands> | CLICommandShorthand<In, Out, PikkuFunctionConfig>;
+export type CLICommandDefinition<In, Out, PikkuFunctionConfig extends CorePikkuFunctionConfig<CorePikkuFunction<In, Out, any, any, any> | CorePikkuFunctionSessionless<In, Out, any, any, any>>, PikkuPermission extends CorePikkuPermission<any, any, any>, PikkuMiddleware extends CorePikkuMiddleware, Options = any, Subcommands extends Record<string, CoreCLICommandConfig<any, any, any>> = Record<string, CoreCLICommandConfig<any, any, any>>> = CoreCLICommand<In, Out, PikkuFunctionConfig, PikkuPermission, PikkuMiddleware, Options, Subcommands> | CLICommandShorthand<In, Out, PikkuFunctionConfig>;
 /**
  * CLI wiring configuration
  */

package/dist/wirings/cli/define-cli-commands.d.ts

@@ -0,0 +1,19 @@
+import type { CoreCLICommandConfig } from './cli.types.js';
+/**
+ * Type-safe helper for defining CLI commands that can be composed.
+ * Returns the commands record as-is (identity function) for use with `wireCLI`.
+ *
+ * @example
+ * ```typescript
+ * export const chatCommands = defineCLICommands({
+ *   chat: pikkuCLICommand({ func: chatFunc }),
+ *   'chat:history': pikkuCLICommand({ func: historyFunc }),
+ * })
+ *
+ * wireCLI({
+ *   program: 'my-app',
+ *   commands: { ...chatCommands, other: pikkuCLICommand({ func: otherFunc }) }
+ * })
+ * ```
+ */
+export declare function defineCLICommands<T extends Record<string, CoreCLICommandConfig<any, any, any, any>>>(commands: T): T;

package/dist/wirings/cli/define-cli-commands.js

@@ -0,0 +1,20 @@
+/**
+ * Type-safe helper for defining CLI commands that can be composed.
+ * Returns the commands record as-is (identity function) for use with `wireCLI`.
+ *
+ * @example
+ * ```typescript
+ * export const chatCommands = defineCLICommands({
+ *   chat: pikkuCLICommand({ func: chatFunc }),
+ *   'chat:history': pikkuCLICommand({ func: historyFunc }),
+ * })
+ *
+ * wireCLI({
+ *   program: 'my-app',
+ *   commands: { ...chatCommands, other: pikkuCLICommand({ func: otherFunc }) }
+ * })
+ * ```
+ */
+export function defineCLICommands(commands) {
+    return commands;
+}

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

@@ -1,5 +1,4 @@
-export * from './cli.types.js';
-export * from './cli-runner.js';
-export * from './command-parser.js';
 export { wireCLI, runCLICommand, pikkuCLIRender, executeCLI, CLIError, } from './cli-runner.js';
 export { parseCLIArguments, generateCommandHelp } from './command-parser.js';
+export { defineCLICommands } from './define-cli-commands.js';
+export type { CLIMeta, CLICommandMeta, CLIProgramMeta, CoreCLI, CoreCLICommandConfig, CorePikkuCLIRender, } from './cli.types.js';

package/dist/wirings/cli/index.js

@@ -1,5 +1,3 @@
-export * from './cli.types.js';
-export * from './cli-runner.js';
-export * from './command-parser.js';
 export { wireCLI, runCLICommand, pikkuCLIRender, executeCLI, CLIError, } from './cli-runner.js';
 export { parseCLIArguments, generateCommandHelp } from './command-parser.js';
+export { defineCLICommands } from './define-cli-commands.js';

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

@@ -0,0 +1,69 @@
+import type { HTTPRouteMap, HTTPRouteContract, HTTPRoutesGroupConfig, WireHTTPRoutesConfig } from './http.types.js';
+/**
+ * Type-safe helper for defining route contracts that can be composed.
+ * Supports optional group-level config that cascades to all routes.
+ *
+ * @example
+ * ```typescript
+ * // Simple routes without group config
+ * export const todosRoutes = defineHTTPRoutes({
+ *   list: { method: 'get', route: '/todos', func: listTodos },
+ *   get: { method: 'get', route: '/todos/:id', func: getTodo },
+ * })
+ *
+ * // Routes with group-level config
+ * export const todosRoutes = defineHTTPRoutes({
+ *   auth: true,
+ *   tags: ['todos'],
+ *   routes: {
+ *     list: { method: 'get', route: '/todos', func: listTodos },
+ *     get: { method: 'get', route: '/todos/:id', func: getTodo },
+ *   }
+ * })
+ * ```
+ */
+export declare function defineHTTPRoutes<T extends HTTPRouteMap>(routes: T): HTTPRouteContract<T>;
+export declare function defineHTTPRoutes<T extends HTTPRouteMap>(config: HTTPRoutesGroupConfig & {
+    routes: T;
+}): HTTPRouteContract<T>;
+/**
+ * Wires multiple HTTP routes from a nested map or array configuration.
+ * Inspired by ts-rest's contract pattern, provides a single place to wire an entire API.
+ *
+ * @example
+ * ```typescript
+ * // Nested object format
+ * wireHTTPRoutes({
+ *   basePath: '/api/v1',
+ *   tags: ['api'],
+ *   routes: {
+ *     todos: {
+ *       list: { method: 'get', route: '/todos', func: listTodos },
+ *       get: { method: 'get', route: '/todos/:id', func: getTodo },
+ *     },
+ *     auth: {
+ *       login: { method: 'post', route: '/auth/login', func: login, auth: false },
+ *     },
+ *   },
+ * })
+ *
+ * // Flat array format
+ * wireHTTPRoutes({
+ *   basePath: '/api',
+ *   routes: [
+ *     { method: 'get', route: '/todos', func: listTodos },
+ *     { method: 'post', route: '/todos', func: createTodo },
+ *   ],
+ * })
+ *
+ * // Composing route contracts
+ * wireHTTPRoutes({
+ *   basePath: '/api/v1',
+ *   routes: {
+ *     todos: todosRoutes,  // from defineHTTPRoutes()
+ *     auth: authRoutes,    // from defineHTTPRoutes()
+ *   },
+ * })
+ * ```
+ */
+export declare const wireHTTPRoutes: (config: WireHTTPRoutesConfig) => void;

package/dist/wirings/http/http-routes.js

@@ -0,0 +1,139 @@
+import { wireHTTP } from './http-runner.js';
+export function defineHTTPRoutes(configOrRoutes) {
+    // If it has a 'routes' property and contains a map (not a route config), it's config + routes
+    if ('routes' in configOrRoutes &&
+        typeof configOrRoutes.routes === 'object' &&
+        !isRouteConfig(configOrRoutes.routes)) {
+        return configOrRoutes;
+    }
+    // Otherwise it's just routes
+    return { routes: configOrRoutes };
+}
+/**
+ * Wires multiple HTTP routes from a nested map or array configuration.
+ * Inspired by ts-rest's contract pattern, provides a single place to wire an entire API.
+ *
+ * @example
+ * ```typescript
+ * // Nested object format
+ * wireHTTPRoutes({
+ *   basePath: '/api/v1',
+ *   tags: ['api'],
+ *   routes: {
+ *     todos: {
+ *       list: { method: 'get', route: '/todos', func: listTodos },
+ *       get: { method: 'get', route: '/todos/:id', func: getTodo },
+ *     },
+ *     auth: {
+ *       login: { method: 'post', route: '/auth/login', func: login, auth: false },
+ *     },
+ *   },
+ * })
+ *
+ * // Flat array format
+ * wireHTTPRoutes({
+ *   basePath: '/api',
+ *   routes: [
+ *     { method: 'get', route: '/todos', func: listTodos },
+ *     { method: 'post', route: '/todos', func: createTodo },
+ *   ],
+ * })
+ *
+ * // Composing route contracts
+ * wireHTTPRoutes({
+ *   basePath: '/api/v1',
+ *   routes: {
+ *     todos: todosRoutes,  // from defineHTTPRoutes()
+ *     auth: authRoutes,    // from defineHTTPRoutes()
+ *   },
+ * })
+ * ```
+ */
+export const wireHTTPRoutes = (config) => {
+    const { routes, ...groupConfig } = config;
+    if (Array.isArray(routes)) {
+        routes.forEach((route) => registerRoute(route, groupConfig));
+    }
+    else {
+        processRouteMap(routes, groupConfig);
+    }
+};
+/**
+ * Recursively processes a route map, handling nested maps and contracts
+ */
+function processRouteMap(map, parentConfig) {
+    for (const [_key, value] of Object.entries(map)) {
+        if (isRouteConfig(value)) {
+            registerRoute(value, parentConfig);
+        }
+        else if (isRouteContract(value)) {
+            // Merge parent config with contract config, then process routes
+            const mergedConfig = mergeGroupConfig(parentConfig, value);
+            processRouteMap(value.routes, mergedConfig);
+        }
+        else {
+            // Nested map without config
+            processRouteMap(value, parentConfig);
+        }
+    }
+}
+/**
+ * Merge group configs with proper cascading behavior:
+ * - basePath: Concatenates
+ * - tags: Merges (parent + child)
+ * - middleware: Merges (parent runs first)
+ * - auth: Inner overrides outer
+ * - permissions: Inner overrides outer
+ */
+function mergeGroupConfig(parent, child) {
+    return {
+        basePath: (parent.basePath || '') + (child.basePath || ''),
+        tags: [...(parent.tags || []), ...(child.tags || [])],
+        middleware: [...(parent.middleware || []), ...(child.middleware || [])],
+        auth: child.auth ?? parent.auth,
+        permissions: child.permissions ?? parent.permissions,
+    };
+}
+/**
+ * Registers a single route by calling wireHTTP with merged configuration
+ */
+function registerRoute(route, groupConfig) {
+    const fullRoute = (groupConfig.basePath || '') + route.route;
+    wireHTTP({
+        method: route.method,
+        route: fullRoute,
+        func: route.func,
+        auth: route.auth ?? groupConfig.auth,
+        tags: [...(groupConfig.tags || []), ...(route.tags || [])],
+        middleware: [
+            ...(groupConfig.middleware || []),
+            ...(route.middleware || []),
+        ],
+        permissions: route.permissions ?? groupConfig.permissions,
+        contentType: route.contentType,
+        timeout: route.timeout,
+        headers: route.headers,
+        docs: route.docs,
+        sse: route.sse,
+    });
+}
+/**
+ * Type guard to check if a value is an individual route config
+ */
+function isRouteConfig(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'method' in value &&
+        'func' in value &&
+        'route' in value);
+}
+/**
+ * Type guard to check if a value is a route contract (has routes property but is not a route config)
+ */
+function isRouteContract(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'routes' in value &&
+        !('method' in value) &&
+        !('func' in value));
+}