@volter/world-core 3.0.162 → 3.0.164

package/src/runtime.ts

@@ -16,11 +16,12 @@ export { ORIGINAL_PATH_HEADER } from './sigv4.ts';
 export { createTwinFetchFromHandler, placedCookies, TWIN_PREFIX_HEADER, TWIN_REQUEST_SCOPES, TWIN_SITES_HEADER, TWIN_SITE_HEADER, siteLabel, siteUrlOf, twinPublicBase, twinSiteUrl, twinVendorUrl, withRequestScopes } from './twin-fetch.ts';
 export { isReadOnlyRequest, READ_ONLY_REQUEST_HEADER, ReadOnlyRequestError, runAsReadOnlyRequest, runAsVendorMove, writesRefused } from './request-scope.ts';
 export { compileSurface, createDerivedFetch, matchOperation, observeDerivedDispatch } from './derived.ts';
+export { hostOf, laneSelector, slashesMerged, unitRequestRouter, worldDoorMatcher } from './pack-fetch.ts';
 export { currentTraceparent, deliveryTraceHeaders, newTraceparent, parseTraceparent, runWithRequestTrace, runWithTraceparent, TRACEPARENT_HEADER, traceparentForDelivery, validTraceparent } from './trace-context.ts';
 export type { Traceparent } from './trace-context.ts';
 export type { DerivedCall, DerivedCoreOutcome, DerivedDispatch, DerivedFetch, DerivedFetchOptions, DerivedHandler, DerivedOperation, DerivedOwner, DerivedSurface, BoardFrame } from './derived.ts';
 export { authRefusal, bindSemantics, coreFor, crossCutting, flagOf, derivedRequestScopes, observeTransitions, resourcesOfType as twinResourcesOfType, semanticsContext, stateOf, transitionFor, parseBracketForm, readParams, render as renderDerived, serveCore, sse, vendorError } from './derived-core.ts';
-export { deliverEvents, fillEnvelope, setDeliveryObserver, signEvent, signEventAll, verifyEvent } from './events.ts';
+export { deliverEvents, fillEnvelope, setDeliveryObserver, settleEventDeliveries, signEvent, signEventAll, verifyEvent } from './events.ts';
 export { equalSecrets, hmac, jwks, jwtDecode, jwtSign, jwtSignClaims, jwtVerify, jwtVerifySignature, keyId, lettersFrom, md5, sha256, SIGNING_ALGORITHMS, uuidFrom } from './signing.ts';
 export type { HandlerCrypto, Jwk, Jwks, JwtDecodeOptions, JwtSignatureOptions, JwtVerdict, JwtVerificationKey, SigningKey } from './signing.ts';
 export type { EventDelivery, EventRender, EventScheme, EventsDecl, EventTransport, EventWrite } from './events.ts';

package/src/serve-http.ts

@@ -1,7 +1,7 @@
 // The HTTP server seam of the kernel (docs/contributing/architecture.md#the-serve-seam): a fetch handler on
 // a port, in the shape every `Bun.serve` call already has, so the serve path meets the runtime in
-// ONE place. Bun-backed where Bun is the runtime; `node:http`-backed otherwise, the request rebuilt
-// as a standard Request and the handler's Response written back. Async, because binding a port is
+// ONE place. Ordinary HTTP uses `node:http`; requested WebSockets retain Bun's native backend.
+// The request is rebuilt as a standard Request and the handler's Response written back. Async, because binding a port is
 // asynchronous on Node — Bun's synchronous bind is the special case.
 //
 // Nothing here runs at module scope (the served-handler registry is made on first use), and `node:http` is reached through `process.getBuiltinModule`
@@ -10,6 +10,7 @@
 
 import type { TwinStream } from './twin-fetch.ts';
 import { worldBootAnswer } from './world-boot.ts';
+import { DEFAULT_MAX_DECODED_REQUEST_BODY_SIZE, RequestBodyTooLargeError } from './request-body.ts';
 
 /** One socket library at the host seam, shared by inbound upgrades and authenticated outbound relays. */
 const socketLibrary = () => import('ws');
@@ -41,7 +42,7 @@ export type ServeHttpOptions = {
   fetch: HttpHandler;
   /** seconds a connection may idle (Bun honors it; Node's keep-alive timeout is set from it) */
   idleTimeout?: number;
-  /** Explicit transport limit in bytes; absent, Bun retains its 128 MiB default. */
+  /** Explicit transport limit in bytes; absent, 128 MiB on both runtimes. */
   maxRequestBodySize?: number;
   /** what a thrown handler answers with; absent, a 500 carrying the error (as Bun.serve) */
   error?: (error: Error) => Response | Promise<Response>;
@@ -101,7 +102,7 @@ export async function serveHttp(options: ServeHttpOptions): Promise<HttpServer>
   const hostname = options.hostname ?? '127.0.0.1';
   const urlHost = options.hostname ?? '127.0.0.1';
   const bun = bunRuntime();
-  if (bun) {
+  if (bun && (options.upgrade !== undefined || 'websocket' in options)) {
     // the global `Bun.serve` — the request journal's wrap of it (serve.ts) applies to packs and to
     // this seam alike, so the seam never decorates twice on Bun
     const upgrade = options.upgrade;
@@ -221,7 +222,8 @@ function builtin<T>(name: string): T {
 
 async function serveOnNode(options: ServeHttpOptions & { hostname: string; urlHost: string }): Promise<HttpServer> {
   const http = builtin<NodeHttp>('node:http');
-  const { Readable } = builtin<NodeStream>('node:stream');
+  const { Readable, Transform } = builtin<NodeStream>('node:stream');
+  const requestLimit = options.maxRequestBodySize ?? DEFAULT_MAX_DECODED_REQUEST_BODY_SIZE;
   if ('websocket' in options) throw new Error('serveHttp: use the portable upgrade callbacks for WebSocket support on Node');
   const protocol = options.tls ? 'https' : 'http';
   const factory = (handler: import('node:http').RequestListener) => options.tls
@@ -245,23 +247,35 @@ async function serveOnNode(options: ServeHttpOptions & { hostname: string; urlHo
     } catch { /* hostile thrown values are still reported by stage */ }
     try { process.stderr.write(`serveHttp ${stage}: ${detail.slice(0, 512)}\n`); } catch { /* stderr is best-effort */ }
   };
-  const active = new Set<AbortController>();
+  const active = new Set<() => void>();
   // Node's Request signal is dependent on the source signal. Neither a pending
   // handler nor a streaming response necessarily keeps the Request alive, so
   // retain it until the whole HTTP response path (including body cleanup) ends.
   const activeRequests = new Set<Request>();
   const server = factory((req: import('node:http').IncomingMessage, res: import('node:http').ServerResponse) => {
     const controller = new AbortController();
-    active.add(controller);
-    const abort = () => { if (!controller.signal.aborted) controller.abort(); };
+    const socket = req.socket;
+    const hasInputBody = req.headers['transfer-encoding'] !== undefined || Number(req.headers['content-length']) > 0;
+    let incoming: import('node:stream').Transform | undefined;
+    let flushingBodyRefusal = false;
+    const abort = () => {
+      if (!controller.signal.aborted) controller.abort();
+      incoming?.destroy(controller.signal.reason);
+      if (!flushingBodyRefusal) {
+        req.destroy();
+        if (!res.writableFinished) res.destroy();
+        socket.destroy();
+      }
+    };
+    active.add(abort);
     const onRequestClose = () => { if (!req.complete) abort(); };
-    const onResponseClose = () => { if (!res.writableFinished) abort(); };
+    const onResponseClose = () => { if (!res.writableFinished) { flushingBodyRefusal = false; abort(); } };
     const onSocketClose = () => { if (!res.writableFinished) abort(); };
     req.on('aborted', abort);
     req.on('close', onRequestClose);
     req.on('error', abort);
-    req.socket.on('close', onSocketClose);
-    req.socket.on('error', abort);
+    socket.on('close', onSocketClose);
+    socket.on('error', abort);
     res.on('close', onResponseClose);
     res.on('error', abort);
     const disconnected = () => controller.signal.aborted || res.destroyed;
@@ -288,17 +302,50 @@ async function serveOnNode(options: ServeHttpOptions & { hostname: string; urlHo
       if (disconnected()) closed();
     });
     let request: Request | undefined;
+    let bodyTooLarge = false;
+    const rejectBody = () => {
+      if (bodyTooLarge) return;
+      bodyTooLarge = true;
+      const error = new RequestBodyTooLargeError();
+      if (incoming) req.unpipe(incoming);
+      req.pause();
+      if (!res.headersSent && !res.destroyed) {
+        for (const name of res.getHeaderNames()) res.removeHeader(name);
+        flushingBodyRefusal = true;
+        res.writeHead(413, { 'connection': 'close', 'content-type': 'text/plain', 'content-length': Buffer.byteLength(error.message) });
+        res.once('finish', () => { flushingBodyRefusal = false; req.destroy(); });
+        res.end(error.message);
+      } else if (!res.destroyed) res.destroy(error);
+      abort();
+    };
+    const inputSettled = new Promise<void>((resolve) => {
+      const settled = () => { req.off('end', settled); req.off('close', settled); resolve(); };
+      req.once('end', settled);
+      req.once('close', settled);
+    });
     const handle = async () => {
       const method = req.method ?? 'GET';
+      if (Number(req.headers['content-length']) > requestLimit) { rejectBody(); return; }
       let response: Response;
       try {
         const headers = new Headers();
         for (const [k, v] of Object.entries(req.headers)) { if (v === undefined) continue; if (Array.isArray(v)) for (const one of v) headers.append(k, one); else headers.set(k, v); }
         const url = `${protocol}://${req.headers.host ?? `${options.hostname}:${(server.address() as { port: number } | null)?.port ?? 0}`}${req.url ?? '/'}`;
         const withBody = method !== 'GET' && method !== 'HEAD';
-        const init: RequestInit & { duplex?: 'half' } = { method, headers, signal: controller.signal, ...(withBody ? { body: Readable.toWeb(req) as unknown as ReadableStream, duplex: 'half' } : {}) };
+        let received = 0;
+        incoming = new Transform({ transform(chunk: Buffer, _encoding, callback) {
+          received += chunk.byteLength;
+          if (received > requestLimit) { rejectBody(); callback(new RequestBodyTooLargeError()); }
+          else callback(null, chunk);
+        } });
+        const inputClosed = () => { if (!req.readableEnded) abort(); };
+        incoming.on('error', inputClosed);
+        incoming.once('close', inputClosed);
+        const init: RequestInit & { duplex?: 'half' } = { method, headers, signal: controller.signal, ...(withBody ? { body: Readable.toWeb(incoming) as unknown as ReadableStream, duplex: 'half' } : {}) };
         request = new Request(url, init);
         activeRequests.add(request);
+        req.pipe(incoming);
+        if (!withBody) incoming.resume();
         response = await options.fetch(request);
       } catch (error) {
         if (disconnected()) return;
@@ -340,6 +387,7 @@ async function serveOnNode(options: ServeHttpOptions & { hostname: string; urlHo
         if (disconnected()) { await cancelOwnedReader(); return; }
         res.statusCode = response.status;
         for (const [k, v] of response.headers) { if (k !== 'set-cookie') res.setHeader(k, v); }
+        res.strictContentLength = response.headers.has('content-length');
         const cookies = response.headers.getSetCookie?.() ?? [];
         if (cookies.length) res.setHeader('set-cookie', cookies);
         if (reader) {
@@ -382,12 +430,18 @@ async function serveOnNode(options: ServeHttpOptions & { hostname: string; urlHo
       if (!res.destroyed) res.destroy(error instanceof Error ? error : new Error(String(error)));
     }).then(async () => {
       await responseSettled;
-      active.delete(controller);
+      // A runtime may retire its native body forwarding when the response ends.
+      // Close unfinished input after the response flushes; a consumed upload keeps its connection.
+      if (hasInputBody && !incoming?.readableEnded) abort();
+      else incoming?.resume();
+      await inputSettled;
+      if (incoming) { req.unpipe(incoming); incoming.destroy(); }
+      active.delete(abort);
       req.off('aborted', abort);
       req.off('close', onRequestClose);
       req.off('error', abort);
-      req.socket.off('close', onSocketClose);
-      req.socket.off('error', abort);
+      socket.off('close', onSocketClose);
+      socket.off('error', abort);
       res.off('close', onResponseClose);
       res.off('error', abort);
     });
@@ -415,7 +469,7 @@ async function serveOnNode(options: ServeHttpOptions & { hostname: string; urlHo
   const port = (server.address() as { port: number }).port;
   return {
     hostname: options.hostname, port, url: new URL(`${protocol}://${options.urlHost}:${port}/`),
-    stop: (closeActive = true) => new Promise<void>((resolve) => { if (closeActive) { for (const controller of active) controller.abort(); for (const peer of socketServer?.clients ?? []) peer.terminate(); } socketServer?.close(); server.close(() => { if (closeActive && active.size) reportCleanup('forced stop left pending handler cleanup', `${active.size} request(s)`); resolve(); }); if (closeActive) server.closeAllConnections(); }),
+    stop: (closeActive = true) => new Promise<void>((resolve) => { if (closeActive) { for (const abort of active) abort(); for (const peer of socketServer?.clients ?? []) peer.terminate(); } socketServer?.close(); server.close(() => { if (closeActive && active.size) reportCleanup('forced stop left pending handler cleanup', `${active.size} request(s)`); resolve(); }); if (closeActive) server.closeAllConnections(); }),
   };
 }