@apocaliss92/nodelink-js 0.6.1 → 0.6.2

package/dist/index.d.cts

@@ -291,9 +291,44 @@ declare function decodeHeader(buf: AnyBuffer): {
  * - expects each message to start with the magic header
  * - supports multiple messages per TCP chunk
  * - waits for full body before emitting
+ *
+ * Accumulation strategy: incoming chunks are appended to a pending list
+ * (O(1) per chunk) and only concatenated into a contiguous `this.buffer`
+ * when a parse is actually attempted. This avoids the previous O(n²)
+ * behavior where every TCP chunk re-copied the whole retained buffer —
+ * costly for large video frames fragmented across many small chunks.
+ *
+ * The observable behavior (the exact sequence of frames emitted, magic
+ * realignment, multi-message chunks, waiting for a complete body) is
+ * identical to the prior `Buffer.concat`-per-chunk implementation.
  */
 declare class BaichuanFrameParser {
+    /** Retained-but-unconsumed contiguous bytes from previous push() calls. */
     private buffer;
+    /** Chunks received since the last materialization, not yet concatenated. */
+    private pending;
+    /** Total bytes held in `pending` (kept in sync to avoid re-summing). */
+    private pendingLen;
+    /**
+     * Total contiguous bytes (`buffer` + `pending`) required before the next
+     * parse attempt can make progress. While buffered bytes stay below this,
+     * incoming chunks are merely stashed in `pending` with no copy. This is
+     * the mechanism that turns the worst case (a large frame fragmented over
+     * many small TCP chunks) from O(n²) into O(n): we concatenate once, when
+     * enough bytes have arrived, instead of on every chunk.
+     *
+     * Starts at 4 — the minimum needed to inspect the magic header.
+     */
+    private needed;
+    /**
+     * Collapse `this.buffer` + all `pending` chunks into a single contiguous
+     * buffer. The retained leftover is copied at most once per materialize(),
+     * and materialize() only runs when `needed` bytes are available — so a
+     * fragmented frame is assembled with a single concat, not one per chunk.
+     */
+    private materialize;
+    /** Total buffered bytes, whether materialized or still pending. */
+    private get available();
     push(chunk: Buffer): BaichuanFrame[];
 }
 

package/dist/index.d.ts

@@ -1166,9 +1166,44 @@ export declare type BaichuanFrame = {
  * - expects each message to start with the magic header
  * - supports multiple messages per TCP chunk
  * - waits for full body before emitting
+ *
+ * Accumulation strategy: incoming chunks are appended to a pending list
+ * (O(1) per chunk) and only concatenated into a contiguous `this.buffer`
+ * when a parse is actually attempted. This avoids the previous O(n²)
+ * behavior where every TCP chunk re-copied the whole retained buffer —
+ * costly for large video frames fragmented across many small chunks.
+ *
+ * The observable behavior (the exact sequence of frames emitted, magic
+ * realignment, multi-message chunks, waiting for a complete body) is
+ * identical to the prior `Buffer.concat`-per-chunk implementation.
  */
 export declare class BaichuanFrameParser {
+    /** Retained-but-unconsumed contiguous bytes from previous push() calls. */
     private buffer;
+    /** Chunks received since the last materialization, not yet concatenated. */
+    private pending;
+    /** Total bytes held in `pending` (kept in sync to avoid re-summing). */
+    private pendingLen;
+    /**
+     * Total contiguous bytes (`buffer` + `pending`) required before the next
+     * parse attempt can make progress. While buffered bytes stay below this,
+     * incoming chunks are merely stashed in `pending` with no copy. This is
+     * the mechanism that turns the worst case (a large frame fragmented over
+     * many small TCP chunks) from O(n²) into O(n): we concatenate once, when
+     * enough bytes have arrived, instead of on every chunk.
+     *
+     * Starts at 4 — the minimum needed to inspect the magic header.
+     */
+    private needed;
+    /**
+     * Collapse `this.buffer` + all `pending` chunks into a single contiguous
+     * buffer. The retained leftover is copied at most once per materialize(),
+     * and materialize() only runs when `needed` bytes are available — so a
+     * fragmented frame is assembled with a single concat, not one per chunk.
+     */
+    private materialize;
+    /** Total buffered bytes, whether materialized or still pending. */
+    private get available();
     push(chunk: Buffer): BaichuanFrame[];
 }
 

package/dist/index.js

@@ -69,7 +69,7 @@ import {
   setGlobalLogger,
   tcpReachabilityProbe,
   xmlIndicatesFloodlight
-} from "./chunk-EAHRVNEX.js";
+} from "./chunk-D4TKRGUP.js";
 import {
   ReolinkCgiApi,
   ReolinkHttpClient,
@@ -116,7 +116,7 @@ import {
   upsertXmlTag,
   xmlEscape,
   zipDirectory
-} from "./chunk-XDVBNZGR.js";
+} from "./chunk-IQVVVSXO.js";
 import {
   AesStreamDecryptor,
   BC_AES_IV,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apocaliss92/nodelink-js",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "TypeScript library implementing Reolink Baichuan protocol (control + streaming) with CGI and RTSP helpers. Full TypeScript support with comprehensive type definitions.",
   "license": "MIT",
   "author": "",