acrylblends 1.0.10 → 1.2.0

package/lib/cordis/node-server.d.ts

@@ -1,6 +1,9 @@
-import { c as UpgradeHubOptions, i as testWebSocket, l as UpgradeRouter, n as TestWebSocketOptions, o as UpgradeEmitter, p as WebSocketLike, r as TestWebSocketResult, s as UpgradeHub, t as TestSocket, u as RequestError } from "../test-websocket-DyeS50Tr.js";
+import { t as ConnectionInfo } from "../connection-ZLEso7XL.js";
+import { c as UpgradeHubOptions, i as testWebSocket, l as UpgradeRouter, n as TestWebSocketOptions, o as UpgradeEmitter, p as WebSocketLike, r as TestWebSocketResult, s as UpgradeHub, t as TestSocket, u as RequestError } from "../test-websocket-GUTAkFQT.js";
 import { n as UpgradeWebSocket } from "../index-C-SklY6u.js";
 import { n as serveStatic, t as ServeStaticOptions } from "../serve-static-B7sqnftW.js";
+import { IncomingMessage, ServerResponse } from "node:http";
+import { Duplex } from "node:stream";
 import { Context, Service } from "@deepseek-ai/cordis";
 import z from "@deepseek-ai/schemastery";
 
@@ -8,6 +11,24 @@ import z from "@deepseek-ai/schemastery";
 /** Stable Cordis plugin name, equal to the package name and the Loader row id. */
 declare const name = "acryl-node-server";
 declare const inject: string[];
+/** A raw node handler: the request and response are the platform's, and the adapter writes nothing for them. */
+interface RawRoute {
+  readonly kind: 'prefix' | 'exact';
+  readonly path: string;
+  readonly handler: (req: IncomingMessage, res: ServerResponse) => void | Promise<void>;
+}
+/** A raw upgrade handler: the socket is the handler's once the path matches; the router never sees the upgrade. */
+interface RawUpgradeRoute {
+  readonly path: string;
+  readonly handler: (req: IncomingMessage, socket: Duplex, head: Buffer) => void | Promise<void>;
+}
+/**
+ * Answer a request before raw routes and the router, or pass it on with `undefined`. The callback runs synchronously, so a request no gate answers still
+ * reaches a raw route's sentinel synchronously; a gate that needs the router (a host keeping an app's URLs in scope under a prefix, the ACRYL frame's canvas)
+ * returns its promise, and the adapter handles that like the router's own answer. `connection` carries the socket facts, which a router mount needs to check
+ * the peer and the real port.
+ */
+type RequestGate = (request: Request, connection: ConnectionInfo) => Response | Promise<Response> | undefined;
 interface Config {
   hostname: string;
   port: number;
@@ -22,28 +43,105 @@ declare module '@deepseek-ai/cordis' {
     nodeServer: NodeServer;
   }
 }
+/**
+ * Milliseconds a request already in flight, or an upgraded socket's own owner, may finish once the server stops taking new work. A save during a
+ * restart must not be cut; a stream that never ends must not hold the stop open.
+ */
+declare const STOP_GRACE_MS = 2000;
 declare class NodeServer extends Service {
   readonly hostname: string;
   readonly config: Config;
   private readonly server;
+  private readonly router;
   private hub;
   private bound;
+  /** The one stop this server runs: a second call (the disposer after an explicit stop) waits on the same promise. */
+  private stopping;
+  /** Requests whose response has not finished yet: the stop waits for them before their sockets are cut. */
+  private active;
+  /** Upgraded sockets this server handed out (WebSockets): neither close() nor closeAllConnections() reaches them, so the stop tracks them itself. */
+  private readonly upgraded;
+  /** Raw routes registered by the host's compatibility layer (see {@link registerRaw}). */
+  private readonly rawExact;
+  private readonly rawPrefix;
+  private readonly rawUpgrades;
+  /** Gates registered by a host that maps an app's URLs (see {@link NodeServer.gate}); they run in the order they were added. */
+  private readonly gates;
+  /** One raw dispatch per upgrade request: a second listener (or a re-added one) must never emit the same request again. */
+  private readonly rawUpgradeSeen;
   constructor(ctx: Context, config: Config);
+  /**
+   * Stop serving, gracefully, and resolve once the port is free: no new connections; requests already in flight may finish (a stream that never ends is
+   * cut) within {@link STOP_GRACE_MS}; each upgraded socket's owner closes it with a close frame first, and what is left is destroyed. Idempotent - the
+   * disposer calls it.
+   *
+   * Calling this BEFORE the rest of the app is disposed is what makes the grace count: the router has its own disposal, and it aborts in-flight requests
+   * and ends their bodies by design, concurrently with every other disposer (Cordis runs them together). A launcher that disposes the context directly
+   * therefore cuts the request this drains; a launcher that stops the server first lets it answer, then disposes.
+   */
+  stop(): Promise<void>;
+  private closeGracefully;
+  /**
+   * Wait, bounded, until no request is in flight and no upgraded socket is left; true when both reached zero inside the bound. Every pass sweeps idle
+   * keep-alive sockets again: the single sweep `close()` does misses one that becomes idle after its request finished, and such a socket would otherwise
+   * hold the stop to its deadline.
+   */
+  private settleStop;
+  /**
+   * Serve a raw node handler at `path`, beside the router: `exact` matches the pathname only, `prefix` the path and everything below it. The
+   * handler gets the platform's `IncomingMessage`/`ServerResponse` and owns the response; the router is not run for it. A path already served
+   * throws. The returned remover restores the path (the server itself goes on serving the rest).
+   */
+  registerRaw(route: RawRoute): () => void;
+  /**
+   * Answer matching requests before raw routes and the router, so a host can keep an app's URLs in scope under a prefix (the frame's canvas). A gate runs
+   * synchronously and can answer with a promise (see {@link RequestGate}); gates run in the order they were added, and the returned remover takes this one back.
+   */
+  gate(handler: RequestGate): () => void;
+  /**
+   * A gate's asynchronous answer: run the request it was given through the router, in the adapter's request form (a gate never makes one itself), with the
+   * socket facts. The raw routes do not run for that request.
+   */
+  throughRouter(request: Request, connection?: ConnectionInfo): Promise<Response>;
+  /**
+   * Claim an upgrade path for a raw node handler: the handler receives `(req, socket, head)` and from then on owns the socket. The router's
+   * WebSocket handling never sees a claimed upgrade. A path already claimed throws; the remover releases the claim. The transport's one raw
+   * listener exists for the server's whole lifetime and consults this registry, so claims coming and going never add or remove a listener.
+   */
+  registerRawUpgrade(route: RawUpgradeRoute): () => void;
+  /** The raw handler for a request: an exact path first, then the longest matching prefix. */
+  private rawFor;
   /**
    * `upgradeWebSocket` for the plugin that asks (call it once, in `apply`): `app.get('/ws', upgrade((c) => ({ onMessage(event, ws) { ... } })))`. Checks go in ordinary middleware on the
    * route, and a handler that returns a `Response` refuses the upgrade with that status before any handshake. Every socket it accepts belongs to the calling plugin: when the plugin
    * unloads they are closed with 1001 within `websocket.grace` and the handler sees `close` once. Pass `{ textOnly: true }` to drop binary frames. Needs the `ws` package.
    */
   upgrades(): UpgradeWebSocket<WebSocketLike>;
+  /** How many `upgrade` listeners the transport holds (raw plus router setups); a test asserts it does not grow across claim changes. */
+  get upgradeListenerCount(): number;
   /** How many WebSocket connections are open now. */
   get sockets(): number;
   /** The port in use, 0 before the server listens. */
   get port(): number;
   /** The address clients use. */
   get url(): string;
-  /** Bind, scanning past taken ports. */
+  /** Bind, scanning past taken ports and past the ports a browser refuses. */
   listen(): Promise<void>;
 }
+/**
+ * The ports every Fetch client refuses to connect to: the Fetch standard's bad ports (https://fetch.spec.whatwg.org/#port-blocking). Chromium
+ * refuses a page on one (ERR_UNSAFE_PORT) and Node's fetch answers "bad port"; the list below is the one Node 24 reports, probed port by port
+ * on 2026-11-03 (82 ports, 1 to 10080). An app's stable port is hashed into 3100..3999, and 3659 is on the list: without this rule one app in
+ * 900 would come up on an address no browser may open, which the frame gate caught that day (verify-frame-token was refused at 3659).
+ */
+declare const RESTRICTED_PORTS: ReadonlySet<number>;
+/** Whether a browser refuses to open this port. */
+declare function isRestrictedPort(port: number): boolean;
+/**
+ * The ports `listen` may try, in order: `port` with at most `scan` further ones, without the ports a browser refuses. Port 0 stays alone: the
+ * system chooses it, and the ports it hands out are above the restricted range.
+ */
+declare function portCandidates(port: number, scan: number): number[];
 /**
  * Whether a failed bind means "this port, try the next one". A port another socket holds answers `EADDRINUSE` everywhere. On Windows a port
  * inside a range the system reserves (Hyper-V, WSL and Docker exclude ranges, `netsh interface ipv4 show excludedportrange`) answers
@@ -54,4 +152,4 @@ declare function isPortUnavailable(error: unknown, platform?: NodeJS.Platform):
 /** Loads once the server listens, so a plugin that injects `nodeServer` can rely on `url`. A failure to bind fails the plugin. */
 declare function apply(ctx: Context, config?: Partial<Config>): Promise<void>;
 //#endregion
-export { Config, NodeServer, RequestError, type ServeStaticOptions, type TestSocket, type TestWebSocketOptions, type TestWebSocketResult, UpgradeEmitter, UpgradeHub, type UpgradeHubOptions, type UpgradeRouter, apply, inject, isPortUnavailable, name, serveStatic, testWebSocket };
+export { Config, NodeServer, RESTRICTED_PORTS, RawRoute, RawUpgradeRoute, RequestError, RequestGate, STOP_GRACE_MS, type ServeStaticOptions, type TestSocket, type TestWebSocketOptions, type TestWebSocketResult, UpgradeEmitter, UpgradeHub, type UpgradeHubOptions, type UpgradeRouter, apply, inject, isPortUnavailable, isRestrictedPort, name, portCandidates, serveStatic, testWebSocket };

package/lib/cordis/node-server.js

@@ -1,4 +1,4 @@
-import { l as RequestError, n as UpgradeEmitter, r as UpgradeHub, t as testWebSocket } from "../test-websocket-BLeEvybj.js";
+import { d as RequestError, n as UpgradeEmitter, r as UpgradeHub, t as testWebSocket } from "../test-websocket-CQOSvBth.js";
 import { t as serveStatic } from "../serve-static-C1Nkj_xB.js";
-import { a as isPortUnavailable, i as inject, n as NodeServer, o as name, r as apply, t as Config } from "../src-LX0E4ec4.js";
-export { Config, NodeServer, RequestError, UpgradeEmitter, UpgradeHub, apply, inject, isPortUnavailable, name, serveStatic, testWebSocket };
+import { a as apply, c as isRestrictedPort, i as STOP_GRACE_MS, l as name, n as NodeServer, o as inject, r as RESTRICTED_PORTS, s as isPortUnavailable, t as Config, u as portCandidates } from "../src-CtkIX_Gg.js";
+export { Config, NodeServer, RESTRICTED_PORTS, RequestError, STOP_GRACE_MS, UpgradeEmitter, UpgradeHub, apply, inject, isPortUnavailable, isRestrictedPort, name, portCandidates, serveStatic, testWebSocket };

package/lib/cordis/router-http.d.ts

@@ -1,5 +1,5 @@
 import { n as UpgradeWebSocket } from "../index-C-SklY6u.js";
-import { i as RouterHttpService } from "../index-DMOtA-NJ.js";
+import { i as RouterHttpService } from "../index-DGq7H0lb.js";
 import { IncomingMessage, ServerResponse } from "node:http";
 import { Duplex } from "node:stream";
 import { Context, Service } from "@deepseek-ai/cordis";
@@ -52,6 +52,10 @@ declare class RouterHttp extends Service implements RouterHttpService {
   private readonly router;
   private readonly web;
   private hub;
+  /** One upgrade helper per calling context: a fresh wrapper per call made every service event look like an owner change. */
+  private readonly upgradeHelpers;
+  /** A stable identity for this service instance's hub: a caller that must recognize the same owner across calls keys on this, not on a helper. */
+  private readonly hubIdentity;
   /** The adapter's own context: the hub lives as long as the adapter, whichever plugin asked for it first (`this.ctx` is the caller's). */
   private readonly home;
   private readonly upgradesIn;
@@ -69,6 +73,8 @@ declare class RouterHttp extends Service implements RouterHttpService {
    * `upgradeWebSocket` for the calling plugin: the sockets its routes accept are closed with 1001 when it unloads. Needs the `ws` package.
    * The route must be on a path the plugin mounted with `upgrade: [path]`.
    */
+  /** Stable for this service's lifetime; a re-provided adapter has a new one, which is how a caller sees a new owner. */
+  hubToken(): object;
   upgrades(): UpgradeWebSocket;
   /** How many WebSocket connections are open now. */
   get sockets(): number;

package/lib/cordis/router-http.js

@@ -1,5 +1,5 @@
-import { n as UpgradeEmitter, r as UpgradeHub } from "../test-websocket-BLeEvybj.js";
-import "../src-LX0E4ec4.js";
+import { n as UpgradeEmitter, r as UpgradeHub } from "../test-websocket-CQOSvBth.js";
+import "../src-CtkIX_Gg.js";
 import { Readable } from "node:stream";
 import { Service } from "@deepseek-ai/cordis";
 import { pipeline } from "node:stream/promises";
@@ -59,6 +59,33 @@ async function sendResponse(res, response, method) {
 }
 //#endregion
 //#region ../../plugins/acryl-router-http/src/serve.ts
+/** How long a refusal waits for a request body the handler never read. */
+const REQUEST_BODY_SETTLE_MS = 1e3;
+/**
+* Read and discard a request body the handler left unread (a guard's 403, a 415, a body over its limit), so the client can finish sending and
+* read the answer. Ending a response while request data is still arriving makes Node close the socket with that data pending, and the peer sees a
+* reset instead of the answer: reliably on Windows (the workspace git worktree test's read ECONNRESET) and on other systems under load. Bounded:
+* a client that stops sending waits at most `ms`, then loses the socket as before.
+*/
+function settleRequestBody(req, ms = REQUEST_BODY_SETTLE_MS) {
+	if (req.readableEnded || req.destroyed) return Promise.resolve();
+	return new Promise((resolve) => {
+		let timer;
+		const done = () => {
+			if (timer !== void 0) clearTimeout(timer);
+			req.off("end", done);
+			req.off("close", done);
+			req.off("error", done);
+			resolve();
+		};
+		timer = setTimeout(done, ms);
+		timer.unref?.();
+		req.once("end", done);
+		req.once("close", done);
+		req.once("error", done);
+		req.resume();
+	});
+}
 /**
 * Serve one node request through the router and write the result. The request's abort signal fires when the client
 * disconnects before the response finished; the socket's peer address and local port travel as connection info, never in the request.
@@ -78,6 +105,7 @@ async function serve(router, req, res) {
 	} catch {
 		response = new Response("Internal Server Error", { status: 500 });
 	}
+	if (method !== "GET" && method !== "HEAD") await settleRequestBody(req);
 	await sendResponse(res, response, method);
 }
 //#endregion
@@ -91,6 +119,10 @@ var RouterHttp = class extends Service {
 	router;
 	web;
 	hub;
+	/** One upgrade helper per calling context: a fresh wrapper per call made every service event look like an owner change. */
+	upgradeHelpers = /* @__PURE__ */ new WeakMap();
+	/** A stable identity for this service instance's hub: a caller that must recognize the same owner across calls keys on this, not on a helper. */
+	hubIdentity = {};
 	/** The adapter's own context: the hub lives as long as the adapter, whichever plugin asked for it first (`this.ctx` is the caller's). */
 	home;
 	upgradesIn = new UpgradeEmitter();
@@ -141,8 +173,17 @@ var RouterHttp = class extends Service {
 	* `upgradeWebSocket` for the calling plugin: the sockets its routes accept are closed with 1001 when it unloads. Needs the `ws` package.
 	* The route must be on a path the plugin mounted with `upgrade: [path]`.
 	*/
+	/** Stable for this service's lifetime; a re-provided adapter has a new one, which is how a caller sees a new owner. */
+	hubToken() {
+		return this.hubIdentity;
+	}
 	upgrades() {
-		return this.ensureHub().upgradeWebSocketFor(this.ctx);
+		const owner = this.ctx;
+		const cached = this.upgradeHelpers.get(owner);
+		if (cached !== void 0) return cached;
+		const created = this.ensureHub().upgradeWebSocketFor(owner);
+		this.upgradeHelpers.set(owner, created);
+		return created;
 	}
 	/** How many WebSocket connections are open now. */
 	get sockets() {

package/lib/cordis/router.d.ts

@@ -2,6 +2,6 @@ import { B as NotFoundHandler, L as MiddlewareHandler, O as Handler, Q as Valida
 import { c as StatusCode, n as ContentfulStatusCode } from "../http-status-DaAwGAFL.js";
 import { a as getConnInfo, i as connectionOf, n as RouterBindings, r as RouterEnv, t as ConnectionInfo } from "../connection-ZLEso7XL.js";
 import { t as Acryl } from "../app-D8riatvv.js";
-import { a as TrailingSlash, i as RouterHttpService, n as MountableApp, o as apply, r as Router, s as name, t as Config } from "../index-DMOtA-NJ.js";
+import { a as TrailingSlash, i as RouterHttpService, n as MountableApp, o as apply, r as Router, s as name, t as Config } from "../index-DGq7H0lb.js";
 import { t as HTTPException } from "../http-exception-kpGJkmpi.js";
 export { Acryl, type AcrylRequest, Config, type ConnectionInfo, type ContentfulStatusCode, Context, type ContextRenderer, type ContextVariableMap, type Env, type ErrorHandler, type ExecutionContext, HTTPException, type Handler, type Input, type MiddlewareHandler, type MountableApp, type Next, type NotFoundHandler, type NotFoundResponse, Router, type RouterBindings, type RouterEnv, type RouterHttpService, type Schema, type StatusCode, type ToSchema, type TrailingSlash, type TypedResponse, type ValidationTargets, apply, connectionOf, getConnInfo, name };

package/lib/cordis/router.js

@@ -2,5 +2,5 @@ import { t as HTTPException } from "../http-exception-MjWkT89V.js";
 import { t as Context } from "../context-CkOh7Ygv.js";
 import { t as Acryl } from "../app-CQcGWjrk.js";
 import { n as getConnInfo, t as connectionOf } from "../connection-C7xgP1hP.js";
-import { i as name, n as Router, r as apply, t as Config } from "../src-BTBm4OPD.js";
+import { i as name, n as Router, r as apply, t as Config } from "../src-iBJ2ysV9.js";
 export { Acryl, Config, Context, HTTPException, Router, apply, connectionOf, getConnInfo, name };

package/lib/cordis/state.d.ts

@@ -24,9 +24,10 @@ declare class State extends Service {
   keys(): string[];
   /**
    * The current value of `key` as a server-sent event stream: the value now, then one event per change, until the client cancels or the router
-   * is disposed (both abort the stream). A comment line goes out every 15 seconds so proxies and browsers keep an idle stream open.
+   * is disposed (both abort the stream). A comment line goes out every 15 seconds so proxies and browsers keep an idle stream open. A string value travels as it is; with `json`
+   * (the `?json=1` of the browser client) every value is JSON, so `"12"` and `12` can be told apart.
    */
-  stream(key: string, c: Context$1): Response | undefined;
+  stream(key: string, c: Context$1, json?: boolean): Response | undefined;
 }
 declare function apply(ctx: Context): void;
 //#endregion