@milaboratories/pf-driver 1.0.39 → 1.0.41

package/src/driver_impl.ts

@@ -29,50 +29,50 @@ import {
   type PTableRecordSingleValueFilterV2,
   type PTableRecordFilter,
   type JsonSerializable,
-} from '@platforma-sdk/model';
-import type { PFrameInternal } from '@milaboratories/pl-model-middle-layer';
+} from "@platforma-sdk/model";
+import type { PFrameInternal } from "@milaboratories/pl-model-middle-layer";
 import {
   assertNever,
   ConcurrencyLimitingExecutor,
   type PoolEntry,
-} from '@milaboratories/ts-helpers';
-import { PFrameFactory } from '@milaboratories/pframes-rs-node';
-import { tmpdir } from 'node:os';
-import type {
-  AbstractInternalPFrameDriver,
-} from './driver_decl';
-import { logPFrames } from './logging';
+} from "@milaboratories/ts-helpers";
+import { PFrameFactory } from "@milaboratories/pframes-rs-node";
+import { tmpdir } from "node:os";
+import type { AbstractInternalPFrameDriver } from "./driver_decl";
+import { logPFrames } from "./logging";
 import {
   PFramePool,
   type LocalBlobProvider as PoolLocalBlobProvider,
   type RemoteBlobProvider as PoolRemoteBlobProvider,
-} from './pframe_pool';
-import { PTableDefPool } from './ptable_def_pool';
-import { PTablePool } from './ptable_pool';
+} from "./pframe_pool";
+import { PTableDefPool } from "./ptable_def_pool";
+import { PTablePool } from "./ptable_pool";
 import {
   PTableCachePerFrame,
   PTableCachePerFrameOpsDefaults,
   type PTableCachePerFrameOps,
-} from './ptable_cache_per_frame';
+} from "./ptable_cache_per_frame";
 import {
   PTableCachePlain,
   PTableCachePlainOpsDefaults,
   type PTableCachePlainOps,
-} from './ptable_cache_plain';
+} from "./ptable_cache_plain";
 
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-export interface LocalBlobProvider<TreeEntry extends JsonSerializable>
-  extends PoolLocalBlobProvider<TreeEntry> { }
+export interface LocalBlobProvider<
+  TreeEntry extends JsonSerializable,
+> extends PoolLocalBlobProvider<TreeEntry> {}
 
 export interface RemoteBlobProvider<TreeEntry extends JsonSerializable>
   extends PoolRemoteBlobProvider<TreeEntry>, AsyncDisposable {}
 
-export type AbstractPFrameDriverOps = PTableCachePerFrameOps & PTableCachePlainOps & {
-  /** Concurrency limits for `getUniqueValues` and `calculateTableData` requests */
-  pFrameConcurrency: number;
-  /** Concurrency limits for `getShape` and `getData` requests */
-  pTableConcurrency: number;
-};
+export type AbstractPFrameDriverOps = PTableCachePerFrameOps &
+  PTableCachePlainOps & {
+    /** Concurrency limits for `getUniqueValues` and `calculateTableData` requests */
+    pFrameConcurrency: number;
+    /** Concurrency limits for `getShape` and `getData` requests */
+    pTableConcurrency: number;
+  };
 
 export const AbstractPFrameDriverOpsDefaults: AbstractPFrameDriverOps = {
   ...PTableCachePerFrameOpsDefaults,
@@ -86,8 +86,10 @@ export type DataInfoResolver<PColumnData, TreeEntry extends JsonSerializable> =
   data: PColumnData,
 ) => PFrameInternal.DataInfo<TreeEntry>;
 
-export class AbstractPFrameDriver<PColumnData, TreeEntry extends JsonSerializable>
-implements AbstractInternalPFrameDriver<PColumnData> {
+export class AbstractPFrameDriver<
+  PColumnData,
+  TreeEntry extends JsonSerializable,
+> implements AbstractInternalPFrameDriver<PColumnData> {
   private readonly logger: PFrameInternal.Logger;
 
   private readonly localBlobProvider: LocalBlobProvider<TreeEntry>;
@@ -134,7 +136,12 @@ implements AbstractInternalPFrameDriver<PColumnData> {
     this.frameConcurrencyLimiter = new ConcurrencyLimitingExecutor(options.pFrameConcurrency);
     this.tableConcurrencyLimiter = new ConcurrencyLimitingExecutor(options.pTableConcurrency);
 
-    this.pFrames = new PFramePool(this.localBlobProvider, this.remoteBlobProvider, this.logger, spillPath);
+    this.pFrames = new PFramePool(
+      this.localBlobProvider,
+      this.remoteBlobProvider,
+      this.logger,
+      spillPath,
+    );
     this.pTableDefs = new PTableDefPool(this.logger);
     this.pTables = new PTablePool(this.pFrames, this.pTableDefs, this.logger);
 
@@ -154,27 +161,33 @@ implements AbstractInternalPFrameDriver<PColumnData> {
   // Internal / Config API Methods
   //
 
-  public createPFrame(
-    def: PFrameDef<PColumn<PColumnData>>,
-  ): PoolEntry<PFrameHandle> {
+  public createPFrame(def: PFrameDef<PColumn<PColumnData>>): PoolEntry<PFrameHandle> {
     const ValueTypes = new Set(Object.values(ValueType));
 
     const supportedColumns = def.filter((column) => ValueTypes.has(column.spec.valueType));
     const uniqueColumns = uniqueBy(supportedColumns, (column) => column.id);
-    const columns = uniqueColumns.map((c) => mapPObjectData(c, (d) => this.resolveDataInfo(c.spec, d)));
+    const columns = uniqueColumns.map((c) =>
+      mapPObjectData(c, (d) => this.resolveDataInfo(c.spec, d)),
+    );
 
     return this.pFrames.acquire(columns);
   }
 
-  public createPTable(
-    rawDef: PTableDef<PColumn<PColumnData>>,
-  ): PoolEntry<PTableHandle> {
+  public createPTable(rawDef: PTableDef<PColumn<PColumnData>>): PoolEntry<PTableHandle> {
     const pFrameEntry = this.createPFrame(extractAllColumns(rawDef.src));
-    const sortedDef = sortPTableDef(migratePTableFilters(mapPTableDef(rawDef, (c) => c.id), this.logger));
+    const sortedDef = sortPTableDef(
+      migratePTableFilters(
+        mapPTableDef(rawDef, (c) => c.id),
+        this.logger,
+      ),
+    );
 
     const pTableEntry = this.pTableDefs.acquire({ def: sortedDef, pFrameHandle: pFrameEntry.key });
     if (logPFrames()) {
-      this.logger('info', `Create PTable call (pFrameHandle = ${pFrameEntry.key}; pTableHandle = ${pTableEntry.key})`);
+      this.logger(
+        "info",
+        `Create PTable call (pFrameHandle = ${pFrameEntry.key}; pTableHandle = ${pTableEntry.key})`,
+      );
     }
 
     const unref = () => {
@@ -201,14 +214,16 @@ implements AbstractInternalPFrameDriver<PColumnData> {
       ...request,
       compatibleWith:
         request.compatibleWith.length !== 0
-          ? [{
-              axesSpec: [
-                ...new Map(request.compatibleWith.map(
-                  (item) => [canonicalizeJson(item), item] as const,
-                )).values(),
-              ],
-              qualifications: [],
-            }]
+          ? [
+              {
+                axesSpec: [
+                  ...new Map(
+                    request.compatibleWith.map((item) => [canonicalizeJson(item), item] as const),
+                  ).values(),
+                ],
+                qualifications: [],
+              },
+            ]
           : [],
     };
 
@@ -218,16 +233,24 @@ implements AbstractInternalPFrameDriver<PColumnData> {
     const response = await pFrame.findColumns(iRequest);
     return {
       hits: response.hits
-        .filter((h) => // only exactly matching columns
-          h.mappingVariants.length === 0
-          || h.mappingVariants.some((v) =>
-            v.qualifications.forHit.length === 0
-            && v.qualifications.forQueries.every((q) => q.length === 0)))
+        .filter(
+          (h) =>
+            // only exactly matching columns
+            h.mappingVariants.length === 0 ||
+            h.mappingVariants.some(
+              (v) =>
+                v.qualifications.forHit.length === 0 &&
+                v.qualifications.forQueries.every((q) => q.length === 0),
+            ),
+        )
         .map((h) => h.hit),
     };
   }
 
-  public async getColumnSpec(handle: PFrameHandle, columnId: PObjectId): Promise<PColumnSpec | null> {
+  public async getColumnSpec(
+    handle: PFrameHandle,
+    columnId: PObjectId,
+  ): Promise<PColumnSpec | null> {
     const { pFramePromise } = this.pFrames.getByKey(handle);
     const pFrame = await pFramePromise;
     return await pFrame.getColumnSpec(columnId);
@@ -246,7 +269,8 @@ implements AbstractInternalPFrameDriver<PColumnData> {
     signal?: AbortSignal,
   ): Promise<CalculateTableDataResponse> {
     if (logPFrames()) {
-      this.logger('info',
+      this.logger(
+        "info",
         `Call calculateTableData, handle = ${handle}, request = ${JSON.stringify(request, bigintReplacer)}`,
       );
     }
@@ -292,7 +316,8 @@ implements AbstractInternalPFrameDriver<PColumnData> {
     signal?: AbortSignal,
   ): Promise<UniqueValuesResponse> {
     if (logPFrames()) {
-      this.logger('info',
+      this.logger(
+        "info",
         `Call getUniqueValues, handle = ${handle}, request = ${JSON.stringify(request, bigintReplacer)}`,
       );
     }
@@ -302,12 +327,15 @@ implements AbstractInternalPFrameDriver<PColumnData> {
 
     const combinedSignal = AbortSignal.any([signal, disposeSignal].filter((s) => !!s));
     return await this.frameConcurrencyLimiter.run(async () => {
-      return await pFrame.getUniqueValues({
-        ...request,
-        filters: migrateFilters(request.filters, this.logger),
-      }, {
-        signal: combinedSignal,
-      });
+      return await pFrame.getUniqueValues(
+        {
+          ...request,
+          filters: migrateFilters(request.filters, this.logger),
+        },
+        {
+          signal: combinedSignal,
+        },
+      );
     });
   }
 
@@ -387,16 +415,16 @@ function sortPTableDef(def: PTableDef<PObjectId>): PTableDef<PObjectId> {
     }
     const type = lhs.type;
     switch (type) {
-      case 'column':
+      case "column":
         return lhs.column < (rhs as typeof lhs).column ? -1 : 1;
-      case 'slicedColumn':
-      case 'artificialColumn':
+      case "slicedColumn":
+      case "artificialColumn":
         return lhs.newId < (rhs as typeof lhs).newId ? -1 : 1;
-      case 'inlineColumn': {
+      case "inlineColumn": {
         return lhs.column.id < (rhs as typeof lhs).column.id ? -1 : 1;
       }
-      case 'inner':
-      case 'full': {
+      case "inner":
+      case "full": {
         const rhsInner = rhs as typeof lhs;
         if (lhs.entries.length !== rhsInner.entries.length) {
           return lhs.entries.length - rhsInner.entries.length;
@@ -409,7 +437,7 @@ function sortPTableDef(def: PTableDef<PObjectId>): PTableDef<PObjectId> {
         }
         return 0;
       }
-      case 'outer': {
+      case "outer": {
         const rhsOuter = rhs as typeof lhs;
         const cmp = cmpJoinEntries(lhs.primary, rhsOuter.primary);
         if (cmp !== 0) {
@@ -432,19 +460,19 @@ function sortPTableDef(def: PTableDef<PObjectId>): PTableDef<PObjectId> {
   }
   function sortJoinEntry(entry: JoinEntry<PObjectId>): JoinEntry<PObjectId> {
     switch (entry.type) {
-      case 'column':
-      case 'slicedColumn':
-      case 'inlineColumn':
+      case "column":
+      case "slicedColumn":
+      case "inlineColumn":
         return entry;
-      case 'artificialColumn': {
+      case "artificialColumn": {
         const sortedAxesIndices = entry.axesIndices.toSorted((lhs, rhs) => lhs - rhs);
         return {
           ...entry,
           axesIndices: sortedAxesIndices,
         };
       }
-      case 'inner':
-      case 'full': {
+      case "inner":
+      case "full": {
         const sortedEntries = entry.entries.map(sortJoinEntry);
         sortedEntries.sort(cmpJoinEntries);
         return {
@@ -452,7 +480,7 @@ function sortPTableDef(def: PTableDef<PObjectId>): PTableDef<PObjectId> {
           entries: sortedEntries,
         };
       }
-      case 'outer': {
+      case "outer": {
         const sortedSecondary = entry.secondary.map(sortJoinEntry);
         sortedSecondary.sort(cmpJoinEntries);
         return {
@@ -467,14 +495,14 @@ function sortPTableDef(def: PTableDef<PObjectId>): PTableDef<PObjectId> {
   }
   function sortFilters(filters: PTableRecordFilter[]): PTableRecordFilter[] {
     return filters.toSorted((lhs, rhs) => {
-      if (lhs.column.type === 'axis' && rhs.column.type === 'axis') {
+      if (lhs.column.type === "axis" && rhs.column.type === "axis") {
         const lhsId = canonicalizeJson(getAxisId(lhs.column.id));
         const rhsId = canonicalizeJson(getAxisId(rhs.column.id));
         return lhsId < rhsId ? -1 : 1;
-      } else if (lhs.column.type === 'column' && rhs.column.type === 'column') {
+      } else if (lhs.column.type === "column" && rhs.column.type === "column") {
         return lhs.column.id < rhs.column.id ? -1 : 1;
       } else {
-        return lhs.column.type === 'axis' ? -1 : 1;
+        return lhs.column.type === "axis" ? -1 : 1;
       }
     });
   }
@@ -493,11 +521,11 @@ function migrateFilters(
   const filtersV1 = [];
   const filtersV2: PTableRecordSingleValueFilterV2[] = [];
   for (const filter of filters) {
-    if ((filter.type as unknown) === 'bySingleColumn') {
+    if ((filter.type as unknown) === "bySingleColumn") {
       filtersV1.push(filter);
       filtersV2.push({
         ...filter,
-        type: 'bySingleColumnV2',
+        type: "bySingleColumnV2",
       });
     } else {
       filtersV2.push(filter);
@@ -505,7 +533,8 @@ function migrateFilters(
   }
   if (filtersV1.length > 0) {
     const filtersV1Json = JSON.stringify(filtersV1);
-    logger('warn',
+    logger(
+      "warn",
       `type overwritten from 'bySingleColumn' to 'bySingleColumnV2' for filters: ${filtersV1Json}`,
     );
   }
@@ -513,15 +542,21 @@ function migrateFilters(
 }
 
 function migratePTableFilters<T>(
-  def: Omit<PTableDef<T>, 'partitionFilters'> | PTableDef<T>,
+  def: Omit<PTableDef<T>, "partitionFilters"> | PTableDef<T>,
   logger: PFrameInternal.Logger,
 ): PTableDef<T> {
-  if (!('partitionFilters' in def)) {
+  if (!("partitionFilters" in def)) {
     // For old blocks assume all axes filters to be partition filters
     return {
       ...def,
-      partitionFilters: migrateFilters(def.filters.filter((f) => f.column.type === 'axis'), logger),
-      filters: migrateFilters(def.filters.filter((f) => f.column.type === 'column'), logger),
+      partitionFilters: migrateFilters(
+        def.filters.filter((f) => f.column.type === "axis"),
+        logger,
+      ),
+      filters: migrateFilters(
+        def.filters.filter((f) => f.column.type === "column"),
+        logger,
+      ),
     };
   }
   return {

package/src/index.ts

@@ -1,4 +1,4 @@
-export * from './driver_decl';
-export * from './driver_impl';
-export * from './data_info_helpers';
-export * from './driver_double';
+export * from "./driver_decl";
+export * from "./driver_impl";
+export * from "./data_info_helpers";
+export * from "./driver_double";

package/src/pframe_pool.ts

@@ -8,19 +8,16 @@ import {
   type JsonSerializable,
   type PColumn,
   type PFrameHandle,
-} from '@platforma-sdk/model';
-import { hashJson, PFrameInternal } from '@milaboratories/pl-model-middle-layer';
-import {
-  RefCountPoolBase,
-  type PoolEntry,
-} from '@milaboratories/ts-helpers';
-import { PFrameFactory } from '@milaboratories/pframes-rs-node';
-import { mapValues } from 'es-toolkit';
-import { logPFrames } from './logging';
+} from "@platforma-sdk/model";
+import { hashJson, PFrameInternal } from "@milaboratories/pl-model-middle-layer";
+import { RefCountPoolBase, type PoolEntry } from "@milaboratories/ts-helpers";
+import { PFrameFactory } from "@milaboratories/pframes-rs-node";
+import { mapValues } from "es-toolkit";
+import { logPFrames } from "./logging";
 
 export interface LocalBlobProvider<TreeEntry extends JsonSerializable> {
   acquire(params: TreeEntry): PoolEntry<PFrameInternal.PFrameBlobId>;
-  makeDataSource(signal: AbortSignal): Omit<PFrameInternal.PFrameDataSourceV2, 'parquetServer'>;
+  makeDataSource(signal: AbortSignal): Omit<PFrameInternal.PFrameDataSourceV2, "parquetServer">;
 }
 
 export interface RemoteBlobProvider<TreeEntry extends JsonSerializable> {
@@ -59,14 +56,14 @@ export class PFrameHolder<TreeEntry extends JsonSerializable> implements Disposa
       data: PFrameInternal.DataInfo<TreeEntry>,
     ): PFrameInternal.DataInfo<PFrameInternal.PFrameBlobId> => {
       switch (data.type) {
-        case 'Json':
+        case "Json":
           return { ...data };
-        case 'JsonPartitioned':
+        case "JsonPartitioned":
           return {
             ...data,
             parts: mapValues(data.parts, makeLocalBlobId),
           };
-        case 'BinaryPartitioned':
+        case "BinaryPartitioned":
           return {
             ...data,
             parts: mapValues(data.parts, (v) => ({
@@ -74,7 +71,7 @@ export class PFrameHolder<TreeEntry extends JsonSerializable> implements Disposa
               values: makeLocalBlobId(v.values),
             })),
           };
-        case 'ParquetPartitioned':
+        case "ParquetPartitioned":
           return {
             ...data,
             parts: mapValues(data.parts, (v) => ({
@@ -110,7 +107,7 @@ export class PFrameHolder<TreeEntry extends JsonSerializable> implements Disposa
         .catch((err) => {
           this.dispose();
           pFrame.dispose();
-          const error = new PFrameDriverError('PFrame creation failed asynchronously');
+          const error = new PFrameDriverError("PFrame creation failed asynchronously");
           error.cause = new Error(
             `PFrame cannot be created from columns: ${JSON.stringify(jsonifiedColumns)}`,
             { cause: ensureError(err) },
@@ -118,7 +115,7 @@ export class PFrameHolder<TreeEntry extends JsonSerializable> implements Disposa
           throw error;
         });
     } catch (err: unknown) {
-      const error = new PFrameDriverError('PFrame creation failed synchronously');
+      const error = new PFrameDriverError("PFrame creation failed synchronously");
       error.cause = new Error(
         `PFrame cannot be created from columns: ${JSON.stringify(jsonifiedColumns)}`,
         { cause: ensureError(err) },
@@ -141,15 +138,17 @@ export class PFrameHolder<TreeEntry extends JsonSerializable> implements Disposa
     this.dispose();
     void this.pFramePromise
       .then((pFrame) => pFrame.dispose())
-      .catch(() => { /* mute error */ });
+      .catch(() => {
+        /* mute error */
+      });
   }
 }
 
-export class PFramePool<TreeEntry extends JsonSerializable>
-  extends RefCountPoolBase<
-    PColumn<PFrameInternal.DataInfo<TreeEntry>>[],
-    PFrameHandle,
-    PFrameHolder<TreeEntry>> {
+export class PFramePool<TreeEntry extends JsonSerializable> extends RefCountPoolBase<
+  PColumn<PFrameInternal.DataInfo<TreeEntry>>[],
+  PFrameHandle,
+  PFrameHolder<TreeEntry>
+> {
   constructor(
     private readonly localBlobProvider: LocalBlobProvider<TreeEntry>,
     private readonly remoteBlobProvider: RemoteBlobProvider<TreeEntry>,
@@ -159,7 +158,9 @@ export class PFramePool<TreeEntry extends JsonSerializable>
     super();
   }
 
-  protected calculateParamsKey(params: PColumn<PFrameInternal.DataInfo<TreeEntry>>[]): PFrameHandle {
+  protected calculateParamsKey(
+    params: PColumn<PFrameInternal.DataInfo<TreeEntry>>[],
+  ): PFrameHandle {
     return stableKeyFromPFrameData(params);
   }
 
@@ -168,9 +169,9 @@ export class PFramePool<TreeEntry extends JsonSerializable>
     key: PFrameHandle,
   ): PFrameHolder<TreeEntry> {
     if (logPFrames()) {
-      this.logger('info',
-        `PFrame creation (pFrameHandle = ${key}): `
-        + `${JSON.stringify(params, bigintReplacer)}`,
+      this.logger(
+        "info",
+        `PFrame creation (pFrameHandle = ${key}): ` + `${JSON.stringify(params, bigintReplacer)}`,
       );
     }
     return new PFrameHolder(
@@ -209,7 +210,7 @@ function stableKeyFromPFrameData<TreeEntry extends JsonSerializable>(
       };
       const type = r.type;
       switch (type) {
-        case 'Json':
+        case "Json":
           result = {
             type: r.type,
             keyLength: r.keyLength,
@@ -219,7 +220,7 @@ function stableKeyFromPFrameData<TreeEntry extends JsonSerializable>(
             })),
           };
           break;
-        case 'JsonPartitioned':
+        case "JsonPartitioned":
           result = {
             type: r.type,
             keyLength: r.partitionKeyLength,
@@ -229,7 +230,7 @@ function stableKeyFromPFrameData<TreeEntry extends JsonSerializable>(
             })),
           };
           break;
-        case 'BinaryPartitioned':
+        case "BinaryPartitioned":
           result = {
             type: r.type,
             keyLength: r.partitionKeyLength,
@@ -239,26 +240,30 @@ function stableKeyFromPFrameData<TreeEntry extends JsonSerializable>(
             })),
           };
           break;
-        case 'ParquetPartitioned':
+        case "ParquetPartitioned":
           result = {
             type: r.type,
             keyLength: r.partitionKeyLength,
             payload: Object.entries(r.parts).map(([part, info]) => ({
               key: part,
-              value: info.dataDigest || [
-                canonicalizeJson(info.data),
-                JSON.stringify({ axes: info.axes, column: info.column }),
-              ] as const,
+              value:
+                info.dataDigest ||
+                ([
+                  canonicalizeJson(info.data),
+                  JSON.stringify({ axes: info.axes, column: info.column }),
+                ] as const),
             })),
           };
           break;
         default:
-          throw new PFrameDriverError(`unsupported resource type: ${JSON.stringify(type satisfies never)}`);
+          throw new PFrameDriverError(
+            `unsupported resource type: ${JSON.stringify(type satisfies never)}`,
+          );
       }
-      result.payload.sort((lhs, rhs) => lhs.key < rhs.key ? -1 : 1);
+      result.payload.sort((lhs, rhs) => (lhs.key < rhs.key ? -1 : 1));
       return result;
     }),
   );
-  orderedData.sort((lhs, rhs) => lhs.id < rhs.id ? -1 : 1);
+  orderedData.sort((lhs, rhs) => (lhs.id < rhs.id ? -1 : 1));
   return hashJson(orderedData) as string as PFrameHandle;
 }

package/src/ptable_cache_per_frame.ts

@@ -1,9 +1,9 @@
-import type { PFrameHandle, PTableHandle } from '@platforma-sdk/model';
-import type { PFrameInternal } from '@milaboratories/pl-model-middle-layer';
-import type { PoolEntry } from '@milaboratories/ts-helpers';
-import { LRUCache } from 'lru-cache';
-import { logPFrames } from './logging';
-import type { PTableHolder } from './ptable_pool';
+import type { PFrameHandle, PTableHandle } from "@platforma-sdk/model";
+import type { PFrameInternal } from "@milaboratories/pl-model-middle-layer";
+import type { PoolEntry } from "@milaboratories/ts-helpers";
+import { LRUCache } from "lru-cache";
+import { logPFrames } from "./logging";
+import type { PTableHolder } from "./ptable_pool";
 
 export type PTableCachePerFrameOps = {
   /** Maximum number of `calculateTableData` results cached for each PFrame */
@@ -22,7 +22,10 @@ export const PTableCachePerFrameOpsDefaults: PTableCachePerFrameOps = {
 };
 
 export class PTableCachePerFrame {
-  private readonly perFrame = new Map<PFrameHandle, LRUCache<PTableHandle, PoolEntry<PTableHandle, PTableHolder>>>();
+  private readonly perFrame = new Map<
+    PFrameHandle,
+    LRUCache<PTableHandle, PoolEntry<PTableHandle, PTableHolder>>
+  >();
   private readonly global: LRUCache<PTableHandle, PoolEntry<PTableHandle, PTableHolder>>;
   private readonly disposeListeners = new Set<PTableHandle>();
 
@@ -33,7 +36,7 @@ export class PTableCachePerFrame {
     this.global = new LRUCache<PTableHandle, PoolEntry<PTableHandle, PTableHolder>>({
       maxSize: this.ops.pFramesCacheMaxSize,
       dispose: (resource, key, reason) => {
-        if (reason === 'evict') {
+        if (reason === "evict") {
           this.perFrame.get(resource.resource.pFrame)?.delete(key);
         }
 
@@ -43,7 +46,7 @@ export class PTableCachePerFrame {
 
         resource.unref();
         if (logPFrames()) {
-          logger('info', `calculateTableData cache - removed PTable ${key} (reason: ${reason})`);
+          logger("info", `calculateTableData cache - removed PTable ${key} (reason: ${reason})`);
         }
       },
     });
@@ -52,7 +55,7 @@ export class PTableCachePerFrame {
   public cache(resource: PoolEntry<PTableHandle, PTableHolder>, size: number): void {
     const key = resource.key;
     if (logPFrames()) {
-      this.logger('info', `calculateTableData cache - added PTable ${key} with size ${size}`);
+      this.logger("info", `calculateTableData cache - added PTable ${key} with size ${size}`);
     }
 
     this.global.set(key, resource, { size: Math.max(size, 1) }); // 1 is minimum size to avoid cache evictions
@@ -62,7 +65,7 @@ export class PTableCachePerFrame {
       perFrame = new LRUCache<PTableHandle, PoolEntry<PTableHandle, PTableHolder>>({
         max: this.ops.pFrameCacheMaxCount,
         dispose: (_resource, key, reason) => {
-          if (reason === 'evict') {
+          if (reason === "evict") {
             this.global.delete(key);
           }
         },
@@ -77,10 +80,10 @@ export class PTableCachePerFrame {
         this.global.delete(key);
 
         this.disposeListeners.delete(key);
-        resource.resource.disposeSignal.removeEventListener('abort', disposeListener);
+        resource.resource.disposeSignal.removeEventListener("abort", disposeListener);
       };
       this.disposeListeners.add(key);
-      resource.resource.disposeSignal.addEventListener('abort', disposeListener);
+      resource.resource.disposeSignal.addEventListener("abort", disposeListener);
     }
   }
 }