@synnaxlabs/client 0.57.0 → 0.57.1

package/dist/src/framer/cache/dynamic.d.ts

@@ -1,5 +1,5 @@
 import { alamos } from '@synnaxlabs/alamos';
-import { MultiSeries, Series, TimeSpan, TimeStamp } from '@synnaxlabs/x';
+import { MultiSeries, Series, TimeRange, TimeSpan, TimeStamp } from '@synnaxlabs/x';
 import { Transform } from './transform';
 /** Response from a write to the {@link Dynamic} cache. */
 export interface WriteResponse {
@@ -47,15 +47,35 @@ export declare class Dynamic {
      * should this be modified by the caller.
      */
     get leadingBuffer(): Series | null;
+    /**
+     * @returns the time range the buffer's samples actually cover: its start to the last
+     * stamped write, or the wall clock when the buffer holds unstamped data. Unlike the
+     * buffer's provisional time range, the end never claims future time. Null when there
+     * is no buffer.
+     */
+    get dataTimeRange(): TimeRange | null;
     /**
      * @returns a list of buffers that were filled by the cache during the write. If the
      * current buffer is able to fit all writes, no buffers will be returned.
      */
     write(series: MultiSeries): WriteResponse;
     private allocate;
+    /**
+     * @returns the sample capacity for a buffer that must hold the given series whole:
+     * the configured size, or the series' own size when that is larger.
+     */
+    private capacityFor;
     private allocStart;
     private allocCurr;
+    /** @returns the timestamp the flushed buffer's end was stamped with, or null when
+     * there was no buffer. */
     private flushCurr;
+    /**
+     * @returns a right-sized copy of a buffer that rotated with most of its space
+     * unused, or the buffer itself. A rotated buffer holds its whole allocation until
+     * it is collected, which is wasteful when an oversized series ended it early.
+     */
+    private compacted;
     private _write;
     private updateAvgRate;
     private nextBufferSize;

package/dist/src/framer/cache/dynamic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dynamic.d.ts","sourceRoot":"","sources":["../../../../src/framer/cache/dynamic.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAGL,WAAW,EACX,MAAM,EACN,KAAK,QAAQ,EACb,SAAS,EACV,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAsB,KAAK,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAE9E,0DAA0D;AAC1D,MAAM,WAAW,aAAa;IAC5B,0EAA0E;IAC1E,OAAO,EAAE,WAAW,CAAC;IACrB,6DAA6D;IAC7D,SAAS,EAAE,WAAW,CAAC;CACxB;AAED,2CAA2C;AAC3C,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,iBAAiB,EAAE,MAAM,GAAG,QAAQ,CAAC;IACrC,+EAA+E;IAC/E,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,wBAAwB;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC,eAAe,CAAC;IACzC,8BAA8B;IAC9B,GAAG,CAAC,EAAE,MAAM,SAAS,CAAC;CACvB;AAYD;;;;GAIG;AACH,qBAAa,OAAO;IAClB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAsC;IAE5D,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,IAAI,CAAuB;IACnC;;iDAE6C;IAC7C,OAAO,CAAC,WAAW,CAA0B;IAC7C,OAAO,CAAC,OAAO,CAAa;IAC5B,OAAO,CAAC,eAAe,CAAY;IACnC,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAkB;gBAE1B,KAAK,EAAE,YAAY;IAY/B,kEAAkE;IAClE,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED;;;OAGG;IACH,IAAI,aAAa,IAAI,MAAM,GAAG,IAAI,CAEjC;IAED;;;OAGG;IACH,KAAK,CAAC,MAAM,EAAE,WAAW,GAAG,aAAa;IAUzC,OAAO,CAAC,QAAQ;IAgChB,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,SAAS;IAkBjB,OAAO,CAAC,SAAS;IAQjB,OAAO,CAAC,MAAM;IAmEd,OAAO,CAAC,aAAa;IAWrB,OAAO,CAAC,cAAc;IAQtB;;;;OAIG;IACH,KAAK,IAAI,MAAM,GAAG,IAAI;IAStB,wDAAwD;IACxD,KAAK,IAAI,IAAI;CAGd"}
+{"version":3,"file":"dynamic.d.ts","sourceRoot":"","sources":["../../../../src/framer/cache/dynamic.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAGL,WAAW,EACX,MAAM,EAEN,SAAS,EACT,KAAK,QAAQ,EACb,SAAS,EACV,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAsB,KAAK,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAE9E,0DAA0D;AAC1D,MAAM,WAAW,aAAa;IAC5B,0EAA0E;IAC1E,OAAO,EAAE,WAAW,CAAC;IACrB,6DAA6D;IAC7D,SAAS,EAAE,WAAW,CAAC;CACxB;AAED,2CAA2C;AAC3C,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,iBAAiB,EAAE,MAAM,GAAG,QAAQ,CAAC;IACrC,+EAA+E;IAC/E,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,wBAAwB;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC,eAAe,CAAC;IACzC,8BAA8B;IAC9B,GAAG,CAAC,EAAE,MAAM,SAAS,CAAC;CACvB;AAwCD;;;;GAIG;AACH,qBAAa,OAAO;IAClB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAsC;IAE5D,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,IAAI,CAAuB;IACnC;;iDAE6C;IAC7C,OAAO,CAAC,WAAW,CAA0B;IAC7C,OAAO,CAAC,OAAO,CAAa;IAC5B,OAAO,CAAC,eAAe,CAAY;IACnC,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAkB;gBAE1B,KAAK,EAAE,YAAY;IAY/B,kEAAkE;IAClE,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED;;;OAGG;IACH,IAAI,aAAa,IAAI,MAAM,GAAG,IAAI,CAEjC;IAED;;;;;OAKG;IACH,IAAI,aAAa,IAAI,SAAS,GAAG,IAAI,CAGpC;IAED;;;OAGG;IACH,KAAK,CAAC,MAAM,EAAE,WAAW,GAAG,aAAa;IAUzC,OAAO,CAAC,QAAQ;IA4BhB;;;OAGG;IACH,OAAO,CAAC,WAAW;IAUnB,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,SAAS;IAejB;8BAC0B;IAC1B,OAAO,CAAC,SAAS;IAUjB;;;;OAIG;IACH,OAAO,CAAC,SAAS;IAOjB,OAAO,CAAC,MAAM;IAgEd,OAAO,CAAC,aAAa;IAWrB,OAAO,CAAC,cAAc;IAQtB;;;;OAIG;IACH,KAAK,IAAI,MAAM,GAAG,IAAI;IAStB,wDAAwD;IACxD,KAAK,IAAI,IAAI;CAGd"}

package/dist/src/framer/cache/reader.d.ts

@@ -22,22 +22,36 @@ export interface ReaderProps {
      * @default TimeSpan.milliseconds(5)
      */
     overlapThreshold?: TimeSpan;
+    /**
+     * Deadline for a single remote fetch. A fetch that does not settle within it rejects
+     * the reads it serves with an Unreachable error.
+     * @default TimeSpan.seconds(30)
+     */
+    fetchTimeout?: TimeSpan;
 }
 /**
  * Reads historical telemetry, serving from the cache and batch-filling gaps from the
- * server. A batch failure rejects only the reads whose gaps were in the failed fetch.
+ * server. A fetch failure rejects only the reads whose gaps were in the failed fetch.
  */
 export declare class Reader {
     private readonly props;
     private readonly batcher;
-    private readonly mu;
+    private closed;
+    private readonly inFlight;
     constructor(props: ReaderProps);
     /**
      * Reads the given time range for the given channel.
      * @throws {UnexpectedError} if the reader is closed while the read is pending.
+     * @throws {Unreachable} if a fetch serving the read exceeds the fetch timeout.
      */
     read(tr: TimeRange, channel: channel.Key): Promise<MultiSeries>;
     private batchRead;
+    private fetchGap;
+    private fetchWithDeadline;
+    /**
+     * Closes the reader, rejecting every pending read with an UnexpectedError. In-flight
+     * fetch results are discarded when they arrive.
+     */
     close(): Promise<void>;
 }
 //# sourceMappingURL=reader.d.ts.map

package/dist/src/framer/cache/reader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reader.d.ts","sourceRoot":"","sources":["../../../../src/framer/cache/reader.ts"],"names":[],"mappings":"AASA,OAAO,EAEL,WAAW,EAGX,SAAS,EACT,QAAQ,EACT,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAE5C,uEAAuE;AACvE,MAAM,WAAW,YAAY;IAC3B,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,CAAC,GAAG,EAAE,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;CACtD;AAaD,MAAM,WAAW,WAAW;IAC1B,yDAAyD;IACzD,UAAU,EAAE,YAAY,CAAC;IACzB,qEAAqE;IACrE,KAAK,EAAE,KAAK,CAAC;IACb;;;;OAIG;IACH,aAAa,CAAC,EAAE,QAAQ,CAAC;IACzB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,QAAQ,CAAC;CAC7B;AAED;;;GAGG;AACH,qBAAa,MAAM;IACjB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA+C;IACrE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAgC;IAExD,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAoC;gBAE3C,KAAK,EAAE,WAAW;IAkB9B;;;OAGG;IACG,IAAI,CAAC,EAAE,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,CAAC,GAAG,GAAG,OAAO,CAAC,WAAW,CAAC;YAUvD,SAAS;IAsDjB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAM7B"}
+{"version":3,"file":"reader.d.ts","sourceRoot":"","sources":["../../../../src/framer/cache/reader.ts"],"names":[],"mappings":"AAUA,OAAO,EAGL,WAAW,EAEX,SAAS,EACT,QAAQ,EACT,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAE5C,uEAAuE;AACvE,MAAM,WAAW,YAAY;IAC3B,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,CAAC,GAAG,EAAE,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;CACtD;AAqBD,MAAM,WAAW,WAAW;IAC1B,yDAAyD;IACzD,UAAU,EAAE,YAAY,CAAC;IACzB,qEAAqE;IACrE,KAAK,EAAE,KAAK,CAAC;IACb;;;;OAIG;IACH,aAAa,CAAC,EAAE,QAAQ,CAAC;IACzB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,QAAQ,CAAC;IAC5B;;;;OAIG;IACH,YAAY,CAAC,EAAE,QAAQ,CAAC;CACzB;AAED;;;GAGG;AACH,qBAAa,MAAM;IACjB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA+C;IACrE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAgC;IACxD,OAAO,CAAC,MAAM,CAAS;IAGvB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAsB;gBAEnC,KAAK,EAAE,WAAW;IAkB9B;;;;OAIG;IACG,IAAI,CAAC,EAAE,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,CAAC,GAAG,GAAG,OAAO,CAAC,WAAW,CAAC;YAUvD,SAAS;YA2CT,QAAQ;YAiCR,iBAAiB;IA0B/B;;;OAGG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAO7B"}

package/dist/src/framer/cache/unary.d.ts

@@ -23,10 +23,12 @@ export declare class Unary {
     flushDynamic(): void;
     writeStatic(series: MultiSeries): void;
     /**
-     * Reads cached data overlapping the given time range. The result includes the
-     * live leading buffer when it overlaps, but the buffer never claims coverage:
-     * its samples carry provisional leading alignments that cannot pair with fetched
-     * data on another channel, so its span is still reported as a gap to fetch. A
+     * Reads cached data overlapping the given time range. The result includes the live
+     * leading buffer when the data it actually holds overlaps the range, judged by the
+     * last stamped write rather than the buffer's provisional MAX end, so the buffer
+     * never leaks into reads of spans it has no samples for. It never claims coverage
+     * either: its samples carry provisional leading alignments that cannot pair with
+     * fetched data on another channel, so its span is still reported as a gap to fetch. A
      * span may therefore return in both its streamed and fetched representation.
      */
     read(tr: TimeRange): DirtyReadResult;

package/dist/src/framer/cache/unary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"unary.d.ts","sourceRoot":"","sources":["../../../../src/framer/cache/unary.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,WAAW,EAAE,KAAK,MAAM,EAAE,KAAK,SAAS,EAAE,MAAM,eAAe,CAAC;AAGzE,OAAO,EAAW,KAAK,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACpE,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,SAAS,EAEd,KAAK,WAAW,EACjB,MAAM,uBAAuB,CAAC;AAE/B,MAAM,WAAW,UACf,SAAQ,WAAW,EAAE,IAAI,CAAC,YAAY,EAAE,mBAAmB,CAAC;CAAG;AAEjE;;;;GAIG;AACH,qBAAa,KAAK;IAChB,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAU;gBAEtB,KAAK,EAAE,UAAU;IAS7B,YAAY,CAAC,MAAM,EAAE,WAAW,GAAG,WAAW;IAQ9C,IAAI,aAAa,IAAI,MAAM,GAAG,IAAI,CAGjC;IAED;;;;OAIG;IACH,YAAY,IAAI,IAAI;IAOpB,WAAW,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI;IAKtC;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,EAAE,SAAS,GAAG,eAAe;IASpC,EAAE,IAAI,SAAS;IAKf,KAAK,IAAI,IAAI;IAMb,OAAO,CAAC,SAAS;CAIlB"}
+{"version":3,"file":"unary.d.ts","sourceRoot":"","sources":["../../../../src/framer/cache/unary.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,WAAW,EAAE,KAAK,MAAM,EAAE,KAAK,SAAS,EAAE,MAAM,eAAe,CAAC;AAGzE,OAAO,EAAW,KAAK,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACpE,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,SAAS,EAEd,KAAK,WAAW,EACjB,MAAM,uBAAuB,CAAC;AAE/B,MAAM,WAAW,UACf,SAAQ,WAAW,EAAE,IAAI,CAAC,YAAY,EAAE,mBAAmB,CAAC;CAAG;AAEjE;;;;GAIG;AACH,qBAAa,KAAK;IAChB,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAU;gBAEtB,KAAK,EAAE,UAAU;IAS7B,YAAY,CAAC,MAAM,EAAE,WAAW,GAAG,WAAW;IAQ9C,IAAI,aAAa,IAAI,MAAM,GAAG,IAAI,CAGjC;IAED;;;;OAIG;IACH,YAAY,IAAI,IAAI;IAOpB,WAAW,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI;IAKtC;;;;;;;;OAQG;IACH,IAAI,CAAC,EAAE,EAAE,SAAS,GAAG,eAAe;IAWpC,EAAE,IAAI,SAAS;IAKf,KAAK,IAAI,IAAI;IAMb,OAAO,CAAC,SAAS;CAIlB"}

package/dist/src/index.d.ts

@@ -10,7 +10,7 @@ export { type ConnectOptions, default as Synnax, type SynnaxParams, synnaxParams
 export * from './connection';
 export { control } from './control';
 export { device } from './device';
-export { AuthError, ContiguityError, DisconnectedError, isConnectionError, MultipleFoundError, NotFoundError, QueryError, RouteError, UnexpectedError, ValidationError, } from './errors';
+export { AccessDeniedError, AuthError, ContiguityError, DisconnectedError, isConnectionError, MultipleFoundError, NotFoundError, QueryError, RouteError, UnexpectedError, ValidationError, } from './errors';
 export { ethercat } from './ethercat';
 export { framer } from './framer';
 export { Frame } from './framer/frame';

package/dist/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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"}

package/dist/testutil.js

@@ -1,4 +1,4 @@
-import { B as e, G as t, K as n, V as r, W as i, Z as a, d as o, t as s, z as c } from "./client-B08VDLSA.js";
+import { B as e, G as t, K as n, V as r, W as i, Z as a, d as o, t as s, z as c } from "./client-DDACDVZ-.js";
 import { DataType as l, TimeSpan as u, TimeStamp as d, array as f, errors as p, id as m } from "@synnaxlabs/x";
 import { afterAll as h } from "vitest";
 import { connect as g, createServer as _ } from "node:net";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synnaxlabs/client",
-  "version": "0.57.0",
+  "version": "0.57.1",
   "description": "The Synnax Client Library",
   "keywords": [
     "synnax",
@@ -27,7 +27,7 @@
     "zod": "^4.4.3",
     "@synnaxlabs/alamos": "^0.57.0",
     "@synnaxlabs/freighter": "^0.57.0",
-    "@synnaxlabs/x": "^0.57.0"
+    "@synnaxlabs/x": "^0.57.1"
   },
   "peerDependencies": {
     "vitest": "^4.1.10"
@@ -44,10 +44,10 @@
     "typescript": "^7.0.2",
     "vite": "^8.2.0",
     "vitest": "^4.1.10",
-    "@synnaxlabs/madge": "^0.0.0",
-    "@synnaxlabs/tsconfig": "^0.0.0",
     "@synnaxlabs/eslint-config": "^0.0.0",
-    "@synnaxlabs/vite-plugin": "^0.0.0"
+    "@synnaxlabs/madge": "^0.0.0",
+    "@synnaxlabs/vite-plugin": "^0.0.0",
+    "@synnaxlabs/tsconfig": "^0.0.0"
   },
   "type": "module",
   "files": [

package/src/framer/cache/dynamic.ts

@@ -13,6 +13,8 @@ import {
   math,
   MultiSeries,
   Series,
+  Size,
+  TimeRange,
   type TimeSpan,
   TimeStamp,
 } from "@synnaxlabs/x";
@@ -52,6 +54,34 @@ const MAX_DEF_WRITES = 100;
 // Variable-rate types allocate bytes, not samples. Rough bytes-per-sample estimate.
 const VARIABLE_DT_MULTIPLIER = 40;
 
+/**
+ * @returns true when every byte of the series fits in the buffer's free space. Measured
+ * in bytes because a variable-length buffer counts its capacity that way.
+ */
+const fits = (buffer: Series, series: Series): boolean =>
+  series.byteLength.valueOf() <=
+  buffer.byteCapacity.valueOf() - buffer.byteLength.valueOf();
+
+// Bounds on compacting a buffer that rotated early. Both have to trip: the fraction
+// spares a nearly full buffer, the floor one whose waste is not worth a copy.
+const COMPACT_MAX_FILL = 0.25;
+const COMPACT_MIN_WASTE = Size.kilobytes(256);
+
+/**
+ * @returns true when copying the buffer's samples into a right-sized series is worth
+ * the copy. A held buffer never qualifies: the holder keeps the original alive, so a
+ * copy would only add a second allocation, and it would break the object identity a
+ * consumer that both reads and streams deduplicates on.
+ */
+const shouldCompact = (buffer: Series): boolean => {
+  if (buffer.refCount > 0 || buffer.length === 0) return false;
+  const used = buffer.byteLength.valueOf();
+  const capacity = buffer.byteCapacity.valueOf();
+  return (
+    capacity - used > COMPACT_MIN_WASTE.valueOf() && used < capacity * COMPACT_MAX_FILL
+  );
+};
+
 /**
  * A cache for channel data that maintains a single, rolling Series as a buffer
  * for channel data. The buffer's data type is derived from the first written series,
@@ -96,6 +126,17 @@ export class Dynamic {
     return this.curr;
   }
 
+  /**
+   * @returns the time range the buffer's samples actually cover: its start to the last
+   * stamped write, or the wall clock when the buffer holds unstamped data. Unlike the
+   * buffer's provisional time range, the end never claims future time. Null when there
+   * is no buffer.
+   */
+  get dataTimeRange(): TimeRange | null {
+    if (this.curr == null) return null;
+    return new TimeRange(this.curr.timeRange.start, this.currDataEnd ?? this.now());
+  }
+
   /**
    * @returns a list of buffers that were filled by the cache during the write. If the
    * current buffer is able to fit all writes, no buffers will be returned.
@@ -115,7 +156,6 @@ export class Dynamic {
     alignment: bigint,
     start: TimeStamp,
     source: Series,
-    sampleIndex: number,
   ): Series {
     this.counter++;
     const dt = this.props.transform.resolveDataType(source.dataType);
@@ -127,8 +167,7 @@ export class Dynamic {
     let sampleOffset: math.Numeric = 0;
     if (narrowing)
       if (source.dataType.equals(DataType.TIMESTAMP)) sampleOffset = start.valueOf();
-      else if (sampleIndex < source.length)
-        sampleOffset = BigInt(source.data[sampleIndex].valueOf());
+      else if (source.length > 0) sampleOffset = BigInt(source.data[0].valueOf());
     return Series.alloc({
       capacity: dt.isVariable ? capacity * VARIABLE_DT_MULTIPLIER : capacity,
       dataType: dt,
@@ -140,6 +179,18 @@ export class Dynamic {
     });
   }
 
+  /**
+   * @returns the sample capacity for a buffer that must hold the given series whole:
+   * the configured size, or the series' own size when that is larger.
+   */
+  private capacityFor(source: Series): number {
+    const dt = this.props.transform.resolveDataType(source.dataType);
+    const required = dt.isVariable
+      ? Math.ceil(source.byteLength.valueOf() / VARIABLE_DT_MULTIPLIER)
+      : source.length;
+    return Math.max(this.nextBufferSize(), required);
+  }
+
   // Unstamped series (virtual channels, writes without an in-frame index) fall back
   // to the wall clock.
   private allocStart(series: Series): TimeStamp {
@@ -148,28 +199,41 @@ export class Dynamic {
 
   private allocCurr(
     res: WriteResponse,
-    alignment: bigint,
-    start: TimeStamp,
     source: Series,
-    sampleIndex: number,
+    start: TimeStamp | null,
   ): Series {
     this.curr = this.allocate(
-      this.nextBufferSize(),
-      alignment,
-      start,
+      this.capacityFor(source),
+      source.alignment,
+      start ?? this.allocStart(source),
       source,
-      sampleIndex,
     );
     res.allocated.push(this.curr);
     return this.curr;
   }
 
-  private flushCurr(res: WriteResponse): void {
-    if (this.curr == null) return;
-    this.curr.timeRange.end = this.currDataEnd ?? this.now();
+  /** @returns the timestamp the flushed buffer's end was stamped with, or null when
+   * there was no buffer. */
+  private flushCurr(res: WriteResponse): TimeStamp | null {
+    if (this.curr == null) return null;
+    const end = this.currDataEnd ?? this.now();
+    this.curr.timeRange.end = end;
     this.currDataEnd = null;
-    res.flushed.push(this.curr);
+    res.flushed.push(this.compacted(this.curr, res));
     this.curr = null;
+    return end;
+  }
+
+  /**
+   * @returns a right-sized copy of a buffer that rotated with most of its space
+   * unused, or the buffer itself. A rotated buffer holds its whole allocation until
+   * it is collected, which is wasteful when an oversized series ended it early.
+   */
+  private compacted(buffer: Series, res: WriteResponse): Series {
+    // A buffer allocated during this same write has not reached its subscribers yet,
+    // so its reference count cannot yet report who is about to hold it.
+    if (!shouldCompact(buffer) || res.allocated.series.includes(buffer)) return buffer;
+    return buffer.compact();
   }
 
   private _write(series: Series, res: WriteResponse): void {
@@ -194,9 +258,8 @@ export class Dynamic {
       }
     }
     let curr = this.curr;
-    if (curr == null)
-      curr = this.allocCurr(res, series.alignment, this.allocStart(series), series, 0);
-    else {
+    let trimmed = false;
+    if (curr != null) {
       // overlap > 0: the incoming series steps back into samples the current buffer
       // already holds. overlap < 0: there is a gap between the buffer and the series.
       const overlap = Number(curr.alignment + BigInt(curr.length) - series.alignment);
@@ -205,38 +268,36 @@ export class Dynamic {
         // the cache with overlapping series. sub() is zero-copy.
         if (overlap >= series.length) return;
         series = series.sub(overlap);
+        trimmed = true;
       } else if (overlap < 0) {
         this.flushCurr(res);
-        curr = this.allocCurr(
-          res,
-          series.alignment,
-          this.allocStart(series),
-          series,
-          0,
-        );
+        curr = null;
       }
     }
-    while (true) {
-      const converted = transform.convert(series, curr.sampleOffset);
-      const amountWritten = curr.write(converted);
-      if (amountWritten === series.length) {
-        this.currDataEnd = series.timeRange.isZero ? null : series.timeRange.end;
-        this.updateAvgRate(series);
-        return;
+    const convert = (buffer: Series): Series =>
+      transform.convert(series, buffer.sampleOffset);
+    let rotationStart: TimeStamp | null = null;
+    if (curr != null) {
+      const converted = convert(curr);
+      // A series never splits across two buffers. The timestamp where a split falls is
+      // not in the data, so both sides would have to guess the boundary they share, and
+      // a guess lands outside the data whenever samples are irregular.
+      if (fits(curr, converted)) curr.write(converted);
+      else {
+        const end = this.flushCurr(res);
+        // A trimmed series keeps the whole frame's start, which is earlier than the
+        // samples it still holds. Those samples begin where the buffer they were
+        // trimmed against ends, so the next buffer starts there.
+        if (trimmed) rotationStart = end;
+        curr = null;
       }
-      // The timestamp at the split point is unknowable from the data series, so
-      // both sides fall back to the wall clock.
-      this.currDataEnd = null;
-      this.flushCurr(res);
-      curr = this.allocCurr(
-        res,
-        series.alignment + BigInt(amountWritten),
-        this.now(),
-        series,
-        amountWritten,
-      );
-      series = series.slice(amountWritten);
     }
+    if (curr == null) {
+      curr = this.allocCurr(res, series, rotationStart);
+      curr.write(convert(curr));
+    }
+    this.currDataEnd = series.timeRange.isZero ? null : series.timeRange.end;
+    this.updateAvgRate(series);
   }
 
   private updateAvgRate(series: Series): void {

package/src/framer/cache/reader.ts

@@ -7,11 +7,12 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
+import { Unreachable } from "@synnaxlabs/freighter";
 import {
   debounce,
+  errors,
   MultiSeries,
   type Series,
-  sync,
   TimeRange,
   TimeSpan,
 } from "@synnaxlabs/x";
@@ -31,10 +32,18 @@ interface ReadRequest {
   gaps: TimeRange[];
 }
 
+// Tracks one read's outstanding fetches, so the read settles when its last fetch lands.
+// The first failure among them wins.
+interface Tracker {
+  entry: debounce.Entry<ReadRequest>;
+  remaining: number;
+  failure?: unknown;
+}
+
 interface BatchFetch {
   gap: TimeRange;
   channels: Set<channel.Key>;
-  entries: Set<debounce.Entry<ReadRequest>>;
+  trackers: Set<Tracker>;
 }
 
 export interface ReaderProps {
@@ -53,17 +62,25 @@ export interface ReaderProps {
    * @default TimeSpan.milliseconds(5)
    */
   overlapThreshold?: TimeSpan;
+  /**
+   * Deadline for a single remote fetch. A fetch that does not settle within it rejects
+   * the reads it serves with an Unreachable error.
+   * @default TimeSpan.seconds(30)
+   */
+  fetchTimeout?: TimeSpan;
 }
 
 /**
  * Reads historical telemetry, serving from the cache and batch-filling gaps from the
- * server. A batch failure rejects only the reads whose gaps were in the failed fetch.
+ * server. A fetch failure rejects only the reads whose gaps were in the failed fetch.
  */
 export class Reader {
   private readonly props: Required<Omit<ReaderProps, "batchDebounce">>;
   private readonly batcher: debounce.Batcher<ReadRequest>;
-  // Serializes batch execution against close, so close waits for the batch in flight.
-  private readonly mu = sync.newMutex({ closed: false });
+  private closed = false;
+  // Reads whose fetches are in flight, so close can reject them without waiting on the
+  // fetches themselves.
+  private readonly inFlight = new Set<Tracker>();
 
   constructor(props: ReaderProps) {
     const {
@@ -71,90 +88,144 @@ export class Reader {
       cache,
       batchDebounce = TimeSpan.milliseconds(50),
       overlapThreshold = TimeSpan.milliseconds(5),
+      fetchTimeout = TimeSpan.seconds(30),
     } = props;
-    this.props = { readRemote, cache, overlapThreshold };
+    this.props = { readRemote, cache, overlapThreshold, fetchTimeout };
     this.batcher = new debounce.Batcher({
       interval: batchDebounce,
-      exec: async (entries) =>
-        await this.mu.runExclusive(async () => {
-          if (this.mu.closed) throw new UnexpectedError("telemetry reader is closed");
-          await this.batchRead(entries);
-        }),
+      exec: async (entries) => {
+        if (this.closed) throw new UnexpectedError("telemetry reader is closed");
+        await this.batchRead(entries);
+      },
     });
   }
 
   /**
    * Reads the given time range for the given channel.
    * @throws {UnexpectedError} if the reader is closed while the read is pending.
+   * @throws {Unreachable} if a fetch serving the read exceeds the fetch timeout.
    */
   async read(tr: TimeRange, channel: channel.Key): Promise<MultiSeries> {
     const { cache } = this.props;
     const unary = cache.get(channel);
     const { series, gaps } = unary.read(tr);
     if (gaps.length === 0) return series;
-    if (this.mu.closed) throw new UnexpectedError("telemetry reader is closed");
+    if (this.closed) throw new UnexpectedError("telemetry reader is closed");
     await this.batcher.enqueue({ channel, gaps });
     return unary.read(tr).series;
   }
 
   private async batchRead(entries: Array<debounce.Entry<ReadRequest>>): Promise<void> {
-    const { readRemote, cache, overlapThreshold } = this.props;
+    const { cache, overlapThreshold } = this.props;
     const batched: BatchFetch[] = [];
+    const trackers = new Map<debounce.Entry<ReadRequest>, Tracker>();
     entries.forEach((entry) => {
       const unary = cache.get(entry.req.channel);
       entry.req.gaps.forEach((rawGap) => {
-        // A concurrent batch or a streaming write may have filled part of the gap
-        // while this entry sat in the debounce window.
+        // An earlier batch or a streaming write may have filled part of the gap while
+        // this entry sat in the debounce window.
         unary.read(rawGap).gaps.forEach((gap) => {
+          let tracker = trackers.get(entry);
+          if (tracker == null) {
+            tracker = { entry, remaining: 0 };
+            trackers.set(entry, tracker);
+            this.inFlight.add(tracker);
+          }
           const g = batched.find((r) => r.gap.equals(gap, overlapThreshold));
-          if (g == null)
+          if (g == null) {
             batched.push({
               gap,
               channels: new Set([entry.req.channel]),
-              entries: new Set([entry]),
+              trackers: new Set([tracker]),
             });
-          else {
+            tracker.remaining++;
+          } else {
             g.channels.add(entry.req.channel);
             g.gap = TimeRange.max(g.gap, gap);
-            g.entries.add(entry);
+            if (!g.trackers.has(tracker)) {
+              g.trackers.add(tracker);
+              tracker.remaining++;
+            }
           }
         });
       });
     });
-    const failures = new Map<debounce.Entry<ReadRequest>, unknown>();
-    await Promise.all(
-      batched.map(async ({ gap, channels, entries: served }) => {
-        try {
-          const frame = await readRemote(gap, Array.from(channels));
-          // Group series by key in one pass; per-key get() scans the whole frame.
-          const grouped = new Map<channel.Key, Series[]>();
-          frame.forEach((k, s) => {
-            const key = k as channel.Key;
-            const existing = grouped.get(key);
-            if (existing == null) grouped.set(key, [s]);
-            else existing.push(s);
-          });
-          channels.forEach((key) =>
-            cache.get(key).writeStatic(new MultiSeries(grouped.get(key) ?? [])),
-          );
-        } catch (err) {
-          served.forEach((entry) => {
-            if (!failures.has(entry)) failures.set(entry, err);
-          });
-        }
-      }),
-    );
     entries.forEach((entry) => {
-      const err = failures.get(entry);
-      if (err == null) entry.resolve();
-      else entry.reject(err);
+      if (!trackers.has(entry)) entry.resolve();
     });
+    await Promise.all(batched.map(async (b) => await this.fetchGap(b)));
   }
 
-  async close(): Promise<void> {
-    this.batcher.close(new UnexpectedError("telemetry reader is closed"));
-    await this.mu.runExclusive(async () => {
-      this.mu.closed = true;
+  // Never throws: every outcome, including a deadline expiry and a post-close arrival,
+  // settles through the trackers.
+  private async fetchGap({ gap, channels, trackers }: BatchFetch): Promise<void> {
+    const { cache } = this.props;
+    let failure: unknown;
+    try {
+      const frame = await this.fetchWithDeadline(gap, Array.from(channels));
+      if (!this.closed) {
+        // Group series by key in one pass; per-key get() scans the whole frame.
+        const grouped = new Map<channel.Key, Series[]>();
+        frame.forEach((k, s) => {
+          const key = k as channel.Key;
+          const existing = grouped.get(key);
+          if (existing == null) grouped.set(key, [s]);
+          else existing.push(s);
+        });
+        channels.forEach((key) =>
+          cache.get(key).writeStatic(new MultiSeries(grouped.get(key) ?? [])),
+        );
+      }
+    } catch (err) {
+      failure = err;
+    }
+    trackers.forEach((tracker) => {
+      // close() already settled it.
+      if (!this.inFlight.has(tracker)) return;
+      if (failure != null) tracker.failure ??= failure;
+      tracker.remaining--;
+      if (tracker.remaining > 0) return;
+      this.inFlight.delete(tracker);
+      if (tracker.failure == null) tracker.entry.resolve();
+      else tracker.entry.reject(tracker.failure);
     });
   }
+
+  private async fetchWithDeadline(
+    gap: TimeRange,
+    channels: channel.Key[],
+  ): Promise<Frame> {
+    const { readRemote, fetchTimeout } = this.props;
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const deadline = new Promise<never>((_, reject) => {
+      timer = setTimeout(() => {
+        const timeout = fetchTimeout.toString();
+        const message = `gap read for ${gap.toString()} timed out after ${timeout}`;
+        reject(new Unreachable({ message }));
+      }, fetchTimeout.milliseconds);
+    });
+    const fetched = readRemote(gap, channels);
+    try {
+      return await Promise.race([fetched, deadline]);
+    } catch (err) {
+      // The read already failed for its callers; a late settle of the losing fetch must
+      // not surface as an unhandled rejection.
+      fetched.catch(() => {});
+      throw errors.fromUnknown(err);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+
+  /**
+   * Closes the reader, rejecting every pending read with an UnexpectedError. In-flight
+   * fetch results are discarded when they arrive.
+   */
+  async close(): Promise<void> {
+    this.closed = true;
+    const err = new UnexpectedError("telemetry reader is closed");
+    this.batcher.close(err);
+    this.inFlight.forEach(({ entry }) => entry.reject(err));
+    this.inFlight.clear();
+  }
 }