@nifrajs/core 3.1.0 → 3.2.0

package/src/server/validation.ts

@@ -0,0 +1,19 @@
+import type { StandardIssue } from "../schema/standard.ts"
+import { type ResponseResult, status } from "./runtime-core.ts"
+
+function validationIssues(issues: ReadonlyArray<StandardIssue>): {
+  ok: false
+  error: string
+  issues: unknown[]
+} {
+  const serialized = issues.map((issue) => {
+    const path = issue.path?.map((seg) => String(typeof seg === "object" ? seg.key : seg))
+    return path !== undefined ? { message: issue.message, path } : { message: issue.message }
+  })
+  return { ok: false, error: "validation", issues: serialized }
+}
+
+/** The shared 422 response result used by every body-validation lane. */
+export function plainValidationError(issues: ReadonlyArray<StandardIssue>): ResponseResult {
+  return status(422, validationIssues(issues))
+}

package/src/server/ws-bun.ts

@@ -28,6 +28,10 @@ export interface BunSocket {
   send(data: string | ArrayBufferView | ArrayBuffer, compress?: boolean): number
   close(code?: number, reason?: string): void
   readonly readyState: number
+  // Bun's native (uWebSockets) topic pub/sub - used only in native-pubsub mode (no per-socket
+  // outbound validation), where `app.publish` routes through the Bun server's `publish`.
+  subscribe(topic: string): void
+  unsubscribe(topic: string): void
   // readonly: we never reassign `ws.data` wholesale, only mutate its fields (`.nifra`, `.data`).
   readonly data: BunWsData
 }
@@ -38,11 +42,19 @@ function toBinaryData(message: ArrayBuffer | Uint8Array): Uint8Array {
   return message instanceof Uint8Array ? message : new Uint8Array(message)
 }
 
-/** Wrap a Bun `ServerWebSocket` as the portable {@link NifraWebSocket} handed to WS callbacks. */
+/**
+ * Wrap a Bun `ServerWebSocket` as the portable {@link NifraWebSocket} handed to WS callbacks.
+ *
+ * `nativePubsub` selects the topic backend: in native mode `subscribe`/`unsubscribe` go straight to
+ * Bun's own (uWebSockets) pub/sub so a broadcast via the Bun server's `publish` reaches this socket
+ * with no per-connection JS loop; otherwise they use the runtime-neutral {@link TopicRegistry}. Native
+ * mode is used only when no route validates outbound frames, so raw and validated sends are identical.
+ */
 function wrapBunSocket(
   raw: BunSocket,
   topics: TopicRegistry,
   handler: WebSocketHandler,
+  nativePubsub: boolean,
 ): NifraWebSocket {
   let ws!: NifraWebSocket
   const reportError = (error: unknown): void => reportWsError(error, ws, handler)
@@ -61,8 +73,12 @@ function wrapBunSocket(
     get readyState() {
       return raw.readyState
     },
-    subscribe: (topic) => topics.subscribe(topic, ws),
-    unsubscribe: (topic) => topics.unsubscribe(topic, ws),
+    subscribe: nativePubsub
+      ? (topic) => raw.subscribe(topic)
+      : (topic) => topics.subscribe(topic, ws),
+    unsubscribe: nativePubsub
+      ? (topic) => raw.unsubscribe(topic)
+      : (topic) => topics.unsubscribe(topic, ws),
     get data() {
       return raw.data.data
     },
@@ -99,26 +115,43 @@ function dispatchWsCallback(
   }
 }
 
-/** The shared Bun `websocket` dispatcher config for one app - each connection's
- * `ws.data.handler` is the matched route's handler, set by `server.upgrade`. */
-export function createBunWsHandlers(topics: TopicRegistry): BunWsHandlers {
+/**
+ * The shared Bun `websocket` dispatcher config for one app - each connection's `ws.data.handler` is
+ * the matched route's handler, set by `server.upgrade`.
+ *
+ * `nativePubsub` (set by `listen()` when the app has no validated-send route) makes subscriptions use
+ * Bun's own pub/sub; there the registry holds nothing and Bun auto-drops native subscriptions on
+ * close, so the `unsubscribeAll` sweep is skipped.
+ */
+export function createBunWsHandlers(topics: TopicRegistry, nativePubsub = false): BunWsHandlers {
   return {
     open: (raw) => {
       const ws = raw as BunSocket
-      const nifra = wrapBunSocket(ws, topics, ws.data.handler)
+      const nifra = wrapBunSocket(ws, topics, ws.data.handler, nativePubsub)
       ws.data.nifra = nifra
       dispatchWsCallback(() => ws.data.handler.open?.(nifra), nifra, ws.data.handler)
     },
     message: (raw, message) => {
       const ws = raw as BunSocket
-      const nifra = ws.data.nifra ?? wrapBunSocket(ws, topics, ws.data.handler)
+      const handler = ws.data.handler
+      const nifra = ws.data.nifra ?? wrapBunSocket(ws, topics, handler, nativePubsub)
       const data: WebSocketData = typeof message === "string" ? message : toBinaryData(message)
-      dispatchWsCallback(() => ws.data.handler.message?.(nifra, data), nifra, ws.data.handler)
+      // Hottest WS path - dispatch inline rather than through `dispatchWsCallback` so no per-frame
+      // closure is allocated. Same contract: a sync throw or async rejection routes to `handler.error`.
+      try {
+        const result = handler.message?.(nifra, data)
+        if (result instanceof Promise)
+          result.catch((e: unknown) => reportWsError(e, nifra, handler))
+      } catch (error) {
+        reportWsError(error, nifra, handler)
+      }
     },
     close: (raw, code, reason) => {
       const ws = raw as BunSocket
-      const nifra = ws.data.nifra ?? wrapBunSocket(ws, topics, ws.data.handler)
-      topics.unsubscribeAll(nifra) // drop topic subscriptions so the registry never holds a dead socket
+      const nifra = ws.data.nifra ?? wrapBunSocket(ws, topics, ws.data.handler, nativePubsub)
+      // Registry mode: drop topic subscriptions so it never holds a dead socket. Native mode: Bun
+      // unsubscribes the socket from every topic on close, so there is nothing to sweep here.
+      if (!nativePubsub) topics.unsubscribeAll(nifra)
       dispatchWsCallback(() => ws.data.handler.close?.(nifra, code, reason), nifra, ws.data.handler)
     },
   }

package/src/server/ws-hook.ts

@@ -30,8 +30,9 @@ export interface WsRuntime {
   wrapHandler(handler: WebSocketHandler): WebSocketHandler
   /** One in-process pub/sub registry per app (backs `ws.subscribe` + `app.publish`). */
   createTopics(): TopicRegistry
-  /** The Bun `websocket` config for `listen()` when the app has WS routes. */
-  bunHandlers(topics: TopicRegistry): BunWsHandlers
+  /** The Bun `websocket` config for `listen()` when the app has WS routes. `nativePubsub` routes
+   * `ws.subscribe` through Bun's own pub/sub (set when no route validates outbound frames). */
+  bunHandlers(topics: TopicRegistry, nativePubsub?: boolean): BunWsHandlers
   /** `attachWebSocket` - wires a standard server socket (Workers `WebSocketPair`) to a handler. */
   attach(
     socket: StandardWebSocket,

package/src/server.ts

@@ -70,8 +70,13 @@ export {
   toVercelHandler,
   type VercelHandler,
 } from "./server/platform-adapters.ts"
-export type { Registry, RouteInfo } from "./server/registry.ts"
-export { type PlainRender, type ResponseResult, status } from "./server/runtime-core.ts"
+export type { Registry, ResponseMapFor, RouteInfo, RouteInfoFor } from "./server/registry.ts"
+export {
+  type PlainRender,
+  type ResponseResult,
+  type StatusResponse,
+  status,
+} from "./server/runtime-core.ts"
 export {
   type AdmissionController,
   type AdmissionDecision,

package/src/single-copy.ts

@@ -472,7 +472,9 @@ export function singleCopyPlugin(options: SingleCopyOptions = {}): SingleCopyPlu
         const scopes = declared
           .filter((entry) => entry.endsWith("/*"))
           .map((entry) => `${escapeRegExp(entry.slice(0, -1))}[^/]+`)
-        const alternatives = [...exact.map((name) => `${name}(?:/.*)?`), ...scopes]
+        // Subpaths pin too, for exact names and scope patterns alike: `@nifrajs/core/server` must
+        // resolve to the same copy as `@nifrajs/core`, or a deep import quietly splits the package.
+        const alternatives = [...exact, ...scopes].map((name) => `${name}(?:/.*)?`)
         if (alternatives.length > 0) {
           const filter = new RegExp(`^(?:${alternatives.join("|")})$`)
           build.onResolve({ filter }, (args) => {