@ny4n/server 0.0.0-stage → 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Mario Zechner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,63 @@
-# Temporary Holding Version
+# @ny4n/server
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Experimental local server that routes clients to application-hosted durable Sessions.
+
+The current slice supports server- and Session-scoped facet-service routing and multi-presentation attachment. `RoutedServerServiceHost.attachClient()` creates one connection-scoped server service endpoint with narrow attachment-management capabilities. `RoutedSessionHandle.attachClient()` returns a presentation-scoped Session capability. Its `invokeService()` forwards an opaque service/member envelope to the selected Session endpoint; the server validates the attachment route but does not load the facet contract.
+
+- server service calls and subscriptions route opaquely through the connection's `RoutedServerServiceAttachment`;
+- the application-owned `SessionDirectory` projects the private catalog into replicated presentation-safe state;
+- the application-owned `SessionManagement` creates, removes, attaches, and detaches Sessions without exposing route IDs in business results;
+- attachment changes are published out of band after the router installs or clears the live route;
+- Session service calls route through `invokeService` without server-side business-payload decoding;
+- service subscription updates remain scoped to the requesting attachment;
+- application observations such as transcripts route as ordinary service state without server-owned business schemas.
+
+A Session may have multiple presentation attachments. Repeating `attach` from one connection is idempotent; every successful attachment has a server-generated `attachmentId` delivered only as routing control data. Session requests carry `{ serverId, sessionId, attachmentId }`, and the server rejects stale or mismatched routes. Losing a connection rejects its local responses but releases its attachment only after admitted service calls settle. The host decides when zero presentation demand and worker-local Harness activity permit worker retirement. Server shutdown closes every routed Session handle, releasing its worker and Session writer ownership.
+
+```ts
+import { randomUUID } from "node:crypto";
+import {
+  type RoutedServerServiceHost,
+  type RoutedSessionHandle,
+  type ServerHost,
+  type SessionMetadata,
+  SessionNotFoundError,
+} from "@ny4n/server";
+import { createUnixServer, getUnixSocketPath } from "@ny4n/server/unix";
+
+interface StoredSession extends SessionMetadata {
+  path: string;
+}
+
+async function startServer(
+  serverServices: RoutedServerServiceHost,
+  sessions: Map<string, StoredSession>,
+  openRoutedSession: (session: StoredSession) => Promise<RoutedSessionHandle>,
+) {
+  const host: ServerHost<StoredSession> = {
+    serverServices,
+    async resolveSession(sessionId) {
+      const metadata = sessions.get(sessionId);
+      if (!metadata) throw new SessionNotFoundError(`Unknown session: ${sessionId}`);
+      return metadata;
+    },
+    openSession: (metadata) => openRoutedSession(metadata),
+  };
+
+  const serverId = randomUUID();
+  const server = createUnixServer(host, {
+    serverId,
+    path: getUnixSocketPath(serverId, "/run/user/1000/nyan"),
+  });
+  await server.start();
+  return server;
+}
+```
+
+Applications supply a required server service host, a bounded Session resolver, and a routed Session factory. `SessionMetadata` only requires an `id`; applications may extend it with their own storage fields. Session discovery and management are application-owned services; the protocol server only asks the resolver for metadata when routing an attachment. The host owns acquiring the worker-local Session and Harness. Failures are cleaned up in that worker. Neither an open JavaScript Session nor a Harness crosses the process boundary.
+
+`serverId` is a logical identity supplied by the launcher, not a socket address. The Unix preset requires an explicit physical `path`; `getUnixSocketPath()` derives one from a caller-selected directory. Choose a short, private runtime directory rather than deriving the route from an unbounded home-directory path. A long-lived launcher can reuse the same ID and path when replacing a server process.
+
+`Server` composes transports through `ServerListener`; peer authentication remains application policy and is not implemented by the experimental Unix transport. The Unix submodule provides `createUnixListener()` and `createUnixServer()`. Low-level routed-envelope validation, CBOR, and framing come from `@ny4n/protocol`; Chord owns service-control parsing, error codes, snapshots and updates, and each subscription's replicated-state encoder.
+
+Server and worker lifecycle is managed outside the public Nyan protocol. The replaceable application server converts connection attachments into private demand updates; the worker combines generation-tagged demand with authoritative Harness activity. The experimental coordinator only supplies stable routing and reports generic server-generation connection changes.

package/dist/connection.d.ts

@@ -0,0 +1,32 @@
+import type { ServiceStateEncoder } from "@ny4n/chord";
+import type { ClientMessageDecoder, RpcTarget } from "@ny4n/protocol";
+import type { MaybePromise, RoutedServerServiceAttachment } from "./types.ts";
+/** An established, authorized ordered byte connection. */
+export interface ByteConnection {
+    readonly closed: boolean;
+    send(chunk: Uint8Array): Promise<void>;
+    close(finalChunk?: Uint8Array): MaybePromise<void>;
+}
+export interface ByteConnectionHandler {
+    onData(chunk: Uint8Array): void;
+    onClose(): void;
+    onError(error: Error): void;
+}
+export type ByteConnectionAcceptor = (connection: ByteConnection) => ByteConnectionHandler;
+export type ConnectionStage = "awaitingHello" | "handshaking" | "ready" | "closing" | "closed";
+export interface ConnectionState {
+    connection: ByteConnection;
+    decoder: ClientMessageDecoder;
+    serviceStateEncoders: Map<string, ServiceStateEncoder>;
+    stage: ConnectionStage;
+    disconnected: boolean;
+    handshake?: Promise<void>;
+    handshakeTimeout: NodeJS.Timeout;
+    serverServices?: RoutedServerServiceAttachment;
+    activeRequests: Map<string, {
+        controller: AbortController;
+        target: RpcTarget;
+    }>;
+}
+export declare function isTerminalConnection(state: ConnectionState): boolean;
+//# sourceMappingURL=connection.d.ts.map

package/dist/connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../src/connection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,KAAK,EAAE,oBAAoB,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEtE,OAAO,KAAK,EAAE,YAAY,EAAE,6BAA6B,EAAE,MAAM,YAAY,CAAC;AAE9E,0DAA0D;AAC1D,MAAM,WAAW,cAAc;IAC9B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,IAAI,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACvC,KAAK,CAAC,UAAU,CAAC,EAAE,UAAU,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;CACnD;AAED,MAAM,WAAW,qBAAqB;IACrC,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAAC;IAChC,OAAO,IAAI,IAAI,CAAC;IAChB,OAAO,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CAC5B;AAED,MAAM,MAAM,sBAAsB,GAAG,CAAC,UAAU,EAAE,cAAc,KAAK,qBAAqB,CAAC;AAE3F,MAAM,MAAM,eAAe,GAAG,eAAe,GAAG,aAAa,GAAG,OAAO,GAAG,SAAS,GAAG,QAAQ,CAAC;AAE/F,MAAM,WAAW,eAAe;IAC/B,UAAU,EAAE,cAAc,CAAC;IAC3B,OAAO,EAAE,oBAAoB,CAAC;IAC9B,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;IACvD,KAAK,EAAE,eAAe,CAAC;IACvB,YAAY,EAAE,OAAO,CAAC;IACtB,SAAS,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,gBAAgB,EAAE,MAAM,CAAC,OAAO,CAAC;IACjC,cAAc,CAAC,EAAE,6BAA6B,CAAC;IAC/C,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,UAAU,EAAE,eAAe,CAAC;QAAC,MAAM,EAAE,SAAS,CAAA;KAAE,CAAC,CAAC;CAChF;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAEpE"}

package/dist/connection.js

@@ -0,0 +1,4 @@
+export function isTerminalConnection(state) {
+    return state.disconnected || state.stage === "closing" || state.stage === "closed";
+}
+//# sourceMappingURL=connection.js.map

package/dist/connection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection.js","sourceRoot":"","sources":["../src/connection.ts"],"names":[],"mappings":"AAkCA,MAAM,UAAU,oBAAoB,CAAC,KAAsB;IAC1D,OAAO,KAAK,CAAC,YAAY,IAAI,KAAK,CAAC,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,KAAK,KAAK,QAAQ,CAAC;AACpF,CAAC","sourcesContent":["import type { ServiceStateEncoder } from \"@ny4n/chord\";\nimport type { ClientMessageDecoder, RpcTarget } from \"@ny4n/protocol\";\n\nimport type { MaybePromise, RoutedServerServiceAttachment } from \"./types.ts\";\n\n/** An established, authorized ordered byte connection. */\nexport interface ByteConnection {\n\treadonly closed: boolean;\n\tsend(chunk: Uint8Array): Promise<void>;\n\tclose(finalChunk?: Uint8Array): MaybePromise<void>;\n}\n\nexport interface ByteConnectionHandler {\n\tonData(chunk: Uint8Array): void;\n\tonClose(): void;\n\tonError(error: Error): void;\n}\n\nexport type ByteConnectionAcceptor = (connection: ByteConnection) => ByteConnectionHandler;\n\nexport type ConnectionStage = \"awaitingHello\" | \"handshaking\" | \"ready\" | \"closing\" | \"closed\";\n\nexport interface ConnectionState {\n\tconnection: ByteConnection;\n\tdecoder: ClientMessageDecoder;\n\tserviceStateEncoders: Map<string, ServiceStateEncoder>;\n\tstage: ConnectionStage;\n\tdisconnected: boolean;\n\thandshake?: Promise<void>;\n\thandshakeTimeout: NodeJS.Timeout;\n\tserverServices?: RoutedServerServiceAttachment;\n\tactiveRequests: Map<string, { controller: AbortController; target: RpcTarget }>;\n}\n\nexport function isTerminalConnection(state: ConnectionState): boolean {\n\treturn state.disconnected || state.stage === \"closing\" || state.stage === \"closed\";\n}\n"]}

package/dist/errors.d.ts

@@ -0,0 +1,25 @@
+import type { RemoteServiceErrorCode } from "@ny4n/chord";
+type ServerOperationErrorCode = RemoteServiceErrorCode | "wrong_server" | "session_not_found" | "session_ambiguous" | "session_not_attached" | "server_draining";
+export declare const INTERNAL_SERVER_ERROR_MESSAGE = "Internal server error";
+/** A host or lifecycle error that can safely cross the protocol boundary. */
+export declare class ServerError extends Error {
+    readonly code: ServerOperationErrorCode;
+    constructor(code: ServerOperationErrorCode, message: string);
+}
+export declare class WrongServerError extends ServerError {
+    constructor();
+}
+export declare class SessionNotFoundError extends ServerError {
+    constructor(message?: string);
+}
+export declare class SessionAmbiguousError extends ServerError {
+    constructor();
+}
+export declare class SessionNotAttachedError extends ServerError {
+    constructor();
+}
+export declare class ServerDrainingError extends ServerError {
+    constructor();
+}
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAE1D,KAAK,wBAAwB,GAC1B,sBAAsB,GACtB,cAAc,GACd,mBAAmB,GACnB,mBAAmB,GACnB,sBAAsB,GACtB,iBAAiB,CAAC;AAErB,eAAO,MAAM,6BAA6B,0BAA0B,CAAC;AAErE,6EAA6E;AAC7E,qBAAa,WAAY,SAAQ,KAAK;IACrC,QAAQ,CAAC,IAAI,EAAE,wBAAwB,CAAC;IAExC,YAAY,IAAI,EAAE,wBAAwB,EAAE,OAAO,EAAE,MAAM,EAI1D;CACD;AAED,qBAAa,gBAAiB,SAAQ,WAAW;IAChD,cAGC;CACD;AAED,qBAAa,oBAAqB,SAAQ,WAAW;IACpD,YAAY,OAAO,SAA0B,EAG5C;CACD;AAED,qBAAa,qBAAsB,SAAQ,WAAW;IACrD,cAGC;CACD;AAED,qBAAa,uBAAwB,SAAQ,WAAW;IACvD,cAGC;CACD;AAED,qBAAa,mBAAoB,SAAQ,WAAW;IACnD,cAGC;CACD"}

package/dist/errors.js

@@ -0,0 +1,41 @@
+export const INTERNAL_SERVER_ERROR_MESSAGE = "Internal server error";
+/** A host or lifecycle error that can safely cross the protocol boundary. */
+export class ServerError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "ServerError";
+        this.code = code;
+    }
+}
+export class WrongServerError extends ServerError {
+    constructor() {
+        super("wrong_server", "Request was addressed to another server");
+        this.name = "WrongServerError";
+    }
+}
+export class SessionNotFoundError extends ServerError {
+    constructor(message = "Session was not found") {
+        super("session_not_found", message);
+        this.name = "SessionNotFoundError";
+    }
+}
+export class SessionAmbiguousError extends ServerError {
+    constructor() {
+        super("session_ambiguous", "Session ID matches more than one session");
+        this.name = "SessionAmbiguousError";
+    }
+}
+export class SessionNotAttachedError extends ServerError {
+    constructor() {
+        super("session_not_attached", "Session is not attached to this client");
+        this.name = "SessionNotAttachedError";
+    }
+}
+export class ServerDrainingError extends ServerError {
+    constructor() {
+        super("server_draining", "Server is draining");
+        this.name = "ServerDrainingError";
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAUA,MAAM,CAAC,MAAM,6BAA6B,GAAG,uBAAuB,CAAC;AAErE,6EAA6E;AAC7E,MAAM,OAAO,WAAY,SAAQ,KAAK;IAC5B,IAAI,CAA2B;IAExC,YAAY,IAA8B,EAAE,OAAe;QAC1D,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,aAAa,CAAC;QAC1B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IAClB,CAAC;CACD;AAED,MAAM,OAAO,gBAAiB,SAAQ,WAAW;IAChD;QACC,KAAK,CAAC,cAAc,EAAE,yCAAyC,CAAC,CAAC;QACjE,IAAI,CAAC,IAAI,GAAG,kBAAkB,CAAC;IAChC,CAAC;CACD;AAED,MAAM,OAAO,oBAAqB,SAAQ,WAAW;IACpD,YAAY,OAAO,GAAG,uBAAuB;QAC5C,KAAK,CAAC,mBAAmB,EAAE,OAAO,CAAC,CAAC;QACpC,IAAI,CAAC,IAAI,GAAG,sBAAsB,CAAC;IACpC,CAAC;CACD;AAED,MAAM,OAAO,qBAAsB,SAAQ,WAAW;IACrD;QACC,KAAK,CAAC,mBAAmB,EAAE,0CAA0C,CAAC,CAAC;QACvE,IAAI,CAAC,IAAI,GAAG,uBAAuB,CAAC;IACrC,CAAC;CACD;AAED,MAAM,OAAO,uBAAwB,SAAQ,WAAW;IACvD;QACC,KAAK,CAAC,sBAAsB,EAAE,wCAAwC,CAAC,CAAC;QACxE,IAAI,CAAC,IAAI,GAAG,yBAAyB,CAAC;IACvC,CAAC;CACD;AAED,MAAM,OAAO,mBAAoB,SAAQ,WAAW;IACnD;QACC,KAAK,CAAC,iBAAiB,EAAE,oBAAoB,CAAC,CAAC;QAC/C,IAAI,CAAC,IAAI,GAAG,qBAAqB,CAAC;IACnC,CAAC;CACD","sourcesContent":["import type { RemoteServiceErrorCode } from \"@ny4n/chord\";\n\ntype ServerOperationErrorCode =\n\t| RemoteServiceErrorCode\n\t| \"wrong_server\"\n\t| \"session_not_found\"\n\t| \"session_ambiguous\"\n\t| \"session_not_attached\"\n\t| \"server_draining\";\n\nexport const INTERNAL_SERVER_ERROR_MESSAGE = \"Internal server error\";\n\n/** A host or lifecycle error that can safely cross the protocol boundary. */\nexport class ServerError extends Error {\n\treadonly code: ServerOperationErrorCode;\n\n\tconstructor(code: ServerOperationErrorCode, message: string) {\n\t\tsuper(message);\n\t\tthis.name = \"ServerError\";\n\t\tthis.code = code;\n\t}\n}\n\nexport class WrongServerError extends ServerError {\n\tconstructor() {\n\t\tsuper(\"wrong_server\", \"Request was addressed to another server\");\n\t\tthis.name = \"WrongServerError\";\n\t}\n}\n\nexport class SessionNotFoundError extends ServerError {\n\tconstructor(message = \"Session was not found\") {\n\t\tsuper(\"session_not_found\", message);\n\t\tthis.name = \"SessionNotFoundError\";\n\t}\n}\n\nexport class SessionAmbiguousError extends ServerError {\n\tconstructor() {\n\t\tsuper(\"session_ambiguous\", \"Session ID matches more than one session\");\n\t\tthis.name = \"SessionAmbiguousError\";\n\t}\n}\n\nexport class SessionNotAttachedError extends ServerError {\n\tconstructor() {\n\t\tsuper(\"session_not_attached\", \"Session is not attached to this client\");\n\t\tthis.name = \"SessionNotAttachedError\";\n\t}\n}\n\nexport class ServerDrainingError extends ServerError {\n\tconstructor() {\n\t\tsuper(\"server_draining\", \"Server is draining\");\n\t\tthis.name = \"ServerDrainingError\";\n\t}\n}\n"]}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./errors.ts";
+export * from "./listener.ts";
+export * from "./server.ts";
+export * from "./types.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from "./errors.js";
+export * from "./listener.js";
+export * from "./server.js";
+export * from "./types.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC","sourcesContent":["export * from \"./errors.ts\";\nexport * from \"./listener.ts\";\nexport * from \"./server.ts\";\nexport * from \"./types.ts\";\n"]}

package/dist/listener.d.ts

@@ -0,0 +1,8 @@
+import type { ByteConnectionAcceptor } from "./connection.ts";
+/** Supplies established byte connections after any required transport authentication. */
+export interface ServerListener {
+    /** Starts listening and passes authorized connections to accept. */
+    start(accept: ByteConnectionAcceptor): Promise<void>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=listener.d.ts.map

package/dist/listener.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"listener.d.ts","sourceRoot":"","sources":["../src/listener.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAE9D,yFAAyF;AACzF,MAAM,WAAW,cAAc;IAC9B,oEAAoE;IACpE,KAAK,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACrD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACvB"}

package/dist/listener.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=listener.js.map

package/dist/listener.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"listener.js","sourceRoot":"","sources":["../src/listener.ts"],"names":[],"mappings":"","sourcesContent":["import type { ByteConnectionAcceptor } from \"./connection.ts\";\n\n/** Supplies established byte connections after any required transport authentication. */\nexport interface ServerListener {\n\t/** Starts listening and passes authorized connections to accept. */\n\tstart(accept: ByteConnectionAcceptor): Promise<void>;\n\tclose(): Promise<void>;\n}\n"]}

package/dist/server.d.ts

@@ -0,0 +1,45 @@
+import { type ByteConnection, type ByteConnectionHandler } from "./connection.ts";
+import type { ServerHost, ServerOptions, SessionMetadata } from "./types.ts";
+export declare class Server<TMetadata extends SessionMetadata = SessionMetadata> {
+    readonly serverId: string;
+    /** Resolves after shutdown, or rejects when listener or routed-Session cleanup fails. */
+    readonly closed: Promise<void>;
+    private readonly host;
+    private readonly listeners;
+    private readonly maxFrameLength;
+    private readonly handshakeTimeoutMs;
+    private readonly onConnectionCountChanged;
+    private readonly onError;
+    private readonly connections;
+    private readonly sessions;
+    private closing;
+    private closePromise?;
+    private closedSettled;
+    private rejectClosed;
+    private resolveClosed;
+    private startPromise?;
+    private started;
+    constructor(host: ServerHost<TMetadata>, options: ServerOptions);
+    start(): Promise<this>;
+    private startInternal;
+    accept(connection: ByteConnection): ByteConnectionHandler;
+    close(): Promise<void>;
+    private closeInternal;
+    private receive;
+    private dispatchMessage;
+    private finishHandshake;
+    private handleCancel;
+    private handleRequest;
+    private transportClosed;
+    private disconnect;
+    private sendServiceUpdate;
+    private sendMessage;
+    private failProtocol;
+    private closeServerState;
+    private closeConnection;
+    private toProtocolError;
+    private notifyConnectionCountChanged;
+    private reportError;
+    private settleClosed;
+}
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AA8BA,OAAO,EACN,KAAK,cAAc,EACnB,KAAK,qBAAqB,EAG1B,MAAM,iBAAiB,CAAC;AAIzB,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAM7E,qBAAa,MAAM,CAAC,SAAS,SAAS,eAAe,GAAG,eAAe;IACtE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,yFAAyF;IACzF,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAE/B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAwB;IAC7C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA4B;IACtD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAS;IAC5C,OAAO,CAAC,QAAQ,CAAC,wBAAwB,CAAwC;IACjF,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuC;IAC/D,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA8B;IAC1D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA2B;IACpD,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,YAAY,CAAC,CAAgB;IACrC,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,YAAY,CAA4B;IAChD,OAAO,CAAC,aAAa,CAAc;IACnC,OAAO,CAAC,YAAY,CAAC,CAAgB;IACrC,OAAO,CAAC,OAAO,CAAS;IAExB,YAAY,IAAI,EAAE,UAAU,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,aAAa,EA0B9D;IAED,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAMrB;YAEa,aAAa;IAiC3B,MAAM,CAAC,UAAU,EAAE,cAAc,GAAG,qBAAqB,CAsCxD;IAEK,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAK3B;YAEa,aAAa;IAyB3B,OAAO,CAAC,OAAO;IAef,OAAO,CAAC,eAAe;YAuCT,eAAe;IAoC7B,OAAO,CAAC,YAAY;YAQN,aAAa;IAoG3B,OAAO,CAAC,eAAe;IAWvB,OAAO,CAAC,UAAU;YAqBJ,iBAAiB;YAcjB,WAAW;YAsBX,YAAY;YAeZ,gBAAgB;YAehB,eAAe;IAQ7B,OAAO,CAAC,eAAe;IAWvB,OAAO,CAAC,4BAA4B;IAQpC,OAAO,CAAC,WAAW;IAQnB,OAAO,CAAC,YAAY;CAMpB"}