request-iframe 0.1.0 → 0.2.0

package/esm/api/client.js

@@ -1,8 +1,10 @@
-import { getIframeTargetOrigin, generateInstanceId } from '../utils';
-import { RequestIframeClientServer } from '../core/client-server';
-import { RequestIframeClientImpl } from '../core/client';
+import { getIframeTargetOrigin } from '../utils/iframe';
+import { generateInstanceId } from '../utils/id';
+import { RequestIframeClientImpl } from '../impl/client';
 import { setupClientDebugInterceptors } from '../utils/debug';
-import { Messages, ErrorCode } from '../constants';
+import { setRequestIframeLogLevel } from '../utils/logger';
+import { Messages, ErrorCode, OriginConstant, LogLevel } from '../constants';
+import { clearMessageChannelCache } from '../message/channel-cache';
 
 /**
  * Create a client (for sending requests)
@@ -14,7 +16,7 @@ import { Messages, ErrorCode } from '../constants';
  */
 export function requestIframeClient(target, options) {
   var targetWindow = null;
-  var targetOrigin = '*';
+  var targetOrigin = OriginConstant.ANY;
   if (target.tagName === 'IFRAME') {
     var iframe = target;
     targetWindow = iframe.contentWindow;
@@ -27,7 +29,7 @@ export function requestIframeClient(target, options) {
     }
   } else {
     targetWindow = target;
-    targetOrigin = '*';
+    targetOrigin = OriginConstant.ANY;
   }
 
   // Allow user to override targetOrigin explicitly
@@ -41,15 +43,8 @@ export function requestIframeClient(target, options) {
   // Generate instance ID first (will be used by both client and server)
   var instanceId = generateInstanceId();
 
-  // Create ClientServer (internally obtains or creates a shared MessageChannel)
-  var server = new RequestIframeClientServer({
-    secretKey,
-    ackTimeout: options === null || options === void 0 ? void 0 : options.ackTimeout,
-    autoOpen: options === null || options === void 0 ? void 0 : options.autoOpen
-  }, instanceId);
-
-  // Create client instance
-  var client = new RequestIframeClientImpl(targetWindow, targetOrigin, server, {
+  // Create client instance (internally creates its core message server)
+  var client = new RequestIframeClientImpl(targetWindow, targetOrigin, {
     secretKey,
     ackTimeout: options === null || options === void 0 ? void 0 : options.ackTimeout,
     timeout: options === null || options === void 0 ? void 0 : options.timeout,
@@ -57,12 +52,23 @@ export function requestIframeClient(target, options) {
     returnData: options === null || options === void 0 ? void 0 : options.returnData,
     headers: options === null || options === void 0 ? void 0 : options.headers,
     allowedOrigins: options === null || options === void 0 ? void 0 : options.allowedOrigins,
-    validateOrigin: options === null || options === void 0 ? void 0 : options.validateOrigin
+    validateOrigin: options === null || options === void 0 ? void 0 : options.validateOrigin,
+    autoOpen: options === null || options === void 0 ? void 0 : options.autoOpen,
+    autoAckMaxMetaLength: options === null || options === void 0 ? void 0 : options.autoAckMaxMetaLength,
+    autoAckMaxIdLength: options === null || options === void 0 ? void 0 : options.autoAckMaxIdLength
   }, instanceId);
 
-  // If trace mode is enabled, register debug interceptors
+  /**
+   * Trace/log level:
+   * - default: only warn/error will be printed (logger default)
+   * - if trace enabled: raise log level and (optionally) enable detailed debug interceptors
+   */
   if (options !== null && options !== void 0 && options.trace) {
-    setupClientDebugInterceptors(client);
+    var level = options.trace === true ? LogLevel.TRACE : options.trace;
+    setRequestIframeLogLevel(level);
+    if (level === LogLevel.TRACE || level === LogLevel.INFO) {
+      setupClientDebugInterceptors(client);
+    }
   }
   return client;
 }
@@ -72,8 +78,11 @@ export function requestIframeClient(target, options) {
  * Note: This clears the shared message channel for the specified secretKey
  */
 export function clearRequestIframeClientCache(secretKey) {
-  // Now client is no longer cached, only need to clear MessageChannel cache
-  // MessageChannel cleanup is handled by clearMessageChannelCache in cache.ts
-  // Empty implementation kept here to maintain API compatibility
-  void secretKey;
+  // Client is not cached; this helper only clears shared MessageChannel cache.
+  // If secretKey is provided, only clear channels under that secretKey.
+  if (typeof secretKey === 'string') {
+    clearMessageChannelCache(secretKey);
+    return;
+  }
+  clearMessageChannelCache();
 }

package/esm/api/endpoint.js

@@ -0,0 +1,229 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import "core-js/modules/es.array.map.js";
+import { getIframeTargetOrigin } from '../utils/iframe';
+import { generateInstanceId } from '../utils/id';
+import { isWindowAvailable } from '../utils/window';
+import { RequestIframeClientImpl } from '../impl/client';
+import { RequestIframeServerImpl } from '../impl/server';
+import { setupClientDebugInterceptors, setupServerDebugListeners } from '../utils/debug';
+import { setRequestIframeLogLevel } from '../utils/logger';
+import { Messages, ErrorCode, OriginConstant, LogLevel } from '../constants';
+
+/**
+ * Endpoint facade type (client + server).
+ */
+
+/**
+ * Endpoint facade options (client + server).
+ *
+ * - For client-side sending: uses RequestIframeClientOptions fields (targetOrigin, headers, etc.)
+ * - For server-side handling: uses RequestIframeServerOptions fields (middlewares, allowedOrigins, etc.)
+ *
+ * Note: overlapping fields (autoOpen/trace/allowedOrigins/validateOrigin/ackTimeout/autoAckMax*) apply to both sides.
+ */
+
+class RequestIframeEndpointApiFacade {
+  constructor(params) {
+    var _params$options;
+    _defineProperty(this, "desiredOpen_", true);
+    /** Client send APIs */
+    _defineProperty(this, "send", (path, body, options) => this.getClient().send(path, body, options));
+    _defineProperty(this, "sendFile", (path, content, options) => this.getClient().sendFile(path, content, options));
+    _defineProperty(this, "sendStream", (path, stream, options) => this.getClient().sendStream(path, stream, options));
+    _defineProperty(this, "isConnect", () => this.getClient().isConnect());
+    _defineProperty(this, "getCookies", path => this.getClient().getCookies(path));
+    _defineProperty(this, "getCookie", (name, path) => this.getClient().getCookie(name, path));
+    _defineProperty(this, "setCookie", (name, value, options) => this.getClient().setCookie(name, value, options));
+    _defineProperty(this, "removeCookie", (name, path) => this.getClient().removeCookie(name, path));
+    _defineProperty(this, "clearCookies", () => this.getClient().clearCookies());
+    /** Server routing/middleware APIs */
+    _defineProperty(this, "use", (pathOrMiddleware, middleware) => this.getServer().use(pathOrMiddleware, middleware));
+    _defineProperty(this, "on", (path, handler) => this.getServer().on(path, handler));
+    _defineProperty(this, "off", path => this.getServer().off(path));
+    _defineProperty(this, "map", handlers => this.getServer().map(handlers));
+    this.targetWindow_ = params.targetWindow;
+    this.targetOrigin_ = params.targetOrigin;
+    this.options_ = params.options;
+    this.endpointId_ = params.endpointId;
+    this.desiredOpen_ = ((_params$options = params.options) === null || _params$options === void 0 ? void 0 : _params$options.autoOpen) !== false;
+  }
+
+  /**
+   * Lazy create client.
+   */
+  getClient() {
+    if (!this.client_) {
+      var options = this.options_;
+      var client = new RequestIframeClientImpl(this.targetWindow_, this.targetOrigin_, {
+        secretKey: options === null || options === void 0 ? void 0 : options.secretKey,
+        ackTimeout: options === null || options === void 0 ? void 0 : options.ackTimeout,
+        timeout: options === null || options === void 0 ? void 0 : options.timeout,
+        asyncTimeout: options === null || options === void 0 ? void 0 : options.asyncTimeout,
+        returnData: options === null || options === void 0 ? void 0 : options.returnData,
+        headers: options === null || options === void 0 ? void 0 : options.headers,
+        allowedOrigins: options === null || options === void 0 ? void 0 : options.allowedOrigins,
+        validateOrigin: options === null || options === void 0 ? void 0 : options.validateOrigin,
+        autoOpen: false,
+        autoAckMaxMetaLength: options === null || options === void 0 ? void 0 : options.autoAckMaxMetaLength,
+        autoAckMaxIdLength: options === null || options === void 0 ? void 0 : options.autoAckMaxIdLength
+      }, this.endpointId_);
+      if (options !== null && options !== void 0 && options.trace) {
+        var level = options.trace === true ? LogLevel.TRACE : options.trace;
+        setRequestIframeLogLevel(level);
+        if (level === LogLevel.TRACE || level === LogLevel.INFO) {
+          setupClientDebugInterceptors(client);
+        }
+      }
+      this.client_ = client;
+    }
+    if (this.desiredOpen_ && !this.client_.isOpen) {
+      this.client_.open();
+    }
+    if (!this.desiredOpen_ && this.client_.isOpen) {
+      this.client_.close();
+    }
+    return this.client_;
+  }
+
+  /**
+   * Lazy create server.
+   */
+  getServer() {
+    if (!this.server_) {
+      var options = this.options_;
+      var server = new RequestIframeServerImpl({
+        secretKey: options === null || options === void 0 ? void 0 : options.secretKey,
+        id: this.endpointId_,
+        ackTimeout: options === null || options === void 0 ? void 0 : options.ackTimeout,
+        autoOpen: false,
+        allowedOrigins: options === null || options === void 0 ? void 0 : options.allowedOrigins,
+        validateOrigin: options === null || options === void 0 ? void 0 : options.validateOrigin,
+        maxConcurrentRequestsPerClient: options === null || options === void 0 ? void 0 : options.maxConcurrentRequestsPerClient,
+        autoAckMaxMetaLength: options === null || options === void 0 ? void 0 : options.autoAckMaxMetaLength,
+        autoAckMaxIdLength: options === null || options === void 0 ? void 0 : options.autoAckMaxIdLength
+      });
+      if (options !== null && options !== void 0 && options.trace) {
+        var level = options.trace === true ? LogLevel.TRACE : options.trace;
+        setRequestIframeLogLevel(level);
+        if (level === LogLevel.TRACE || level === LogLevel.INFO) {
+          setupServerDebugListeners(server);
+        }
+      }
+      this.server_ = server;
+    }
+    if (this.desiredOpen_ && !this.server_.isOpen) {
+      this.server_.open();
+    }
+    if (!this.desiredOpen_ && this.server_.isOpen) {
+      this.server_.close();
+    }
+    return this.server_;
+  }
+
+  /**
+   * Optional accessors for debugging.
+   * Note: accessing will trigger lazy creation.
+   */
+  get client() {
+    return this.getClient();
+  }
+  get server() {
+    return this.getServer();
+  }
+
+  /** Client fields */
+  get targetWindow() {
+    return this.targetWindow_;
+  }
+  get id() {
+    return this.endpointId_;
+  }
+  get isOpen() {
+    /**
+     * Facade-level open state.
+     * - When client/server is lazily created later, it will follow this state.
+     */
+    return this.desiredOpen_;
+  }
+  get interceptors() {
+    return this.getClient().interceptors;
+  }
+  set interceptors(value) {
+    this.getClient().interceptors = value;
+  }
+  isAvailable() {
+    return isWindowAvailable(this.targetWindow_);
+  }
+  open() {
+    var _this$client_, _this$server_;
+    this.desiredOpen_ = true;
+    (_this$client_ = this.client_) === null || _this$client_ === void 0 || _this$client_.open();
+    (_this$server_ = this.server_) === null || _this$server_ === void 0 || _this$server_.open();
+  }
+  close() {
+    var _this$client_2, _this$server_2;
+    this.desiredOpen_ = false;
+    (_this$client_2 = this.client_) === null || _this$client_2 === void 0 || _this$client_2.close();
+    (_this$server_2 = this.server_) === null || _this$server_2 === void 0 || _this$server_2.close();
+  }
+  destroy() {
+    var _this$client_3, _this$server_3;
+    /**
+     * Destroy created sides only.
+     * They share the underlying MessageChannel via cache ref-counting, so partial creation is safe.
+     */
+    (_this$client_3 = this.client_) === null || _this$client_3 === void 0 || _this$client_3.destroy();
+    (_this$server_3 = this.server_) === null || _this$server_3 === void 0 || _this$server_3.destroy();
+    this.client_ = undefined;
+    this.server_ = undefined;
+  }
+  /** Server fields */
+  get secretKey() {
+    var _this$options_;
+    return (_this$options_ = this.options_) === null || _this$options_ === void 0 ? void 0 : _this$options_.secretKey;
+  }
+}
+
+/**
+ * Create an endpoint facade (client + server) for a peer window/iframe.
+ *
+ * It can:
+ * - send requests to the peer (client)
+ * - handle requests from the peer (server)
+ */
+export function requestIframeEndpoint(target, options) {
+  var _options$id;
+  var targetWindow = null;
+  var targetOrigin = OriginConstant.ANY;
+  if (target.tagName === 'IFRAME') {
+    var iframe = target;
+    targetWindow = iframe.contentWindow;
+    targetOrigin = getIframeTargetOrigin(iframe);
+    if (!targetWindow) {
+      throw {
+        message: Messages.IFRAME_NOT_READY,
+        code: ErrorCode.IFRAME_NOT_READY
+      };
+    }
+  } else {
+    targetWindow = target;
+    targetOrigin = OriginConstant.ANY;
+  }
+
+  /** Allow user to override targetOrigin explicitly */
+  if (options !== null && options !== void 0 && options.targetOrigin) {
+    targetOrigin = options.targetOrigin;
+  }
+
+  /**
+   * Endpoint uses ONE shared id by default, so it behaves like a single endpoint.
+   * If options.id is provided, it becomes the shared id for both client+server.
+   */
+  var endpointId = (_options$id = options === null || options === void 0 ? void 0 : options.id) !== null && _options$id !== void 0 ? _options$id : generateInstanceId();
+  return new RequestIframeEndpointApiFacade({
+    targetWindow,
+    targetOrigin,
+    options,
+    endpointId
+  });
+}

package/esm/api/server.js

@@ -1,6 +1,8 @@
-import { RequestIframeServerImpl } from '../core/server';
+import { RequestIframeServerImpl } from '../impl/server';
 import { setupServerDebugListeners } from '../utils/debug';
+import { setRequestIframeLogLevel } from '../utils/logger';
 import { getCachedServer, cacheServer, clearServerCache } from '../utils/cache';
+import { LogLevel } from '../constants';
 
 /**
  * Create a server (for receiving and handling requests)
@@ -32,12 +34,22 @@ export function requestIframeServer(options) {
     autoOpen: options === null || options === void 0 ? void 0 : options.autoOpen,
     allowedOrigins: options === null || options === void 0 ? void 0 : options.allowedOrigins,
     validateOrigin: options === null || options === void 0 ? void 0 : options.validateOrigin,
-    maxConcurrentRequestsPerClient: options === null || options === void 0 ? void 0 : options.maxConcurrentRequestsPerClient
+    maxConcurrentRequestsPerClient: options === null || options === void 0 ? void 0 : options.maxConcurrentRequestsPerClient,
+    autoAckMaxMetaLength: options === null || options === void 0 ? void 0 : options.autoAckMaxMetaLength,
+    autoAckMaxIdLength: options === null || options === void 0 ? void 0 : options.autoAckMaxIdLength
   });
 
-  // If trace mode is enabled, register debug listeners
+  /**
+   * Trace/log level:
+   * - default: only warn/error will be printed (logger default)
+   * - if trace enabled: raise log level and (optionally) enable detailed debug listeners
+   */
   if (options !== null && options !== void 0 && options.trace) {
-    setupServerDebugListeners(server);
+    var level = options.trace === true ? LogLevel.TRACE : options.trace;
+    setRequestIframeLogLevel(level);
+    if (level === LogLevel.TRACE || level === LogLevel.INFO) {
+      setupServerDebugListeners(server);
+    }
   }
 
   // Cache server if id is specified
@@ -51,9 +63,7 @@ export function requestIframeServer(options) {
  * Clear server cache (for testing or reset)
  * Note: This clears the cached server instances
  */
-export function clearRequestIframeServerCache(secretKey) {
-  // Clear server cache
-  clearServerCache();
-  // MessageChannel cleanup is handled by clearMessageChannelCache in cache.ts
-  void secretKey;
+export function clearRequestIframeServerCache(arg) {
+  /** Clear server cache */
+  clearServerCache(arg);
 }

package/esm/constants/debug.js

@@ -0,0 +1,17 @@
+/**
+ * Debug constants (event names for structured logs).
+ */
+
+export var DebugEvent = {
+  CLIENT_REQUEST_START: 'client.request.start',
+  CLIENT_REQUEST_SUCCESS: 'client.request.success',
+  CLIENT_REQUEST_SUCCESS_FILE: 'client.request.success.file',
+  CLIENT_REQUEST_SUCCESS_STREAM: 'client.request.success.stream',
+  CLIENT_REQUEST_FAILED: 'client.request.failed',
+  CLIENT_MESSAGE_INBOUND: 'client.message.inbound',
+  CLIENT_MESSAGE_OUTBOUND: 'client.message.outbound',
+  SERVER_REQUEST_RECEIVED: 'server.request.received',
+  SERVER_RESPONSE_SEND: 'server.response.send',
+  SERVER_MESSAGE_INBOUND: 'server.message.inbound',
+  SERVER_MESSAGE_OUTBOUND: 'server.message.outbound'
+};

package/esm/constants/index.js

@@ -1,11 +1,11 @@
-/**
- * Protocol version constants
- * Used to identify the protocol version of messages, for compatibility handling in future version upgrades
- * 
- * Version compatibility strategy:
- * - Only check minimum supported version, reject deprecated old versions
- * - Don't check maximum version, as new versions usually maintain backward compatibility with old message formats
- * - This way new version servers can be compatible with old version clients, without forcing client upgrades
+/**
+ * Protocol version constants
+ * Used to identify the protocol version of messages, for compatibility handling in future version upgrades
+ * 
+ * Version compatibility strategy:
+ * - Only check minimum supported version, reject deprecated old versions
+ * - Don't check maximum version, as new versions usually maintain backward compatibility with old message formats
+ * - This way new version servers can be compatible with old version clients, without forcing client upgrades
  */
 export var ProtocolVersion = {
   /** Current protocol version */
@@ -14,16 +14,34 @@ export var ProtocolVersion = {
   MIN_SUPPORTED: 1
 };
 
-/**
- * Protocol version type
+/**
+ * Special origin values
  */
+export var OriginConstant = {
+  /** Wildcard origin (postMessage targetOrigin = '*') */
+  ANY: '*'
+};
+
+/**
+ * Auto-ack (ACK-only) limits.
+ */
+export var AutoAckConstant = {
+  /** Max length of ack.id to be echoed back in auto-ack */
+  MAX_ID_LENGTH: 1024,
+  /** Max length of ack.meta to be echoed back in auto-ack */
+  MAX_META_LENGTH: 5120
+};
 
-/**
- * Protocol validation result
+/**
+ * Protocol version type
  */
 
-/**
- * HTTP status code constants
+/**
+ * Protocol validation result
+ */
+
+/**
+ * HTTP status code constants
  */
 export var HttpStatus = {
   OK: 200,
@@ -40,8 +58,8 @@ export var HttpStatus = {
   SERVICE_UNAVAILABLE: 503
 };
 
-/**
- * HTTP status text constants
+/**
+ * HTTP status text constants
  */
 export var HttpStatusText = {
   [HttpStatus.OK]: 'OK',
@@ -58,15 +76,15 @@ export var HttpStatusText = {
   [HttpStatus.SERVICE_UNAVAILABLE]: 'Service Unavailable'
 };
 
-/**
- * Get status text
+/**
+ * Get status text
  */
 export function getStatusText(code) {
   return HttpStatusText[code] || 'Unknown';
 }
 
-/**
- * Error code constants
+/**
+ * Error code constants
  */
 export var ErrorCode = {
   /** ACK confirmation timeout */
@@ -96,11 +114,27 @@ export var ErrorCode = {
   /** Too many concurrent requests (rate limiting) */
   TOO_MANY_REQUESTS: 'TOO_MANY_REQUESTS',
   /** Stream start not received in time */
-  STREAM_START_TIMEOUT: 'STREAM_START_TIMEOUT'
+  STREAM_START_TIMEOUT: 'STREAM_START_TIMEOUT',
+  /** Stream has already started */
+  STREAM_ALREADY_STARTED: 'STREAM_ALREADY_STARTED',
+  /** Stream has ended */
+  STREAM_ENDED: 'STREAM_ENDED',
+  /** Stream idle timeout */
+  STREAM_TIMEOUT: 'STREAM_TIMEOUT',
+  /** Stream expired */
+  STREAM_EXPIRED: 'STREAM_EXPIRED',
+  /** Stream read error */
+  STREAM_READ_ERROR: 'STREAM_READ_ERROR',
+  /** Stream write() is only available when mode is push */
+  STREAM_WRITE_ONLY_IN_PUSH_MODE: 'STREAM_WRITE_ONLY_IN_PUSH_MODE',
+  /** Stream pending queue overflow */
+  STREAM_PENDING_QUEUE_OVERFLOW: 'STREAM_PENDING_QUEUE_OVERFLOW',
+  /** Stream pending bytes overflow */
+  STREAM_PENDING_BYTES_OVERFLOW: 'STREAM_PENDING_BYTES_OVERFLOW'
 };
 
-/**
- * Message type constants
+/**
+ * Message type constants
  */
 export var MessageType = {
   /** Request message */
@@ -113,8 +147,6 @@ export var MessageType = {
   RESPONSE: 'response',
   /** Error message */
   ERROR: 'error',
-  /** Client confirms response received */
-  RECEIVED: 'received',
   /** Ping message (for connection detection) */
   PING: 'ping',
   /** Pong message (for connection detection) */
@@ -130,9 +162,7 @@ export var MessageType = {
   /** Stream cancel */
   STREAM_CANCEL: 'stream_cancel',
   /** Stream pull (receiver requests next chunks) */
-  STREAM_PULL: 'stream_pull',
-  /** Stream ack (receiver acknowledges a chunk) */
-  STREAM_ACK: 'stream_ack'
+  STREAM_PULL: 'stream_pull'
 };
 export var MessageRole = {
   /** Server role */
@@ -140,15 +170,15 @@ export var MessageRole = {
   /** Client role */
   CLIENT: 'client'
 };
-/**
- * Default timeout configuration (milliseconds)
+/**
+ * Default timeout configuration (milliseconds)
  */
 export var DefaultTimeout = {
-  /** 
-   * ACK confirmation timeout: 1000ms (1s)
-   * Used for both client waiting for server ACK and server waiting for client RECEIVED.
-   * Increased from 500ms to accommodate slower environments or busy browsers where postMessage
-   * serialization/deserialization may take longer.
+  /** 
+   * ACK confirmation timeout: 1000ms (1s)
+   * Used for requireAck confirmation (ACK-only).
+   * Increased from 500ms to accommodate slower environments or busy browsers where postMessage
+   * serialization/deserialization may take longer.
    */
   ACK: 1000,
   /** Request timeout: 5s */
@@ -157,8 +187,8 @@ export var DefaultTimeout = {
   ASYNC: 120000
 };
 
-/**
- * HTTP Header name constants
+/**
+ * HTTP Header name constants
  */
 export var HttpHeader = {
   /** Set-Cookie (server sets cookie) */
@@ -173,20 +203,20 @@ export var HttpHeader = {
   COOKIE: 'Cookie'
 };
 
-/**
- * HTTP Header name type
+/**
+ * HTTP Header name type
  */
 
-/**
- * Message type union type
+/**
+ * Message type union type
  */
 
-/**
- * Error code union type
+/**
+ * Error code union type
  */
 
-/**
- * Stream type constants
+/**
+ * Stream type constants
  */
 export var StreamType = {
   /** Normal data stream */
@@ -195,18 +225,18 @@ export var StreamType = {
   FILE: 'file'
 };
 
-/**
- * Stream mode constants
- * - PULL: receiver pulls next chunks (backpressure)
- * - PUSH: producer pushes via write()
+/**
+ * Stream mode constants
+ * - PULL: receiver pulls next chunks (backpressure)
+ * - PUSH: producer pushes via write()
  */
 export var StreamMode = {
   PULL: 'pull',
   PUSH: 'push'
 };
-/**
- * Stream internal message type constants (for stream internal message handling)
- * Note: These are MessageType.STREAM_* values with the stream_ prefix removed
+/**
+ * Stream internal message type constants (for stream internal message handling)
+ * Note: These are MessageType.STREAM_* values with the stream_ prefix removed
  */
 export var StreamInternalMessageType = {
   /** Data message */
@@ -218,21 +248,19 @@ export var StreamInternalMessageType = {
   /** Cancel message */
   CANCEL: 'cancel',
   /** Pull message */
-  PULL: 'pull',
-  /** Ack message */
-  ACK: 'ack'
+  PULL: 'pull'
 };
 
-/**
- * Stream internal message type value type
+/**
+ * Stream internal message type value type
  */
 
-/**
- * Stream type value type
+/**
+ * Stream type value type
  */
 
-/**
- * Stream state constants
+/**
+ * Stream state constants
  */
 export var StreamState = {
   /** Pending */
@@ -247,11 +275,32 @@ export var StreamState = {
   CANCELLED: 'cancelled'
 };
 
-/**
- * Stream state value type
+/**
+ * Stream state value type
  */
 
-/**
- * Message constants (for multi-language support)
+/**
+ * Stream event name constants (for stream.on / observability)
+ */
+export var StreamEvent = {
+  START: 'start',
+  DATA: 'data',
+  READ: 'read',
+  WRITE: 'write',
+  SEND: 'send',
+  PULL: 'pull',
+  ACK: 'ack',
+  END: 'end',
+  CANCEL: 'cancel',
+  ERROR: 'error',
+  TIMEOUT: 'timeout',
+  EXPIRED: 'expired',
+  STATE: 'state'
+};
+/**
+ * Message constants (for multi-language support)
  */
-export { Messages, formatMessage, setMessages, resetMessages, getMessages } from './messages';
+export { Messages, formatMessage, setMessages, resetMessages, getMessages } from './messages';
+export { WarnOnceKey, buildWarnOnceKey } from './warn-once';
+export { LogLevel } from './log';
+export { DebugEvent } from './debug';