@milaboratories/pframes-rs-node 1.0.57 → 1.0.61

package/export/wrapper.ts

@@ -2,7 +2,6 @@ import humanizeDuration from 'humanize-duration';
 import { ulid } from 'ulid';
 import {
   AbortError,
-  DataInfo,
   PColumnInfo,
   PColumnSpec,
   PFrameError,
@@ -37,42 +36,48 @@ import {
   hashCreateTableRequestColumnId
 } from './dump';
 
-export class PFrame implements PFrameInternal.PFrameV9 {
-  public readonly id: FrameId = ulid() as FrameId;
-  private readonly frame: NodeFrameSymbol;
+export async function pprofDump(): Promise<Uint8Array> {
+  try {
+    return await AddonSymbol.pprofDump();
+  } catch (err: unknown) {
+    throw new PFrameError(
+      `PFrame pprofDump failed, ` + `error:\n` + `${ensureError(err)}`
+    );
+  }
+}
 
-  static async pprofDump(): Promise<Uint8Array> {
-    try {
-      return await AddonSymbol.pprofDump();
-    } catch (err: unknown) {
-      throw new PFrameError(
-        `PFrame pprofDump failed, ` + `error:\n` + `${ensureError(err).message}`
-      );
-    }
+export class PFrame implements PFrameInternal.PFrameV10 {
+  readonly #frame: NodeFrameSymbol;
+
+  readonly #id: FrameId = ulid() as FrameId;
+
+  get id(): FrameId {
+    return this.#id;
   }
 
-  constructor(
-    spillPath: string,
-    public readonly logger?: PFrameInternal.Logger
-  ) {
+  readonly #logger: PFrameInternal.Logger;
+
+  constructor(options: PFrameInternal.PFrameOptions) {
+    this.#logger = options.logger ?? (() => {});
+
     dump(
       [`${this.id}`, `${this.id}.json`],
       {
         timeStamp: Date.now(),
         requestType: 'create'
       },
-      this.logger
+      this.#logger
     );
 
     try {
-      this.frame = AddonSymbol.pFrameCreate(spillPath, logger);
-      this.logger?.('info', `PFrame ${this.id} created`);
+      this.#frame = AddonSymbol.pFrameCreate(options.spillPath, options.logger);
+      this.#logger('info', `PFrame ${this.id} created`);
     } catch (err: unknown) {
       throw new PFrameError(
         `PFrame ${this.id} creation failed, ` +
-          `logger: ${logger?.toString()}, ` +
+          `logger: ${this.#logger?.toString()}, ` +
           `error:\n` +
-          `${ensureError(err).message}`
+          `${ensureError(err)}`
       );
     }
   }
@@ -89,7 +94,7 @@ export class PFrame implements PFrameInternal.PFrameV9 {
           columnSpec
         }
       },
-      this.logger
+      this.#logger
     );
 
     dump(
@@ -97,18 +102,18 @@ export class PFrame implements PFrameInternal.PFrameV9 {
       {
         ...columnSpec
       },
-      this.logger
+      this.#logger
     );
 
     try {
-      return AddonSymbol.pFrameAddColumnSpec(this.frame, columnId, columnSpec);
+      return AddonSymbol.pFrameAddColumnSpec(this.#frame, columnId, columnSpec);
     } catch (err: unknown) {
       throw new PFrameError(
         `PFrame ${this.id} addColumnSpec request ${requestId} failed, ` +
           `columnId: ${JSON.stringify(columnId)}, ` +
           `columnSpec: ${JSON.stringify(columnSpec)}, ` +
           `error:\n` +
-          `${ensureError(err).message}`
+          `${ensureError(err)}`
       );
     }
   }
@@ -121,7 +126,7 @@ export class PFrame implements PFrameInternal.PFrameV9 {
         timeStamp: Date.now(),
         requestType: 'setDataSource'
       },
-      this.logger
+      this.#logger
     );
 
     const wrappedDataSource = {
@@ -138,10 +143,10 @@ export class PFrame implements PFrameInternal.PFrameV9 {
               blobIds
             }
           },
-          this.logger
+          this.#logger
         );
 
-        this.logger?.(
+        this.#logger(
           'info',
           `PFrame ${this.id} preloadBlob started, blobIds: ${JSON.stringify(blobIds)}`
         );
@@ -150,7 +155,7 @@ export class PFrame implements PFrameInternal.PFrameV9 {
           return await dataSource.preloadBlob(blobIds);
         } finally {
           const t1 = performance.now();
-          this.logger?.(
+          this.#logger(
             'info',
             `PFrame ${this.id} preloadBlob finished, took ${humanizeDuration(Math.round(t1 - t0))} (${blobIds.length} blobs)`
           );
@@ -169,25 +174,25 @@ export class PFrame implements PFrameInternal.PFrameV9 {
               blobId
             }
           },
-          this.logger
+          this.#logger
         );
 
         const blob = await dataSource.resolveBlobContent(blobId);
-        this.logger?.('info', `PFrame ${this.id} resolved blob ${blobId}`);
-        dump([`${this.id}`, `data`, `${blobId}`], blob, this.logger);
+        this.#logger('info', `PFrame ${this.id} resolved blob ${blobId}`);
+        dump([`${this.id}`, `data`, `${blobId}`], blob, this.#logger);
 
         return blob;
       }
     };
 
     try {
-      return AddonSymbol.pFrameSetDataSource(this.frame, wrappedDataSource);
+      return AddonSymbol.pFrameSetDataSource(this.#frame, wrappedDataSource);
     } catch (err: unknown) {
       throw new PFrameError(
         `PFrame ${this.id} setDataSource request ${requestId} failed, ` +
           `dataSource: ${dataSource.toString()}, ` +
           `error:\n` +
-          `${ensureError(err).message}`
+          `${ensureError(err)}`
       );
     }
   }
@@ -210,7 +215,7 @@ export class PFrame implements PFrameInternal.PFrameV9 {
           dataInfo
         }
       },
-      this.logger
+      this.#logger
     );
 
     dump(
@@ -218,13 +223,13 @@ export class PFrame implements PFrameInternal.PFrameV9 {
       {
         ...dataInfo
       },
-      this.logger
+      this.#logger
     );
 
     try {
       ops?.signal?.throwIfAborted();
       return AddonSymbol.pFrameSetColumnData(
-        this.frame,
+        this.#frame,
         columnId,
         dataInfo,
         ops?.signal
@@ -235,7 +240,7 @@ export class PFrame implements PFrameInternal.PFrameV9 {
           `columnId: ${JSON.stringify(columnId)}, ` +
           `dataInfo: ${JSON.stringify(dataInfo)}, ` +
           `error:\n` +
-          `${ensureError(err).message}`
+          `${ensureError(err)}`
       );
     }
   }
@@ -248,17 +253,17 @@ export class PFrame implements PFrameInternal.PFrameV9 {
         timeStamp: Date.now(),
         requestType: 'dispose'
       },
-      this.logger
+      this.#logger
     );
 
     try {
-      AddonSymbol.pFrameDispose(this.frame);
-      this.logger?.('info', `PFrame ${this.id} disposed`);
+      AddonSymbol.pFrameDispose(this.#frame);
+      this.#logger('info', `PFrame ${this.id} disposed`);
     } catch (err: unknown) {
       throw new PFrameError(
         `PFrame ${this.id} dispose request ${requestId} failed, ` +
           `error:\n` +
-          `${ensureError(err).message}`
+          `${ensureError(err)}`
       );
     }
   }
@@ -278,22 +283,22 @@ export class PFrame implements PFrameInternal.PFrameV9 {
         requestType: 'findColumns',
         requestData: request
       },
-      this.logger
+      this.#logger
     );
 
     const t0 = performance.now();
     try {
-      return await AddonSymbol.pFrameFindColumns(this.frame, request);
+      return await AddonSymbol.pFrameFindColumns(this.#frame, request);
     } catch (err: unknown) {
       throw new PFrameError(
         `PFrame ${this.id} findColumns request ${requestId} failed, ` +
           `request: ${JSON.stringify(request)}, ` +
           `error:\n` +
-          `${ensureError(err).message}`
+          `${ensureError(err)}`
       );
     } finally {
       const t1 = performance.now();
-      this.logger?.(
+      this.#logger(
         'info',
         `PFrame ${this.id} findColumns request ${requestId} took ${humanizeDuration(Math.round(t1 - t0))}`
       );
@@ -311,22 +316,22 @@ export class PFrame implements PFrameInternal.PFrameV9 {
         requestType: 'deleteColumn',
         requestData: request
       },
-      this.logger
+      this.#logger
     );
 
     const t0 = performance.now();
     try {
-      return await AddonSymbol.pFrameDeleteColumn(this.frame, request);
+      return await AddonSymbol.pFrameDeleteColumn(this.#frame, request);
     } catch (err: unknown) {
       throw new PFrameError(
         `PFrame ${this.id} deleteColumn request ${requestId} failed, ` +
           `request: ${JSON.stringify(request)}, ` +
           `error:\n` +
-          `${ensureError(err).message}`
+          `${ensureError(err)}`
       );
     } finally {
       const t1 = performance.now();
-      this.logger?.(
+      this.#logger(
         'info',
         `PFrame ${this.id} deleteColumn request ${requestId} took ${humanizeDuration(Math.round(t1 - t0))}`
       );
@@ -344,22 +349,22 @@ export class PFrame implements PFrameInternal.PFrameV9 {
           columnId: hashColumnId(columnId)
         }
       },
-      this.logger
+      this.#logger
     );
 
     const t0 = performance.now();
     try {
-      return await AddonSymbol.pFrameGetColumnSpec(this.frame, columnId);
+      return await AddonSymbol.pFrameGetColumnSpec(this.#frame, columnId);
     } catch (err: unknown) {
       throw new PFrameError(
         `PFrame ${this.id} getColumnSpec request ${requestId} failed, ` +
           `columnId: ${JSON.stringify(columnId)}, ` +
           `error:\n` +
-          `${ensureError(err).message}`
+          `${ensureError(err)}`
       );
     } finally {
       const t1 = performance.now();
-      this.logger?.(
+      this.#logger(
         'info',
         `PFrame ${this.id} getColumnSpec request ${requestId} took ${humanizeDuration(Math.round(t1 - t0))}`
       );
@@ -374,61 +379,59 @@ export class PFrame implements PFrameInternal.PFrameV9 {
         timeStamp: Date.now(),
         requestType: 'listColumns'
       },
-      this.logger
+      this.#logger
     );
 
     const t0 = performance.now();
     try {
-      return await AddonSymbol.pFrameListColumns(this.frame);
+      return await AddonSymbol.pFrameListColumns(this.#frame);
     } catch (err: unknown) {
       throw new PFrameError(
         `PFrame ${this.id} listColumns request ${requestId} failed, ` +
           `error:\n` +
-          `${ensureError(err).message}`
+          `${ensureError(err)}`
       );
     } finally {
       const t1 = performance.now();
-      this.logger?.(
+      this.#logger(
         'info',
         `PFrame ${this.id} listColumns request ${requestId} took ${humanizeDuration(Math.round(t1 - t0))}`
       );
     }
   }
 
-  createTable(
-    request: PFrameInternal.CreateTableRequestV3
-  ): PFrameInternal.PTableV6 {
+  createTable(request: PFrameInternal.CreateTableRequestV3): PTable {
     const requestId = ulid() as TableId;
     const dumpData = {
       timeStamp: Date.now(),
       requestType: 'createTable',
       requestData: hashCreateTableRequestColumnId(request)
     };
-    dump([`${this.id}`, `${requestId}.json`], dumpData, this.logger);
+    dump([`${this.id}`, `${requestId}.json`], dumpData, this.#logger);
     dump(
       [`${this.id}`, `${requestId}`, `${requestId}.json`],
       dumpData,
-      this.logger
+      this.#logger
     );
 
     const t0 = performance.now();
     try {
       const boxed = AddonSymbol.pFrameCreateTable(
-        this.frame,
+        this.#frame,
         requestId,
         request
       );
-      return new PTable(this, requestId, boxed);
+      return new PTable(this, requestId, boxed, this.#logger);
     } catch (err: unknown) {
       throw new PFrameError(
         `PFrame ${this.id} createTable request ${requestId} failed, ` +
           `request: ${JSON.stringify(request)}, ` +
           `error:\n` +
-          `${ensureError(err).message}`
+          `${ensureError(err)}`
       );
     } finally {
       const t1 = performance.now();
-      this.logger?.(
+      this.#logger(
         'info',
         `PFrame ${this.id} createTable request ${requestId} took ${humanizeDuration(Math.round(t1 - t0))}`
       );
@@ -449,10 +452,10 @@ export class PFrame implements PFrameInternal.PFrameV9 {
         requestType: 'getUniqueValues',
         requestData: hashUniqueValuesRequestColumnId(request)
       },
-      this.logger
+      this.#logger
     );
 
-    this.logger?.(
+    this.#logger(
       'info',
       `PFrame ${this.id} getUniqueValues request ${requestId} started`
     );
@@ -460,7 +463,7 @@ export class PFrame implements PFrameInternal.PFrameV9 {
     try {
       ops?.signal?.throwIfAborted();
       return await AddonSymbol.pFrameGetUniqueValues(
-        this.frame,
+        this.#frame,
         requestId,
         request,
         ops?.signal
@@ -475,11 +478,11 @@ export class PFrame implements PFrameInternal.PFrameV9 {
         `PFrame ${this.id} getUniqueValues request ${requestId} failed, ` +
           `request: ${JSON.stringify(request)}, ` +
           `error:\n` +
-          `${ensureError(err).message}`
+          `${ensureError(err)}`
       );
     } finally {
       const t1 = performance.now();
-      this.logger?.(
+      this.#logger(
         'info',
         `PFrame ${this.id} getUniqueValues request ${requestId} finished, took ${humanizeDuration(Math.round(t1 - t0))}`
       );
@@ -487,33 +490,49 @@ export class PFrame implements PFrameInternal.PFrameV9 {
   }
 }
 
-class PTable implements PFrameInternal.PTableV6 {
+class PTable implements PFrameInternal.PTableV7 {
+  readonly #frame: PFrame;
+  readonly #table: NodeTableSymbol;
+
+  readonly #id: string;
+
+  get id(): string {
+    return this.#id;
+  }
+
+  readonly #logger: PFrameInternal.Logger;
+
   constructor(
-    private readonly frame: PFrame,
-    public readonly id: string,
-    private readonly table: NodeTableSymbol
+    frame: PFrame,
+    id: string,
+    table: NodeTableSymbol,
+    logger: PFrameInternal.Logger
   ) {
-    this.frame.logger?.('info', `PTable ${this.id} created`);
+    this.#frame = frame;
+    this.#table = table;
+    this.#id = id;
+    this.#logger = logger;
+    this.#logger('info', `PTable ${this.id} created`);
   }
 
   getSpec(): PTableColumnSpec[] {
     const requestId = ulid();
     dump(
-      [`${this.frame.id}`, `${this.id}`, `${requestId}.json`],
+      [`${this.#frame.id}`, `${this.id}`, `${requestId}.json`],
       {
         timeStamp: Date.now(),
         requestType: 'getSpec'
       },
-      this.frame.logger
+      this.#logger
     );
 
     try {
-      return AddonSymbol.pTableGetSpec(this.table);
+      return AddonSymbol.pTableGetSpec(this.#table);
     } catch (err: unknown) {
       throw new PFrameError(
         `PTable ${this.id} getSpec request ${requestId} failed, ` +
           `error:\n` +
-          `${ensureError(err).message}`
+          `${ensureError(err)}`
       );
     }
   }
@@ -521,7 +540,7 @@ class PTable implements PFrameInternal.PTableV6 {
   getColumnIndices(columnIds: PTableColumnId[]): number[] {
     const requestId = ulid();
     dump(
-      [`${this.frame.id}`, `${this.id}`, `${requestId}.json`],
+      [`${this.#frame.id}`, `${this.id}`, `${requestId}.json`],
       {
         timeStamp: Date.now(),
         requestType: 'getColumnIndices',
@@ -529,17 +548,17 @@ class PTable implements PFrameInternal.PTableV6 {
           columnIds: columnIds.map(hashTableColumnId)
         }
       },
-      this.frame.logger
+      this.#logger
     );
 
     try {
-      return AddonSymbol.pTableGetColumnIndices(this.table, columnIds);
+      return AddonSymbol.pTableGetColumnIndices(this.#table, columnIds);
     } catch (err: unknown) {
       throw new PFrameError(
         `PTable ${this.id} getColumnIndices request ${requestId} failed, ` +
           `columnIds: ${JSON.stringify(columnIds)}, ` +
           `error:\n` +
-          `${ensureError(err).message}`
+          `${ensureError(err)}`
       );
     }
   }
@@ -550,15 +569,15 @@ class PTable implements PFrameInternal.PTableV6 {
   }): Promise<number> {
     const requestId = ulid();
     dump(
-      [`${this.frame.id}`, `${this.id}`, `${requestId}.json`],
+      [`${this.#frame.id}`, `${this.id}`, `${requestId}.json`],
       {
         timeStamp: Date.now(),
         requestType: 'getFootprint'
       },
-      this.frame.logger
+      this.#logger
     );
 
-    this.frame.logger?.(
+    this.#logger(
       'info',
       `PTable ${this.id} getFootprint request ${requestId} started`
     );
@@ -566,7 +585,7 @@ class PTable implements PFrameInternal.PTableV6 {
     try {
       ops?.signal?.throwIfAborted();
       return await AddonSymbol.pTableGetFootprint(
-        this.table,
+        this.#table,
         ops?.withPredecessors ?? false,
         ops?.signal
       );
@@ -579,11 +598,11 @@ class PTable implements PFrameInternal.PTableV6 {
       throw new PFrameError(
         `PTable ${this.id} getFootprint request ${requestId} failed, ` +
           `error:\n` +
-          `${ensureError(err).message}`
+          `${ensureError(err)}`
       );
     } finally {
       const t1 = performance.now();
-      this.frame.logger?.(
+      this.#logger(
         'info',
         `PTable ${this.id} getFootprint request ${requestId} finished, took ${humanizeDuration(Math.round(t1 - t0))}`
       );
@@ -593,22 +612,22 @@ class PTable implements PFrameInternal.PTableV6 {
   async getShape(ops?: { signal?: AbortSignal }): Promise<PTableShape> {
     const requestId = ulid();
     dump(
-      [`${this.frame.id}`, `${this.id}`, `${requestId}.json`],
+      [`${this.#frame.id}`, `${this.id}`, `${requestId}.json`],
       {
         timeStamp: Date.now(),
         requestType: 'getShape'
       },
-      this.frame.logger
+      this.#logger
     );
 
-    this.frame.logger?.(
+    this.#logger(
       'info',
       `PTable ${this.id} getShape request ${requestId} started`
     );
     const t0 = performance.now();
     try {
       ops?.signal?.throwIfAborted();
-      return await AddonSymbol.pTableGetShape(this.table, ops?.signal);
+      return await AddonSymbol.pTableGetShape(this.#table, ops?.signal);
     } catch (err: unknown) {
       if (isAbortError(err)) {
         throw new AbortError(
@@ -618,11 +637,11 @@ class PTable implements PFrameInternal.PTableV6 {
       throw new PFrameError(
         `PTable ${this.id} getShape request ${requestId} failed, ` +
           `error:\n` +
-          `${ensureError(err).message}`
+          `${ensureError(err)}`
       );
     } finally {
       const t1 = performance.now();
-      this.frame.logger?.(
+      this.#logger(
         'info',
         `PTable ${this.id} getShape request ${requestId} finished, took ${humanizeDuration(Math.round(t1 - t0))}`
       );
@@ -638,7 +657,7 @@ class PTable implements PFrameInternal.PTableV6 {
   ): Promise<PTableVector[]> {
     const requestId = ulid() as TableId;
     dump(
-      [`${this.frame.id}`, `${this.id}`, `${requestId}.json`],
+      [`${this.#frame.id}`, `${this.id}`, `${requestId}.json`],
       {
         timeStamp: Date.now(),
         requestType: 'getData',
@@ -647,10 +666,10 @@ class PTable implements PFrameInternal.PTableV6 {
           range: ops?.range ?? null
         }
       },
-      this.frame.logger
+      this.#logger
     );
 
-    this.frame.logger?.(
+    this.#logger(
       'info',
       `PTable ${this.id} getData request ${requestId} started`
     );
@@ -659,7 +678,7 @@ class PTable implements PFrameInternal.PTableV6 {
     try {
       ops?.signal?.throwIfAborted();
       const result = await AddonSymbol.pTableGetData(
-        this.table,
+        this.#table,
         requestId,
         columnIndices,
         ops?.range,
@@ -678,18 +697,18 @@ class PTable implements PFrameInternal.PTableV6 {
           `columnIndices: ${JSON.stringify(columnIndices)}, ` +
           `range: ${ops?.range ? JSON.stringify(ops.range) : undefined}, ` +
           `error:\n` +
-          `${ensureError(err).message}`
+          `${ensureError(err)}`
       );
     } finally {
       const t1 = performance.now();
-      this.frame.logger?.(
+      this.#logger(
         'info',
         `PTable ${this.id} getData request ${requestId} finished, took ${humanizeDuration(Math.round(t1 - t0))} (${rowCount} rows)`
       );
     }
   }
 
-  filter(request: PTableRecordFilter[]): PFrameInternal.PTableV6 {
+  filter(request: PTableRecordFilter[]): PTable {
     const requestId = ulid() as TableId;
     const dumpData = {
       timeStamp: Date.now(),
@@ -699,38 +718,34 @@ class PTable implements PFrameInternal.PTableV6 {
         filters: request.map(hashFilterColumnId)
       }
     };
+    dump([`${this.#frame.id}`, `${requestId}.json`], dumpData, this.#logger);
     dump(
-      [`${this.frame.id}`, `${requestId}.json`],
+      [`${this.#frame.id}`, `${requestId}`, `${requestId}.json`],
       dumpData,
-      this.frame.logger
-    );
-    dump(
-      [`${this.frame.id}`, `${requestId}`, `${requestId}.json`],
-      dumpData,
-      this.frame.logger
+      this.#logger
     );
 
     const t0 = performance.now();
     try {
-      const boxed = AddonSymbol.pTableFilter(this.table, requestId, request);
-      return new PTable(this.frame, requestId, boxed);
+      const boxed = AddonSymbol.pTableFilter(this.#table, requestId, request);
+      return new PTable(this.#frame, requestId, boxed, this.#logger);
     } catch (err: unknown) {
       throw new PFrameError(
         `PTable ${this.id} filter request ${requestId} failed, ` +
           `request: ${JSON.stringify(request)}, ` +
           `error:\n` +
-          `${ensureError(err).message}`
+          `${ensureError(err)}`
       );
     } finally {
       const t1 = performance.now();
-      this.frame.logger?.(
+      this.#logger(
         'info',
         `PTable ${this.id} filter request ${requestId} took ${humanizeDuration(Math.round(t1 - t0))}`
       );
     }
   }
 
-  sort(request: PTableSorting[]): PFrameInternal.PTableV6 {
+  sort(request: PTableSorting[]): PTable {
     const requestId = ulid() as TableId;
     const dumpData = {
       timeStamp: Date.now(),
@@ -738,31 +753,27 @@ class PTable implements PFrameInternal.PTableV6 {
       requestType: 'sort',
       requestData: request.map(hashSortingColumnId)
     };
+    dump([`${this.#frame.id}`, `${requestId}.json`], dumpData, this.#logger);
     dump(
-      [`${this.frame.id}`, `${requestId}.json`],
-      dumpData,
-      this.frame.logger
-    );
-    dump(
-      [`${this.frame.id}`, `${requestId}`, `${requestId}.json`],
+      [`${this.#frame.id}`, `${requestId}`, `${requestId}.json`],
       dumpData,
-      this.frame.logger
+      this.#logger
     );
 
     const t0 = performance.now();
     try {
-      const boxed = AddonSymbol.pTableSort(this.table, requestId, request);
-      return new PTable(this.frame, requestId, boxed);
+      const boxed = AddonSymbol.pTableSort(this.#table, requestId, request);
+      return new PTable(this.#frame, requestId, boxed, this.#logger);
     } catch (err: unknown) {
       throw new PFrameError(
         `PTable ${this.id} sort request ${requestId} failed, ` +
           `request: ${JSON.stringify(request)}, ` +
           `error:\n` +
-          `${ensureError(err).message}`
+          `${ensureError(err)}`
       );
     } finally {
       const t1 = performance.now();
-      this.frame.logger?.(
+      this.#logger(
         'info',
         `PTable ${this.id} sort request ${requestId} took ${humanizeDuration(Math.round(t1 - t0))}`
       );
@@ -772,22 +783,22 @@ class PTable implements PFrameInternal.PTableV6 {
   dispose() {
     const requestId = ulid();
     dump(
-      [`${this.frame.id}`, `${this.id}`, `${requestId}.json`],
+      [`${this.#frame.id}`, `${this.id}`, `${requestId}.json`],
       {
         timeStamp: Date.now(),
         requestType: 'dispose'
       },
-      this.frame.logger
+      this.#logger
     );
 
     try {
-      AddonSymbol.pTableDispose(this.table);
-      this.frame.logger?.('info', `PTable ${this.id} disposed`);
+      AddonSymbol.pTableDispose(this.#table);
+      this.#logger('info', `PTable ${this.id} disposed`);
     } catch (err: unknown) {
       throw new PFrameError(
         `PTable ${this.id} dispose request ${requestId} failed, ` +
           `error:\n` +
-          `${ensureError(err).message}`
+          `${ensureError(err)}`
       );
     }
   }