@milaboratories/pl-middle-layer 1.53.3 → 1.54.1

package/src/js_render/computable_context.ts

@@ -34,6 +34,7 @@ import {
   mapValueInVOE,
 } from "@platforma-sdk/model";
 import { notEmpty } from "@milaboratories/ts-helpers";
+import { PoolEntryGuard } from "@milaboratories/pl-model-common";
 import { randomUUID } from "node:crypto";
 import type { Optional } from "utility-types";
 import type { BlockContextAny } from "../middle_layer/block_ctx";
@@ -44,18 +45,15 @@ import type { ResultPool } from "../pool/result_pool";
 import type { JsExecutionContext } from "./context";
 import type { VmFunctionImplementation } from "quickjs-emscripten";
 import { Scope, type QuickJSHandle } from "quickjs-emscripten";
-import type {
-  AxesId,
-  AxesSpec,
-  DiscoverColumnsRequest,
-  DiscoverColumnsResponse,
-  PColumnSpec,
-  PTableColumnId,
-  PTableColumnSpec,
-  SingleAxisSelector,
-  SpecFrameHandle,
+import {
+  resolveRequiredServices,
+  serviceFnKey,
+  Services,
+  ModelServiceRegistry,
+  ServiceInjectionError,
+  ServiceMethodNotFoundError,
 } from "@milaboratories/pl-model-common";
-import { SpecDriver } from "./spec_driver";
+import { getServiceInjectors } from "./service_injectors";
 
 function bytesToBase64(data: Uint8Array | undefined): string | undefined {
   return data !== undefined ? Buffer.from(data).toString("base64") : undefined;
@@ -69,18 +67,18 @@ export class ComputableContextHelper implements JsRenderInternal.GlobalCfgRender
 
   private computableCtx: ComputableCtx | undefined;
   private readonly accessors = new Map<string, PlTreeNodeAccessor | undefined>();
-  private readonly specDriver = new SpecDriver();
-
   private _meta: Map<string, Block> | undefined;
   private get meta(): Map<string, Block> {
     if (this._meta === undefined) {
-      if (this.computableCtx === undefined)
-        throw new Error("blockMeta can't be resolved in this context");
-      this._meta = this.blockCtx.blockMeta(this.computableCtx);
+      this._meta = this.blockCtx.blockMeta(this.requireComputableCtx);
     }
     return this._meta;
   }
 
+  public get serviceRegistry(): ModelServiceRegistry {
+    return this.env.serviceRegistry;
+  }
+
   constructor(
     private readonly parent: JsExecutionContext,
     private readonly blockCtx: BlockContextAny,
@@ -96,21 +94,29 @@ export class ComputableContextHelper implements JsRenderInternal.GlobalCfgRender
     this.accessors.clear();
   }
 
+  private get requireComputableCtx(): ComputableCtx {
+    if (this.computableCtx === undefined)
+      throw new Error("computableCtx not available (called from future mapper?)");
+    return this.computableCtx;
+  }
+
+  public addOnDestroy(callback: () => void): void {
+    this.requireComputableCtx.addOnDestroy(callback);
+  }
+
   //
   // Methods for injected ctx object
   //
 
   getAccessorHandleByName(name: string): string | undefined {
-    if (this.computableCtx === undefined)
-      throw new Error("Accessors can't be used in this context");
+    const cCtx = this.requireComputableCtx;
     const wellKnownAccessor = (name: string, ctxKey: "staging" | "prod"): string | undefined => {
       if (!this.accessors.has(name)) {
         const lambda = this.blockCtx[ctxKey];
         if (lambda === undefined) throw new Error("Staging context not available");
-        const entry = lambda(this.computableCtx!);
+        const entry = lambda(cCtx);
         if (!entry) this.accessors.set(name, undefined);
-        else
-          this.accessors.set(name, this.computableCtx!.accessor(entry).node({ ignoreError: true }));
+        else this.accessors.set(name, cCtx.accessor(entry).node({ ignoreError: true }));
       }
       return this.accessors.get(name) ? name : undefined;
     };
@@ -336,14 +342,10 @@ export class ComputableContextHelper implements JsRenderInternal.GlobalCfgRender
   private _resultPool: ResultPool | undefined = undefined;
   private get resultPool(): ResultPool {
     if (this._resultPool === undefined) {
-      if (this.computableCtx === undefined)
-        throw new Error(
-          "can't use result pool in this context (most porbably called from the future mapper)",
-        );
       this._resultPool = notEmpty(
         this.blockCtx.getResultsPool,
         "getResultsPool",
-      )(this.computableCtx);
+      )(this.requireComputableCtx);
     }
     return this._resultPool;
   }
@@ -355,7 +357,9 @@ export class ComputableContextHelper implements JsRenderInternal.GlobalCfgRender
   public getDataFromResultPool(): ResultCollection<PObject<string>> {
     const collection = this.resultPool.getData();
     if (collection.instabilityMarker !== undefined)
-      this.computableCtx!.markUnstable(`incomplete_result_pool:${collection.instabilityMarker}`);
+      this.requireComputableCtx.markUnstable(
+        `incomplete_result_pool:${collection.instabilityMarker}`,
+      );
     return {
       isComplete: collection.isComplete,
       entries: collection.entries.map((e) => ({
@@ -370,7 +374,9 @@ export class ComputableContextHelper implements JsRenderInternal.GlobalCfgRender
   > {
     const collection = this.resultPool.getDataWithErrors();
     if (collection.instabilityMarker !== undefined)
-      this.computableCtx!.markUnstable(`incomplete_result_pool:${collection.instabilityMarker}`);
+      this.requireComputableCtx.markUnstable(
+        `incomplete_result_pool:${collection.instabilityMarker}`,
+      );
     return {
       isComplete: collection.isComplete,
       entries: collection.entries.map((e) => ({
@@ -387,7 +393,9 @@ export class ComputableContextHelper implements JsRenderInternal.GlobalCfgRender
   public getSpecsFromResultPool(): ResultCollection<PObjectSpec> {
     const specs = this.resultPool.getSpecs();
     if (specs.instabilityMarker !== undefined)
-      this.computableCtx!.markUnstable(`specs_from_pool_incomplete:${specs.instabilityMarker}`);
+      this.requireComputableCtx.markUnstable(
+        `specs_from_pool_incomplete:${specs.instabilityMarker}`,
+      );
     return specs;
   }
 
@@ -408,79 +416,37 @@ export class ComputableContextHelper implements JsRenderInternal.GlobalCfgRender
   public createPFrame(
     def: PFrameDef<PColumn<string | PColumnValues | DataInfo<string>>>,
   ): PFrameHandle {
-    if (this.computableCtx === undefined)
-      throw new Error(
-        "can't instantiate PFrames from this context (most porbably called from the future mapper)",
-      );
-    const { key, unref } = this.env.driverKit.pFrameDriver.createPFrame(
-      def.map((c) => mapPObjectData(c, (d) => this.transformInputPData(d))),
+    using guard = new PoolEntryGuard(
+      this.env.driverKit.pFrameDriver.createPFrame(
+        def.map((c) => mapPObjectData(c, (d) => this.transformInputPData(d))),
+      ),
     );
-    this.computableCtx.addOnDestroy(unref);
-    return key;
+    this.requireComputableCtx.addOnDestroy(guard.entry.unref);
+    return guard.keep().key;
   }
 
   public createPTable(
     def: PTableDef<PColumn<string | PColumnValues | DataInfo<string>>>,
   ): PTableHandle {
-    if (this.computableCtx === undefined)
-      throw new Error(
-        "can't instantiate PTable from this context (most porbably called from the future mapper)",
-      );
-    const { key, unref } = this.env.driverKit.pFrameDriver.createPTable(
-      mapPTableDef(def, (c) => mapPObjectData(c, (d) => this.transformInputPData(d))),
+    using guard = new PoolEntryGuard(
+      this.env.driverKit.pFrameDriver.createPTable(
+        mapPTableDef(def, (c) => mapPObjectData(c, (d) => this.transformInputPData(d))),
+      ),
     );
-    this.computableCtx.addOnDestroy(unref);
-    return key;
+    this.requireComputableCtx.addOnDestroy(guard.entry.unref);
+    return guard.keep().key;
   }
+
   public createPTableV2(
     def: PTableDefV2<PColumn<string | PColumnValues | DataInfo<string>>>,
   ): PTableHandle {
-    if (this.computableCtx === undefined)
-      throw new Error(
-        "can't instantiate PTable from this context (most porbably called from the future mapper)",
-      );
-    const { key, unref } = this.env.driverKit.pFrameDriver.createPTableV2(
-      mapPTableDefV2(def, (c) => mapPObjectData(c, (d) => this.transformInputPData(d))),
+    using guard = new PoolEntryGuard(
+      this.env.driverKit.pFrameDriver.createPTableV2(
+        mapPTableDefV2(def, (c) => mapPObjectData(c, (d) => this.transformInputPData(d))),
+      ),
     );
-    this.computableCtx.addOnDestroy(unref);
-    return key;
-  }
-
-  //
-  // Spec Frames
-  //
-
-  public createSpecFrame(specs: Record<string, PColumnSpec>): SpecFrameHandle {
-    const handle = this.specDriver.createSpecFrame(specs);
-    this.computableCtx?.addOnDestroy(() => this.specDriver.disposeSpecFrame(handle));
-    return handle;
-  }
-
-  public specFrameDiscoverColumns(
-    handle: SpecFrameHandle,
-    request: DiscoverColumnsRequest,
-  ): DiscoverColumnsResponse {
-    return this.specDriver.specFrameDiscoverColumns(handle as SpecFrameHandle, request);
-  }
-
-  public disposeSpecFrame(handle: SpecFrameHandle): void {
-    this.specDriver.disposeSpecFrame(handle as SpecFrameHandle);
-  }
-
-  public expandAxes(spec: AxesSpec): AxesId {
-    return this.specDriver.expandAxes(spec);
-  }
-
-  public collapseAxes(ids: AxesId): AxesSpec {
-    return this.specDriver.collapseAxes(ids);
-  }
-
-  public findAxis(spec: AxesSpec, selector: SingleAxisSelector): number {
-    return this.specDriver.findAxis(spec, selector);
-  }
-
-  public findTableColumn(tableSpec: PTableColumnSpec[], selector: PTableColumnId): number {
-    return this.specDriver.findTableColumn(tableSpec, selector);
+    this.requireComputableCtx.addOnDestroy(guard.entry.unref);
+    return guard.keep().key;
   }
 
   /**
@@ -597,49 +563,32 @@ export class ComputableContextHelper implements JsRenderInternal.GlobalCfgRender
       if (checkBlockFlag(this.featureFlags, "supportsLazyState")) {
         // injecting lazy state functions
         exportCtxFunction("args", () => {
-          if (this.computableCtx === undefined)
-            throw new Error(
-              `Add dummy call to ctx.args outside the future lambda. Can't be directly used in this context.`,
-            );
-          const args = this.blockCtx.args(this.computableCtx);
+          const cCtx = this.requireComputableCtx;
+          const args = this.blockCtx.args(cCtx);
           return args === undefined ? vm.undefined : vm.newString(args);
         });
         exportCtxFunction("blockStorage", () => {
-          if (this.computableCtx === undefined)
-            throw new Error(
-              `Add dummy call to ctx.blockStorage outside the future lambda. Can't be directly used in this context.`,
-            );
-          return vm.newString(this.blockCtx.blockStorage(this.computableCtx) ?? "{}");
+          return vm.newString(this.blockCtx.blockStorage(this.requireComputableCtx) ?? "{}");
         });
         exportCtxFunction("data", () => {
-          if (this.computableCtx === undefined)
-            throw new Error(
-              `Add dummy call to ctx.data outside the future lambda. Can't be directly used in this context.`,
-            );
-          return vm.newString(this.blockCtx.data(this.computableCtx) ?? "{}");
+          return vm.newString(this.blockCtx.data(this.requireComputableCtx) ?? "{}");
         });
         exportCtxFunction("activeArgs", () => {
-          if (this.computableCtx === undefined)
-            throw new Error(
-              `Add dummy call to ctx.activeArgs outside the future lambda. Can't be directly used in this context.`,
-            );
-          const res = this.blockCtx.activeArgs(this.computableCtx);
+          const cCtx = this.requireComputableCtx;
+          const res = this.blockCtx.activeArgs(cCtx);
           return res === undefined ? vm.undefined : vm.newString(res);
         });
         // For v1/v2 blocks, also inject uiState (extracted from state.uiState)
         if (isLegacyBlock) {
           exportCtxFunction("uiState", () => {
-            if (this.computableCtx === undefined)
-              throw new Error(
-                `Add dummy call to ctx.uiState outside the future lambda. Can't be directly used in this context.`,
-              );
-            return vm.newString(extractUiState(this.blockCtx.data(this.computableCtx)));
+            return vm.newString(extractUiState(this.blockCtx.data(this.requireComputableCtx)));
           });
         }
       } else {
-        const args = this.blockCtx.args(this.computableCtx!);
-        const activeArgs = this.blockCtx.activeArgs(this.computableCtx!);
-        const data = this.blockCtx.data(this.computableCtx!);
+        const cCtx = this.requireComputableCtx;
+        const args = this.blockCtx.args(cCtx);
+        const activeArgs = this.blockCtx.activeArgs(cCtx);
+        const data = this.blockCtx.data(cCtx);
         if (args !== undefined) {
           vm.setProp(configCtx, "args", localScope.manage(vm.newString(args)));
         }
@@ -888,10 +837,6 @@ export class ComputableContextHelper implements JsRenderInternal.GlobalCfgRender
         );
       });
 
-      //
-      // PFrames / PTables
-      //
-
       exportCtxFunction("createPFrame", (def) => {
         return parent.exportSingleValue(
           this.createPFrame(
@@ -920,63 +865,52 @@ export class ComputableContextHelper implements JsRenderInternal.GlobalCfgRender
       });
 
       //
-      // Spec Frames
+      // Services
       //
 
-      exportCtxFunction("createSpecFrame", (specs) => {
-        return parent.exportSingleValue(
-          this.createSpecFrame(parent.importObjectViaJson(specs) as Record<string, PColumnSpec>),
-          undefined,
-        );
-      });
-
-      exportCtxFunction("specFrameDiscoverColumns", (handle, request) => {
-        return parent.exportObjectViaJson(
-          this.specFrameDiscoverColumns(
-            vm.getString(handle) as SpecFrameHandle,
-            parent.importObjectViaJson(request) as DiscoverColumnsRequest,
-          ),
-          undefined,
-        );
-      });
-
-      exportCtxFunction("disposeSpecFrame", (handle) => {
-        this.disposeSpecFrame(vm.getString(handle) as SpecFrameHandle);
-      });
+      const requiredServiceNames = new Set(resolveRequiredServices(this.featureFlags) as string[]);
+      const serviceFunctions = new Map<string, VmFunctionImplementation<QuickJSHandle>>();
+      const injectors = getServiceInjectors();
 
-      exportCtxFunction("expandAxes", (spec) => {
-        return parent.exportObjectViaJson(
-          this.expandAxes(parent.importObjectViaJson(spec) as AxesSpec),
-          undefined,
-        );
-      });
+      for (const [key, serviceId] of Object.entries(Services)) {
+        if (!requiredServiceNames.has(serviceId)) continue;
+        const injector = injectors[key as keyof typeof injectors];
+        try {
+          const methods = injector({ host: this, vm: parent });
+          for (const [method, fn] of Object.entries(methods)) {
+            serviceFunctions.set(serviceFnKey(serviceId, method), fn);
+          }
+        } catch (e) {
+          throw new ServiceInjectionError(`Failed to inject service "${serviceId}"`, { cause: e });
+        }
+      }
 
-      exportCtxFunction("collapseAxes", (ids) => {
-        return parent.exportObjectViaJson(
-          this.collapseAxes(parent.importObjectViaJson(ids) as AxesId),
-          undefined,
-        );
+      exportCtxFunction("getServiceNames", () => {
+        return parent.exportObjectViaJson([...requiredServiceNames]);
       });
 
-      exportCtxFunction("findAxis", (spec, selector) => {
-        return parent.exportSingleValue(
-          this.findAxis(
-            parent.importObjectViaJson(spec) as AxesSpec,
-            parent.importObjectViaJson(selector) as SingleAxisSelector,
-          ),
-          undefined,
-        );
+      exportCtxFunction("getServiceMethods", (serviceIdHandle) => {
+        const serviceId = vm.getString(serviceIdHandle);
+        const pfx = serviceFnKey(serviceId);
+        const methods = [...serviceFunctions.keys()]
+          .filter((k) => k.startsWith(pfx))
+          .map((k) => k.slice(pfx.length));
+        return parent.exportObjectViaJson(methods, undefined);
       });
 
-      exportCtxFunction("findTableColumn", (tableSpec, selector) => {
-        return parent.exportSingleValue(
-          this.findTableColumn(
-            parent.importObjectViaJson(tableSpec) as PTableColumnSpec[],
-            parent.importObjectViaJson(selector) as PTableColumnId,
-          ),
-          undefined,
-        );
-      });
+      exportCtxFunction(
+        "callServiceMethod",
+        function (this: QuickJSHandle, serviceIdHandle, methodHandle, ...argHandles) {
+          const serviceId = vm.getString(serviceIdHandle);
+          const method = vm.getString(methodHandle);
+          const fn = serviceFunctions.get(serviceFnKey(serviceId, method));
+          if (!fn)
+            throw new ServiceMethodNotFoundError(
+              `Method "${method}" not found on service "${serviceId}"`,
+            );
+          return fn.call(this, ...argHandles);
+        },
+      );
 
       //
       // Computable

package/src/js_render/context.ts

@@ -200,7 +200,7 @@ export class JsExecutionContext {
 
   public exportSingleValue(
     obj: boolean | number | string | null | ArrayBuffer | undefined,
-    scope: Scope | undefined,
+    scope?: Scope,
   ): QuickJSHandle {
     const result = this.tryExportSingleValue(obj, scope);
     if (result === undefined) {
@@ -211,7 +211,7 @@ export class JsExecutionContext {
     return result;
   }
 
-  public tryExportSingleValue(obj: unknown, scope: Scope | undefined): QuickJSHandle | undefined {
+  public tryExportSingleValue(obj: unknown, scope?: Scope): QuickJSHandle | undefined {
     let handle: QuickJSHandle;
     let manage = false;
     switch (typeof obj) {
@@ -244,13 +244,13 @@ export class JsExecutionContext {
     return manage && scope != undefined ? scope.manage(handle) : handle;
   }
 
-  public exportObjectUniversal(obj: unknown, scope: Scope | undefined): QuickJSHandle {
+  public exportObjectUniversal(obj: unknown, scope?: Scope): QuickJSHandle {
     const simpleHandle = this.tryExportSingleValue(obj, scope);
     if (simpleHandle !== undefined) return simpleHandle;
     return this.exportObjectViaJson(obj, scope);
   }
 
-  public exportObjectViaJson(obj: unknown, scope: Scope | undefined): QuickJSHandle {
+  public exportObjectViaJson(obj: unknown, scope?: Scope): QuickJSHandle {
     const t0 = performance.now();
     const json = JSON.stringify(obj);
     this.stats.serInBytes += json.length;

package/src/js_render/service_injectors.ts

@@ -0,0 +1,153 @@
+import type { QuickJSHandle, VmFunctionImplementation } from "quickjs-emscripten";
+import type { InferServiceModel, ServiceBrand } from "@milaboratories/pl-model-common";
+import { Services, ServiceNotRegisteredError } from "@milaboratories/pl-model-common";
+import type {
+  AxesId,
+  AxesSpec,
+  DataInfo,
+  PColumn,
+  PColumnSpec,
+  PColumnValues,
+  PTableColumnId,
+  PTableColumnSpec,
+  SingleAxisSelector,
+  DeleteColumnRequest,
+  DiscoverColumnsRequest,
+  PFrameDef,
+  SpecQuery,
+  PTableDef,
+  PTableDefV2,
+  SpecFrameHandle,
+} from "@milaboratories/pl-model-common";
+import { PoolEntryGuard } from "@milaboratories/pl-model-common";
+import type { JsExecutionContext } from "./context";
+import type { ComputableContextHelper } from "./computable_context";
+
+type VmMethod = VmFunctionImplementation<QuickJSHandle>;
+
+export type ServiceInjectorContext = {
+  host: ComputableContextHelper;
+  vm: JsExecutionContext;
+};
+
+// Each injector returns a record of method name -> VM function implementation.
+// The framework automatically registers them with serviceFnKey(serviceId, methodName).
+export type ServiceInjector<Methods extends string = string> = (
+  ctx: ServiceInjectorContext,
+) => Record<Methods, VmMethod>;
+
+// Type-safe injector for a specific service — must return all methods from the model interface.
+type ServiceInjectorFor<S extends keyof typeof Services> = ServiceInjector<
+  string & keyof InferServiceModel<ServiceBrand<(typeof Services)[S]>>
+>;
+
+// Complete, type-checked injector map.
+// Adding a service to Services without an entry here is a compile-time error.
+// Missing a method from the interface is also a compile-time error.
+type ServiceInjectorMap = { [K in keyof typeof Services]: ServiceInjectorFor<K> };
+
+export function getServiceInjectors(): ServiceInjectorMap {
+  return {
+    PFrameSpec: ({ host, vm }: ServiceInjectorContext) => {
+      const driver = host.serviceRegistry.get(Services.PFrameSpec);
+      if (!driver)
+        throw new ServiceNotRegisteredError(
+          `Service "${Services.PFrameSpec}" has no factory in ModelServiceRegistry. Provide a non-null factory.`,
+        );
+
+      return {
+        createSpecFrame: (specs: QuickJSHandle) => {
+          using guard = new PoolEntryGuard(
+            driver.createSpecFrame(vm.importObjectViaJson(specs) as Record<string, PColumnSpec>),
+          );
+          host.addOnDestroy(guard.entry.unref);
+          const entry = guard.keep();
+          // TODO: add [Symbol.dispose] once QuickJS supports ES2024 explicit resource management
+          const obj = vm.vm.newObject();
+          vm.vm.newString(entry.key).consume((k) => vm.vm.setProp(obj, "key", k));
+          vm.vm
+            .newFunction("unref", () => {
+              entry.unref();
+            })
+            .consume((fn) => vm.vm.setProp(obj, "unref", fn));
+          return obj;
+        },
+
+        discoverColumns: (handle: QuickJSHandle, request: QuickJSHandle) =>
+          vm.exportObjectViaJson(
+            driver.discoverColumns(
+              vm.vm.getString(handle) as SpecFrameHandle,
+              vm.importObjectViaJson(request) as DiscoverColumnsRequest,
+            ),
+          ),
+
+        deleteColumn: (handle: QuickJSHandle, request: QuickJSHandle) =>
+          vm.exportObjectViaJson(
+            driver.deleteColumn(
+              vm.vm.getString(handle) as SpecFrameHandle,
+              vm.importObjectViaJson(request) as DeleteColumnRequest,
+            ),
+          ),
+
+        evaluateQuery: (handle: QuickJSHandle, request: QuickJSHandle) =>
+          vm.exportObjectViaJson(
+            driver.evaluateQuery(
+              vm.vm.getString(handle) as SpecFrameHandle,
+              vm.importObjectViaJson(request) as SpecQuery,
+            ),
+          ),
+
+        expandAxes: (spec: QuickJSHandle) =>
+          vm.exportObjectViaJson(driver.expandAxes(vm.importObjectViaJson(spec) as AxesSpec)),
+
+        collapseAxes: (ids: QuickJSHandle) =>
+          vm.exportObjectViaJson(driver.collapseAxes(vm.importObjectViaJson(ids) as AxesId)),
+
+        findAxis: (spec: QuickJSHandle, selector: QuickJSHandle) =>
+          vm.exportSingleValue(
+            driver.findAxis(
+              vm.importObjectViaJson(spec) as AxesSpec,
+              vm.importObjectViaJson(selector) as SingleAxisSelector,
+            ),
+          ),
+
+        findTableColumn: (tableSpec: QuickJSHandle, selector: QuickJSHandle) =>
+          vm.exportSingleValue(
+            driver.findTableColumn(
+              vm.importObjectViaJson(tableSpec) as PTableColumnSpec[],
+              vm.importObjectViaJson(selector) as PTableColumnId,
+            ),
+          ),
+      };
+    },
+
+    PFrame: ({ host, vm }: ServiceInjectorContext) => ({
+      createPFrame: (def: QuickJSHandle) =>
+        vm.exportSingleValue(
+          host.createPFrame(
+            vm.importObjectViaJson(def) as PFrameDef<
+              PColumn<string | PColumnValues | DataInfo<string>>
+            >,
+          ),
+        ),
+
+      createPTable: (def: QuickJSHandle) =>
+        vm.exportSingleValue(
+          host.createPTable(
+            vm.importObjectViaJson(def) as PTableDef<
+              PColumn<string | PColumnValues | DataInfo<string>>
+            >,
+          ),
+        ),
+
+      createPTableV2: (def: QuickJSHandle) =>
+        vm.exportSingleValue(
+          host.createPTableV2(
+            vm.importObjectViaJson(def) as PTableDefV2<
+              PColumn<string | PColumnValues | DataInfo<string>>
+            >,
+          ),
+        ),
+    }),
+  };
+}

package/src/middle_layer/middle_layer.ts

@@ -32,6 +32,11 @@ import type { MiddleLayerDriverKit } from "./driver_kit";
 import { initDriverKit } from "./driver_kit";
 import type { BlockCodeFeatureFlags, DriverKit, SupportedRequirement } from "@platforma-sdk/model";
 import { RuntimeCapabilities } from "@platforma-sdk/model";
+import {
+  type ModelServiceRegistry,
+  registerServiceCapabilities,
+} from "@milaboratories/pl-model-common";
+import { createModelServiceRegistry } from "../service_factories";
 import type { DownloadUrlDriver } from "@milaboratories/pl-drivers";
 import { V2RegistryProvider } from "../block_registry";
 import type { Dispatcher } from "undici";
@@ -54,6 +59,7 @@ export interface MiddleLayerEnvironment {
   readonly blockUpdateWatcher: BlockUpdateWatcher;
   readonly quickJs: QuickJSWASMModule;
   readonly driverKit: MiddleLayerDriverKit;
+  readonly serviceRegistry: ModelServiceRegistry;
   readonly projectHelper: ProjectHelper;
 }
 
@@ -115,6 +121,11 @@ export class MiddleLayer {
     return this.env.driverKit;
   }
 
+  /** Returns the service registry for service introspection. */
+  public get serviceRegistry(): ModelServiceRegistry {
+    return this.env.serviceRegistry;
+  }
+
   //
   // Project List Manipulation
   //
@@ -335,8 +346,13 @@ export class MiddleLayer {
     runtimeCapabilities.addSupportedRequirement("requiresModelAPIVersion", 1);
     runtimeCapabilities.addSupportedRequirement("requiresModelAPIVersion", 2);
     runtimeCapabilities.addSupportedRequirement("requiresCreatePTable", 2);
+    registerServiceCapabilities((flag, value) =>
+      runtimeCapabilities.addSupportedRequirement(flag, value),
+    );
     // runtime capabilities of the desktop are to be added by the desktop app / test framework
 
+    const serviceRegistry = createModelServiceRegistry({ logger });
+
     const env: MiddleLayerEnvironment = {
       pl,
       blockEventDispatcher: new BlockEventDispatcher(),
@@ -354,9 +370,11 @@ export class MiddleLayer {
         preferredUpdateChannel: ops.preferredUpdateChannel,
       }),
       runtimeCapabilities,
+      serviceRegistry,
       quickJs,
       projectHelper: new ProjectHelper(quickJs, logger),
       dispose: async () => {
+        await serviceRegistry.dispose();
         await retryHttpDispatcher.destroy();
         await driverKit.dispose();
       },

package/src/pool/driver.ts

@@ -219,7 +219,6 @@ class BlobStore extends PFrameInternal.BaseObjectStore {
             type: "Ok",
             size: blob.size,
             range: translatedRange,
-            // eslint-disable-next-line n/no-unsupported-features/node-builtins
             data: Readable.fromWeb(data),
           });
         },
@@ -268,6 +267,7 @@ class RemoteBlobProviderImpl implements RemoteBlobProvider<PlTreeEntry> {
 
   async [Symbol.asyncDispose](): Promise<void> {
     await this.server.stop();
+    await this.pool[Symbol.asyncDispose]();
   }
 }