@pikku/core 0.12.78 → 0.12.80

package/src/wirings/cli/cli.types.ts

@@ -197,18 +197,6 @@ export type ValidateParameters<Params extends string, Input> =
     ? Params
     : never
 
-/**
- * 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, 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.
@@ -290,33 +278,6 @@ export type CLICommandShorthand<
   >,
 > = PikkuFunctionConfig
 
-/**
- * Command definition (either full or shorthand)
- */
-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/src/wirings/cli/command-parser.test.ts

@@ -710,5 +710,24 @@ describe('Command Parser', () => {
       assert.ok(result.errors.some((e) => e.includes('Unknown option: -x')))
       assert.deepStrictEqual(result.warnings, [])
     })
+    describe('short-flag cluster is bounded (DoS)', () => {
+      test('a huge short-flag cluster yields a single error, not one per char', () => {
+        const huge = '-' + 'a'.repeat(200_000)
+        const result = parseCLIArguments(
+          ['greet', 'Alice', huge],
+          'test-cli',
+          testMeta
+        )
+        const clusterErrors = result.errors.filter((e) =>
+          e.includes('Unknown option')
+        )
+        // Without the cap this would be ~200k errors (one per character).
+        assert.ok(
+          clusterErrors.length <= 2,
+          `expected the oversized cluster to collapse to a single error, got ${clusterErrors.length}`
+        )
+        assert.ok(result.errors.some((e) => e.includes('too long')))
+      })
+    })
   })
 })

package/src/wirings/cli/command-parser.ts

@@ -86,6 +86,15 @@ export interface ParsedCommand {
   warnings: string[]
 }
 
+/**
+ * A real short-flag cluster is a handful of characters (`-abc`). Anything past
+ * this is treated as a single malformed token rather than scanned per
+ * character — the parser runs over untrusted CLI-channel frames, and a
+ * multi-megabyte `-aaaa…` would otherwise be O(length) work that also pushed
+ * one error per character.
+ */
+const MAX_SHORT_FLAG_CLUSTER = 64
+
 export function parseCLIArguments(
   args: string[],
   programName: string,
@@ -238,6 +247,13 @@ export function parseCLIArguments(
         }
       }
     } else if (arg.startsWith('-') && arg.length > 1) {
+      if (arg.length > MAX_SHORT_FLAG_CLUSTER) {
+        result.errors.push(
+          `Unknown option: ${arg.slice(0, MAX_SHORT_FLAG_CLUSTER)}… (too long)`
+        )
+        currentIndex++
+        continue
+      }
       for (let i = 1; i < arg.length; i++) {
         const shortFlag = arg[i]
 
@@ -354,7 +370,7 @@ function parseOptionValue(value: string, optionDef?: CLIOption): any {
     return parseFloat(value)
   }
 
-  if (optionDef.choices && !optionDef.choices.includes(value as any)) {
+  if (optionDef.choices && !optionDef.choices.includes(value as never)) {
     // Deliberately not an error here — applyOptionDefaults reports bad choices.
     return value
   }

package/src/wirings/gateway/gateway-authorization.test.ts

@@ -8,6 +8,7 @@ import {
   addGlobalPermission,
   clearPermissionsCache,
 } from '../../permissions.js'
+import { addTagMiddleware } from '../../middleware-runner.js'
 import type {
   GatewayAdapter,
   GatewayInboundMessage,
@@ -84,6 +85,31 @@ const seedCompiledMeta = () => {
   }
 }
 
+/**
+ * What the inspector records for a gateway and the function it was wired with.
+ * These tests wire gateways by hand, so nothing populates it otherwise — and it
+ * has to be in place before `wireGateway`, exactly as the generated bootstrap
+ * loads every meta file before any wiring file.
+ */
+const seedDeclaredHandler = (
+  gatewayName: string,
+  funcId: string,
+  funcMeta: Record<string, any>,
+  gatewayMeta: Record<string, any> = {}
+) => {
+  ;(pikkuState(null, 'function', 'meta') as any)[funcId] = {
+    pikkuFuncId: funcId,
+    inputSchemaName: null,
+    outputSchemaName: null,
+    ...funcMeta,
+  }
+  ;(pikkuState(null, 'gateway', 'meta') as any)[gatewayName] = {
+    pikkuFuncId: funcId,
+    name: gatewayName,
+    ...gatewayMeta,
+  }
+}
+
 const postMessage = async (route: string) => {
   const request = new Request(`http://localhost${route}`, {
     method: 'POST',
@@ -229,6 +255,68 @@ describe('gateway handler authorization', () => {
       assert.deepEqual(calls, ['ran'])
     })
 
+    test('a handler declared with pikkuFunc keeps its session requirement', async () => {
+      const calls: string[] = []
+
+      seedDeclaredHandler('declared-session', 'myHandler', {
+        sessionless: false,
+      })
+
+      wireGateway({
+        name: 'declared-session',
+        type: 'webhook',
+        route: '/webhooks/declared-session',
+        adapter: createMockAdapter(),
+        func: {
+          func: async () => {
+            calls.push('ran')
+            return { text: 'reply' }
+          },
+        } as any,
+      })
+
+      seedCompiledMeta()
+      httpRouter.initialize()
+
+      const response = await postMessage('/webhooks/declared-session')
+
+      assert.equal(response.status, 403)
+      assert.deepEqual(
+        calls,
+        [],
+        'a session-required pikkuFunc must not be silently made sessionless'
+      )
+    })
+
+    test('a handler declared sessionless keeps running without a session', async () => {
+      const calls: string[] = []
+
+      seedDeclaredHandler('declared-sessionless', 'mySessionlessHandler', {
+        sessionless: true,
+      })
+
+      wireGateway({
+        name: 'declared-sessionless',
+        type: 'webhook',
+        route: '/webhooks/declared-sessionless',
+        adapter: createMockAdapter(),
+        func: {
+          func: async () => {
+            calls.push('ran')
+            return { text: 'reply' }
+          },
+        } as any,
+      })
+
+      seedCompiledMeta()
+      httpRouter.initialize()
+
+      const response = await postMessage('/webhooks/declared-sessionless')
+
+      assert.equal(response.status, 200)
+      assert.deepEqual(calls, ['ran'])
+    })
+
     test('gateway-level auth: true requires a session', async () => {
       const calls: string[] = []
 
@@ -281,6 +369,49 @@ describe('gateway handler authorization', () => {
       assert.deepEqual(calls, [], 'auth: true must require a session')
     })
 
+    test('tag middleware declared for the gateway actually runs', async () => {
+      const order: string[] = []
+
+      addTagMiddleware('audited', [
+        async (_s: any, _wire: any, next: any) => {
+          order.push('middleware')
+          await next()
+        },
+      ] as any)
+
+      seedDeclaredHandler(
+        'tagged',
+        'myTaggedHandler',
+        { sessionless: true },
+        { tags: ['audited'], middleware: [{ type: 'tag', tag: 'audited' }] }
+      )
+
+      wireGateway({
+        name: 'tagged',
+        type: 'webhook',
+        route: '/webhooks/tagged',
+        adapter: createMockAdapter(),
+        func: {
+          func: async () => {
+            order.push('handler')
+            return { text: 'reply' }
+          },
+        } as any,
+      })
+
+      seedCompiledMeta()
+      httpRouter.initialize()
+
+      const response = await postMessage('/webhooks/tagged')
+
+      assert.equal(response.status, 200)
+      assert.deepEqual(
+        order,
+        ['middleware', 'handler'],
+        'addTagMiddleware must gate a gateway carrying the tag'
+      )
+    })
+
     test('the adapter still auto-sends the handler reply', async () => {
       const adapter = createMockAdapter()
 

package/src/wirings/gateway/gateway-channel-meta.test.ts

@@ -0,0 +1,44 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { pikkuState, resetPikkuState } from '../../pikku-state.js'
+import { wireGateway } from './gateway-runner.js'
+
+const wireWebsocketGateway = (name: string) => {
+  resetPikkuState()
+  wireGateway({
+    name,
+    type: 'websocket',
+    route: `/${name}`,
+    adapter: { name: 'test', parse: () => null, send: async () => {} },
+    func: { func: async () => undefined },
+  } as any)
+  return pikkuState(null, 'channel', 'meta')[name]!
+}
+
+describe('a gateway-wired websocket channel writes complete channel meta', () => {
+  test('the fields every channel reader indexes are present', () => {
+    const meta = wireWebsocketGateway('chatGateway')
+
+    // channel-handler.ts indexes messageWirings without a guard, and the
+    // serverless and local runners read disconnect directly.
+    assert.deepEqual(
+      meta.messageWirings,
+      {},
+      'messageWirings must be an object — channel-handler indexes it unguarded'
+    )
+    assert.equal(meta.disconnect, null)
+    assert.equal(meta.input, null)
+  })
+
+  test('it is marked as gateway-wired', () => {
+    assert.equal(wireWebsocketGateway('flagged').gateway, true)
+  })
+
+  test('connect and message point at the generated handlers', () => {
+    const meta = wireWebsocketGateway('handlers')
+
+    assert.equal(meta.connect?.pikkuFuncId, 'gateway__handlers__connect')
+    assert.equal(meta.message?.pikkuFuncId, 'gateway__handlers__message')
+  })
+})

package/src/wirings/gateway/gateway-runner.ts

@@ -3,6 +3,7 @@ import { NotFoundError, UnauthorizedError } from '../../errors/errors.js'
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js'
 import { runMiddleware } from '../../middleware-runner.js'
 import { httpRouter } from '../http/routers/http-router.js'
+import type { CoreHTTPFunctionWiring } from '../http/http.types.js'
 import type {
   CoreGateway,
   GatewayAdapter,
@@ -23,20 +24,46 @@ const bridgeMiddlewareSession = async (wire: PikkuRawWire): Promise<void> => {
   }
 }
 
+/**
+ * Metadata the inspector recorded for the function the gateway was wired with.
+ * The bootstrap loads every meta file before any wiring file, so this is
+ * already populated by the time a gateway wires itself. A gateway wired by
+ * hand rather than through codegen has no entry, and falls back to the
+ * sessionless default below.
+ */
+const declaredHandlerMeta = (config: CoreGateway) => {
+  const declaredFuncId = pikkuState(null, 'gateway', 'meta')[config.name]
+    ?.pikkuFuncId
+  return declaredFuncId
+    ? pikkuState(null, 'function', 'meta')[declaredFuncId]
+    : undefined
+}
+
 // knowledge: decisions/security/gateway-handlers-run-through-the-function-runner-gate.md
 const registerGatewayHandler = (config: CoreGateway): string => {
   const funcId = gatewayHandlerFuncId(config.name)
   const funcMeta = pikkuState(null, 'function', 'meta')
+  const declared = declaredHandlerMeta(config)
   funcMeta[funcId] = {
+    ...declared,
     pikkuFuncId: funcId,
-    inputSchemaName: null,
-    outputSchemaName: null,
-    sessionless: true,
+    inputSchemaName: declared?.inputSchemaName ?? null,
+    outputSchemaName: declared?.outputSchemaName ?? null,
+    sessionless: declared?.sessionless ?? true,
   }
-  addFunction(funcId, config.func as any)
+  addFunction(funcId, config.func)
   return funcId
 }
 
+/**
+ * Tag middleware the inspector resolved for this gateway. It is keyed by
+ * gateway name rather than reachable from `config`, because `tags` is a
+ * compile-time input everywhere — nothing at runtime maps a tag to its
+ * middleware group.
+ */
+const gatewayInheritedMiddleware = (config: CoreGateway) =>
+  pikkuState(null, 'gateway', 'meta')[config.name]?.middleware
+
 export const resolveGatewayAdapter = (
   config: CoreGateway,
   services: CoreSingletonServices
@@ -73,7 +100,7 @@ export const wireGateway = (config: CoreGateway): void => {
       break
     default:
       throw new Error(
-        `Unknown gateway type '${(config as any).type}' for gateway '${config.name}'`
+        `Unknown gateway type '${config.type}' for gateway '${config.name}'`
       )
   }
 }
@@ -92,7 +119,7 @@ const wireWebhookGateway = (config: CoreGateway): void => {
     func: createWebhookPostHandler(config),
   }
 
-  addFunction(postFuncId, postHandler as any)
+  addFunction(postFuncId, postHandler)
 
   if (!routes.has('post')) {
     routes.set('post', new Map())
@@ -102,7 +129,10 @@ const wireWebhookGateway = (config: CoreGateway): void => {
     route,
     func: postHandler,
     auth: false,
-  } as any)
+    // A gateway handler takes (services, data, wire) rather than a pikku
+    // function's shape, so it never matches CorePikkuFunctionConfig. It is only
+    // ever invoked through runPikkuFunc, which is what makes that safe.
+  } as unknown as CoreHTTPFunctionWiring<unknown, unknown, string>)
 
   // knowledge: decisions/internals/gateway-adapters-resolve-lazily-and-are-promise-cached.md
   if (typeof adapter === 'function' || adapter.verifyWebhook) {
@@ -113,7 +143,7 @@ const wireWebhookGateway = (config: CoreGateway): void => {
       func: createWebhookVerifyHandler(config),
     }
 
-    addFunction(verifyFuncId, verifyHandler as any)
+    addFunction(verifyFuncId, verifyHandler)
 
     if (!routes.has('get')) {
       routes.set('get', new Map())
@@ -125,7 +155,7 @@ const wireWebhookGateway = (config: CoreGateway): void => {
       auth: false,
       // knowledge: decisions/internals/gateway-webhook-challenges-echo-bytes-not-json.md
       returnsJSON: false,
-    } as any)
+    } as unknown as CoreHTTPFunctionWiring<unknown, unknown, string>)
   }
 
   httpRouter.reset()
@@ -134,6 +164,7 @@ const wireWebhookGateway = (config: CoreGateway): void => {
 const createWebhookPostHandler = (config: CoreGateway) => {
   const { name, middleware: userMiddleware } = config
   const handlerFuncId = registerGatewayHandler(config)
+  const inheritedMiddleware = gatewayInheritedMiddleware(config)
 
   return async (
     services: CoreSingletonServices,
@@ -160,16 +191,17 @@ const createWebhookPostHandler = (config: CoreGateway) => {
       platform: adapter.name,
       send: (msg: GatewayOutboundMessage) => adapter.send(parsed.senderId, msg),
     }
-    ;(wire as any).gateway = gateway
+    wire.gateway = gateway
 
     // Gateway middleware runs outside the gate so it can establish the session the gate checks.
     const invoke = async () => {
-      await bridgeMiddlewareSession(wire as any)
+      await bridgeMiddlewareSession(wire)
       return await runPikkuFunc('gateway', name, handlerFuncId, {
         singletonServices: services,
         data: () => parsed,
         auth: config.auth,
-        wire: wire as any,
+        inheritedMiddleware,
+        wire,
       })
     }
 
@@ -247,18 +279,22 @@ const wireWebsocketGateway = (config: CoreGateway): void => {
     name,
     route,
     gateway: true,
+    input: null,
     connect: { pikkuFuncId: connectFuncId },
+    disconnect: null,
     message: { pikkuFuncId: messageFuncId },
-  } as any
+    messageWirings: {},
+  }
 
   const userMiddleware = config.middleware as CorePikkuMiddleware[] | undefined
   const handlerFuncId = registerGatewayHandler(config)
+  const inheritedMiddleware = gatewayInheritedMiddleware(config)
 
   addFunction(connectFuncId, {
     auth: false,
     func: async (services: any, _data: unknown, wire: PikkuWire) => {
       const adapter = await resolveGatewayAdapter(config, services)
-      ;(wire as any).gateway = {
+      wire.gateway = {
         gatewayName: name,
         senderId: '',
         platform: adapter.name,
@@ -267,7 +303,7 @@ const wireWebsocketGateway = (config: CoreGateway): void => {
         },
       } satisfies PikkuGateway
     },
-  } as any)
+  })
 
   addFunction(messageFuncId, {
     auth: false,
@@ -284,15 +320,16 @@ const wireWebsocketGateway = (config: CoreGateway): void => {
           wire.channel?.send(msg)
         },
       }
-      ;(wire as any).gateway = gateway
+      wire.gateway = gateway
 
       const invoke = async () => {
-        await bridgeMiddlewareSession(wire as any)
+        await bridgeMiddlewareSession(wire)
         return await runPikkuFunc('gateway', name, handlerFuncId, {
           singletonServices: services,
           data: () => parsed,
           auth: config.auth,
-          wire: wire as any,
+          inheritedMiddleware,
+          wire,
         })
       }
 
@@ -307,7 +344,7 @@ const wireWebsocketGateway = (config: CoreGateway): void => {
         wire.channel?.send(result)
       }
     },
-  } as any)
+  })
 
   // knowledge: decisions/internals/gateway-wiring-is-a-meta-wiring-over-http-and-channels.md
   channels.set(name, {
@@ -316,7 +353,7 @@ const wireWebsocketGateway = (config: CoreGateway): void => {
     auth: false,
     onConnect: { func: async () => {} },
     onMessage: { func: async () => {} },
-  } as any)
+  })
 
   httpRouter.reset()
 }
@@ -333,6 +370,7 @@ export const createListenerMessageHandler = (
 ): ((rawData: unknown) => Promise<void>) => {
   const userMiddleware = config.middleware as CorePikkuMiddleware[] | undefined
   const handlerFuncId = registerGatewayHandler(config)
+  const inheritedMiddleware = gatewayInheritedMiddleware(config)
 
   return async (rawData: unknown): Promise<void> => {
     const adapter = await resolveGatewayAdapter(config, singletonServices)
@@ -346,7 +384,7 @@ export const createListenerMessageHandler = (
       platform: adapter.name,
       send: (msg: GatewayOutboundMessage) => adapter.send(parsed.senderId, msg),
     }
-    ;(wire as any).gateway = gateway
+    wire.gateway = gateway
 
     const invoke = async () => {
       await bridgeMiddlewareSession(wire)
@@ -354,14 +392,16 @@ export const createListenerMessageHandler = (
         singletonServices,
         data: () => parsed,
         auth: config.auth,
+        inheritedMiddleware,
         wire,
       })
     }
 
+    // knowledge: decisions/internals/gateway-listener-middleware-runs-without-an-rpc-on-the-wire.md
     const result: any = userMiddleware?.length
       ? await runMiddleware(
           singletonServices,
-          wire as any,
+          wire as PikkuWire,
           userMiddleware,
           invoke
         )

package/src/wirings/http/http-routes.ts

@@ -1,4 +1,5 @@
 import type {
+  CoreHTTPFunctionWiring,
   HTTPRouteConfig,
   HTTPRouteMap,
   HTTPRouteContract,
@@ -84,7 +85,9 @@ function registerRoute(
     timeout: route.timeout,
     headers: route.headers,
     sse: route.sse,
-  } as any)
+    // `CoreHTTPFunctionWiring` is discriminated by `method`, and a group builds
+    // its routes from a method chosen at runtime — no arm can be narrowed to.
+  } as CoreHTTPFunctionWiring<unknown, unknown, string>)
 }
 
 function isRouteConfig(value: unknown): value is HTTPRouteConfig {

package/src/wirings/http/http-runner.ts

@@ -33,8 +33,10 @@ import { isProduction } from '../../env.js'
 import { pikkuState } from '../../pikku-state.js'
 import { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js'
 import { PikkuFetchHTTPRequest } from './pikku-fetch-http-request.js'
-import type { PikkuChannel } from '../channel/channel.types.js'
-import { unsupportedChannelRemote } from '../channel/channel-rpc.js'
+import type { BinaryData, PikkuChannel } from '../channel/channel.types.js'
+// The leaf module, not the channel-rpc barrel: http needs one refusal
+// function, and the barrel drags in 4,932 lines of channel RPC runtime.
+import { unsupportedChannelRemote } from '../channel/channel-rpc.types.js'
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js'
 import { applyWebResponse } from './web-request.js'
 import { httpRouter } from './routers/http-router.js'
@@ -68,26 +70,6 @@ export const addHTTPMiddleware = <PikkuMiddleware extends CorePikkuMiddleware>(
   return middleware
 }
 
-/**
- * @deprecated HTTP-route-level permissions were removed in #972 — permissions
- * are now function-scoped only (declare them on the function via
- * `pikkuFunc({ permissions })`). This throwing stub exists solely so the pinned
- * bootstrap CLI (which still generates an `addHTTPPermission` wrapper) can
- * resolve the import at build time; it is never called. Delete once
- * `PIKKU_CLI_VERSION` in the CLI build is bumped past the release that removes
- * HTTP-route permissions.
- */
-export const addHTTPPermission = (
-  _pattern: string,
-  _permissions:
-    | Record<string, CorePikkuPermission | CorePikkuPermission[]>
-    | CorePikkuPermission[]
-): never => {
-  throw new Error(
-    'addHTTPPermission was removed in #972 — HTTP-route-level permissions no longer exist. Declare permissions on the function definition instead: pikkuFunc({ permissions }).'
-  )
-}
-
 export const wireHTTP = <
   In,
   Out,
@@ -126,7 +108,8 @@ export const wireHTTP = <
   }
   pikkuState(null, 'http', 'routes')
     .get(httpWiring.method)
-    ?.set(httpWiring.route, httpWiring as any)
+    // knowledge: decisions/internals/wiring-registries-erase-the-generics-their-wire-functions-capture.md
+    ?.set(httpWiring.route, httpWiring as CoreHTTPFunctionWiring<any, any, any>)
 }
 
 const getMatchingRoute = (requestType: string, requestPath: string) => {
@@ -261,7 +244,8 @@ const executeRoute = async (
       setState: (s) => {
         sseState = s
       },
-      getState: () => sseState as any,
+      // knowledge: decisions/internals/channel-state-accessors-are-unsound-generics-that-every-implementation-asserts.md
+      getState: () => sseState as never,
       clearState: () => {
         sseState = undefined
       },
@@ -275,7 +259,7 @@ const executeRoute = async (
       const channelHandler = {
         getChannel: () => channelRef,
         send: (data: unknown, isBinary?: boolean) => {
-          if (isBinary) channelRef.sendBinary(data as any)
+          if (isBinary) channelRef.sendBinary(data as BinaryData)
           else channelRef.send(data)
         },
         sendBinary: (data: any) => channelRef.sendBinary(data),
@@ -424,7 +408,8 @@ export const fetchData = async <In, Out>(
             globalMiddleware as CorePikkuMiddleware[]
           )
         }
-        response.status(204).json(undefined as any)
+        // 204 carries no body, and `json` has no no-content overload.
+        response.status(204).json(undefined as never)
         return
       }
       scopedLogger.info({

package/src/wirings/http/http.types.ts

@@ -73,10 +73,6 @@ export interface PikkuHTTP<In = unknown> {
   response?: PikkuHTTPResponse
 }
 
-export type RequestHeaders =
-  | Record<string, string | string[] | undefined>
-  | ((headerName: string) => string | string[] | undefined)
-
 export type PikkuQuery<T = Record<string, string | undefined>> = Record<
   string,
   string | T | null | Array<T | null>
@@ -207,17 +203,6 @@ export type HTTPWiringMeta = CommonWireMeta & {
 }
 export type HTTPWiringsMeta = Record<HTTPMethod, Record<string, HTTPWiringMeta>>
 
-export type HTTPFunctionsMeta = Array<{
-  name: string
-  inputs: string[] | null
-  outputs: string[] | null
-}>
-
-export type HTTPWiringMiddleware = {
-  route: string
-  middleware: CorePikkuMiddleware[]
-}
-
 export interface PikkuHTTPRequest<In = unknown> {
   method(): HTTPMethod
   path(): string