@wireflowapp/websocket-core 0.0.0-stage → 1.0.0

package/README.md

@@ -1,3 +1,35 @@
-# Temporary Holding Version
+# @wireflowapp/websocket-core
 
-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-independent native WebSocket client and connection manager for **Wireflow**.
+
+## Features
+
+- **Standard WebSocket API**: Clean abstraction over the browser native WebSocket API.
+- **Resilient Reconnection**: Backed by `@wireflowapp/core`'s `RetryManager` for predictable backoff and exhaustion.
+- **SSR Safe**: Safe to import and evaluate in server-side rendering environments without throwing.
+- **Typed Events**: Simple and strongly-typed listener subscription (`open`, `message`, `error`, `close`, `statusChange`).
+
+## Installation
+
+```bash
+pnpm add @wireflowapp/websocket-core @wireflowapp/core
+```
+
+## Quick Start
+
+```ts
+import { WebSocketClient } from "@wireflowapp/websocket-core";
+
+const client = new WebSocketClient("wss://example.com/ws", {
+  retryAttempts: 5,
+  retryDelay: 3000,
+});
+
+client.on("open", () => {
+  client.send(JSON.stringify({ type: "hello" }));
+});
+
+client.on("message", (event) => {
+  console.log("Received:", event.data);
+});
+```

package/dist/index.d.mts

@@ -0,0 +1,115 @@
+import { ConnectionStatus, WireFlowConfig, ConnectionResult } from '@wireflowapp/core';
+
+type WebSocketDataType = string | ArrayBufferLike | Blob | ArrayBufferView;
+interface WebSocketEventMap {
+    open: Event;
+    close: CloseEvent;
+    error: Event;
+    message: MessageEvent;
+    statusChange: ConnectionStatus;
+}
+type WebSocketEventListener<K extends keyof WebSocketEventMap> = (event: WebSocketEventMap[K]) => void;
+interface WebSocketOptions extends WireFlowConfig {
+    /**
+     * Sub-protocol string or array of sub-protocol strings.
+     */
+    protocols?: string | string[];
+    /**
+     * The binary type for received data: "blob" or "arraybuffer".
+     */
+    binaryType?: BinaryType;
+    /**
+     * Callback fired when connection opens.
+     */
+    onOpen?: (event: Event) => void;
+    /**
+     * Callback fired when connection closes.
+     */
+    onClose?: (event: CloseEvent) => void;
+    /**
+     * Callback fired when a WebSocket error occurs.
+     */
+    onError?: (event: Event) => void;
+    /**
+     * Callback fired when a message is received.
+     */
+    onMessage?: (event: MessageEvent) => void;
+    /**
+     * Callback fired when the connection status changes.
+     */
+    onStatusChange?: (status: ConnectionStatus) => void;
+}
+interface IWebSocketClient {
+    readonly status: ConnectionStatus;
+    readonly socket: WebSocket | null;
+    readonly url: string;
+    connect(): void;
+    retry(): void;
+    disconnect(): void;
+    send(data: WebSocketDataType): boolean;
+    on<K extends keyof WebSocketEventMap>(event: K, listener: WebSocketEventListener<K>): () => void;
+    off<K extends keyof WebSocketEventMap>(event: K, listener: WebSocketEventListener<K>): void;
+    once<K extends keyof WebSocketEventMap>(event: K, listener: WebSocketEventListener<K>): () => void;
+    dispose(): void;
+}
+
+declare class WebSocketClient implements IWebSocketClient, ConnectionResult {
+    private readonly _url;
+    private readonly _options;
+    private readonly _retryManager;
+    private _socket;
+    private _status;
+    private _isManualDisconnect;
+    private _listeners;
+    constructor(url: string, options?: WebSocketOptions);
+    get url(): string;
+    get status(): ConnectionStatus;
+    get socket(): WebSocket | null;
+    get isRetrying(): boolean;
+    get retryAttempts(): number;
+    connect(): void;
+    retry(): void;
+    disconnect(): void;
+    send(data: WebSocketDataType): boolean;
+    on<K extends keyof WebSocketEventMap>(event: K, listener: WebSocketEventListener<K>): () => void;
+    off<K extends keyof WebSocketEventMap>(event: K, listener: WebSocketEventListener<K>): void;
+    once<K extends keyof WebSocketEventMap>(event: K, listener: WebSocketEventListener<K>): () => void;
+    dispose(): void;
+    private createSocket;
+    private cleanUpExistingSocket;
+    private attachSocketEvents;
+    private detachSocketEvents;
+    private handleSocketFailure;
+    private setStatus;
+    private emit;
+}
+
+/**
+ * WebSocketManager provides explicit instance management and lifecycle
+ * disposal for multiple WebSocketClient connections.
+ */
+declare class WebSocketManager {
+    private _clients;
+    /**
+     * Retrieves an existing client or creates and registers a new one.
+     */
+    getOrCreate(url: string, options?: WebSocketOptions, key?: string): WebSocketClient;
+    /**
+     * Retrieves a client by key, if present.
+     */
+    get(key: string): WebSocketClient | undefined;
+    /**
+     * Checks if a client is registered under the given key.
+     */
+    has(key: string): boolean;
+    /**
+     * Disconnects, disposes, and removes a client by key.
+     */
+    remove(key: string): boolean;
+    /**
+     * Disposes and clears all tracked WebSocket clients.
+     */
+    clear(): void;
+}
+
+export { type IWebSocketClient, WebSocketClient, type WebSocketDataType, type WebSocketEventListener, type WebSocketEventMap, WebSocketManager, type WebSocketOptions };

package/dist/index.d.ts

@@ -0,0 +1,115 @@
+import { ConnectionStatus, WireFlowConfig, ConnectionResult } from '@wireflowapp/core';
+
+type WebSocketDataType = string | ArrayBufferLike | Blob | ArrayBufferView;
+interface WebSocketEventMap {
+    open: Event;
+    close: CloseEvent;
+    error: Event;
+    message: MessageEvent;
+    statusChange: ConnectionStatus;
+}
+type WebSocketEventListener<K extends keyof WebSocketEventMap> = (event: WebSocketEventMap[K]) => void;
+interface WebSocketOptions extends WireFlowConfig {
+    /**
+     * Sub-protocol string or array of sub-protocol strings.
+     */
+    protocols?: string | string[];
+    /**
+     * The binary type for received data: "blob" or "arraybuffer".
+     */
+    binaryType?: BinaryType;
+    /**
+     * Callback fired when connection opens.
+     */
+    onOpen?: (event: Event) => void;
+    /**
+     * Callback fired when connection closes.
+     */
+    onClose?: (event: CloseEvent) => void;
+    /**
+     * Callback fired when a WebSocket error occurs.
+     */
+    onError?: (event: Event) => void;
+    /**
+     * Callback fired when a message is received.
+     */
+    onMessage?: (event: MessageEvent) => void;
+    /**
+     * Callback fired when the connection status changes.
+     */
+    onStatusChange?: (status: ConnectionStatus) => void;
+}
+interface IWebSocketClient {
+    readonly status: ConnectionStatus;
+    readonly socket: WebSocket | null;
+    readonly url: string;
+    connect(): void;
+    retry(): void;
+    disconnect(): void;
+    send(data: WebSocketDataType): boolean;
+    on<K extends keyof WebSocketEventMap>(event: K, listener: WebSocketEventListener<K>): () => void;
+    off<K extends keyof WebSocketEventMap>(event: K, listener: WebSocketEventListener<K>): void;
+    once<K extends keyof WebSocketEventMap>(event: K, listener: WebSocketEventListener<K>): () => void;
+    dispose(): void;
+}
+
+declare class WebSocketClient implements IWebSocketClient, ConnectionResult {
+    private readonly _url;
+    private readonly _options;
+    private readonly _retryManager;
+    private _socket;
+    private _status;
+    private _isManualDisconnect;
+    private _listeners;
+    constructor(url: string, options?: WebSocketOptions);
+    get url(): string;
+    get status(): ConnectionStatus;
+    get socket(): WebSocket | null;
+    get isRetrying(): boolean;
+    get retryAttempts(): number;
+    connect(): void;
+    retry(): void;
+    disconnect(): void;
+    send(data: WebSocketDataType): boolean;
+    on<K extends keyof WebSocketEventMap>(event: K, listener: WebSocketEventListener<K>): () => void;
+    off<K extends keyof WebSocketEventMap>(event: K, listener: WebSocketEventListener<K>): void;
+    once<K extends keyof WebSocketEventMap>(event: K, listener: WebSocketEventListener<K>): () => void;
+    dispose(): void;
+    private createSocket;
+    private cleanUpExistingSocket;
+    private attachSocketEvents;
+    private detachSocketEvents;
+    private handleSocketFailure;
+    private setStatus;
+    private emit;
+}
+
+/**
+ * WebSocketManager provides explicit instance management and lifecycle
+ * disposal for multiple WebSocketClient connections.
+ */
+declare class WebSocketManager {
+    private _clients;
+    /**
+     * Retrieves an existing client or creates and registers a new one.
+     */
+    getOrCreate(url: string, options?: WebSocketOptions, key?: string): WebSocketClient;
+    /**
+     * Retrieves a client by key, if present.
+     */
+    get(key: string): WebSocketClient | undefined;
+    /**
+     * Checks if a client is registered under the given key.
+     */
+    has(key: string): boolean;
+    /**
+     * Disconnects, disposes, and removes a client by key.
+     */
+    remove(key: string): boolean;
+    /**
+     * Disposes and clears all tracked WebSocket clients.
+     */
+    clear(): void;
+}
+
+export { type IWebSocketClient, WebSocketClient, type WebSocketDataType, type WebSocketEventListener, type WebSocketEventMap, WebSocketManager, type WebSocketOptions };

package/dist/index.js

@@ -0,0 +1,292 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  WebSocketClient: () => WebSocketClient,
+  WebSocketManager: () => WebSocketManager
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/WebSocketClient.ts
+var import_core = require("@wireflowapp/core");
+var WebSocketClient = class {
+  _url;
+  _options;
+  _retryManager;
+  _socket = null;
+  _status = "Idle";
+  _isManualDisconnect = false;
+  _listeners = /* @__PURE__ */ new Map();
+  constructor(url, options = {}) {
+    this._url = url;
+    this._options = options;
+    const resolved = import_core.WireFlowManager.resolve(options);
+    this._retryManager = new import_core.RetryManager({
+      retryAttempts: resolved.retryAttempts,
+      retryDelay: resolved.retryDelay,
+      onRetryAttempt: () => {
+        this.setStatus("Connecting");
+      },
+      onExhausted: () => {
+        this.setStatus("Failed");
+      }
+    });
+    if (resolved.autoConnect) {
+      this.connect();
+    }
+  }
+  get url() {
+    return this._url;
+  }
+  get status() {
+    return this._status;
+  }
+  get socket() {
+    return this._socket;
+  }
+  get isRetrying() {
+    return this._retryManager.isRetrying;
+  }
+  get retryAttempts() {
+    return this._retryManager.attempts;
+  }
+  connect() {
+    if (this._status === "Connected") {
+      return;
+    }
+    if (this._socket && this._socket.readyState === WebSocket.CONNECTING) {
+      return;
+    }
+    if (typeof WebSocket === "undefined") {
+      this.setStatus("Idle");
+      return;
+    }
+    this._retryManager.reset();
+    this._isManualDisconnect = false;
+    this.createSocket();
+  }
+  retry() {
+    if (this._status === "Connected") {
+      return;
+    }
+    this._retryManager.reset();
+    this._isManualDisconnect = false;
+    this.createSocket();
+  }
+  disconnect() {
+    this._isManualDisconnect = true;
+    this._retryManager.cancel();
+    if (this._socket) {
+      this.detachSocketEvents(this._socket);
+      try {
+        if (this._socket.readyState === WebSocket.OPEN || this._socket.readyState === WebSocket.CONNECTING) {
+          this._socket.close(1e3, "Normal Closure");
+        }
+      } catch {
+      }
+      this._socket = null;
+    }
+    this.setStatus("Idle");
+  }
+  send(data) {
+    if (this._socket && this._socket.readyState === WebSocket.OPEN) {
+      this._socket.send(data);
+      return true;
+    }
+    return false;
+  }
+  on(event, listener) {
+    if (!this._listeners.has(event)) {
+      this._listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this._listeners.get(event).add(listener);
+    return () => this.off(event, listener);
+  }
+  off(event, listener) {
+    const set = this._listeners.get(event);
+    if (set) {
+      set.delete(listener);
+    }
+  }
+  once(event, listener) {
+    const onceWrapper = ((data) => {
+      this.off(event, onceWrapper);
+      listener(data);
+    });
+    return this.on(event, onceWrapper);
+  }
+  dispose() {
+    this.disconnect();
+    this._listeners.clear();
+    this._retryManager.dispose();
+  }
+  createSocket() {
+    this.setStatus("Connecting");
+    try {
+      this.cleanUpExistingSocket();
+      const protocols = this._options.protocols;
+      const socket = protocols ? new WebSocket(this._url, protocols) : new WebSocket(this._url);
+      if (this._options.binaryType) {
+        socket.binaryType = this._options.binaryType;
+      }
+      this._socket = socket;
+      this.attachSocketEvents(socket);
+    } catch {
+      this.handleSocketFailure();
+    }
+  }
+  cleanUpExistingSocket() {
+    if (this._socket) {
+      this.detachSocketEvents(this._socket);
+      try {
+        this._socket.close();
+      } catch {
+      }
+      this._socket = null;
+    }
+  }
+  attachSocketEvents(socket) {
+    socket.onopen = (event) => {
+      if (this._socket !== socket) return;
+      this._retryManager.reset();
+      this.setStatus("Connected");
+      this.emit("open", event);
+      this._options.onOpen?.(event);
+    };
+    socket.onmessage = (event) => {
+      if (this._socket !== socket) return;
+      this.emit("message", event);
+      this._options.onMessage?.(event);
+    };
+    socket.onerror = (event) => {
+      if (this._socket !== socket) return;
+      this.emit("error", event);
+      this._options.onError?.(event);
+    };
+    socket.onclose = (event) => {
+      if (this._socket !== socket) return;
+      this.emit("close", event);
+      this._options.onClose?.(event);
+      this.detachSocketEvents(socket);
+      this._socket = null;
+      if (this._isManualDisconnect) {
+        this.setStatus("Idle");
+      } else {
+        this.handleSocketFailure();
+      }
+    };
+  }
+  detachSocketEvents(socket) {
+    socket.onopen = null;
+    socket.onmessage = null;
+    socket.onerror = null;
+    socket.onclose = null;
+  }
+  handleSocketFailure() {
+    const resolved = import_core.WireFlowManager.resolve(this._options);
+    if (!resolved.retryOnDisconnect) {
+      this.setStatus("Failed");
+      return;
+    }
+    const scheduled = this._retryManager.scheduleRetry(() => {
+      if (!this._isManualDisconnect) {
+        this.createSocket();
+      }
+    });
+    if (scheduled) {
+      this.setStatus("Connecting");
+    } else {
+      this.setStatus("Failed");
+    }
+  }
+  setStatus(status) {
+    if (this._status !== status) {
+      this._status = status;
+      this.emit("statusChange", status);
+      this._options.onStatusChange?.(status);
+    }
+  }
+  emit(event, data) {
+    const set = this._listeners.get(event);
+    if (set) {
+      const listeners = Array.from(set);
+      for (const listener of listeners) {
+        try {
+          listener(data);
+        } catch {
+        }
+      }
+    }
+  }
+};
+
+// src/WebSocketManager.ts
+var WebSocketManager = class {
+  _clients = /* @__PURE__ */ new Map();
+  /**
+   * Retrieves an existing client or creates and registers a new one.
+   */
+  getOrCreate(url, options, key = url) {
+    let client = this._clients.get(key);
+    if (!client) {
+      client = new WebSocketClient(url, options);
+      this._clients.set(key, client);
+    }
+    return client;
+  }
+  /**
+   * Retrieves a client by key, if present.
+   */
+  get(key) {
+    return this._clients.get(key);
+  }
+  /**
+   * Checks if a client is registered under the given key.
+   */
+  has(key) {
+    return this._clients.has(key);
+  }
+  /**
+   * Disconnects, disposes, and removes a client by key.
+   */
+  remove(key) {
+    const client = this._clients.get(key);
+    if (client) {
+      client.dispose();
+      return this._clients.delete(key);
+    }
+    return false;
+  }
+  /**
+   * Disposes and clears all tracked WebSocket clients.
+   */
+  clear() {
+    for (const client of this._clients.values()) {
+      client.dispose();
+    }
+    this._clients.clear();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WebSocketClient,
+  WebSocketManager
+});

package/dist/index.mjs

@@ -0,0 +1,267 @@
+// src/WebSocketClient.ts
+import {
+  RetryManager,
+  WireFlowManager
+} from "@wireflowapp/core";
+var WebSocketClient = class {
+  _url;
+  _options;
+  _retryManager;
+  _socket = null;
+  _status = "Idle";
+  _isManualDisconnect = false;
+  _listeners = /* @__PURE__ */ new Map();
+  constructor(url, options = {}) {
+    this._url = url;
+    this._options = options;
+    const resolved = WireFlowManager.resolve(options);
+    this._retryManager = new RetryManager({
+      retryAttempts: resolved.retryAttempts,
+      retryDelay: resolved.retryDelay,
+      onRetryAttempt: () => {
+        this.setStatus("Connecting");
+      },
+      onExhausted: () => {
+        this.setStatus("Failed");
+      }
+    });
+    if (resolved.autoConnect) {
+      this.connect();
+    }
+  }
+  get url() {
+    return this._url;
+  }
+  get status() {
+    return this._status;
+  }
+  get socket() {
+    return this._socket;
+  }
+  get isRetrying() {
+    return this._retryManager.isRetrying;
+  }
+  get retryAttempts() {
+    return this._retryManager.attempts;
+  }
+  connect() {
+    if (this._status === "Connected") {
+      return;
+    }
+    if (this._socket && this._socket.readyState === WebSocket.CONNECTING) {
+      return;
+    }
+    if (typeof WebSocket === "undefined") {
+      this.setStatus("Idle");
+      return;
+    }
+    this._retryManager.reset();
+    this._isManualDisconnect = false;
+    this.createSocket();
+  }
+  retry() {
+    if (this._status === "Connected") {
+      return;
+    }
+    this._retryManager.reset();
+    this._isManualDisconnect = false;
+    this.createSocket();
+  }
+  disconnect() {
+    this._isManualDisconnect = true;
+    this._retryManager.cancel();
+    if (this._socket) {
+      this.detachSocketEvents(this._socket);
+      try {
+        if (this._socket.readyState === WebSocket.OPEN || this._socket.readyState === WebSocket.CONNECTING) {
+          this._socket.close(1e3, "Normal Closure");
+        }
+      } catch {
+      }
+      this._socket = null;
+    }
+    this.setStatus("Idle");
+  }
+  send(data) {
+    if (this._socket && this._socket.readyState === WebSocket.OPEN) {
+      this._socket.send(data);
+      return true;
+    }
+    return false;
+  }
+  on(event, listener) {
+    if (!this._listeners.has(event)) {
+      this._listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this._listeners.get(event).add(listener);
+    return () => this.off(event, listener);
+  }
+  off(event, listener) {
+    const set = this._listeners.get(event);
+    if (set) {
+      set.delete(listener);
+    }
+  }
+  once(event, listener) {
+    const onceWrapper = ((data) => {
+      this.off(event, onceWrapper);
+      listener(data);
+    });
+    return this.on(event, onceWrapper);
+  }
+  dispose() {
+    this.disconnect();
+    this._listeners.clear();
+    this._retryManager.dispose();
+  }
+  createSocket() {
+    this.setStatus("Connecting");
+    try {
+      this.cleanUpExistingSocket();
+      const protocols = this._options.protocols;
+      const socket = protocols ? new WebSocket(this._url, protocols) : new WebSocket(this._url);
+      if (this._options.binaryType) {
+        socket.binaryType = this._options.binaryType;
+      }
+      this._socket = socket;
+      this.attachSocketEvents(socket);
+    } catch {
+      this.handleSocketFailure();
+    }
+  }
+  cleanUpExistingSocket() {
+    if (this._socket) {
+      this.detachSocketEvents(this._socket);
+      try {
+        this._socket.close();
+      } catch {
+      }
+      this._socket = null;
+    }
+  }
+  attachSocketEvents(socket) {
+    socket.onopen = (event) => {
+      if (this._socket !== socket) return;
+      this._retryManager.reset();
+      this.setStatus("Connected");
+      this.emit("open", event);
+      this._options.onOpen?.(event);
+    };
+    socket.onmessage = (event) => {
+      if (this._socket !== socket) return;
+      this.emit("message", event);
+      this._options.onMessage?.(event);
+    };
+    socket.onerror = (event) => {
+      if (this._socket !== socket) return;
+      this.emit("error", event);
+      this._options.onError?.(event);
+    };
+    socket.onclose = (event) => {
+      if (this._socket !== socket) return;
+      this.emit("close", event);
+      this._options.onClose?.(event);
+      this.detachSocketEvents(socket);
+      this._socket = null;
+      if (this._isManualDisconnect) {
+        this.setStatus("Idle");
+      } else {
+        this.handleSocketFailure();
+      }
+    };
+  }
+  detachSocketEvents(socket) {
+    socket.onopen = null;
+    socket.onmessage = null;
+    socket.onerror = null;
+    socket.onclose = null;
+  }
+  handleSocketFailure() {
+    const resolved = WireFlowManager.resolve(this._options);
+    if (!resolved.retryOnDisconnect) {
+      this.setStatus("Failed");
+      return;
+    }
+    const scheduled = this._retryManager.scheduleRetry(() => {
+      if (!this._isManualDisconnect) {
+        this.createSocket();
+      }
+    });
+    if (scheduled) {
+      this.setStatus("Connecting");
+    } else {
+      this.setStatus("Failed");
+    }
+  }
+  setStatus(status) {
+    if (this._status !== status) {
+      this._status = status;
+      this.emit("statusChange", status);
+      this._options.onStatusChange?.(status);
+    }
+  }
+  emit(event, data) {
+    const set = this._listeners.get(event);
+    if (set) {
+      const listeners = Array.from(set);
+      for (const listener of listeners) {
+        try {
+          listener(data);
+        } catch {
+        }
+      }
+    }
+  }
+};
+
+// src/WebSocketManager.ts
+var WebSocketManager = class {
+  _clients = /* @__PURE__ */ new Map();
+  /**
+   * Retrieves an existing client or creates and registers a new one.
+   */
+  getOrCreate(url, options, key = url) {
+    let client = this._clients.get(key);
+    if (!client) {
+      client = new WebSocketClient(url, options);
+      this._clients.set(key, client);
+    }
+    return client;
+  }
+  /**
+   * Retrieves a client by key, if present.
+   */
+  get(key) {
+    return this._clients.get(key);
+  }
+  /**
+   * Checks if a client is registered under the given key.
+   */
+  has(key) {
+    return this._clients.has(key);
+  }
+  /**
+   * Disconnects, disposes, and removes a client by key.
+   */
+  remove(key) {
+    const client = this._clients.get(key);
+    if (client) {
+      client.dispose();
+      return this._clients.delete(key);
+    }
+    return false;
+  }
+  /**
+   * Disposes and clears all tracked WebSocket clients.
+   */
+  clear() {
+    for (const client of this._clients.values()) {
+      client.dispose();
+    }
+    this._clients.clear();
+  }
+};
+export {
+  WebSocketClient,
+  WebSocketManager
+};

package/package.json

@@ -1,6 +1,43 @@
 {
   "name": "@wireflowapp/websocket-core",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.0.0",
+  "description": "Framework-independent native WebSocket engine for Wireflow",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    }
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@wireflowapp/core": "1.0.0"
+  },
+  "keywords": [
+    "websocket",
+    "real-time",
+    "connection",
+    "wireflow"
+  ],
+  "author": "",
+  "license": "MIT",
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
 }