@codex-app-sdk/web 0.0.0-stage → 0.14.1

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,3 +1,28 @@
-# Temporary Holding Version
+# `@codex-app-sdk/web`
 
-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.
+Framework-neutral WebSocket transport for browser Codex surfaces.
+
+```bash
+npm install @codex-app-sdk/core @codex-app-sdk/web
+```
+
+- `@codex-app-sdk/web/client` creates a reconnecting browser-side
+  `CodexSurfaceRendererApi`.
+- `@codex-app-sdk/web/server` binds an already accepted socket to a
+  host-authorized surface lease.
+- `@codex-app-sdk/web/protocol` exports versioned envelopes for custom
+  transport integrations.
+
+Both endpoints default to a 64 MiB message ceiling. The server adapter can wrap
+the EventEmitter-style subset implemented by `ws`, or the host can implement
+`CodexWebSocketPort` for another library.
+
+The package does not create an HTTP server, parse cookies, authenticate users,
+store tokens, manage `codexHome` directories, pool app-server processes, create
+upload routes, or depend on Express or a WebSocket implementation. Those are
+host-application responsibilities.
+
+See the [web integration
+guide](https://codex-app-sdk.github.io/codex-app-sdk/guide/web.html), [web
+API](https://codex-app-sdk.github.io/codex-app-sdk/api/web.html), and [Basic Express
+sample](https://github.com/codex-app-sdk/codex-app-sdk/tree/main/samples/web/basic).

package/dist/chunks/socket-port-QOPQStPy.js

@@ -0,0 +1,20 @@
+//#region src/socket-port.ts
+var e = 64 * 1024 * 1024;
+function t(e, t) {
+	let n;
+	if (typeof e == "string") n = e;
+	else if (e instanceof ArrayBuffer) n = new TextDecoder().decode(e);
+	else if (ArrayBuffer.isView(e)) n = new TextDecoder().decode(e);
+	else throw TypeError("Codex WebSocket messages must contain text or UTF-8 bytes");
+	if (new TextEncoder().encode(n).byteLength > t) throw RangeError(`Codex WebSocket message exceeds the ${t} byte limit`);
+	return n;
+}
+function n(e, t, n) {
+	if (e === void 0) return t;
+	if (!Number.isSafeInteger(e) || e <= 0) throw TypeError(`${n} must be a positive integer`);
+	return e;
+}
+//#endregion
+export { e as n, n as r, t };
+
+//# sourceMappingURL=socket-port-QOPQStPy.js.map

package/dist/chunks/socket-port-QOPQStPy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"socket-port-QOPQStPy.js","names":[],"sources":["../../src/socket-port.ts"],"sourcesContent":["export type CodexWebSocketClose = {\n  code?: number;\n  reason?: string;\n  wasClean?: boolean;\n};\n\n/** Minimal socket seam implemented by browser WebSocket, `ws`, or another host adapter. */\nexport type CodexWebSocketPort = {\n  send(data: string): void;\n  close(code?: number, reason?: string): void;\n  onMessage(listener: (data: unknown) => void): () => void;\n  onClose(listener: (event: CodexWebSocketClose) => void): () => void;\n  onError?(listener: (error: unknown) => void): () => void;\n};\n\nexport const defaultCodexWebSocketMaximumMessageBytes = 64 * 1024 * 1024;\n\nexport function codexWebSocketText(data: unknown, maximumBytes: number): string {\n  let value: string;\n  if (typeof data === 'string') {\n    value = data;\n  } else if (data instanceof ArrayBuffer) {\n    value = new TextDecoder().decode(data);\n  } else if (ArrayBuffer.isView(data)) {\n    value = new TextDecoder().decode(data);\n  } else {\n    throw new TypeError('Codex WebSocket messages must contain text or UTF-8 bytes');\n  }\n  if (new TextEncoder().encode(value).byteLength > maximumBytes) {\n    throw new RangeError(`Codex WebSocket message exceeds the ${maximumBytes} byte limit`);\n  }\n  return value;\n}\n\nexport function positiveWebSocketLimit(\n  value: number | undefined,\n  fallback: number,\n  label: string,\n): number {\n  if (value === undefined) return fallback;\n  if (!Number.isSafeInteger(value) || value <= 0) throw new TypeError(`${label} must be a positive integer`);\n  return value;\n}\n"],"mappings":";AAeA,IAAa,IAA2C,KAAK,OAAO;AAEpE,SAAgB,EAAmB,GAAe,GAA8B;CAC9E,IAAI;CACJ,IAAI,OAAO,KAAS,UAClB,IAAQ;MACH,IAAI,aAAgB,aACzB,IAAQ,IAAI,YAAY,CAAC,CAAC,OAAO,CAAI;MAChC,IAAI,YAAY,OAAO,CAAI,GAChC,IAAQ,IAAI,YAAY,CAAC,CAAC,OAAO,CAAI;MAErC,MAAU,UAAU,2DAA2D;CAEjF,IAAI,IAAI,YAAY,CAAC,CAAC,OAAO,CAAK,CAAC,CAAC,aAAa,GAC/C,MAAU,WAAW,uCAAuC,EAAa,YAAY;CAEvF,OAAO;AACT;AAEA,SAAgB,EACd,GACA,GACA,GACQ;CACR,IAAI,MAAU,KAAA,GAAW,OAAO;CAChC,IAAI,CAAC,OAAO,cAAc,CAAK,KAAK,KAAS,GAAG,MAAU,UAAU,GAAG,EAAM,4BAA4B;CACzG,OAAO;AACT"}

package/dist/client.d.ts

@@ -0,0 +1,31 @@
+import type { CodexSurfaceRendererApi } from '@codex-app-sdk/core/surface';
+import { type CodexWebSocketErrorPayload } from './protocol';
+import { type CodexWebSocketPort } from './socket-port';
+type Awaitable<Value> = Value | Promise<Value>;
+export type CodexWebReconnectOptions = {
+    maxAttempts?: number;
+    initialDelayMs?: number;
+    maximumDelayMs?: number;
+};
+export type CreateCodexWebSurfaceClientOptions = {
+    createSocket(): Awaitable<CodexWebSocketPort>;
+    maxMessageBytes?: number;
+    reconnect?: boolean | CodexWebReconnectOptions;
+    requestTimeoutMs?: number;
+};
+export type CodexWebSurfaceClientConnectionState = 'closed' | 'connecting' | 'disconnected' | 'ready';
+export type CodexWebSurfaceClient = CodexSurfaceRendererApi & {
+    disconnect(code?: number, reason?: string): void;
+    getConnectionState(): CodexWebSurfaceClientConnectionState;
+};
+export declare class CodexWebSocketRemoteError extends Error {
+    readonly code: CodexWebSocketErrorPayload['code'];
+    constructor(error: CodexWebSocketErrorPayload);
+}
+export declare class CodexWebSocketTransportError extends Error {
+    constructor(message: string);
+}
+export declare function createCodexWebSurfaceClient(options: CreateCodexWebSurfaceClientOptions): CodexWebSurfaceClient;
+export declare function createCodexBrowserWebSocketPort(socket: WebSocket): CodexWebSocketPort;
+export type { CodexWebSocketClose, CodexWebSocketPort, } from './socket-port';
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAEV,uBAAuB,EAGxB,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,KAAK,0BAA0B,EAChC,MAAM,YAAY,CAAC;AACpB,OAAO,EAKL,KAAK,kBAAkB,EACxB,MAAM,eAAe,CAAC;AAEvB,KAAK,SAAS,CAAC,KAAK,IAAI,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;AAE/C,MAAM,MAAM,wBAAwB,GAAG;IACrC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,kCAAkC,GAAG;IAC/C,YAAY,IAAI,SAAS,CAAC,kBAAkB,CAAC,CAAC;IAC9C,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,EAAE,OAAO,GAAG,wBAAwB,CAAC;IAC/C,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,oCAAoC,GAC5C,QAAQ,GACR,YAAY,GACZ,cAAc,GACd,OAAO,CAAC;AAEZ,MAAM,MAAM,qBAAqB,GAAG,uBAAuB,GAAG;IAC5D,UAAU,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACjD,kBAAkB,IAAI,oCAAoC,CAAC;CAC5D,CAAC;AAEF,qBAAa,yBAA0B,SAAQ,KAAK;IAClD,QAAQ,CAAC,IAAI,EAAE,0BAA0B,CAAC,MAAM,CAAC,CAAC;gBAEtC,KAAK,EAAE,0BAA0B;CAK9C;AAED,qBAAa,4BAA6B,SAAQ,KAAK;gBACzC,OAAO,EAAE,MAAM;CAI5B;AAID,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,kCAAkC,GAC1C,qBAAqB,CAcvB;AAED,wBAAgB,+BAA+B,CAAC,MAAM,EAAE,SAAS,GAAG,kBAAkB,CAYrF;AAuXD,YAAY,EACV,mBAAmB,EACnB,kBAAkB,GACnB,MAAM,eAAe,CAAC"}

package/dist/client.js

@@ -0,0 +1,289 @@
+import { encodeCodexWebSocketMessage as e } from "./protocol.js";
+import { n as t, r as n, t as r } from "./chunks/socket-port-QOPQStPy.js";
+import { codexSurfaceBridgeOperations as i, createCodexSurfaceStateMirror as a } from "@codex-app-sdk/core/surface-bridge";
+//#region src/client.ts
+var o = class extends Error {
+	code;
+	constructor(e) {
+		super(e.message), this.name = "CodexWebSocketRemoteError", this.code = e.code;
+	}
+}, s = class extends Error {
+	constructor(e) {
+		super(e), this.name = "CodexWebSocketTransportError";
+	}
+}, c = 6e4;
+function l(e) {
+	let t = new d(e), n = {
+		disconnect: (e, n) => t.disconnect(e, n),
+		getConnectionState: () => t.connectionState,
+		onEvent: (e) => t.onEvent(e),
+		onStateChange: (e) => t.onStateChange(e)
+	};
+	for (let e of i) n[e] = e === "connect" ? () => t.connect() : (...n) => t.invoke(e, n);
+	return Object.freeze(n);
+}
+function u(e) {
+	return {
+		send: (t) => e.send(t),
+		close: (t, n) => e.close(t, n),
+		onMessage: (t) => f(e, "message", (e) => t(e.data)),
+		onClose: (t) => f(e, "close", (e) => t({
+			code: e.code,
+			reason: e.reason,
+			wasClean: e.wasClean
+		})),
+		onError: (t) => f(e, "error", t)
+	};
+}
+var d = class {
+	#e;
+	#t;
+	#n;
+	#r;
+	#i = /* @__PURE__ */ new Set();
+	#a = /* @__PURE__ */ new Set();
+	#o = /* @__PURE__ */ new Map();
+	#s = [];
+	#c = null;
+	#l = null;
+	#u = null;
+	#d = null;
+	#f = a();
+	#p = !1;
+	#m = 0;
+	#h = !1;
+	#g = 0;
+	#_ = null;
+	connectionState = "disconnected";
+	constructor(e) {
+		this.#e = e.createSocket, this.#t = n(e.maxMessageBytes, t, "Codex WebSocket message byte limit"), this.#n = n(e.requestTimeoutMs, c, "Codex WebSocket request timeout"), this.#r = p(e.reconnect);
+	}
+	connect() {
+		return this.#h = !1, this.#O(), this.connectionState === "ready" && this.#d ? Promise.resolve(this.#d) : this.#v();
+	}
+	async invoke(t, n) {
+		await this.connect();
+		let r = this.#c;
+		if (!r || this.connectionState !== "ready") throw new s("Codex WebSocket is not connected");
+		let i = g(++this.#m), a = new Promise((e, n) => {
+			let r = setTimeout(() => {
+				this.#o.delete(i), n(new o({
+					code: "request_timeout",
+					message: `Codex WebSocket request '${t}' timed out`
+				}));
+			}, this.#n);
+			this.#o.set(i, {
+				resolve: e,
+				reject: n,
+				timeout: r
+			});
+		});
+		try {
+			r.send(e({
+				version: 1,
+				type: "request",
+				id: i,
+				operation: t,
+				args: _(n)
+			}));
+		} catch (e) {
+			this.#E(i, S(e));
+		}
+		return a;
+	}
+	onStateChange(e) {
+		return this.#i.add(e), () => this.#i.delete(e);
+	}
+	onEvent(e) {
+		return this.#a.add(e), () => this.#a.delete(e);
+	}
+	disconnect(e = 1e3, t = "Codex web client disconnected") {
+		this.#h = !0, this.#O();
+		let n = this.#c;
+		n && n.close(e, t), this.#S({
+			code: e,
+			reason: t,
+			wasClean: !0
+		}, n), this.connectionState = "closed";
+	}
+	#v() {
+		if (this.#l) return this.#l;
+		this.connectionState = "connecting";
+		let e = this.#y();
+		return this.#l = e, e.finally(() => {
+			this.#l === e && (this.#l = null);
+		}).catch(() => void 0), e;
+	}
+	async #y() {
+		let e;
+		try {
+			e = await this.#e();
+		} catch (e) {
+			throw this.connectionState = "disconnected", this.#D(), S(e);
+		}
+		if (this.#h) throw e.close(1e3, "Codex web client is closed"), new s("Codex web client is closed");
+		return this.#b(e), new Promise((t, n) => {
+			this.#u = {
+				socket: e,
+				resolve: t,
+				reject: n
+			};
+		});
+	}
+	#b(e) {
+		this.#k(), this.#c = e, this.#s.push(e.onMessage((t) => this.#x(t, e)), e.onClose((t) => this.#S(t, e))), e.onError && this.#s.push(e.onError((t) => {
+			this.#S({
+				reason: C(t),
+				wasClean: !1
+			}, e);
+		}));
+	}
+	#x(e, t) {
+		if (t !== this.#c || this.#h) return;
+		let n;
+		try {
+			let t = JSON.parse(r(e, this.#t));
+			if (!v(t) || t.version !== 1) throw TypeError("Invalid Codex WebSocket response");
+			n = t;
+		} catch (e) {
+			t.close(4400, "Invalid Codex WebSocket response"), this.#S({
+				code: 4400,
+				reason: C(e)
+			}, t);
+			return;
+		}
+		if (n.type === "ready" && v(n.snapshot) && y(n.stateVersion)) {
+			let e = this.#C(n.snapshot, n.stateVersion);
+			this.#p = !1, this.connectionState = "ready", this.#g = 0, this.#T(e);
+			let r = this.#u;
+			this.#u = null, r?.socket === t && r.resolve(e), n.stateVersion !== void 0 && this.#w(t);
+			return;
+		}
+		if (n.type === "snapshot" && v(n.snapshot) && y(n.stateVersion)) {
+			this.#T(this.#C(n.snapshot, n.stateVersion));
+			return;
+		}
+		if (n.type === "statePatch" && this.#p && b(n.patch)) {
+			let e = this.#f.receive(n.patch);
+			e.status === "applied" ? (this.#d = e.snapshot, this.#T(e.snapshot)) : e.status === "resync" && (t.close(4001, "Codex state stream desynchronized"), this.#S({
+				code: 4001,
+				reason: "Codex state stream desynchronized"
+			}, t));
+			return;
+		}
+		if (n.type === "event" && v(n.event)) {
+			for (let e of this.#a) e(n.event);
+			return;
+		}
+		if (n.type === "response" && typeof n.id == "string" && typeof n.ok == "boolean") {
+			let e = this.#o.get(n.id);
+			if (!e) return;
+			this.#o.delete(n.id), clearTimeout(e.timeout), n.ok ? e.resolve(n.result) : x(n.error) ? e.reject(new o(n.error)) : e.reject(new s("Codex WebSocket returned an invalid error"));
+			return;
+		}
+		t.close(4400, "Invalid Codex WebSocket response"), this.#S({
+			code: 4400,
+			reason: "Invalid Codex WebSocket response"
+		}, t);
+	}
+	#S(e, t) {
+		if (t && t !== this.#c) return;
+		t === this.#c && (this.#c = null), this.#k();
+		let n = new s(e.reason?.trim() || `Codex WebSocket closed${e.code ? ` (${e.code})` : ""}`), r = this.#u;
+		this.#u = null, r && (!t || r.socket === t) && r.reject(n);
+		for (let e of [...this.#o.keys()]) this.#E(e, n);
+		if (this.#h) {
+			this.connectionState = "closed";
+			return;
+		}
+		this.connectionState = "disconnected", h(e) && this.#D();
+	}
+	#C(e, t) {
+		let n = t === void 0 ? e : this.#f.reset({
+			version: t,
+			snapshot: e
+		});
+		return this.#d = n, n;
+	}
+	#w(t) {
+		try {
+			t.send(e({
+				version: 1,
+				type: "enableStatePatches"
+			})), this.#p = !0;
+		} catch {}
+	}
+	#T(e) {
+		for (let t of this.#i) t(e);
+	}
+	#E(e, t) {
+		let n = this.#o.get(e);
+		n && (this.#o.delete(e), clearTimeout(n.timeout), n.reject(t));
+	}
+	#D() {
+		let e = this.#r;
+		if (!e || this.#h || this.#_ || this.#g >= e.maxAttempts) return;
+		let t = Math.min(e.initialDelayMs * 2 ** this.#g, e.maximumDelayMs);
+		this.#g += 1, this.#_ = setTimeout(() => {
+			this.#_ = null, this.#v().catch(() => void 0);
+		}, t);
+	}
+	#O() {
+		this.#_ &&= (clearTimeout(this.#_), null);
+	}
+	#k() {
+		for (let e of this.#s.splice(0)) e();
+	}
+};
+function f(e, t, n) {
+	return e.addEventListener(t, n), () => e.removeEventListener(t, n);
+}
+function p(e) {
+	if (!e) return null;
+	let t = e === !0 ? {} : e;
+	return {
+		maxAttempts: m(t.maxAttempts, 8, "Reconnect maximum attempts"),
+		initialDelayMs: n(t.initialDelayMs, 250, "Reconnect initial delay"),
+		maximumDelayMs: n(t.maximumDelayMs, 5e3, "Reconnect maximum delay")
+	};
+}
+function m(e, t, n) {
+	if (e === void 0) return t;
+	if (!Number.isSafeInteger(e) || e < 0) throw TypeError(`${n} must be a non-negative integer`);
+	return e;
+}
+function h(e) {
+	return e.code === 1e3 ? !1 : e.code === void 0 || e.code < 4400 || e.code > 4499;
+}
+function g(e) {
+	return `codex-${e}-${globalThis.crypto?.randomUUID?.() ?? Math.random().toString(36).slice(2)}`;
+}
+function _(e) {
+	let t = e.length;
+	for (; t > 0 && e[t - 1] === void 0;) --t;
+	return e.slice(0, t);
+}
+function v(e) {
+	if (!e || typeof e != "object" || Array.isArray(e)) return !1;
+	let t = Object.getPrototypeOf(e);
+	return t === Object.prototype || t === null;
+}
+function y(e) {
+	return e === void 0 || Number.isSafeInteger(e);
+}
+function b(e) {
+	return v(e) && Number.isSafeInteger(e.version) && Array.isArray(e.changes);
+}
+function x(e) {
+	return !v(e) || typeof e.message != "string" ? !1 : e.code === "invalid_request" || e.code === "operation_failed" || e.code === "request_timeout" || e.code === "transport_closed";
+}
+function S(e) {
+	return e instanceof s ? e : new s(C(e));
+}
+function C(e) {
+	return e instanceof Error ? e.message : String(e);
+}
+//#endregion
+export { o as CodexWebSocketRemoteError, s as CodexWebSocketTransportError, u as createCodexBrowserWebSocketPort, l as createCodexWebSurfaceClient };
+
+//# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","names":["#createSocket","#maxMessageBytes","#requestTimeoutMs","#reconnect","#stateListeners","#eventListeners","#pending","#socketUnsubscribers","#state","#manualClose","#clearReconnectTimer","#latestSnapshot","#beginConnect","#socket","#requestSequence","#rejectPending","#handleClose","#connectPromise","#open","#scheduleReconnect","#replaceSocket","#readyWaiter","#clearSocketListeners","#receive","#adoptSnapshot","#streamingPatches","#reconnectAttempts","#emitSnapshot","#enableStatePatches","#reconnectTimer"],"sources":["../src/client.ts"],"sourcesContent":["import {\n  codexSurfaceBridgeOperations,\n  type CodexSurfaceBridgeOperation,\n  type CodexSurfaceBridgeOperationArguments,\n  type CodexSurfaceBridgeOperationResult,\n} from '@codex-app-sdk/core/surface-bridge';\nimport type {\n  CodexSurfaceEvent,\n  CodexSurfaceRendererApi,\n  CodexSurfaceSnapshot,\n  CodexSurfaceStatePatch,\n} from '@codex-app-sdk/core/surface';\nimport { createCodexSurfaceStateMirror } from '@codex-app-sdk/core/surface-bridge';\nimport {\n  codexWebSocketProtocolVersion,\n  encodeCodexWebSocketMessage,\n  type CodexWebSocketErrorPayload,\n} from './protocol';\nimport {\n  codexWebSocketText,\n  defaultCodexWebSocketMaximumMessageBytes,\n  positiveWebSocketLimit,\n  type CodexWebSocketClose,\n  type CodexWebSocketPort,\n} from './socket-port';\n\ntype Awaitable<Value> = Value | Promise<Value>;\n\nexport type CodexWebReconnectOptions = {\n  maxAttempts?: number;\n  initialDelayMs?: number;\n  maximumDelayMs?: number;\n};\n\nexport type CreateCodexWebSurfaceClientOptions = {\n  createSocket(): Awaitable<CodexWebSocketPort>;\n  maxMessageBytes?: number;\n  reconnect?: boolean | CodexWebReconnectOptions;\n  requestTimeoutMs?: number;\n};\n\nexport type CodexWebSurfaceClientConnectionState =\n  | 'closed'\n  | 'connecting'\n  | 'disconnected'\n  | 'ready';\n\nexport type CodexWebSurfaceClient = CodexSurfaceRendererApi & {\n  disconnect(code?: number, reason?: string): void;\n  getConnectionState(): CodexWebSurfaceClientConnectionState;\n};\n\nexport class CodexWebSocketRemoteError extends Error {\n  readonly code: CodexWebSocketErrorPayload['code'];\n\n  constructor(error: CodexWebSocketErrorPayload) {\n    super(error.message);\n    this.name = 'CodexWebSocketRemoteError';\n    this.code = error.code;\n  }\n}\n\nexport class CodexWebSocketTransportError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'CodexWebSocketTransportError';\n  }\n}\n\nconst defaultRequestTimeoutMs = 60_000;\n\nexport function createCodexWebSurfaceClient(\n  options: CreateCodexWebSurfaceClientOptions,\n): CodexWebSurfaceClient {\n  const transport = new ClientTransport(options);\n  const api: Record<string, unknown> = {\n    disconnect: (code?: number, reason?: string) => transport.disconnect(code, reason),\n    getConnectionState: () => transport.connectionState,\n    onEvent: (listener: (event: CodexSurfaceEvent) => void) => transport.onEvent(listener),\n    onStateChange: (listener: (snapshot: CodexSurfaceSnapshot) => void) => transport.onStateChange(listener),\n  };\n  for (const operation of codexSurfaceBridgeOperations) {\n    api[operation] = operation === 'connect'\n      ? () => transport.connect()\n      : (...args: unknown[]) => transport.invoke(operation, args);\n  }\n  return Object.freeze(api) as CodexWebSurfaceClient;\n}\n\nexport function createCodexBrowserWebSocketPort(socket: WebSocket): CodexWebSocketPort {\n  return {\n    send: (data) => socket.send(data),\n    close: (code, reason) => socket.close(code, reason),\n    onMessage: (listener) => listenBrowserSocket(socket, 'message', (event) => listener(event.data)),\n    onClose: (listener) => listenBrowserSocket(socket, 'close', (event) => listener({\n      code: event.code,\n      reason: event.reason,\n      wasClean: event.wasClean,\n    })),\n    onError: (listener) => listenBrowserSocket(socket, 'error', listener),\n  };\n}\n\nclass ClientTransport {\n  readonly #createSocket: CreateCodexWebSurfaceClientOptions['createSocket'];\n  readonly #maxMessageBytes: number;\n  readonly #requestTimeoutMs: number;\n  readonly #reconnect: Required<CodexWebReconnectOptions> | null;\n  readonly #stateListeners = new Set<(snapshot: CodexSurfaceSnapshot) => void>();\n  readonly #eventListeners = new Set<(event: CodexSurfaceEvent) => void>();\n  readonly #pending = new Map<string, PendingRequest>();\n  readonly #socketUnsubscribers: Array<() => void> = [];\n  #socket: CodexWebSocketPort | null = null;\n  #connectPromise: Promise<CodexSurfaceSnapshot> | null = null;\n  #readyWaiter: ReadyWaiter | null = null;\n  #latestSnapshot: CodexSurfaceSnapshot | null = null;\n  readonly #state = createCodexSurfaceStateMirror();\n  #streamingPatches = false;\n  #requestSequence = 0;\n  #manualClose = false;\n  #reconnectAttempts = 0;\n  #reconnectTimer: ReturnType<typeof setTimeout> | null = null;\n  connectionState: CodexWebSurfaceClientConnectionState = 'disconnected';\n\n  constructor(options: CreateCodexWebSurfaceClientOptions) {\n    this.#createSocket = options.createSocket;\n    this.#maxMessageBytes = positiveWebSocketLimit(\n      options.maxMessageBytes,\n      defaultCodexWebSocketMaximumMessageBytes,\n      'Codex WebSocket message byte limit',\n    );\n    this.#requestTimeoutMs = positiveWebSocketLimit(\n      options.requestTimeoutMs,\n      defaultRequestTimeoutMs,\n      'Codex WebSocket request timeout',\n    );\n    this.#reconnect = reconnectOptions(options.reconnect);\n  }\n\n  connect(): Promise<CodexSurfaceSnapshot> {\n    this.#manualClose = false;\n    this.#clearReconnectTimer();\n    if (this.connectionState === 'ready' && this.#latestSnapshot) {\n      return Promise.resolve(this.#latestSnapshot);\n    }\n    return this.#beginConnect();\n  }\n\n  async invoke<Name extends CodexSurfaceBridgeOperation>(\n    operation: Name,\n    args: readonly unknown[],\n  ): Promise<CodexSurfaceBridgeOperationResult<Name>> {\n    await this.connect();\n    const socket = this.#socket;\n    if (!socket || this.connectionState !== 'ready') {\n      throw new CodexWebSocketTransportError('Codex WebSocket is not connected');\n    }\n    const id = requestId(++this.#requestSequence);\n    const result = new Promise<CodexSurfaceBridgeOperationResult<Name>>((resolve, reject) => {\n      const timeout = setTimeout(() => {\n        this.#pending.delete(id);\n        reject(new CodexWebSocketRemoteError({\n          code: 'request_timeout',\n          message: `Codex WebSocket request '${operation}' timed out`,\n        }));\n      }, this.#requestTimeoutMs);\n      this.#pending.set(id, {\n        resolve: resolve as (value: unknown) => void,\n        reject,\n        timeout,\n      });\n    });\n    try {\n      socket.send(encodeCodexWebSocketMessage({\n        version: codexWebSocketProtocolVersion,\n        type: 'request',\n        id,\n        operation,\n        args: webSocketArguments(args) as CodexSurfaceBridgeOperationArguments<Name>,\n      }));\n    } catch (error) {\n      this.#rejectPending(id, transportError(error));\n    }\n    return result;\n  }\n\n  onStateChange(listener: (snapshot: CodexSurfaceSnapshot) => void): () => void {\n    this.#stateListeners.add(listener);\n    return () => this.#stateListeners.delete(listener);\n  }\n\n  onEvent(listener: (event: CodexSurfaceEvent) => void): () => void {\n    this.#eventListeners.add(listener);\n    return () => this.#eventListeners.delete(listener);\n  }\n\n  disconnect(code = 1000, reason = 'Codex web client disconnected'): void {\n    this.#manualClose = true;\n    this.#clearReconnectTimer();\n    const socket = this.#socket;\n    if (socket) socket.close(code, reason);\n    this.#handleClose({ code, reason, wasClean: true }, socket);\n    this.connectionState = 'closed';\n  }\n\n  #beginConnect(): Promise<CodexSurfaceSnapshot> {\n    if (this.#connectPromise) return this.#connectPromise;\n    this.connectionState = 'connecting';\n    const connecting = this.#open();\n    this.#connectPromise = connecting;\n    void connecting.finally(() => {\n      if (this.#connectPromise === connecting) this.#connectPromise = null;\n    }).catch(() => undefined);\n    return connecting;\n  }\n\n  async #open(): Promise<CodexSurfaceSnapshot> {\n    let socket: CodexWebSocketPort;\n    try {\n      socket = await this.#createSocket();\n    } catch (error) {\n      this.connectionState = 'disconnected';\n      this.#scheduleReconnect();\n      throw transportError(error);\n    }\n    if (this.#manualClose) {\n      socket.close(1000, 'Codex web client is closed');\n      throw new CodexWebSocketTransportError('Codex web client is closed');\n    }\n    this.#replaceSocket(socket);\n    return new Promise<CodexSurfaceSnapshot>((resolve, reject) => {\n      this.#readyWaiter = { socket, resolve, reject };\n    });\n  }\n\n  #replaceSocket(socket: CodexWebSocketPort): void {\n    this.#clearSocketListeners();\n    this.#socket = socket;\n    this.#socketUnsubscribers.push(\n      socket.onMessage((data) => this.#receive(data, socket)),\n      socket.onClose((close) => this.#handleClose(close, socket)),\n    );\n    if (socket.onError) {\n      this.#socketUnsubscribers.push(socket.onError((error) => {\n        this.#handleClose({ reason: errorMessage(error), wasClean: false }, socket);\n      }));\n    }\n  }\n\n  #receive(data: unknown, socket: CodexWebSocketPort): void {\n    if (socket !== this.#socket || this.#manualClose) return;\n    let message: Record<string, unknown>;\n    try {\n      const value = JSON.parse(codexWebSocketText(data, this.#maxMessageBytes)) as unknown;\n      if (!isPlainObject(value) || value.version !== codexWebSocketProtocolVersion) {\n        throw new TypeError('Invalid Codex WebSocket response');\n      }\n      message = value;\n    } catch (error) {\n      socket.close(4400, 'Invalid Codex WebSocket response');\n      this.#handleClose({ code: 4400, reason: errorMessage(error) }, socket);\n      return;\n    }\n\n    if (message.type === 'ready' && isPlainObject(message.snapshot) && isOptionalStateVersion(message.stateVersion)) {\n      const snapshot = this.#adoptSnapshot(message.snapshot as CodexSurfaceSnapshot, message.stateVersion);\n      this.#streamingPatches = false;\n      this.connectionState = 'ready';\n      this.#reconnectAttempts = 0;\n      this.#emitSnapshot(snapshot);\n      const waiter = this.#readyWaiter;\n      this.#readyWaiter = null;\n      if (waiter?.socket === socket) waiter.resolve(snapshot);\n      // Servers that can stream patches advertise a state version; older ones keep sending snapshots.\n      if (message.stateVersion !== undefined) this.#enableStatePatches(socket);\n      return;\n    }\n    if (message.type === 'snapshot' && isPlainObject(message.snapshot) && isOptionalStateVersion(message.stateVersion)) {\n      this.#emitSnapshot(this.#adoptSnapshot(message.snapshot as CodexSurfaceSnapshot, message.stateVersion));\n      return;\n    }\n    if (message.type === 'statePatch' && this.#streamingPatches && isStatePatch(message.patch)) {\n      const result = this.#state.receive(message.patch);\n      if (result.status === 'applied') {\n        this.#latestSnapshot = result.snapshot;\n        this.#emitSnapshot(result.snapshot);\n      } else if (result.status === 'resync') {\n        // A fresh connection starts from a new versioned snapshot.\n        socket.close(4001, 'Codex state stream desynchronized');\n        this.#handleClose({ code: 4001, reason: 'Codex state stream desynchronized' }, socket);\n      }\n      return;\n    }\n    if (message.type === 'event' && isPlainObject(message.event)) {\n      for (const listener of this.#eventListeners) listener(message.event as CodexSurfaceEvent);\n      return;\n    }\n    if (message.type === 'response' && typeof message.id === 'string' && typeof message.ok === 'boolean') {\n      const pending = this.#pending.get(message.id);\n      if (!pending) return;\n      this.#pending.delete(message.id);\n      clearTimeout(pending.timeout);\n      if (message.ok) {\n        pending.resolve(message.result);\n      } else if (isRemoteError(message.error)) {\n        pending.reject(new CodexWebSocketRemoteError(message.error));\n      } else {\n        pending.reject(new CodexWebSocketTransportError('Codex WebSocket returned an invalid error'));\n      }\n      return;\n    }\n    socket.close(4400, 'Invalid Codex WebSocket response');\n    this.#handleClose({ code: 4400, reason: 'Invalid Codex WebSocket response' }, socket);\n  }\n\n  #handleClose(close: CodexWebSocketClose, socket: CodexWebSocketPort | null): void {\n    if (socket && socket !== this.#socket) return;\n    if (socket === this.#socket) this.#socket = null;\n    this.#clearSocketListeners();\n    const error = new CodexWebSocketTransportError(\n      close.reason?.trim() || `Codex WebSocket closed${close.code ? ` (${close.code})` : ''}`,\n    );\n    const waiter = this.#readyWaiter;\n    this.#readyWaiter = null;\n    if (waiter && (!socket || waiter.socket === socket)) waiter.reject(error);\n    for (const id of [...this.#pending.keys()]) this.#rejectPending(id, error);\n    if (this.#manualClose) {\n      this.connectionState = 'closed';\n      return;\n    }\n    this.connectionState = 'disconnected';\n    if (shouldReconnect(close)) this.#scheduleReconnect();\n  }\n\n  #adoptSnapshot(snapshot: CodexSurfaceSnapshot, stateVersion: number | undefined): CodexSurfaceSnapshot {\n    const adopted = stateVersion === undefined\n      ? snapshot\n      : this.#state.reset({ version: stateVersion, snapshot });\n    this.#latestSnapshot = adopted;\n    return adopted;\n  }\n\n  #enableStatePatches(socket: CodexWebSocketPort): void {\n    try {\n      socket.send(encodeCodexWebSocketMessage({ version: codexWebSocketProtocolVersion, type: 'enableStatePatches' }));\n      this.#streamingPatches = true;\n    } catch {\n      // The session simply stays on snapshots.\n    }\n  }\n\n  #emitSnapshot(snapshot: CodexSurfaceSnapshot): void {\n    for (const listener of this.#stateListeners) listener(snapshot);\n  }\n\n  #rejectPending(id: string, error: Error): void {\n    const pending = this.#pending.get(id);\n    if (!pending) return;\n    this.#pending.delete(id);\n    clearTimeout(pending.timeout);\n    pending.reject(error);\n  }\n\n  #scheduleReconnect(): void {\n    const options = this.#reconnect;\n    if (!options || this.#manualClose || this.#reconnectTimer) return;\n    if (this.#reconnectAttempts >= options.maxAttempts) return;\n    const delay = Math.min(\n      options.initialDelayMs * (2 ** this.#reconnectAttempts),\n      options.maximumDelayMs,\n    );\n    this.#reconnectAttempts += 1;\n    this.#reconnectTimer = setTimeout(() => {\n      this.#reconnectTimer = null;\n      void this.#beginConnect().catch(() => undefined);\n    }, delay);\n  }\n\n  #clearReconnectTimer(): void {\n    if (!this.#reconnectTimer) return;\n    clearTimeout(this.#reconnectTimer);\n    this.#reconnectTimer = null;\n  }\n\n  #clearSocketListeners(): void {\n    for (const unsubscribe of this.#socketUnsubscribers.splice(0)) unsubscribe();\n  }\n}\n\ntype PendingRequest = {\n  resolve(value: unknown): void;\n  reject(error: unknown): void;\n  timeout: ReturnType<typeof setTimeout>;\n};\n\ntype ReadyWaiter = {\n  socket: CodexWebSocketPort;\n  resolve(snapshot: CodexSurfaceSnapshot): void;\n  reject(error: unknown): void;\n};\n\nfunction listenBrowserSocket<Type extends keyof WebSocketEventMap>(\n  socket: WebSocket,\n  type: Type,\n  listener: (event: WebSocketEventMap[Type]) => void,\n): () => void {\n  socket.addEventListener(type, listener);\n  return () => socket.removeEventListener(type, listener);\n}\n\nfunction reconnectOptions(\n  value: CreateCodexWebSurfaceClientOptions['reconnect'],\n): Required<CodexWebReconnectOptions> | null {\n  if (!value) return null;\n  const options = value === true ? {} : value;\n  return {\n    maxAttempts: nonNegativeInteger(options.maxAttempts, 8, 'Reconnect maximum attempts'),\n    initialDelayMs: positiveWebSocketLimit(options.initialDelayMs, 250, 'Reconnect initial delay'),\n    maximumDelayMs: positiveWebSocketLimit(options.maximumDelayMs, 5_000, 'Reconnect maximum delay'),\n  };\n}\n\nfunction nonNegativeInteger(value: number | undefined, fallback: number, label: string): number {\n  if (value === undefined) return fallback;\n  if (!Number.isSafeInteger(value) || value < 0) throw new TypeError(`${label} must be a non-negative integer`);\n  return value;\n}\n\nfunction shouldReconnect(close: CodexWebSocketClose): boolean {\n  if (close.code === 1000) return false;\n  return close.code === undefined || close.code < 4400 || close.code > 4499;\n}\n\nfunction requestId(sequence: number): string {\n  const random = globalThis.crypto?.randomUUID?.() ?? Math.random().toString(36).slice(2);\n  return `codex-${sequence}-${random}`;\n}\n\nfunction webSocketArguments(args: readonly unknown[]): unknown[] {\n  let length = args.length;\n  while (length > 0 && args[length - 1] === undefined) length -= 1;\n  return args.slice(0, length);\n}\n\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;\n  const prototype = Object.getPrototypeOf(value) as object | null;\n  return prototype === Object.prototype || prototype === null;\n}\n\nfunction isOptionalStateVersion(value: unknown): value is number | undefined {\n  return value === undefined || Number.isSafeInteger(value);\n}\n\nfunction isStatePatch(value: unknown): value is CodexSurfaceStatePatch {\n  return isPlainObject(value) && Number.isSafeInteger(value.version) && Array.isArray(value.changes);\n}\n\nfunction isRemoteError(value: unknown): value is CodexWebSocketErrorPayload {\n  if (!isPlainObject(value) || typeof value.message !== 'string') return false;\n  return value.code === 'invalid_request'\n    || value.code === 'operation_failed'\n    || value.code === 'request_timeout'\n    || value.code === 'transport_closed';\n}\n\nfunction transportError(error: unknown): CodexWebSocketTransportError {\n  return error instanceof CodexWebSocketTransportError\n    ? error\n    : new CodexWebSocketTransportError(errorMessage(error));\n}\n\nfunction errorMessage(error: unknown): string {\n  return error instanceof Error ? error.message : String(error);\n}\n\nexport type {\n  CodexWebSocketClose,\n  CodexWebSocketPort,\n} from './socket-port';\n"],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { createCodexBrowserWebSocketPort, createCodexWebSurfaceClient, CodexWebSocketRemoteError, CodexWebSocketTransportError, type CodexWebReconnectOptions, type CodexWebSocketClose, type CodexWebSocketPort, type CodexWebSurfaceClient, type CodexWebSurfaceClientConnectionState, type CreateCodexWebSurfaceClientOptions, } from './client';
+export { bindCodexWebSocket, createCodexNodeWebSocketPort, isAllowedCodexWebSocketOrigin, type BindCodexWebSocketOptions, type CodexWebSocketBinding, type CodexNodeWebSocketLike, type CodexWebSocketSessionLease, type CodexWebSocketSessionRelease, type CodexWebSocketUpgradeRequest, } from './server';
+export { codexWebSocketProtocolVersion, encodeCodexWebSocketMessage, type CodexWebSocketClientMessage, type CodexWebSocketErrorPayload, type CodexWebSocketEvent, type CodexWebSocketFailure, type CodexWebSocketReady, type CodexWebSocketRequest, type CodexWebSocketServerMessage, type CodexWebSocketEnableStatePatches, type CodexWebSocketSnapshot, type CodexWebSocketStatePatch, type CodexWebSocketSuccess, } from './protocol';
+//# 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,OAAO,EACL,+BAA+B,EAC/B,2BAA2B,EAC3B,yBAAyB,EACzB,4BAA4B,EAC5B,KAAK,wBAAwB,EAC7B,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,qBAAqB,EAC1B,KAAK,oCAAoC,EACzC,KAAK,kCAAkC,GACxC,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,kBAAkB,EAClB,4BAA4B,EAC5B,6BAA6B,EAC7B,KAAK,yBAAyB,EAC9B,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,EAC3B,KAAK,0BAA0B,EAC/B,KAAK,4BAA4B,EACjC,KAAK,4BAA4B,GAClC,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,6BAA6B,EAC7B,2BAA2B,EAC3B,KAAK,2BAA2B,EAChC,KAAK,0BAA0B,EAC/B,KAAK,mBAAmB,EACxB,KAAK,qBAAqB,EAC1B,KAAK,mBAAmB,EACxB,KAAK,qBAAqB,EAC1B,KAAK,2BAA2B,EAChC,KAAK,gCAAgC,EACrC,KAAK,sBAAsB,EAC3B,KAAK,wBAAwB,EAC7B,KAAK,qBAAqB,GAC3B,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+import { codexWebSocketProtocolVersion as e, encodeCodexWebSocketMessage as t } from "./protocol.js";
+import { CodexWebSocketRemoteError as n, CodexWebSocketTransportError as r, createCodexBrowserWebSocketPort as i, createCodexWebSurfaceClient as a } from "./client.js";
+import { bindCodexWebSocket as o, createCodexNodeWebSocketPort as s, isAllowedCodexWebSocketOrigin as c } from "./server.js";
+export { n as CodexWebSocketRemoteError, r as CodexWebSocketTransportError, o as bindCodexWebSocket, e as codexWebSocketProtocolVersion, i as createCodexBrowserWebSocketPort, s as createCodexNodeWebSocketPort, a as createCodexWebSurfaceClient, t as encodeCodexWebSocketMessage, c as isAllowedCodexWebSocketOrigin };

package/dist/protocol.d.ts

@@ -0,0 +1,66 @@
+import type { CodexSurfaceBridgeOperation, CodexSurfaceBridgeOperationResult } from '@codex-app-sdk/core/surface-bridge';
+import type { CodexSurfaceEvent, CodexSurfaceSnapshot, CodexSurfaceStatePatch } from '@codex-app-sdk/core/surface';
+export declare const codexWebSocketProtocolVersion: 1;
+export type CodexWebSocketRequest = {
+    version: typeof codexWebSocketProtocolVersion;
+    type: 'request';
+    id: string;
+    operation: CodexSurfaceBridgeOperation;
+    args: unknown[];
+};
+export type CodexWebSocketReady = {
+    version: typeof codexWebSocketProtocolVersion;
+    type: 'ready';
+    snapshot: CodexSurfaceSnapshot;
+    /**
+     * Present when the server can stream state patches. A client that supports
+     * them answers with `enableStatePatches`; others ignore it and keep
+     * receiving `snapshot` messages.
+     */
+    stateVersion?: number;
+};
+export type CodexWebSocketSuccess<Name extends CodexSurfaceBridgeOperation = CodexSurfaceBridgeOperation> = {
+    version: typeof codexWebSocketProtocolVersion;
+    type: 'response';
+    id: string;
+    ok: true;
+    result: CodexSurfaceBridgeOperationResult<Name>;
+};
+export type CodexWebSocketErrorPayload = {
+    code: 'invalid_request' | 'operation_failed' | 'request_timeout' | 'transport_closed';
+    message: string;
+};
+export type CodexWebSocketFailure = {
+    version: typeof codexWebSocketProtocolVersion;
+    type: 'response';
+    id: string;
+    ok: false;
+    error: CodexWebSocketErrorPayload;
+};
+export type CodexWebSocketSnapshot = {
+    version: typeof codexWebSocketProtocolVersion;
+    type: 'snapshot';
+    snapshot: CodexSurfaceSnapshot;
+    /** Present on the base snapshot that starts a patch stream; patches continue from it. */
+    stateVersion?: number;
+};
+export type CodexWebSocketEvent = {
+    version: typeof codexWebSocketProtocolVersion;
+    type: 'event';
+    event: CodexSurfaceEvent;
+};
+/** Client opt-in, sent only after a `ready` that carries `stateVersion`. */
+export type CodexWebSocketEnableStatePatches = {
+    version: typeof codexWebSocketProtocolVersion;
+    type: 'enableStatePatches';
+};
+/** Sent instead of `snapshot` once a client has enabled state patches. */
+export type CodexWebSocketStatePatch = {
+    version: typeof codexWebSocketProtocolVersion;
+    type: 'statePatch';
+    patch: CodexSurfaceStatePatch;
+};
+export type CodexWebSocketClientMessage = CodexWebSocketRequest;
+export type CodexWebSocketServerMessage = CodexWebSocketReady | CodexWebSocketSuccess | CodexWebSocketFailure | CodexWebSocketSnapshot | CodexWebSocketEvent;
+export declare function encodeCodexWebSocketMessage(message: CodexWebSocketClientMessage | CodexWebSocketServerMessage | CodexWebSocketEnableStatePatches | CodexWebSocketStatePatch): string;
+//# sourceMappingURL=protocol.d.ts.map

package/dist/protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../src/protocol.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,2BAA2B,EAC3B,iCAAiC,EAClC,MAAM,oCAAoC,CAAC;AAC5C,OAAO,KAAK,EACV,iBAAiB,EACjB,oBAAoB,EACpB,sBAAsB,EACvB,MAAM,6BAA6B,CAAC;AAErC,eAAO,MAAM,6BAA6B,EAAG,CAAU,CAAC;AAExD,MAAM,MAAM,qBAAqB,GAAG;IAClC,OAAO,EAAE,OAAO,6BAA6B,CAAC;IAC9C,IAAI,EAAE,SAAS,CAAC;IAChB,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,2BAA2B,CAAC;IACvC,IAAI,EAAE,OAAO,EAAE,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,EAAE,OAAO,6BAA6B,CAAC;IAC9C,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,oBAAoB,CAAC;IAC/B;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,qBAAqB,CAAC,IAAI,SAAS,2BAA2B,GAAG,2BAA2B,IAAI;IAC1G,OAAO,EAAE,OAAO,6BAA6B,CAAC;IAC9C,IAAI,EAAE,UAAU,CAAC;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,IAAI,CAAC;IACT,MAAM,EAAE,iCAAiC,CAAC,IAAI,CAAC,CAAC;CACjD,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG;IACvC,IAAI,EAAE,iBAAiB,GAAG,kBAAkB,GAAG,iBAAiB,GAAG,kBAAkB,CAAC;IACtF,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,OAAO,EAAE,OAAO,6BAA6B,CAAC;IAC9C,IAAI,EAAE,UAAU,CAAC;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,KAAK,CAAC;IACV,KAAK,EAAE,0BAA0B,CAAC;CACnC,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,OAAO,EAAE,OAAO,6BAA6B,CAAC;IAC9C,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,EAAE,oBAAoB,CAAC;IAC/B,yFAAyF;IACzF,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,EAAE,OAAO,6BAA6B,CAAC;IAC9C,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,iBAAiB,CAAC;CAC1B,CAAC;AAEF,4EAA4E;AAC5E,MAAM,MAAM,gCAAgC,GAAG;IAC7C,OAAO,EAAE,OAAO,6BAA6B,CAAC;IAC9C,IAAI,EAAE,oBAAoB,CAAC;CAC5B,CAAC;AAEF,0EAA0E;AAC1E,MAAM,MAAM,wBAAwB,GAAG;IACrC,OAAO,EAAE,OAAO,6BAA6B,CAAC;IAC9C,IAAI,EAAE,YAAY,CAAC;IACnB,KAAK,EAAE,sBAAsB,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG,qBAAqB,CAAC;AAChE,MAAM,MAAM,2BAA2B,GACnC,mBAAmB,GACnB,qBAAqB,GACrB,qBAAqB,GACrB,sBAAsB,GACtB,mBAAmB,CAAC;AAExB,wBAAgB,2BAA2B,CACzC,OAAO,EACH,2BAA2B,GAC3B,2BAA2B,GAC3B,gCAAgC,GAChC,wBAAwB,GAC3B,MAAM,CAER"}

package/dist/protocol.js

@@ -0,0 +1,9 @@
+//#region src/protocol.ts
+var e = 1;
+function t(e) {
+	return JSON.stringify(e);
+}
+//#endregion
+export { e as codexWebSocketProtocolVersion, t as encodeCodexWebSocketMessage };
+
+//# sourceMappingURL=protocol.js.map

package/dist/protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.js","names":[],"sources":["../src/protocol.ts"],"sourcesContent":["import type {\n  CodexSurfaceBridgeOperation,\n  CodexSurfaceBridgeOperationResult,\n} from '@codex-app-sdk/core/surface-bridge';\nimport type {\n  CodexSurfaceEvent,\n  CodexSurfaceSnapshot,\n  CodexSurfaceStatePatch,\n} from '@codex-app-sdk/core/surface';\n\nexport const codexWebSocketProtocolVersion = 1 as const;\n\nexport type CodexWebSocketRequest = {\n  version: typeof codexWebSocketProtocolVersion;\n  type: 'request';\n  id: string;\n  operation: CodexSurfaceBridgeOperation;\n  args: unknown[];\n};\n\nexport type CodexWebSocketReady = {\n  version: typeof codexWebSocketProtocolVersion;\n  type: 'ready';\n  snapshot: CodexSurfaceSnapshot;\n  /**\n   * Present when the server can stream state patches. A client that supports\n   * them answers with `enableStatePatches`; others ignore it and keep\n   * receiving `snapshot` messages.\n   */\n  stateVersion?: number;\n};\n\nexport type CodexWebSocketSuccess<Name extends CodexSurfaceBridgeOperation = CodexSurfaceBridgeOperation> = {\n  version: typeof codexWebSocketProtocolVersion;\n  type: 'response';\n  id: string;\n  ok: true;\n  result: CodexSurfaceBridgeOperationResult<Name>;\n};\n\nexport type CodexWebSocketErrorPayload = {\n  code: 'invalid_request' | 'operation_failed' | 'request_timeout' | 'transport_closed';\n  message: string;\n};\n\nexport type CodexWebSocketFailure = {\n  version: typeof codexWebSocketProtocolVersion;\n  type: 'response';\n  id: string;\n  ok: false;\n  error: CodexWebSocketErrorPayload;\n};\n\nexport type CodexWebSocketSnapshot = {\n  version: typeof codexWebSocketProtocolVersion;\n  type: 'snapshot';\n  snapshot: CodexSurfaceSnapshot;\n  /** Present on the base snapshot that starts a patch stream; patches continue from it. */\n  stateVersion?: number;\n};\n\nexport type CodexWebSocketEvent = {\n  version: typeof codexWebSocketProtocolVersion;\n  type: 'event';\n  event: CodexSurfaceEvent;\n};\n\n/** Client opt-in, sent only after a `ready` that carries `stateVersion`. */\nexport type CodexWebSocketEnableStatePatches = {\n  version: typeof codexWebSocketProtocolVersion;\n  type: 'enableStatePatches';\n};\n\n/** Sent instead of `snapshot` once a client has enabled state patches. */\nexport type CodexWebSocketStatePatch = {\n  version: typeof codexWebSocketProtocolVersion;\n  type: 'statePatch';\n  patch: CodexSurfaceStatePatch;\n};\n\nexport type CodexWebSocketClientMessage = CodexWebSocketRequest;\nexport type CodexWebSocketServerMessage =\n  | CodexWebSocketReady\n  | CodexWebSocketSuccess\n  | CodexWebSocketFailure\n  | CodexWebSocketSnapshot\n  | CodexWebSocketEvent;\n\nexport function encodeCodexWebSocketMessage(\n  message:\n    | CodexWebSocketClientMessage\n    | CodexWebSocketServerMessage\n    | CodexWebSocketEnableStatePatches\n    | CodexWebSocketStatePatch,\n): string {\n  return JSON.stringify(message);\n}\n"],"mappings":";AAUA,IAAa,IAAgC;AA8E7C,SAAgB,EACd,GAKQ;CACR,OAAO,KAAK,UAAU,CAAO;AAC/B"}

package/dist/server.d.ts

@@ -0,0 +1,56 @@
+import { type CodexSurfaceBridgeAttachmentResolver, type CodexSurfaceBridgeTarget } from '@codex-app-sdk/core/surface-bridge';
+import { type CodexSurfaceStatePatchSource } from '@codex-app-sdk/core/surface-bridge';
+import { type CodexWebSocketClose, type CodexWebSocketPort } from './socket-port';
+type Awaitable<Value> = Value | Promise<Value>;
+export type CodexWebSocketSessionRelease = {
+    reason: 'authorization_failed' | 'server_closed' | 'socket_closed' | 'surface_failed';
+    close?: CodexWebSocketClose;
+    error?: unknown;
+};
+/** A host-authorized, connection-scoped lease. The host owns its lifecycle and isolation policy. */
+export type CodexWebSocketSessionLease = {
+    /** A `CodexSurface` can stream state patches to clients that opt in; other targets send snapshots. */
+    surface: CodexSurfaceBridgeTarget & Partial<CodexSurfaceStatePatchSource>;
+    resolveAttachment?: CodexSurfaceBridgeAttachmentResolver;
+    release?(context: CodexWebSocketSessionRelease): Awaitable<void>;
+};
+export type BindCodexWebSocketOptions<Context> = {
+    socket: CodexWebSocketPort;
+    context: Context;
+    authorize(context: Context): Awaitable<CodexWebSocketSessionLease | null>;
+    maxMessageBytes?: number;
+};
+export type CodexWebSocketBinding = {
+    /** Resolves after authorization and the initial surface snapshot have been sent. */
+    ready: Promise<void>;
+    close(code?: number, reason?: string): Promise<void>;
+};
+/** The small EventEmitter-style subset implemented by the popular `ws` package. */
+export type CodexNodeWebSocketLike = {
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+    on(event: 'message', listener: (data: unknown) => void): unknown;
+    on(event: 'close', listener: (code: number, reason: unknown) => void): unknown;
+    on(event: 'error', listener: (error: unknown) => void): unknown;
+};
+/** The header subset of a Node `IncomingMessage` (or equivalent) needed to check a WebSocket upgrade. */
+export type CodexWebSocketUpgradeRequest = {
+    headers: Readonly<Record<string, string | readonly string[] | undefined>>;
+};
+/**
+ * Returns true only when a WebSocket upgrade carries exactly one `Origin`
+ * header matching one of `allowedOrigins`. Browsers do not apply the
+ * same-origin policy to WebSockets, so a host that skips this check lets any
+ * website the user visits drive its Codex surface. Requests without an
+ * `Origin` header are rejected.
+ */
+export declare function isAllowedCodexWebSocketOrigin(request: CodexWebSocketUpgradeRequest, allowedOrigins: readonly string[]): boolean;
+/**
+ * Binds an established socket to a required host authorization callback.
+ * HTTP upgrades, cookies, user lookup, runner pooling, and Express integration stay host-owned.
+ */
+export declare function bindCodexWebSocket<Context>(options: BindCodexWebSocketOptions<Context>): CodexWebSocketBinding;
+/** Adapts a `ws`-style socket without importing or depending on that library. */
+export declare function createCodexNodeWebSocketPort(socket: CodexNodeWebSocketLike): CodexWebSocketPort;
+export type { CodexWebSocketClose, CodexWebSocketPort, } from './socket-port';
+//# 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":"AAAA,OAAO,EAGL,KAAK,oCAAoC,EACzC,KAAK,wBAAwB,EAC9B,MAAM,oCAAoC,CAAC;AAE5C,OAAO,EAEL,KAAK,4BAA4B,EAClC,MAAM,oCAAoC,CAAC;AAS5C,OAAO,EAIL,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACxB,MAAM,eAAe,CAAC;AAEvB,KAAK,SAAS,CAAC,KAAK,IAAI,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;AAE/C,MAAM,MAAM,4BAA4B,GAAG;IACzC,MAAM,EAAE,sBAAsB,GAAG,eAAe,GAAG,eAAe,GAAG,gBAAgB,CAAC;IACtF,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF,oGAAoG;AACpG,MAAM,MAAM,0BAA0B,GAAG;IACvC,sGAAsG;IACtG,OAAO,EAAE,wBAAwB,GAAG,OAAO,CAAC,4BAA4B,CAAC,CAAC;IAC1E,iBAAiB,CAAC,EAAE,oCAAoC,CAAC;IACzD,OAAO,CAAC,CAAC,OAAO,EAAE,4BAA4B,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;CAClE,CAAC;AAEF,MAAM,MAAM,yBAAyB,CAAC,OAAO,IAAI;IAC/C,MAAM,EAAE,kBAAkB,CAAC;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,CAAC,0BAA0B,GAAG,IAAI,CAAC,CAAC;IAC1E,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,oFAAoF;IACpF,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IACrB,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACtD,CAAC;AAEF,mFAAmF;AACnF,MAAM,MAAM,sBAAsB,GAAG;IACnC,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5C,EAAE,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,GAAG,OAAO,CAAC;IACjE,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,KAAK,IAAI,GAAG,OAAO,CAAC;IAC/E,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,OAAO,CAAC;CACjE,CAAC;AAEF,yGAAyG;AACzG,MAAM,MAAM,4BAA4B,GAAG;IACzC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,GAAG,SAAS,CAAC,CAAC,CAAC;CAC3E,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,4BAA4B,EACrC,cAAc,EAAE,SAAS,MAAM,EAAE,GAChC,OAAO,CAUT;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EACxC,OAAO,EAAE,yBAAyB,CAAC,OAAO,CAAC,GAC1C,qBAAqB,CAEvB;AAED,iFAAiF;AACjF,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,sBAAsB,GAAG,kBAAkB,CAW/F;AAoTD,YAAY,EACV,mBAAmB,EACnB,kBAAkB,GACnB,MAAM,eAAe,CAAC"}

package/dist/server.js

@@ -0,0 +1,271 @@
+import { encodeCodexWebSocketMessage as e } from "./protocol.js";
+import { n as t, r as n, t as r } from "./chunks/socket-port-QOPQStPy.js";
+import { invokeCodexSurfaceBridgeOperation as i, isCodexSurfaceBridgeOperation as a, isCodexSurfaceStatePatchSource as o } from "@codex-app-sdk/core/surface-bridge";
+//#region src/server.ts
+function s(e, t) {
+	let n = e.headers.origin;
+	if (typeof n != "string") return !1;
+	let r = v(n);
+	return r ? t.some((e) => {
+		let t = v(e);
+		if (!t) throw TypeError(`Invalid allowed Codex WebSocket origin: ${e}`);
+		return t === r;
+	}) : !1;
+}
+function c(e) {
+	return new u(e);
+}
+function l(e) {
+	return {
+		send: (t) => e.send(t),
+		close: (t, n) => e.close(t, n),
+		onMessage: (t) => _(e, "message", t),
+		onClose: (t) => _(e, "close", (e, n) => t({
+			code: typeof e == "number" ? e : void 0,
+			reason: y(n)
+		})),
+		onError: (t) => _(e, "error", t)
+	};
+}
+var u = class {
+	ready;
+	#e;
+	#t;
+	#n;
+	#r;
+	#i = [];
+	#a = null;
+	#o = Promise.resolve();
+	#s = !1;
+	#c = !1;
+	#l = null;
+	#u = null;
+	#d = null;
+	#f = "off";
+	#p = [];
+	constructor(e) {
+		this.#e = e.socket, this.#t = e.context, this.#n = e.authorize, this.#r = n(e.maxMessageBytes, t, "Codex WebSocket message byte limit"), this.#i.push(this.#e.onMessage((e) => this.#h(e)), this.#e.onClose((e) => {
+			this.#y({
+				reason: "socket_closed",
+				close: e
+			});
+		})), this.#e.onError && this.#i.push(this.#e.onError((e) => {
+			this.#y({
+				reason: "socket_closed",
+				error: e
+			});
+		})), this.ready = this.#m();
+	}
+	async close(e = 1e3, t = "Codex web session closed") {
+		this.#c || this.#e.close(e, t), await this.#y({
+			reason: "server_closed",
+			close: {
+				code: e,
+				reason: t,
+				wasClean: !0
+			}
+		});
+	}
+	async #m() {
+		try {
+			let e = await this.#n(this.#t);
+			if (!e) throw this.#e.close(4401, "Unauthorized"), await this.#y({ reason: "authorization_failed" }), Error("Codex WebSocket authorization was denied");
+			if (this.#c) {
+				await e.release?.({ reason: "socket_closed" });
+				return;
+			}
+			this.#a = e;
+			let t = o(e.surface) ? e.surface : null;
+			this.#i.push(e.surface.onStateChange((e) => {
+				this.#s && this.#f === "off" && this.#v({
+					version: 1,
+					type: "snapshot",
+					snapshot: e
+				});
+			}), e.surface.onEvent((e) => {
+				this.#s && this.#v({
+					version: 1,
+					type: "event",
+					event: e
+				});
+			})), t && this.#i.push(t.onStatePatch((e) => {
+				this.#f === "on" ? this.#v(d(e)) : this.#f === "starting" && this.#p.push(e);
+			}));
+			let n = await e.surface.connect(), r = t ? await t.getVersionedSnapshot() : null;
+			if (this.#c) return;
+			this.#u = r ? t : null, this.#d = r?.version ?? null, this.#v({
+				version: 1,
+				type: "ready",
+				...r ? {
+					snapshot: r.snapshot,
+					stateVersion: r.version
+				} : { snapshot: n }
+			}), this.#s = !0;
+		} catch (e) {
+			throw this.#c || (this.#e.close(1011, "Codex web session initialization failed"), await this.#y({
+				reason: "surface_failed",
+				error: e
+			})), e;
+		}
+	}
+	#h(e) {
+		if (this.#c) return;
+		if (!this.#s) {
+			this.#e.close(4400, "Request received before the session was ready"), this.#y({
+				reason: "socket_closed",
+				close: { code: 4400 }
+			});
+			return;
+		}
+		let t;
+		try {
+			if (t = f(r(e, this.#r)), t === "enableStatePatches" && (!this.#u || this.#f !== "off")) throw TypeError("State patches cannot be enabled for this session");
+		} catch {
+			this.#e.close(4400, "Invalid Codex WebSocket request"), this.#y({
+				reason: "socket_closed",
+				close: { code: 4400 }
+			});
+			return;
+		}
+		if (t === "enableStatePatches") {
+			this.#g();
+			return;
+		}
+		this.#o = this.#o.then(() => this.#_(t));
+	}
+	async #g() {
+		let e = this.#u;
+		this.#f = "starting";
+		let t;
+		try {
+			t = await e.getVersionedSnapshot();
+		} catch {
+			t = null;
+		}
+		if (!this.#c) {
+			if (!t) {
+				this.#e.close(1011, "Codex state stream unavailable"), this.#y({ reason: "surface_failed" });
+				return;
+			}
+			t.version !== this.#d && this.#v({
+				version: 1,
+				type: "snapshot",
+				snapshot: t.snapshot,
+				stateVersion: t.version
+			}), this.#f = "on";
+			for (let e of this.#p.splice(0)) e.version > t.version && this.#v(d(e));
+		}
+	}
+	async #_(e) {
+		let t = this.#a;
+		if (!(!t || this.#c)) try {
+			let n = await i(t.surface, e.operation, e.args, t.resolveAttachment ? { resolveAttachment: t.resolveAttachment } : {});
+			this.#v({
+				version: 1,
+				type: "response",
+				id: e.id,
+				ok: !0,
+				result: n
+			});
+		} catch (t) {
+			this.#v(p(e.id, t instanceof TypeError || t instanceof RangeError ? "invalid_request" : "operation_failed", g(t)));
+		}
+	}
+	#v(t) {
+		if (!this.#c) try {
+			let n = e(t);
+			if (new TextEncoder().encode(n).byteLength > this.#r) throw RangeError("Codex WebSocket response exceeds the configured byte limit");
+			this.#e.send(n);
+		} catch (e) {
+			this.#e.close(1011, "Codex WebSocket response failed"), this.#y({
+				reason: "socket_closed",
+				error: e
+			});
+		}
+	}
+	#y(e) {
+		if (this.#l) return this.#l;
+		this.#c = !0, this.#s = !1;
+		for (let e of this.#i.splice(0)) e();
+		let t = this.#a;
+		return this.#a = null, this.#l = Promise.resolve(t?.release?.(e)).then(() => void 0), this.#l;
+	}
+};
+function d(e) {
+	return {
+		version: 1,
+		type: "statePatch",
+		patch: e
+	};
+}
+function f(e) {
+	let t = JSON.parse(e);
+	if (!m(t)) throw TypeError("Codex WebSocket request must be an object");
+	if (t.type === "enableStatePatches") {
+		if (h(t, ["version", "type"]), t.version !== 1) throw TypeError("Codex WebSocket version is invalid");
+		return "enableStatePatches";
+	}
+	if (h(t, [
+		"version",
+		"type",
+		"id",
+		"operation",
+		"args"
+	]), t.version !== 1 || t.type !== "request") throw TypeError("Codex WebSocket request version or type is invalid");
+	if (typeof t.id != "string" || !t.id.trim() || t.id.length > 128) throw TypeError("Codex WebSocket request id is invalid");
+	if (!a(t.operation)) throw TypeError("Codex WebSocket operation is invalid");
+	if (!Array.isArray(t.args)) throw TypeError("Codex WebSocket request args must be an array");
+	return {
+		version: 1,
+		type: "request",
+		id: t.id,
+		operation: t.operation,
+		args: t.args
+	};
+}
+function p(e, t, n) {
+	return {
+		version: 1,
+		type: "response",
+		id: e,
+		ok: !1,
+		error: {
+			code: t,
+			message: n.slice(0, 2e3)
+		}
+	};
+}
+function m(e) {
+	if (!e || typeof e != "object" || Array.isArray(e)) return !1;
+	let t = Object.getPrototypeOf(e);
+	return t === Object.prototype || t === null;
+}
+function h(e, t) {
+	let n = new Set(t);
+	if (Reflect.ownKeys(e).some((e) => typeof e != "string" || !n.has(e))) throw TypeError("Codex WebSocket request contains unsupported properties");
+}
+function g(e) {
+	return e instanceof Error ? e.message : String(e);
+}
+function _(e, t, n) {
+	return t === "message" && e.on(t, n), t === "close" && e.on(t, n), t === "error" && e.on(t, n), () => {
+		let r = e;
+		r.off ? r.off(t, n) : r.removeListener?.(t, n);
+	};
+}
+function v(e) {
+	try {
+		let { origin: t } = new URL(e.trim());
+		return t === "null" ? null : t;
+	} catch {
+		return null;
+	}
+}
+function y(e) {
+	if (typeof e == "string") return e;
+	if (e instanceof ArrayBuffer || ArrayBuffer.isView(e)) return new TextDecoder().decode(e).trim() || void 0;
+}
+//#endregion
+export { c as bindCodexWebSocket, l as createCodexNodeWebSocketPort, s as isAllowedCodexWebSocketOrigin };
+
+//# sourceMappingURL=server.js.map

package/dist/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","names":["#socket","#context","#authorize","#maxMessageBytes","#unsubscribers","#pendingPatches","#receive","#finish","#initialize","#finished","#lease","#acceptingRequests","#patchMode","#send","#patchSource","#readyStateVersion","#enableStatePatches","#requestQueue","#handle","#releasePromise"],"sources":["../src/server.ts"],"sourcesContent":["import {\n  invokeCodexSurfaceBridgeOperation,\n  isCodexSurfaceBridgeOperation,\n  type CodexSurfaceBridgeAttachmentResolver,\n  type CodexSurfaceBridgeTarget,\n} from '@codex-app-sdk/core/surface-bridge';\nimport type { CodexSurfaceStatePatch } from '@codex-app-sdk/core/surface';\nimport {\n  isCodexSurfaceStatePatchSource,\n  type CodexSurfaceStatePatchSource,\n} from '@codex-app-sdk/core/surface-bridge';\nimport {\n  codexWebSocketProtocolVersion,\n  encodeCodexWebSocketMessage,\n  type CodexWebSocketFailure,\n  type CodexWebSocketRequest,\n  type CodexWebSocketServerMessage,\n  type CodexWebSocketStatePatch,\n} from './protocol';\nimport {\n  codexWebSocketText,\n  defaultCodexWebSocketMaximumMessageBytes,\n  positiveWebSocketLimit,\n  type CodexWebSocketClose,\n  type CodexWebSocketPort,\n} from './socket-port';\n\ntype Awaitable<Value> = Value | Promise<Value>;\n\nexport type CodexWebSocketSessionRelease = {\n  reason: 'authorization_failed' | 'server_closed' | 'socket_closed' | 'surface_failed';\n  close?: CodexWebSocketClose;\n  error?: unknown;\n};\n\n/** A host-authorized, connection-scoped lease. The host owns its lifecycle and isolation policy. */\nexport type CodexWebSocketSessionLease = {\n  /** A `CodexSurface` can stream state patches to clients that opt in; other targets send snapshots. */\n  surface: CodexSurfaceBridgeTarget & Partial<CodexSurfaceStatePatchSource>;\n  resolveAttachment?: CodexSurfaceBridgeAttachmentResolver;\n  release?(context: CodexWebSocketSessionRelease): Awaitable<void>;\n};\n\nexport type BindCodexWebSocketOptions<Context> = {\n  socket: CodexWebSocketPort;\n  context: Context;\n  authorize(context: Context): Awaitable<CodexWebSocketSessionLease | null>;\n  maxMessageBytes?: number;\n};\n\nexport type CodexWebSocketBinding = {\n  /** Resolves after authorization and the initial surface snapshot have been sent. */\n  ready: Promise<void>;\n  close(code?: number, reason?: string): Promise<void>;\n};\n\n/** The small EventEmitter-style subset implemented by the popular `ws` package. */\nexport type CodexNodeWebSocketLike = {\n  send(data: string): void;\n  close(code?: number, reason?: string): void;\n  on(event: 'message', listener: (data: unknown) => void): unknown;\n  on(event: 'close', listener: (code: number, reason: unknown) => void): unknown;\n  on(event: 'error', listener: (error: unknown) => void): unknown;\n};\n\n/** The header subset of a Node `IncomingMessage` (or equivalent) needed to check a WebSocket upgrade. */\nexport type CodexWebSocketUpgradeRequest = {\n  headers: Readonly<Record<string, string | readonly string[] | undefined>>;\n};\n\n/**\n * Returns true only when a WebSocket upgrade carries exactly one `Origin`\n * header matching one of `allowedOrigins`. Browsers do not apply the\n * same-origin policy to WebSockets, so a host that skips this check lets any\n * website the user visits drive its Codex surface. Requests without an\n * `Origin` header are rejected.\n */\nexport function isAllowedCodexWebSocketOrigin(\n  request: CodexWebSocketUpgradeRequest,\n  allowedOrigins: readonly string[],\n): boolean {\n  const origin = request.headers.origin;\n  if (typeof origin !== 'string') return false;\n  const requestOrigin = normalizedOrigin(origin);\n  if (!requestOrigin) return false;\n  return allowedOrigins.some((allowedOrigin) => {\n    const allowed = normalizedOrigin(allowedOrigin);\n    if (!allowed) throw new TypeError(`Invalid allowed Codex WebSocket origin: ${allowedOrigin}`);\n    return allowed === requestOrigin;\n  });\n}\n\n/**\n * Binds an established socket to a required host authorization callback.\n * HTTP upgrades, cookies, user lookup, runner pooling, and Express integration stay host-owned.\n */\nexport function bindCodexWebSocket<Context>(\n  options: BindCodexWebSocketOptions<Context>,\n): CodexWebSocketBinding {\n  return new ServerBinding(options);\n}\n\n/** Adapts a `ws`-style socket without importing or depending on that library. */\nexport function createCodexNodeWebSocketPort(socket: CodexNodeWebSocketLike): CodexWebSocketPort {\n  return {\n    send: (data) => socket.send(data),\n    close: (code, reason) => socket.close(code, reason),\n    onMessage: (listener) => nodeSocketListener(socket, 'message', listener),\n    onClose: (listener) => nodeSocketListener(socket, 'close', (code: unknown, reason: unknown) => listener({\n      code: typeof code === 'number' ? code : undefined,\n      reason: socketReason(reason),\n    })),\n    onError: (listener) => nodeSocketListener(socket, 'error', listener),\n  };\n}\n\nclass ServerBinding<Context> implements CodexWebSocketBinding {\n  readonly ready: Promise<void>;\n  readonly #socket: CodexWebSocketPort;\n  readonly #context: Context;\n  readonly #authorize: BindCodexWebSocketOptions<Context>['authorize'];\n  readonly #maxMessageBytes: number;\n  readonly #unsubscribers: Array<() => void> = [];\n  #lease: CodexWebSocketSessionLease | null = null;\n  #requestQueue = Promise.resolve();\n  #acceptingRequests = false;\n  #finished = false;\n  #releasePromise: Promise<void> | null = null;\n  // State stays on full snapshots unless the surface can stream patches and\n  // the client opts in after a `ready` that advertised `stateVersion`.\n  #patchSource: CodexSurfaceStatePatchSource | null = null;\n  #readyStateVersion: number | null = null;\n  #patchMode: 'off' | 'starting' | 'on' = 'off';\n  readonly #pendingPatches: CodexSurfaceStatePatch[] = [];\n\n  constructor(options: BindCodexWebSocketOptions<Context>) {\n    this.#socket = options.socket;\n    this.#context = options.context;\n    this.#authorize = options.authorize;\n    this.#maxMessageBytes = positiveWebSocketLimit(\n      options.maxMessageBytes,\n      defaultCodexWebSocketMaximumMessageBytes,\n      'Codex WebSocket message byte limit',\n    );\n    this.#unsubscribers.push(\n      this.#socket.onMessage((data) => this.#receive(data)),\n      this.#socket.onClose((close) => { void this.#finish({ reason: 'socket_closed', close }); }),\n    );\n    if (this.#socket.onError) {\n      this.#unsubscribers.push(this.#socket.onError((error) => {\n        void this.#finish({ reason: 'socket_closed', error });\n      }));\n    }\n    this.ready = this.#initialize();\n  }\n\n  async close(code = 1000, reason = 'Codex web session closed'): Promise<void> {\n    if (!this.#finished) this.#socket.close(code, reason);\n    await this.#finish({ reason: 'server_closed', close: { code, reason, wasClean: true } });\n  }\n\n  async #initialize(): Promise<void> {\n    try {\n      const lease = await this.#authorize(this.#context);\n      if (!lease) {\n        this.#socket.close(4401, 'Unauthorized');\n        await this.#finish({ reason: 'authorization_failed' });\n        throw new Error('Codex WebSocket authorization was denied');\n      }\n      if (this.#finished) {\n        await lease.release?.({ reason: 'socket_closed' });\n        return;\n      }\n      this.#lease = lease;\n      const patchSource = isCodexSurfaceStatePatchSource(lease.surface) ? lease.surface : null;\n      this.#unsubscribers.push(\n        lease.surface.onStateChange((snapshot) => {\n          if (this.#acceptingRequests && this.#patchMode === 'off') this.#send({\n            version: codexWebSocketProtocolVersion,\n            type: 'snapshot',\n            snapshot,\n          });\n        }),\n        lease.surface.onEvent((event) => {\n          if (this.#acceptingRequests) this.#send({\n            version: codexWebSocketProtocolVersion,\n            type: 'event',\n            event,\n          });\n        }),\n      );\n      if (patchSource) {\n        this.#unsubscribers.push(patchSource.onStatePatch((patch) => {\n          if (this.#patchMode === 'on') this.#send(statePatchMessage(patch));\n          else if (this.#patchMode === 'starting') this.#pendingPatches.push(patch);\n        }));\n      }\n      const snapshot = await lease.surface.connect();\n      const state = patchSource ? await patchSource.getVersionedSnapshot() : null;\n      if (this.#finished) return;\n      this.#patchSource = state ? patchSource : null;\n      this.#readyStateVersion = state?.version ?? null;\n      this.#send({\n        version: codexWebSocketProtocolVersion,\n        type: 'ready',\n        ...(state ? { snapshot: state.snapshot, stateVersion: state.version } : { snapshot }),\n      });\n      this.#acceptingRequests = true;\n    } catch (error) {\n      if (!this.#finished) {\n        this.#socket.close(1011, 'Codex web session initialization failed');\n        await this.#finish({ reason: 'surface_failed', error });\n      }\n      throw error;\n    }\n  }\n\n  #receive(data: unknown): void {\n    if (this.#finished) return;\n    if (!this.#acceptingRequests) {\n      this.#socket.close(4400, 'Request received before the session was ready');\n      void this.#finish({ reason: 'socket_closed', close: { code: 4400 } });\n      return;\n    }\n    let request: CodexWebSocketRequest | 'enableStatePatches';\n    try {\n      request = parseClientMessage(codexWebSocketText(data, this.#maxMessageBytes));\n      if (request === 'enableStatePatches' && (!this.#patchSource || this.#patchMode !== 'off')) {\n        throw new TypeError('State patches cannot be enabled for this session');\n      }\n    } catch {\n      this.#socket.close(4400, 'Invalid Codex WebSocket request');\n      void this.#finish({ reason: 'socket_closed', close: { code: 4400 } });\n      return;\n    }\n    if (request === 'enableStatePatches') {\n      void this.#enableStatePatches();\n      return;\n    }\n    this.#requestQueue = this.#requestQueue.then(() => this.#handle(request));\n  }\n\n  async #enableStatePatches(): Promise<void> {\n    const patchSource = this.#patchSource!;\n    this.#patchMode = 'starting';\n    let state;\n    try {\n      state = await patchSource.getVersionedSnapshot();\n    } catch {\n      state = null;\n    }\n    if (this.#finished) return;\n    if (!state) {\n      // Without a base the client cannot apply patches; a reconnect starts over.\n      this.#socket.close(1011, 'Codex state stream unavailable');\n      void this.#finish({ reason: 'surface_failed' });\n      return;\n    }\n    // Snapshots sent before the switch moved the client past `ready`; give it a new base.\n    if (state.version !== this.#readyStateVersion) this.#send({\n      version: codexWebSocketProtocolVersion,\n      type: 'snapshot',\n      snapshot: state.snapshot,\n      stateVersion: state.version,\n    });\n    this.#patchMode = 'on';\n    for (const patch of this.#pendingPatches.splice(0)) {\n      if (patch.version > state.version) this.#send(statePatchMessage(patch));\n    }\n  }\n\n  async #handle(request: CodexWebSocketRequest): Promise<void> {\n    const lease = this.#lease;\n    if (!lease || this.#finished) return;\n    try {\n      const result = await invokeCodexSurfaceBridgeOperation(\n        lease.surface,\n        request.operation,\n        request.args,\n        lease.resolveAttachment ? { resolveAttachment: lease.resolveAttachment } : {},\n      );\n      this.#send({\n        version: codexWebSocketProtocolVersion,\n        type: 'response',\n        id: request.id,\n        ok: true,\n        result,\n      });\n    } catch (error) {\n      this.#send(failure(\n        request.id,\n        error instanceof TypeError || error instanceof RangeError ? 'invalid_request' : 'operation_failed',\n        errorMessage(error),\n      ));\n    }\n  }\n\n  #send(message: CodexWebSocketServerMessage | CodexWebSocketStatePatch): void {\n    if (this.#finished) return;\n    try {\n      const encoded = encodeCodexWebSocketMessage(message);\n      if (new TextEncoder().encode(encoded).byteLength > this.#maxMessageBytes) {\n        throw new RangeError('Codex WebSocket response exceeds the configured byte limit');\n      }\n      this.#socket.send(encoded);\n    } catch (error) {\n      this.#socket.close(1011, 'Codex WebSocket response failed');\n      void this.#finish({ reason: 'socket_closed', error });\n    }\n  }\n\n  #finish(context: CodexWebSocketSessionRelease): Promise<void> {\n    if (this.#releasePromise) return this.#releasePromise;\n    this.#finished = true;\n    this.#acceptingRequests = false;\n    for (const unsubscribe of this.#unsubscribers.splice(0)) unsubscribe();\n    const lease = this.#lease;\n    this.#lease = null;\n    this.#releasePromise = Promise.resolve(lease?.release?.(context)).then(() => undefined);\n    return this.#releasePromise;\n  }\n}\n\nfunction statePatchMessage(patch: CodexSurfaceStatePatch): CodexWebSocketStatePatch {\n  return { version: codexWebSocketProtocolVersion, type: 'statePatch', patch };\n}\n\nfunction parseClientMessage(text: string): CodexWebSocketRequest | 'enableStatePatches' {\n  const value = JSON.parse(text) as unknown;\n  if (!isPlainObject(value)) throw new TypeError('Codex WebSocket request must be an object');\n  if (value.type === 'enableStatePatches') {\n    onlyKeys(value, ['version', 'type']);\n    if (value.version !== codexWebSocketProtocolVersion) throw new TypeError('Codex WebSocket version is invalid');\n    return 'enableStatePatches';\n  }\n  onlyKeys(value, ['version', 'type', 'id', 'operation', 'args']);\n  if (value.version !== codexWebSocketProtocolVersion || value.type !== 'request') {\n    throw new TypeError('Codex WebSocket request version or type is invalid');\n  }\n  if (typeof value.id !== 'string' || !value.id.trim() || value.id.length > 128) {\n    throw new TypeError('Codex WebSocket request id is invalid');\n  }\n  if (!isCodexSurfaceBridgeOperation(value.operation)) {\n    throw new TypeError('Codex WebSocket operation is invalid');\n  }\n  if (!Array.isArray(value.args)) throw new TypeError('Codex WebSocket request args must be an array');\n  return {\n    version: codexWebSocketProtocolVersion,\n    type: 'request',\n    id: value.id,\n    operation: value.operation,\n    args: value.args,\n  };\n}\n\nfunction failure(\n  id: string,\n  code: CodexWebSocketFailure['error']['code'],\n  message: string,\n): CodexWebSocketFailure {\n  return {\n    version: codexWebSocketProtocolVersion,\n    type: 'response',\n    id,\n    ok: false,\n    error: { code, message: message.slice(0, 2_000) },\n  };\n}\n\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;\n  const prototype = Object.getPrototypeOf(value) as object | null;\n  return prototype === Object.prototype || prototype === null;\n}\n\nfunction onlyKeys(record: Record<string, unknown>, allowedKeys: readonly string[]): void {\n  const allowed = new Set(allowedKeys);\n  if (Reflect.ownKeys(record).some((key) => typeof key !== 'string' || !allowed.has(key))) {\n    throw new TypeError('Codex WebSocket request contains unsupported properties');\n  }\n}\n\nfunction errorMessage(error: unknown): string {\n  return error instanceof Error ? error.message : String(error);\n}\n\nfunction nodeSocketListener(\n  socket: CodexNodeWebSocketLike,\n  event: 'message' | 'close' | 'error',\n  listener: (first: unknown, second?: unknown) => void,\n): () => void {\n  if (event === 'message') socket.on(event, listener as (data: unknown) => void);\n  if (event === 'close') socket.on(event, listener as (code: number, reason: unknown) => void);\n  if (event === 'error') socket.on(event, listener as (error: unknown) => void);\n  return () => {\n    const removable = socket as CodexNodeWebSocketLike & {\n      off?(name: string, callback: (first: unknown, second?: unknown) => void): unknown;\n      removeListener?(name: string, callback: (first: unknown, second?: unknown) => void): unknown;\n    };\n    if (removable.off) removable.off(event, listener);\n    else removable.removeListener?.(event, listener);\n  };\n}\n\nfunction normalizedOrigin(value: string): string | null {\n  try {\n    const { origin } = new URL(value.trim());\n    return origin === 'null' ? null : origin;\n  } catch {\n    return null;\n  }\n}\n\nfunction socketReason(value: unknown): string | undefined {\n  if (typeof value === 'string') return value;\n  if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {\n    const reason = new TextDecoder().decode(value).trim();\n    return reason || undefined;\n  }\n  return undefined;\n}\n\nexport type {\n  CodexWebSocketClose,\n  CodexWebSocketPort,\n} from './socket-port';\n"],"mappings":"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"}

package/dist/socket-port.d.ts

@@ -0,0 +1,17 @@
+export type CodexWebSocketClose = {
+    code?: number;
+    reason?: string;
+    wasClean?: boolean;
+};
+/** Minimal socket seam implemented by browser WebSocket, `ws`, or another host adapter. */
+export type CodexWebSocketPort = {
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+    onMessage(listener: (data: unknown) => void): () => void;
+    onClose(listener: (event: CodexWebSocketClose) => void): () => void;
+    onError?(listener: (error: unknown) => void): () => void;
+};
+export declare const defaultCodexWebSocketMaximumMessageBytes: number;
+export declare function codexWebSocketText(data: unknown, maximumBytes: number): string;
+export declare function positiveWebSocketLimit(value: number | undefined, fallback: number, label: string): number;
+//# sourceMappingURL=socket-port.d.ts.map

package/dist/socket-port.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"socket-port.d.ts","sourceRoot":"","sources":["../src/socket-port.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,2FAA2F;AAC3F,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5C,SAAS,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;IACzD,OAAO,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;IACpE,OAAO,CAAC,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;CAC1D,CAAC;AAEF,eAAO,MAAM,wCAAwC,QAAmB,CAAC;AAEzE,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAe9E;AAED,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,GACZ,MAAM,CAIR"}

package/package.json

@@ -1,6 +1,53 @@
 {
   "name": "@codex-app-sdk/web",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.14.1",
+  "description": "Framework-neutral WebSocket bindings for browser-based Codex applications.",
+  "type": "module",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/codex-app-sdk/codex-app-sdk.git",
+    "directory": "packages/web"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "import": "./dist/client.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js"
+    },
+    "./protocol": {
+      "types": "./dist/protocol.d.ts",
+      "import": "./dist/protocol.js"
+    }
+  },
+  "scripts": {
+    "build": "vite build && tsc -p tsconfig.build.json --declaration --emitDeclarationOnly",
+    "check": "npm run lint && npm run test:coverage && npm run build",
+    "lint": "tsc -p tsconfig.test.json --noEmit",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "test:mutation": "cd ../.. && stryker run packages/web/stryker.config.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "dependencies": {
+    "@codex-app-sdk/core": "0.14.1"
+  },
+  "engines": {
+    "node": ">=22"
+  }
+}