@pikku/core 0.12.79 → 0.12.82

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.test.ts

@@ -70,6 +70,11 @@ class TestResponse extends PikkuMockResponse {
     return this
   }
 
+  redirect(location: string, status: number = 302): this {
+    this.status(status)
+    return this.header('Location', location)
+  }
+
   setMode(mode: 'stream') {
     this.mode = mode
   }
@@ -365,6 +370,67 @@ describe('http-runner helpers', () => {
     assert.equal(response.statusCode, 204)
   })
 
+  test('fetchData keeps a redirect status when the route returns undefined', async () => {
+    setRouteMeta('/redirect')
+    addFunction('pikku_func_name', {
+      func: async (_services: any, _data: any, { http }: any) => {
+        http?.response?.redirect('https://example.com/done', 302)
+      },
+    })
+    wireHTTP({
+      route: '/redirect',
+      method: 'get',
+      auth: false,
+      func: {
+        func: async (_services: any, _data: any, { http }: any) => {
+          http?.response?.redirect('https://example.com/done', 302)
+        },
+      },
+    })
+    httpRouter.initialize()
+
+    const request = new TestRequest('/redirect', 'get')
+    const response = new TestResponse()
+
+    await fetchData(request, response)
+
+    assert.equal(response.statusCode, 302)
+    assert.equal(
+      response.headersMap.get('Location'),
+      'https://example.com/done'
+    )
+  })
+
+  test('fetchData keeps a status the route set alongside a body', async () => {
+    setRouteMeta('/created')
+    addFunction('pikku_func_name', {
+      func: async (_services: any, _data: any, { http }: any) => {
+        http?.response?.status(201)
+        return { id: 'thing-1' }
+      },
+    })
+    wireHTTP({
+      route: '/created',
+      method: 'get',
+      auth: false,
+      func: {
+        func: async (_services: any, _data: any, { http }: any) => {
+          http?.response?.status(201)
+          return { id: 'thing-1' }
+        },
+      },
+    })
+    httpRouter.initialize()
+
+    const request = new TestRequest('/created', 'get')
+    const response = new TestResponse()
+
+    await fetchData(request, response)
+
+    assert.equal(response.statusCode, 201)
+    assert.deepEqual(response.jsonBody, { id: 'thing-1' })
+  })
+
   test('fetchData writes binary responses when returnsJSON is false', async () => {
     setRouteMeta('/binary')
     wireHTTP({

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),
@@ -299,6 +283,8 @@ const executeRoute = async (
     hasSessionChanged: () => userSession.sessionChanged,
   }
 
+  const statusBeforeRoute = http?.response?.statusCode
+
   try {
     result = await runPikkuFunc(
       'http',
@@ -339,14 +325,20 @@ const executeRoute = async (
   if (matchedRoute.route.sse) {
     http?.response?.flushHeaders?.()
   } else {
+    const statusSetByRoute = http?.response?.statusCode !== statusBeforeRoute
+
     if (result instanceof Response) {
       await applyWebResponse(http!.response!, result)
     } else if (result === undefined || result === null) {
-      http?.response?.status(204)
+      if (!statusSetByRoute) {
+        http?.response?.status(204)
+      }
     } else if (route.returnsJSON === false) {
       http?.response?.arrayBuffer(result)
     } else {
-      http?.response?.status(200)
+      if (!statusSetByRoute) {
+        http?.response?.status(200)
+      }
       http?.response?.json(result)
     }
   }
@@ -424,7 +416,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

package/src/wirings/http/index.ts

@@ -2,17 +2,10 @@ export {
   PikkuFetchHTTPRequest,
   DEFAULT_MAX_BODY_SIZE,
 } from './pikku-fetch-http-request.js'
-export type { PikkuFetchHTTPRequestOptions } from './pikku-fetch-http-request.js'
 export { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js'
 export { logRoutes } from './log-http-routes.js'
 
-export {
-  fetch,
-  fetchData,
-  wireHTTP,
-  addHTTPMiddleware,
-  addHTTPPermission,
-} from './http-runner.js'
+export { fetch, fetchData, wireHTTP, addHTTPMiddleware } from './http-runner.js'
 
 export { wireHTTPRoutes, defineHTTPRoutes } from './http-routes.js'
 export { toWebRequest, applyWebResponse } from './web-request.js'
@@ -25,6 +18,7 @@ export type {
   HTTPRouteContract,
   HTTPRouteMap,
   HTTPWiringsMeta,
+  PikkuHTTP,
   PikkuHTTPRequest,
   PikkuHTTPResponse,
   PikkuQuery,

package/src/wirings/http/pikku-fetch-http-request.ts

@@ -248,7 +248,7 @@ function valuesAreEquivalent(a: unknown, b: unknown): boolean {
   return coerce(a) === coerce(b)
 }
 
-function coerce(value: unknown): string | number | boolean {
+function coerce(value: unknown): unknown {
   if (typeof value === 'boolean' || typeof value === 'number') return value
   if (typeof value === 'string') {
     if (value === 'true') return true
@@ -256,5 +256,5 @@ function coerce(value: unknown): string | number | boolean {
     const num = Number(value)
     return isNaN(num) ? value : num
   }
-  return value as any
+  return value
 }

package/src/wirings/http/web-request.ts

@@ -40,7 +40,7 @@ export function toWebRequest(req: PikkuHTTPRequest, baseUrl?: string): Request {
             if (
               parsed &&
               typeof parsed === 'object' &&
-              Object.keys(parsed as any).length > 0
+              Object.keys(parsed as object).length > 0
             ) {
               let reconstructed: string
               if (contentType.includes('application/x-www-form-urlencoded')) {

package/src/wirings/mcp/index.ts

@@ -16,7 +16,6 @@ export type {
   AssertMCPResourceURIParams,
   CoreMCPPrompt,
   CoreMCPResource,
-  CoreMCPTool,
   MCPPromptResponse,
   MCPResourceMeta,
   MCPResourceResponse,

package/src/wirings/mcp/mcp-runner.test.ts

@@ -9,8 +9,11 @@ import {
   wireMCPPrompt,
   wireMCPResource,
 } from './mcp-runner.js'
+import { addGlobalMiddleware } from '../../middleware-runner.js'
 import { addFunction } from '../../function/function-runner.js'
 import { pikkuState, resetPikkuState } from '../../pikku-state.js'
+import { pikkuMiddleware } from '../../types/core.types.js'
+import { addTagMiddleware } from '../../middleware-runner.js'
 
 const logger = {
   debug: () => {},
@@ -166,6 +169,49 @@ describe('runMCPResource', () => {
       },
     })
   })
+
+  test('runs a templated resource middleware when invoked by concrete uri', async () => {
+    let middlewareRan = false
+    // A tag-derived middleware group (this is where a tag-based auth gate lands).
+    addTagMiddleware('secure', [
+      pikkuMiddleware(async (_services, _wire, next) => {
+        middlewareRan = true
+        await next()
+      }),
+    ])
+    pikkuState(null, 'mcp', 'resourcesMeta')['resource://secure/{id}'] = {
+      uri: 'resource://secure/{id}',
+      title: 'Secure',
+      description: 'Secure',
+      pikkuFuncId: 'secureResourceFunc',
+      inputSchema: null,
+      outputSchema: null,
+      // The resource's merged middleware metadata. It must resolve for a concrete
+      // request against the template, or the resource is reachable with its gate
+      // skipped.
+      middleware: [{ type: 'tag', tag: 'secure' }],
+    } as never
+    registerFunction('secureResourceFunc', async () => ({ ok: true }))
+
+    wireMCPResource({
+      uri: 'resource://secure/{id}',
+      title: 'Secure',
+      description: 'Secure',
+      func: { func: async () => ({ ok: true }) } as never,
+    })
+
+    await runMCPResource(
+      { jsonrpc: '2.0', id: 'req-2', params: {} },
+      { mcp: mcpWire as never },
+      'resource://secure/99'
+    )
+
+    assert.equal(
+      middlewareRan,
+      true,
+      'the templated resource middleware must run for a concrete uri'
+    )
+  })
 })
 
 describe('runMCPTool', () => {
@@ -371,6 +417,141 @@ describe('runMCPTool', () => {
   })
 })
 
+describe("MCP carries the caller's HTTP request", () => {
+  // Without this, every auth middleware bails on its first line — each one
+  // opens with `if (!http?.request) return`, so an MCP call arrived at the
+  // function with no session, and a tool fronting a session-requiring function
+  // answered 'Authentication required' to every caller. Nothing else was
+  // missing: global middleware already runs for MCP, and the runner already
+  // builds a session service. Only the request was being dropped.
+  test('exposes http on the wire so session middleware can read it', async () => {
+    pikkuState(null, 'mcp', 'toolsMeta').whoami = {
+      name: 'whoami',
+      title: 'Who am I',
+      description: 'Who am I',
+      pikkuFuncId: 'whoamiFunc',
+      inputSchema: null,
+      outputSchema: 'MCPToolResponse',
+    } as never
+
+    let seenAuthorization: string | undefined
+    registerFunction('whoamiFunc', async (_services, _data, wire) => {
+      seenAuthorization = wire.http?.request?.header('authorization')
+      return [{ type: 'text', text: seenAuthorization ?? 'anonymous' }]
+    })
+
+    const http = {
+      request: {
+        header: (name: string) =>
+          name.toLowerCase() === 'authorization'
+            ? 'Bearer token-abc'
+            : undefined,
+      },
+    }
+
+    const response = await runMCPTool(
+      { jsonrpc: '2.0', id: 'req-http', params: {} },
+      { mcp: mcpWire as never, http: http as never },
+      'whoami'
+    )
+
+    assert.equal(seenAuthorization, 'Bearer token-abc')
+    assert.deepEqual(response, {
+      id: 'req-http',
+      result: [{ type: 'text', text: 'Bearer token-abc' }],
+    })
+  })
+
+  test('omitting http leaves the wire without one rather than inventing it', async () => {
+    pikkuState(null, 'mcp', 'toolsMeta').anon = {
+      name: 'anon',
+      title: 'Anon',
+      description: 'Anon',
+      pikkuFuncId: 'anonFunc',
+      inputSchema: null,
+      outputSchema: 'MCPToolResponse',
+    } as never
+
+    let sawHttp: unknown = 'unset'
+    registerFunction('anonFunc', async (_services, _data, wire) => {
+      sawHttp = wire.http
+      return [{ type: 'text', text: 'ok' }]
+    })
+
+    await runMCPTool(
+      { jsonrpc: '2.0', id: 'req-anon', params: {} },
+      { mcp: mcpWire as never },
+      'anon'
+    )
+
+    assert.equal(sawHttp, undefined)
+  })
+})
+
+describe('MCP tools fronting a session-requiring function', () => {
+  // The whole point of carrying the request: this is the template failure,
+  // reproduced. `listRoomsTool` and five others front a `pikkuFunc`, which
+  // requires a session, and answered 'Authentication required' to every caller
+  // because no request ever reached the middleware that would have set one.
+  test('receive the session set by global middleware from the request', async () => {
+    addGlobalMiddleware([
+      async (_services, wire, next) => {
+        const header = wire.http?.request?.header('authorization')
+        if (header === 'Bearer token-abc') {
+          wire.setSession?.({ userId: 'usr_1', name: 'Rafa' } as never)
+        }
+        await next()
+      },
+    ] as never)
+
+    pikkuState(null, 'mcp', 'toolsMeta').listRooms = {
+      name: 'listRooms',
+      title: 'List rooms',
+      description: 'List rooms',
+      pikkuFuncId: 'listRoomsFunc',
+      inputSchema: null,
+      outputSchema: 'MCPToolResponse',
+    } as never
+
+    // sessionless: false — the distinction that made these tools fail.
+    addFunction(
+      'listRoomsFunc',
+      {
+        func: async (_services: any, _data: any, wire: any) => [
+          { type: 'text', text: wire.session?.userId ?? 'anonymous' },
+        ],
+      } as never,
+      null
+    )
+    pikkuState(null, 'function', 'meta').listRoomsFunc = {
+      name: 'listRoomsFunc',
+      sessionless: false,
+      permissions: [],
+    } as never
+
+    const response = await runMCPTool(
+      { jsonrpc: '2.0', id: 'req-session', params: {} },
+      {
+        mcp: mcpWire as never,
+        http: {
+          request: {
+            header: (name: string) =>
+              name.toLowerCase() === 'authorization'
+                ? 'Bearer token-abc'
+                : undefined,
+          },
+        } as never,
+      },
+      'listRooms'
+    )
+
+    assert.deepEqual(response, {
+      id: 'req-session',
+      result: [{ type: 'text', text: 'usr_1' }],
+    })
+  })
+})
+
 describe('runMCPPrompt', () => {
   test('maps missing prompt registration to not found MCP errors', async () => {
     pikkuState(null, 'mcp', 'promptsMeta').missingPrompt = {

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

@@ -1,4 +1,5 @@
 import type { PikkuRawWire } from '../../types/core.types.js'
+import type { PikkuHTTP } from '../http/http.types.js'
 import type {
   CoreMCPResource,
   CoreMCPPrompt,
@@ -35,16 +36,24 @@ export class MCPError extends Error {
 
 export type RunMCPEndpointParams<Tools extends string = any> = {
   mcp?: PikkuMCP<Tools>
+  /**
+   * The HTTP request the MCP call arrived on, when it arrived over HTTP.
+   *
+   * Auth middleware reads the session off `wire.http.request` — every
+   * implementation opens with `if (!http?.request) return` — so without this an
+   * MCP call reaches the function unauthenticated no matter what middleware the
+   * app has registered, and a tool fronting a session-requiring function can
+   * only ever answer 'Authentication required'.
+   *
+   * Left undefined for transports that have no request to offer, such as stdio.
+   * Those remain anonymous, which is a property of the transport rather than a
+   * default chosen here.
+   */
+  http?: PikkuHTTP
   /** Defaults to enabled outside production. */
   exposeErrors?: boolean
 }
 
-export type JsonRpcError = {
-  code: number
-  message: string
-  data?: any
-}
-
 export const wireMCPResource = <
   PikkuFunctionConfig extends CorePikkuFunctionConfig<
     CorePikkuFunctionSessionless<any, any>
@@ -60,7 +69,7 @@ export const wireMCPResource = <
     )
     return
   }
-  addFunction(mcpResourceMeta.pikkuFuncId, mcpResource.func as any)
+  addFunction(mcpResourceMeta.pikkuFuncId, mcpResource.func)
   const resources = pikkuState(null, 'mcp', 'resources')
   if (resources.has(mcpResource.uri)) {
     throw new Error(`MCP resource already exists: ${mcpResource.uri}`)
@@ -83,7 +92,7 @@ export const wireMCPPrompt = <
     )
     return
   }
-  addFunction(mcpPromptMeta.pikkuFuncId, mcpPrompt.func as any)
+  addFunction(mcpPromptMeta.pikkuFuncId, mcpPrompt.func)
   const prompts = pikkuState(null, 'mcp', 'prompts')
   if (prompts.has(mcpPrompt.name)) {
     throw new Error(`MCP prompt already exists: ${mcpPrompt.name}`)
@@ -103,6 +112,12 @@ export async function runMCPResource(
   const metas = pikkuState(null, 'mcp', 'resourcesMeta')
   const endpoints = pikkuState(null, 'mcp', 'resources')
 
+  // The key the resource's meta (and its middleware) is stored under. For a
+  // templated resource this is the template, not the concrete request URI — so
+  // it must be carried forward, or the meta lookup downstream misses and the
+  // resource's declared middleware (including auth) is silently skipped.
+  let metaKey = uri
+
   if (endpoints.has(uri)) {
     endpoint = endpoints.get(uri)
     pikkuFuncId = metas[uri]?.pikkuFuncId
@@ -119,6 +134,7 @@ export async function runMCPResource(
 
       if (match) {
         endpoint = value
+        metaKey = uriTemplate
         pikkuFuncId = metas[uriTemplate]?.pikkuFuncId
 
         for (let i = 0; i < paramNames.length; i++) {
@@ -140,7 +156,8 @@ export async function runMCPResource(
     pikkuFuncId,
     { ...params, mcp: { ...params.mcp, uri } } as RunMCPEndpointParams<
       keyof CoreMCPResource
-    >
+    >,
+    metaKey
   )
 }
 
@@ -183,7 +200,11 @@ async function runMCPPikkuFunc(
   name: string,
   mcp: CoreMCPResource | CoreMCPPrompt | undefined,
   pikkuFuncId: string | undefined,
-  { mcp: mcpWire, exposeErrors = !isProduction() }: RunMCPEndpointParams
+  { mcp: mcpWire, http, exposeErrors = !isProduction() }: RunMCPEndpointParams,
+  // The key the endpoint's meta is stored under. Differs from `name` only for a
+  // templated resource, where `name` is the concrete URI and the meta lives
+  // under the template. Defaults to `name` for tools and prompts.
+  metaKey: string = name
 ): Promise<JsonRpcResponse> {
   const singletonServices = getSingletonServices()
   const createWireServices = getCreateWireServices()
@@ -214,16 +235,19 @@ async function runMCPPikkuFunc(
     )
     const wire: PikkuRawWire = {
       mcp: mcpWire,
+      // Only when the transport supplied one. Setting `http: undefined`
+      // explicitly would be the same to a reader and different to a spread.
+      ...(http ? { http } : {}),
       ...createMiddlewareSessionWireProps(mcpSessionService),
     }
 
     let meta: any
     if (type === 'resource') {
-      meta = pikkuState(null, 'mcp', 'resourcesMeta')[name]
+      meta = pikkuState(null, 'mcp', 'resourcesMeta')[metaKey]
     } else if (type === 'tool') {
-      meta = pikkuState(null, 'mcp', 'toolsMeta')[name]
+      meta = pikkuState(null, 'mcp', 'toolsMeta')[metaKey]
     } else if (type === 'prompt') {
-      meta = pikkuState(null, 'mcp', 'promptsMeta')[name]
+      meta = pikkuState(null, 'mcp', 'promptsMeta')[metaKey]
     }
 
     let resolvedFuncName = pikkuFuncId
@@ -293,10 +317,6 @@ async function runMCPPikkuFunc(
   }
 }
 
-export const getMCPResources = () => {
-  return pikkuState(null, 'mcp', 'resources')
-}
-
 export const getMCPResourcesMeta = () => {
   return pikkuState(null, 'mcp', 'resourcesMeta')
 }
@@ -305,10 +325,6 @@ export const getMCPToolsMeta = () => {
   return pikkuState(null, 'mcp', 'toolsMeta')
 }
 
-export const getMCPPrompts = () => {
-  return pikkuState(null, 'mcp', 'prompts')
-}
-
 export const getMCPPromptsMeta = () => {
   return pikkuState(null, 'mcp', 'promptsMeta')
 }

package/src/wirings/persona/index.ts

@@ -10,7 +10,6 @@ export type { RoleVerification } from './validate-personas.js'
 export {
   personaEnvironmentErrors,
   personaEnvironmentRefusal,
-  resolvePersonaEnvironments,
 } from './persona-environments.js'
 export type {
   PersonaEnvironment,
@@ -18,14 +17,8 @@ export type {
 } from './persona-environments.js'
 export {
   personaEmail,
-  personaEmailLabel,
   personaEmails,
 } from './persona-email.js'
-export {
-  allowedLinks,
-  applyMailboxAllowlist,
-  isAllowedSender,
-} from './persona-mailbox.js'
 export type {
   MailboxAllowlist,
   PersonaMailbox,
@@ -33,7 +26,6 @@ export type {
 } from './persona-mailbox.js'
 export type {
   CorePersona,
-  CorePersonaAccount,
   CorePersonas,
   PersonaAccountMeta,
   PersonaDefinitions,