@platforma-sdk/model 1.61.1 → 1.62.0

package/src/columns/column_collection_builder.ts

@@ -19,13 +19,7 @@ import { createColumnSnapshot } from "./column_snapshot";
 import type { ColumnSnapshotProvider, ColumnSource } from "./column_snapshot_provider";
 import { ArrayColumnProvider, toColumnSnapshotProvider } from "./column_snapshot_provider";
 
-import type { GlobalCfgRenderCtxMethods } from "../render/internal";
-
-/** Subset of render context methods needed for spec frame operations. */
-type SpecFrameCtx = Pick<
-  GlobalCfgRenderCtxMethods,
-  "createSpecFrame" | "specFrameDiscoverColumns" | "disposeSpecFrame"
->;
+import type { PFrameSpecDriver, PoolEntry, SpecFrameHandle } from "@milaboratories/pl-model-common";
 
 // --- FindColumnsOptions ---
 
@@ -40,7 +34,9 @@ export interface FindColumnsOptions {
 // --- ColumnCollection ---
 
 /** Plain collection — no axis context, selector-based filtering only. */
-export interface ColumnCollection {
+export interface ColumnCollection extends Disposable {
+  /** Release the underlying spec frame WASM resource. */
+  dispose(): void;
   /** Point lookup by provider-native ID. */
   getColumn(id: PObjectId): undefined | ColumnSnapshot<PObjectId>;
 
@@ -53,7 +49,9 @@ export interface ColumnCollection {
 // --- AnchoredColumnCollection ---
 
 /** Axis-aware column collection with anchored identity derivation. */
-export interface AnchoredColumnCollection {
+export interface AnchoredColumnCollection extends Disposable {
+  /** Release the underlying spec frame WASM resource. */
+  dispose(): void;
   /** Point lookup by anchored ID. */
   getColumn(id: SUniversalPColumnId): undefined | ColumnSnapshot<SUniversalPColumnId>;
 
@@ -122,7 +120,7 @@ export interface AnchoredBuildOptions extends BuildOptions {
 export class ColumnCollectionBuilder {
   private readonly providers: ColumnSnapshotProvider[] = [];
 
-  constructor(private readonly specFrameCtx: SpecFrameCtx) {}
+  constructor(private readonly specDriver: PFrameSpecDriver) {}
 
   /**
    * Register a column source. Sources added first take precedence for dedup.
@@ -178,14 +176,14 @@ export class ColumnCollectionBuilder {
       const anchorSpecs = resolveAnchorSpecs(options.anchors, columnMap);
       const idDeriver = new AnchoredIdDeriver(anchorSpecs);
 
-      return new AnchoredColumnCollectionImpl(this.specFrameCtx, {
+      return new AnchoredColumnCollectionImpl(this.specDriver, {
         columns: columnMap,
         idDeriver,
         anchorSpecs,
         columnListComplete: allowPartial ? allComplete : false,
       });
     } else {
-      return new ColumnCollectionImpl(this.specFrameCtx, {
+      return new ColumnCollectionImpl(this.specDriver, {
         columns: columnMap,
         columnListComplete: allowPartial ? allComplete : false,
       });
@@ -230,25 +228,30 @@ interface ColumnCollectionImplOptions {
   readonly columnListComplete?: boolean;
 }
 
-class ColumnCollectionImpl implements ColumnCollection {
+class ColumnCollectionImpl implements ColumnCollection, Disposable {
   private readonly columns: Map<PObjectId, ColumnSnapshot<PObjectId>>;
-  private readonly specFrameHandle: string;
+  private readonly specFrameEntry: PoolEntry<SpecFrameHandle>;
   public readonly columnListComplete: boolean;
 
   constructor(
-    private readonly ctx: SpecFrameCtx,
+    private readonly specDriver: PFrameSpecDriver,
     options: ColumnCollectionImplOptions,
   ) {
     this.columns = options.columns;
     this.columnListComplete = options.columnListComplete ?? false;
-    this.specFrameHandle = this.ctx.createSpecFrame(
-      Array.from(this.columns.entries()).reduce(
-        (acc, [id, col]) => ((acc[id] = col.spec), acc),
-        {} as Record<string, PColumnSpec>,
-      ),
+    this.specFrameEntry = this.specDriver.createSpecFrame(
+      Object.fromEntries(Array.from(this.columns.entries(), ([id, col]) => [id, col.spec])),
     );
   }
 
+  dispose(): void {
+    this.specFrameEntry.unref();
+  }
+
+  [Symbol.dispose](): void {
+    this.dispose();
+  }
+
   getColumn(id: PObjectId): undefined | ColumnSnapshot<PObjectId> {
     const col = this.columns.get(id);
     if (col === undefined) return undefined;
@@ -259,7 +262,7 @@ class ColumnCollectionImpl implements ColumnCollection {
     const includeColumns = options?.include ? toMultiColumnSelectors(options.include) : undefined;
     const excludeColumns = options?.exclude ? toMultiColumnSelectors(options.exclude) : undefined;
 
-    const response = this.ctx.specFrameDiscoverColumns(this.specFrameHandle, {
+    const response = this.specDriver.discoverColumns(this.specFrameEntry.key, {
       includeColumns,
       excludeColumns,
       axes: [],
@@ -288,17 +291,17 @@ interface AnchoredColumnCollectionImplOptions extends ColumnCollectionImplOption
   readonly anchorSpecs: Record<string, PColumnSpec>;
 }
 
-class AnchoredColumnCollectionImpl implements AnchoredColumnCollection {
+class AnchoredColumnCollectionImpl implements AnchoredColumnCollection, Disposable {
   private readonly columns: Map<PObjectId, ColumnSnapshot<PObjectId>>;
   private readonly idDeriver: AnchoredIdDeriver;
-  private readonly specFrameHandle: string;
+  private readonly specFrameEntry: PoolEntry<SpecFrameHandle>;
   private readonly anchorAxes: ColumnAxesWithQualifications[];
   /** Reverse lookup: SUniversalPColumnId → PObjectId */
   private readonly idToOriginal: Map<SUniversalPColumnId, PObjectId>;
   public readonly columnListComplete: boolean;
 
   constructor(
-    private readonly ctx: SpecFrameCtx,
+    private readonly specDriver: PFrameSpecDriver,
     options: AnchoredColumnCollectionImplOptions,
   ) {
     this.columns = options.columns;
@@ -306,11 +309,8 @@ class AnchoredColumnCollectionImpl implements AnchoredColumnCollection {
     this.columnListComplete = options.columnListComplete ?? false;
 
     // Create spec frame from all collected columns
-    this.specFrameHandle = this.ctx.createSpecFrame(
-      Array.from(this.columns.entries()).reduce(
-        (acc, [id, col]) => ((acc[id] = col.spec), acc),
-        {} as Record<string, PColumnSpec>,
-      ),
+    this.specFrameEntry = this.specDriver.createSpecFrame(
+      Object.fromEntries(Array.from(this.columns.entries(), ([id, col]) => [id, col.spec])),
     );
 
     // Build anchor axes for discovery requests
@@ -327,6 +327,14 @@ class AnchoredColumnCollectionImpl implements AnchoredColumnCollection {
     );
   }
 
+  dispose(): void {
+    this.specFrameEntry.unref();
+  }
+
+  [Symbol.dispose](): void {
+    this.dispose();
+  }
+
   getColumn(id: SUniversalPColumnId): undefined | ColumnSnapshot<SUniversalPColumnId> {
     const origId = this.idToOriginal.get(id);
     if (origId === undefined) return undefined;
@@ -341,7 +349,7 @@ class AnchoredColumnCollectionImpl implements AnchoredColumnCollection {
     const includeColumns = options?.include ? toMultiColumnSelectors(options.include) : undefined;
     const excludeColumns = options?.exclude ? toMultiColumnSelectors(options.exclude) : undefined;
 
-    const response = this.ctx.specFrameDiscoverColumns(this.specFrameHandle, {
+    const response = this.specDriver.discoverColumns(this.specFrameEntry.key, {
       includeColumns,
       excludeColumns,
       constraints,

package/src/columns/ctx_column_sources.ts

@@ -17,8 +17,8 @@ import type { ValueOf } from "@milaboratories/helpers";
  *
  * Returns an array of providers suitable for `ColumnCollectionBuilder.addSource()`.
  */
-export function collectCtxColumnSnapshotProviders<A, U>(
-  ctx: RenderCtxBase<A, U>,
+export function collectCtxColumnSnapshotProviders<A, U, S>(
+  ctx: RenderCtxBase<A, U, S>,
 ): ColumnSnapshotProvider[] {
   const providers: ColumnSnapshotProvider[] = [];
 

package/src/components/PlDataTable/createPlDataTable/createPlDataTableV3.ts

@@ -41,6 +41,7 @@ import type { PlDataTableFilters, PlDataTableModel } from "../typesV5";
 import { upgradePlDataTableStateV2 } from "../state-migration";
 import type { PlDataTableStateV2 } from "../state-migration";
 import type { ColumnSource, MatchingMode } from "../../../columns";
+import { Services, type RequireServices } from "@milaboratories/pl-model-common";
 import { ColumnCollectionBuilder } from "../../../columns";
 import { isColumnSnapshotProvider } from "../../../columns/column_snapshot_provider";
 import { collectCtxColumnSnapshotProviders } from "../../../columns/ctx_column_sources";
@@ -184,8 +185,8 @@ export type createPlDataTableOptionsV3 = {
 //   | { annotation: Record<string, string> }
 //   | { ids: Set<string> };
 
-export function createPlDataTableV3<A, U>(
-  ctx: RenderCtxBase<A, U>,
+export function createPlDataTableV3<A, U, S extends RequireServices<typeof Services.PFrameSpec>>(
+  ctx: RenderCtxBase<A, U, S>,
   options: createPlDataTableOptionsV3,
 ): PlDataTableModel | undefined {
   const providers = options.source
@@ -195,170 +196,175 @@ export function createPlDataTableV3<A, U>(
   if (providers.length === 0) return undefined;
 
   // Step 1: Build collection from sources
-  const builder = new ColumnCollectionBuilder(ctx).addSources(providers);
+  const builder = new ColumnCollectionBuilder(ctx.services.pframeSpec).addSources(providers);
   const anchors = options.columns.anchors;
   const collection = isNil(anchors) ? builder.build() : builder.build({ anchors });
 
   if (!collection) return undefined;
+  try {
+    // Step 2: Get data columns, excluding annotation-hidden ones
+    const findOptions = options.columns
+      ? {
+          include: options.columns.include,
+          exclude: options.columns.exclude,
+          mode: options.columns.mode,
+          maxHops: options.columns.maxHops,
+        }
+      : undefined;
+    const findResult = collection.findColumns(findOptions);
+    const snapshots = findResult.map((v) => ("column" in v ? v.column : v));
+    const dataSnapshots = snapshots.filter((s) => !isColumnHidden(s.spec));
+    if (dataSnapshots.length === 0) return undefined;
+
+    // Convert snapshots to PColumn<PColumnDataUniversal>[]
+    const columns: PColumn<PColumnDataUniversal>[] = [];
+    for (const snap of dataSnapshots) {
+      if (!snap.data) return undefined;
+      const data = snap.data.get();
+      if (data === undefined) return undefined;
+      columns.push({ id: snap.id, spec: snap.spec, data });
+    }
 
-  // Step 2: Get data columns, excluding annotation-hidden ones
-  const findOptions = options.columns
-    ? {
-        include: options.columns.include,
-        exclude: options.columns.exclude,
-        mode: options.columns.mode,
-        maxHops: options.columns.maxHops,
-      }
-    : undefined;
-  const findResult = collection.findColumns(findOptions);
-  const snapshots = findResult.map((v) => ("column" in v ? v.column : v));
-  const dataSnapshots = snapshots.filter((s) => !isColumnHidden(s.spec));
-  if (dataSnapshots.length === 0) return undefined;
-
-  // Convert snapshots to PColumn<PColumnDataUniversal>[]
-  const columns: PColumn<PColumnDataUniversal>[] = [];
-  for (const snap of dataSnapshots) {
-    if (!snap.data) return undefined;
-    const data = snap.data.get();
-    if (data === undefined) return undefined;
-    columns.push({ id: snap.id, spec: snap.spec, data });
-  }
+    // Step 3: Normalize table state
+    const tableStateNormalized = upgradePlDataTableStateV2(options.state);
+
+    // Step 4: Get label columns from result pool and match to data columns
+    const allLabelColumns = getAllLabelColumns(ctx.resultPool);
+    if (!allLabelColumns) return undefined;
 
-  // Step 3: Normalize table state
-  const tableStateNormalized = upgradePlDataTableStateV2(options.state);
-
-  // Step 4: Get label columns from result pool and match to data columns
-  const allLabelColumns = getAllLabelColumns(ctx.resultPool);
-  if (!allLabelColumns) return undefined;
-
-  const fullLabelColumns = getMatchingLabelColumns(
-    columns.map(getColumnIdAndSpec),
-    allLabelColumns,
-  );
-
-  const fullColumns = [...columns, ...fullLabelColumns];
-
-  // Step 5: Build column ID set for filter/sorting validation
-  const fullColumnsAxes = uniqueBy(
-    fullColumns.flatMap((c) => c.spec.axesSpec.map((a) => getAxisId(a))),
-    (a) => canonicalizeJson<AxisId>(a),
-  );
-  const fullColumnsIds: PTableColumnId[] = [
-    ...fullColumnsAxes.map((a) => ({ type: "axis", id: a }) satisfies PTableColumnIdAxis),
-    ...fullColumns.map((c) => ({ type: "column", id: c.id }) satisfies PTableColumnIdColumn),
-  ];
-  const fullColumnsIdsSet = new Set(fullColumnsIds.map((c) => canonicalizeJson<PTableColumnId>(c)));
-  const isValidColumnId = (id: string): boolean =>
-    fullColumnsIdsSet.has(id as CanonicalizedJson<PTableColumnId>);
-
-  // Step 6: Filtering validation
-  const stateFilters = tableStateNormalized.pTableParams.filters;
-  const opsFilters = options?.filters ?? null;
-  const filters: null | PlDataTableFilters =
-    stateFilters != null && opsFilters != null
-      ? { type: "and", filters: [stateFilters, opsFilters] }
-      : (stateFilters ?? opsFilters);
-  const filterColumns = filters ? collectFilterSpecColumns(filters) : [];
-  const firstInvalidFilterColumn = filterColumns.find((col) => !isValidColumnId(col));
-  if (firstInvalidFilterColumn)
-    throw new Error(
-      `Invalid filter column ${firstInvalidFilterColumn}: column reference does not match the table columns`,
+    const fullLabelColumns = getMatchingLabelColumns(
+      columns.map(getColumnIdAndSpec),
+      allLabelColumns,
     );
 
-  // Step 7: Sorting validation
-  const userSorting = tableStateNormalized.pTableParams.sorting;
-  const sorting = (isEmpty(userSorting) ? options?.sorting : userSorting) ?? [];
-  const firstInvalidSortingColumn = sorting.find(
-    (s) => !isValidColumnId(canonicalizeJson<PTableColumnId>(s.column)),
-  );
-  if (firstInvalidSortingColumn)
-    throw new Error(
-      `Invalid sorting column ${JSON.stringify(firstInvalidSortingColumn.column)}: column reference does not match the table columns`,
+    const fullColumns = [...columns, ...fullLabelColumns];
+
+    // Step 5: Build column ID set for filter/sorting validation
+    const fullColumnsAxes = uniqueBy(
+      fullColumns.flatMap((c) => c.spec.axesSpec.map((a) => getAxisId(a))),
+      (a) => canonicalizeJson<AxisId>(a),
+    );
+    const fullColumnsIds: PTableColumnId[] = [
+      ...fullColumnsAxes.map((a) => ({ type: "axis", id: a }) satisfies PTableColumnIdAxis),
+      ...fullColumns.map((c) => ({ type: "column", id: c.id }) satisfies PTableColumnIdColumn),
+    ];
+    const fullColumnsIdsSet = new Set(
+      fullColumnsIds.map((c) => canonicalizeJson<PTableColumnId>(c)),
+    );
+    const isValidColumnId = (id: string): boolean =>
+      fullColumnsIdsSet.has(id as CanonicalizedJson<PTableColumnId>);
+
+    // Step 6: Filtering validation
+    const stateFilters = tableStateNormalized.pTableParams.filters;
+    const opsFilters = options?.filters ?? null;
+    const filters: null | PlDataTableFilters =
+      stateFilters != null && opsFilters != null
+        ? { type: "and", filters: [stateFilters, opsFilters] }
+        : (stateFilters ?? opsFilters);
+    const filterColumns = filters ? collectFilterSpecColumns(filters) : [];
+    const firstInvalidFilterColumn = filterColumns.find((col) => !isValidColumnId(col));
+    if (firstInvalidFilterColumn)
+      throw new Error(
+        `Invalid filter column ${firstInvalidFilterColumn}: column reference does not match the table columns`,
+      );
+
+    // Step 7: Sorting validation
+    const userSorting = tableStateNormalized.pTableParams.sorting;
+    const sorting = (isEmpty(userSorting) ? options?.sorting : userSorting) ?? [];
+    const firstInvalidSortingColumn = sorting.find(
+      (s) => !isValidColumnId(canonicalizeJson<PTableColumnId>(s.column)),
+    );
+    if (firstInvalidSortingColumn)
+      throw new Error(
+        `Invalid sorting column ${JSON.stringify(firstInvalidSortingColumn.column)}: column reference does not match the table columns`,
+      );
+
+    // Step 8: Build full table definition and handles
+    const coreJoinType = options?.coreJoinType ?? "full";
+    const fullDef = createPTableDef({
+      columns,
+      labelColumns: fullLabelColumns,
+      coreJoinType,
+      filters,
+      sorting,
+      coreColumnPredicate: options?.coreColumnPredicate,
+    });
+
+    const fullHandle = ctx.createPTableV2(fullDef);
+    const pframeHandle = ctx.createPFrame(fullColumns);
+    if (!fullHandle || !pframeHandle) return undefined;
+
+    // Step 9: Determine hidden columns
+    const hiddenColumns = new Set<PObjectId>(
+      ((): PObjectId[] => {
+        // Inner join works as a filter — all columns must be present
+        if (coreJoinType === "inner") return [];
+
+        const hiddenColIds = tableStateNormalized.pTableParams.hiddenColIds;
+        if (hiddenColIds) return hiddenColIds;
+
+        return columns.filter((c) => isColumnOptional(c.spec)).map((c) => c.id);
+      })(),
     );
 
-  // Step 8: Build full table definition and handles
-  const coreJoinType = options?.coreJoinType ?? "full";
-  const fullDef = createPTableDef({
-    columns,
-    labelColumns: fullLabelColumns,
-    coreJoinType,
-    filters,
-    sorting,
-    coreColumnPredicate: options?.coreColumnPredicate,
-  });
-
-  const fullHandle = ctx.createPTableV2(fullDef);
-  const pframeHandle = ctx.createPFrame(fullColumns);
-  if (!fullHandle || !pframeHandle) return undefined;
-
-  // Step 9: Determine hidden columns
-  const hiddenColumns = new Set<PObjectId>(
-    ((): PObjectId[] => {
-      // Inner join works as a filter — all columns must be present
-      if (coreJoinType === "inner") return [];
-
-      const hiddenColIds = tableStateNormalized.pTableParams.hiddenColIds;
-      if (hiddenColIds) return hiddenColIds;
-
-      return columns.filter((c) => isColumnOptional(c.spec)).map((c) => c.id);
-    })(),
-  );
-
-  // Preserve linker columns
-  columns.filter((c) => isLinkerColumn(c.spec)).forEach((c) => hiddenColumns.delete(c.id));
-
-  // Preserve core columns as they change the shape of join
-  const coreColumnPredicate = options?.coreColumnPredicate;
-  if (coreColumnPredicate) {
-    const coreColumns = columns.flatMap((c) =>
-      coreColumnPredicate(getColumnIdAndSpec(c)) ? [c.id] : [],
+    // Preserve linker columns
+    columns.filter((c) => isLinkerColumn(c.spec)).forEach((c) => hiddenColumns.delete(c.id));
+
+    // Preserve core columns as they change the shape of join
+    const coreColumnPredicate = options?.coreColumnPredicate;
+    if (coreColumnPredicate) {
+      const coreColumns = columns.flatMap((c) =>
+        coreColumnPredicate(getColumnIdAndSpec(c)) ? [c.id] : [],
+      );
+      coreColumns.forEach((c) => hiddenColumns.delete(c));
+    }
+
+    // Preserve sorted columns from being hidden
+    sorting
+      .map((s) => s.column)
+      .filter((c): c is PTableColumnIdColumn => c.type === "column")
+      .forEach((c) => hiddenColumns.delete(c.id));
+
+    // Preserve filter columns from being hidden
+    if (filters) {
+      collectFilterSpecColumns(filters)
+        .flatMap((c) => {
+          const obj = parseJson(c);
+          return obj.type === "column" ? [obj.id] : [];
+        })
+        .forEach((c) => hiddenColumns.delete(c));
+    }
+
+    // Step 10: Build visible table definition
+    const visibleColumns = columns.filter((c) => !hiddenColumns.has(c.id));
+    const visibleLabelColumns = getMatchingLabelColumns(
+      visibleColumns.map(getColumnIdAndSpec),
+      allLabelColumns,
     );
-    coreColumns.forEach((c) => hiddenColumns.delete(c));
-  }
 
-  // Preserve sorted columns from being hidden
-  sorting
-    .map((s) => s.column)
-    .filter((c): c is PTableColumnIdColumn => c.type === "column")
-    .forEach((c) => hiddenColumns.delete(c.id));
-
-  // Preserve filter columns from being hidden
-  if (filters) {
-    collectFilterSpecColumns(filters)
-      .flatMap((c) => {
-        const obj = parseJson(c);
-        return obj.type === "column" ? [obj.id] : [];
-      })
-      .forEach((c) => hiddenColumns.delete(c));
+    if (!allPColumnsReady([...visibleColumns, ...visibleLabelColumns])) return undefined;
+
+    const visibleDef = createPTableDef({
+      columns: visibleColumns,
+      labelColumns: visibleLabelColumns,
+      coreJoinType,
+      filters,
+      sorting,
+      coreColumnPredicate,
+    });
+    const visibleHandle = ctx.createPTableV2(visibleDef);
+
+    if (!visibleHandle) return undefined;
+
+    return {
+      sourceId: tableStateNormalized.pTableParams.sourceId,
+      fullTableHandle: fullHandle,
+      fullPframeHandle: pframeHandle,
+      visibleTableHandle: visibleHandle,
+    } satisfies PlDataTableModel;
+  } finally {
+    collection.dispose();
   }
-
-  // Step 10: Build visible table definition
-  const visibleColumns = columns.filter((c) => !hiddenColumns.has(c.id));
-  const visibleLabelColumns = getMatchingLabelColumns(
-    visibleColumns.map(getColumnIdAndSpec),
-    allLabelColumns,
-  );
-
-  if (!allPColumnsReady([...visibleColumns, ...visibleLabelColumns])) return undefined;
-
-  const visibleDef = createPTableDef({
-    columns: visibleColumns,
-    labelColumns: visibleLabelColumns,
-    coreJoinType,
-    filters,
-    sorting,
-    coreColumnPredicate,
-  });
-  const visibleHandle = ctx.createPTableV2(visibleDef);
-
-  if (!visibleHandle) return undefined;
-
-  return {
-    sourceId: tableStateNormalized.pTableParams.sourceId,
-    fullTableHandle: fullHandle,
-    fullPframeHandle: pframeHandle,
-    visibleTableHandle: visibleHandle,
-  } satisfies PlDataTableModel;
 }
 
 /** Normalize raw ColumnSource | ColumnSource[] into a flat list of sources. */

package/src/components/PlDataTable/createPlDataTable/index.ts

@@ -1,3 +1,4 @@
+import { Services, type RequireServices } from "@milaboratories/pl-model-common";
 import type { RenderCtxBase } from "../../../render";
 import type { PlDataTableModel } from "../typesV5";
 import { createPlDataTableOptionsV2, createPlDataTableV2 } from "./createPlDataTableV2";
@@ -8,12 +9,12 @@ export function createPlDataTable<A, U>(
   ctx: RenderCtxBase<A, U>,
   options: { version: "v2" } & createPlDataTableOptionsV2,
 ): ReturnType<typeof createPlDataTableV2>;
-export function createPlDataTable<A, U>(
-  ctx: RenderCtxBase<A, U>,
+export function createPlDataTable<A, U, S extends RequireServices<typeof Services.PFrameSpec>>(
+  ctx: RenderCtxBase<A, U, S>,
   options: { version?: "v3" } & createPlDataTableOptionsV3,
 ): ReturnType<typeof createPlDataTableV3>;
-export function createPlDataTable<A, U>(
-  ctx: RenderCtxBase<A, U>,
+export function createPlDataTable<A, U, S extends RequireServices<typeof Services.PFrameSpec>>(
+  ctx: RenderCtxBase<A, U, S>,
   options:
     | ({ version: "v2" } & createPlDataTableOptionsV2)
     | ({ version?: "v3" } & createPlDataTableOptionsV3),

package/src/index.ts

@@ -54,6 +54,7 @@ export * from "./block_api_v2";
 export * from "./filters";
 export * from "./annotations";
 export * from "./pframe_utils";
+export * from "./services";
 
 // reexporting everything from SDK model
 export * from "@milaboratories/pl-model-common";

package/src/platforma.ts

@@ -9,6 +9,7 @@ import type {
   OutputWithStatus,
 } from "@milaboratories/pl-model-common";
 import type { SdkInfo } from "./version";
+import type { ServiceDispatch, UiServices as AllUiServices } from "@milaboratories/pl-model-common";
 import type { BlockStatePatch } from "./block_state_patch";
 import type { PluginRecord } from "./block_model";
 import type { PluginHandle, PluginFactoryLike } from "./plugin_handle";
@@ -54,13 +55,18 @@ export interface PlatformaV3<
   >,
   Href extends `/${string}` = `/${string}`,
   Plugins extends Record<string, unknown> = Record<string, unknown>,
+  UiServices extends Partial<AllUiServices> = Partial<AllUiServices>,
 >
   extends BlockApiV3<Data, Args, Outputs, Href>, DriverKit {
   /** Information about SDK version current platforma environment was compiled with. */
   readonly sdkInfo: SdkInfo;
   readonly apiVersion: 3;
+  /** Service dispatch — lists available services, their methods, and invokes them. */
+  readonly serviceDispatch: ServiceDispatch;
   /** @internal Type brand for plugin type inference. Not used at runtime. */
   readonly __pluginsBrand?: Plugins;
+  /** @internal Type brand for UI service type inference. Not used at runtime. */
+  readonly __uiServicesBrand?: UiServices;
 }
 
 export type Platforma<
@@ -148,7 +154,13 @@ export type InferPluginData<Pl, PluginId extends string> =
  * because PluginRecord doesn't carry Config (lost after factory.create()).
  */
 export type InferPluginHandles<T extends Record<string, unknown>> = {
-  readonly [K in keyof T]: T[K] extends PluginRecord<infer Data, infer Params, infer Outputs>
-    ? { handle: PluginHandle<PluginFactoryLike<Data, Params, Outputs>> }
+  readonly [K in keyof T]: T[K] extends PluginRecord<
+    infer Data,
+    infer Params,
+    infer Outputs,
+    infer ModelServices,
+    infer UiServices
+  >
+    ? { handle: PluginHandle<PluginFactoryLike<Data, Params, Outputs, ModelServices, UiServices>> }
     : never;
 };

package/src/plugin_handle.ts

@@ -23,37 +23,55 @@ export interface PluginFactoryLike<
   Data extends Record<string, unknown> = Record<string, unknown>,
   Params extends undefined | Record<string, unknown> = undefined | Record<string, unknown>,
   Outputs extends Record<string, unknown> = Record<string, unknown>,
+  ModelServices = unknown,
+  UiServices = unknown,
 > {
   readonly __types?: {
     data: Data;
     params: Params;
     outputs: Outputs;
+    modelServices: ModelServices;
+    uiServices: UiServices;
   };
 }
 
 /** Extract the Data type from a PluginFactoryLike phantom. */
 export type InferFactoryData<F extends PluginFactoryLike> = NonNullable<
-  F extends PluginFactoryLike<infer D, any, any> ? D : Record<string, unknown>
+  F extends PluginFactoryLike<infer D, any, any, any, any> ? D : Record<string, unknown>
 >;
 
 /** Extract the Params type from a PluginFactoryLike phantom. */
 export type InferFactoryParams<F extends PluginFactoryLike> = NonNullable<
-  F extends PluginFactoryLike<any, infer P, any> ? P : undefined
+  F extends PluginFactoryLike<any, infer P, any, any, any> ? P : undefined
 >;
 
 /** Extract the Outputs type from a PluginFactoryLike phantom. */
 export type InferFactoryOutputs<F extends PluginFactoryLike> = NonNullable<
-  F extends PluginFactoryLike<any, any, infer O> ? O : Record<string, unknown>
+  F extends PluginFactoryLike<any, any, infer O, any, any> ? O : Record<string, unknown>
 >;
 
+/** Extract the pre-resolved model services type from a PluginFactoryLike phantom. */
+export type InferFactoryModelServices<F extends PluginFactoryLike> =
+  F extends PluginFactoryLike<any, any, any, infer ModelServices, any> ? ModelServices : {};
+
+/** Extract the pre-resolved UI services type from a PluginFactoryLike phantom. */
+export type InferFactoryUiServices<F extends PluginFactoryLike> =
+  F extends PluginFactoryLike<any, any, any, any, infer UiServices> ? UiServices : {};
+
 /**
  * Derive a typed PluginHandle from a PluginFactory type.
- * Normalizes the brand to only data/params/outputs (strips config) so handles
+ * Normalizes the brand to data/params/outputs/services (strips config) so handles
  * from InferPluginHandles match handles from InferPluginHandle.
  */
 export type InferPluginHandle<F extends PluginFactoryLike> = NonNullable<
-  F extends PluginFactoryLike<infer Data, infer Params, infer Outputs>
-    ? PluginHandle<PluginFactoryLike<Data, Params, Outputs>>
+  F extends PluginFactoryLike<
+    infer Data,
+    infer Params,
+    infer Outputs,
+    infer ModelServices,
+    infer UiServices
+  >
+    ? PluginHandle<PluginFactoryLike<Data, Params, Outputs, ModelServices, UiServices>>
     : PluginHandle
 >;