@milaboratories/pl-model-common 1.35.0 → 1.36.1

package/src/drivers/pframe/data_types.ts

@@ -48,7 +48,7 @@ function isBitSet(bitVector: Uint8Array, offset: number): boolean {
   return (bitVector[chunkIndex] & mask) > 0;
 }
 
-function isValueNA(vector: PTableVector, row: number): boolean {
+export function isValueNA(vector: PTableVector, row: number): boolean {
   if (vector.isNA) return isBitSet(vector.isNA, row);
 
   // Check for legacy magic values to support old desktop versions
@@ -236,3 +236,32 @@ export type PTableShape = {
   /** Number of rows */
   rows: number;
 };
+
+/** Supported formats for PTable file download. */
+export type PTableDownloadFormat = "csv" | "tsv";
+
+/** Compression applied to the written file. */
+export type PTableDownloadCompression = "none" | "gzip";
+
+/** Options for downloading PTable data to a file. */
+export interface WritePTableToFsOptions {
+  path: string;
+  format: PTableDownloadFormat;
+  columnIndices: number[];
+  range?: TableRange;
+  chunkSize?: number;
+  includeHeader?: boolean;
+  bom?: boolean;
+  compression?: {
+    type: "gzip";
+    level?: number;
+  };
+  signal?: AbortSignal;
+}
+
+/** Result of a PTable file download. */
+export interface WritePTableToFsResult {
+  path: string;
+  rowsWritten: number;
+  bytesWritten: number;
+}

package/src/drivers/pframe/driver.ts

@@ -5,7 +5,13 @@ import type { PColumn } from "./spec/spec";
 import type { PColumnValues, DataInfo } from "./data_info";
 import type { PTableDef, PTableDefV2 } from "./table_calculate";
 import type { AddParameterToAllMethods } from "./type_util";
-import type { PTableShape, PTableVector, TableRange } from "./data_types";
+import type {
+  WritePTableToFsOptions,
+  WritePTableToFsResult,
+  PTableShape,
+  PTableVector,
+  TableRange,
+} from "./data_types";
 import type { FindColumnsRequest, FindColumnsResponse } from "./find_columns";
 import type { PObjectId } from "../../pool";
 import type { PColumnIdAndSpec, PColumnSpec } from "./spec/spec";
@@ -88,6 +94,15 @@ export interface PFrameDriver {
     columnIndices: number[],
     range?: TableRange,
   ): Promise<PTableVector[]>;
+
+  /**
+   * Stream the table to a file at the given path. Caller is responsible
+   * for producing the destination path (e.g. via the `Dialog` service).
+   */
+  writePTableToFs(
+    handle: PTableHandle,
+    options: WritePTableToFsOptions,
+  ): Promise<WritePTableToFsResult>;
 }
 
 //
@@ -102,4 +117,4 @@ type ExpectedPFrameDriverType = ExpectedPFrameDriverTypeF & ExpectedPFrameDriver
 type TypeEqualityGuard<A, B> = Exclude<A, B> | Exclude<B, A>;
 function assert<_T extends never>() {}
 
-assert<TypeEqualityGuard<PFrameDriver, ExpectedPFrameDriverType>>();
+assert<TypeEqualityGuard<Omit<PFrameDriver, "writePTableToFs">, ExpectedPFrameDriverType>>();

package/src/drivers/pframe/query/query_common.ts

@@ -632,23 +632,31 @@ export interface QueryOuterJoin<JE extends QueryJoinEntry<unknown>> {
  * @template A - Axis selector type
  *
  * @example
- * // Slice 3D data [sample, gene, condition] to 1D [gene]
+ * // Spec layer: axisSelector is a SingleAxisSelector.
  * {
  *   type: 'sliceAxes',
  *   input: fullDataQuery,
  *   axisFilters: [
- *     { type: 'constant', axisSelector: { type: 'axis', id: 'sample' }, constant: 'Sample1' },
- *     { type: 'constant', axisSelector: { type: 'axis', id: 'condition' }, constant: 'Treatment' }
+ *     { axisSelector: { name: 'sample' }, constant: 'Sample1' },
+ *     { axisSelector: { name: 'condition' }, constant: 'Treatment' }
  *   ]
  * }
+ *
+ * @example
+ * // Data layer: axisSelector is the axis index.
+ * {
+ *   type: 'sliceAxes',
+ *   input: fullDataQuery,
+ *   axisFilters: [{ axisSelector: 0, constant: 'Sample1' }]
+ * }
  */
-export interface QuerySliceAxes<Q, A extends QueryAxisSelector<unknown>> {
+export interface QuerySliceAxes<Q, A> {
   type: "sliceAxes";
   /** Input query to slice */
   input: Q;
   /** List of axis filters to apply (at least one required) */
   axisFilters: {
-    /** Selector identifying which axis to filter */
+    /** Axis to filter. `SingleAxisSelector` at the spec layer; axis index at the data layer. */
     axisSelector: A;
     /** The constant value to filter the axis to */
     constant: string | number;

package/src/drivers/pframe/query/query_data.ts

@@ -15,7 +15,6 @@ import type {
   ExprStringEquals,
   ExprStringRegex,
   ExprNumericUnary,
-  QueryAxisSelector,
   QueryColumn,
   QuerySparseToDenseColumn,
   QueryFilter,
@@ -40,7 +39,7 @@ type ColumnIdAndTypeSpec = {
   /** Unique identifier of the column */
   id: PObjectId;
   /** Type specification defining axes and column types */
-  typeSpec: TypeSpec;
+  spec: TypeSpec;
 };
 
 /**
@@ -89,7 +88,7 @@ export type DataQueryLinkerJoinLinker = {
 /** @see QueryLinkerJoin */
 export type DataQueryLinkerJoin = QueryLinkerJoin<DataQueryLinkerJoinLinker, DataQueryJoinEntry>;
 /** @see QuerySliceAxes */
-export type DataQuerySliceAxes = QuerySliceAxes<DataQuery, QueryAxisSelector<number>>;
+export type DataQuerySliceAxes = QuerySliceAxes<DataQuery, number>;
 /** @see QuerySort */
 export type DataQuerySort = QuerySort<DataQuery, DataQueryExpression>;
 /** @see QueryFilter */

package/src/drivers/pframe/query/query_spec.ts

@@ -15,7 +15,6 @@ import type {
   ExprStringEquals,
   ExprStringRegex,
   ExprNumericUnary,
-  QueryAxisSelector,
   QueryColumn,
   QuerySparseToDenseColumn,
   QueryFilter,
@@ -28,43 +27,23 @@ import type {
   QuerySymmetricJoin,
   InferBooleanExpressionUnion,
 } from "./query_common";
-import type { Domain, PColumnIdAndSpec, PColumnSpec, SingleAxisSelector } from "../spec";
+import type { Domain, PColumnIdAndSpec, SingleAxisSelector } from "../spec";
 
 /**
- * Column identifier with specification.
- *
- * Pairs a column ID with its full PColumnSpec.
- * Used in spec layer to carry column specification alongside references.
- */
-type ColumnIdAndSpec = {
-  /** Unique identifier of the column */
-  id: PObjectId;
-  /** Full column specification including axes and value type */
-  spec: PColumnSpec;
-};
-
-/**
- * Join entry for spec layer queries.
- *
- * Extends the base join entry with axis qualifications.
- * Qualifications specify additional domain constraints for each axis,
- * enabling more precise control over how columns are joined.
+ * Join entry for spec-layer queries — the base join entry extended with
+ * per-axis domain constraints. Absent `qualifications` is equivalent to `[]`.
  *
  * @example
- * // Join entry with axis qualifications
  * {
  *   entry: querySpec,
- *   qualifications: [
- *     { axis: { name: 'sample' }, contextDomain: { ... } }
- *   ]
+ *   qualifications: [{ axis: { name: 'sample' }, contextDomain: { ... } }]
  * }
  */
 export type SpecQueryJoinEntry<C = PObjectId> = QueryJoinEntry<SpecQuery<C>> & {
-  /** Axis qualifications with additional domain constraints */
-  qualifications: {
-    /** Axis selector identifying which axis to qualify */
+  qualifications?: {
+    /** Axis to qualify. */
     axis: SingleAxisSelector;
-    /** Additional domain constraints for this axis */
+    /** Additional domain constraints for this axis. */
     contextDomain: Domain;
   }[];
 };
@@ -72,7 +51,7 @@ export type SpecQueryJoinEntry<C = PObjectId> = QueryJoinEntry<SpecQuery<C>> & {
 /** @see QueryColumn */
 export type SpecQueryColumn<C = PObjectId> = QueryColumn<C>;
 /** @see QueryInlineColumn */
-export type SpecQueryInlineColumn = QueryInlineColumn<ColumnIdAndSpec>;
+export type SpecQueryInlineColumn = QueryInlineColumn<PColumnIdAndSpec>;
 /** @see QuerySparseToDenseColumn */
 export type SpecQuerySparseToDenseColumn<C = PObjectId> = QuerySparseToDenseColumn<
   C,
@@ -98,10 +77,7 @@ export type SpecQueryLinkerJoin<C = PObjectId> = QueryLinkerJoin<
   SpecQueryJoinEntry<C>
 >;
 /** @see QuerySliceAxes */
-export type SpecQuerySliceAxes<C = PObjectId> = QuerySliceAxes<
-  SpecQuery<C>,
-  QueryAxisSelector<SingleAxisSelector>
->;
+export type SpecQuerySliceAxes<C = PObjectId> = QuerySliceAxes<SpecQuery<C>, SingleAxisSelector>;
 /** @see QuerySort */
 export type SpecQuerySort<C = PObjectId> = QuerySort<SpecQuery<C>, SpecQueryExpression>;
 /** @see QueryFilter */

package/src/drivers/pframe/query/utils.ts

@@ -150,14 +150,21 @@ export function sortSpecQuery(query: SpecQuery): SpecQuery {
           return node;
       }
     },
-    joinEntry: (entry) => ({
-      ...entry,
-      qualifications: entry.qualifications.toSorted((a, b) => {
-        const ak = canonicalizeJson(a.axis);
-        const bk = canonicalizeJson(b.axis);
-        return ak < bk ? -1 : ak === bk ? 0 : 1;
-      }),
-    }),
+    joinEntry: (entry) => {
+      // Preserve absence of `qualifications` (absent == `[]`) so canonical
+      // output is stable across both input forms.
+      if (entry.qualifications === undefined || entry.qualifications.length === 0) {
+        return entry;
+      }
+      return {
+        ...entry,
+        qualifications: entry.qualifications.toSorted((a, b) => {
+          const ak = canonicalizeJson(a.axis);
+          const bk = canonicalizeJson(b.axis);
+          return ak < bk ? -1 : ak === bk ? 0 : 1;
+        }),
+      };
+    },
   });
 }
 
@@ -173,9 +180,9 @@ function cmpQuerySpec(lhs: SpecQuery, rhs: SpecQuery): number {
           ? 0
           : 1;
     case "inlineColumn":
-      return lhs.spec.id < (rhs as typeof lhs).spec.id
+      return lhs.spec.columnId < (rhs as typeof lhs).spec.columnId
         ? -1
-        : lhs.spec.id === (rhs as typeof lhs).spec.id
+        : lhs.spec.columnId === (rhs as typeof lhs).spec.columnId
           ? 0
           : 1;
     case "sparseToDenseColumn":
@@ -237,13 +244,16 @@ function cmpQuerySpec(lhs: SpecQuery, rhs: SpecQuery): number {
 function cmpQueryJoinEntrySpec(lhs: SpecQueryJoinEntry, rhs: SpecQueryJoinEntry): number {
   const cmp = cmpQuerySpec(lhs.entry, rhs.entry);
   if (cmp !== 0) return cmp;
-  if (lhs.qualifications.length !== rhs.qualifications.length) {
-    return lhs.qualifications.length - rhs.qualifications.length;
+  // Absent `qualifications` is equivalent to an empty list.
+  const lhsQ = lhs.qualifications ?? [];
+  const rhsQ = rhs.qualifications ?? [];
+  if (lhsQ.length !== rhsQ.length) {
+    return lhsQ.length - rhsQ.length;
   }
-  for (let i = 0; i < lhs.qualifications.length; i++) {
-    const lhsQ = canonicalizeJson(lhs.qualifications[i]);
-    const rhsQ = canonicalizeJson(rhs.qualifications[i]);
-    if (lhsQ !== rhsQ) return lhsQ < rhsQ ? -1 : 1;
+  for (let i = 0; i < lhsQ.length; i++) {
+    const l = canonicalizeJson(lhsQ[i]);
+    const r = canonicalizeJson(rhsQ[i]);
+    if (l !== r) return l < r ? -1 : 1;
   }
   return 0;
 }

package/src/index.ts

@@ -4,6 +4,7 @@ export * from "./bmodel";
 export * from "./branding";
 export * from "./common_types";
 export * from "./driver_kit";
+export * from "./dialog";
 export * from "./drivers";
 export * from "./errors";
 export * from "./flags";

package/src/services/{service_injector_factory.ts → node_service_handlers.ts}

@@ -1,15 +1,21 @@
 /**
- * UI service injector factory.
+ * Worker-side dispatch table for `node`-kind services.
  *
- * When adding a new node service, add its method wrappers here.
- * Everything else (SERVICE_METHOD_MAP, buildServiceInfo, UiServiceInjectorMap)
- * auto-derives from this factory + Services in service_declarations.ts.
+ * Each entry maps a method name to a closure that calls the real driver
+ * inside the worker process. Used by `callServiceMethod` in the worker
+ * (see `platforma-desktop-app/packages/worker/src/workerApi.ts`) to route
+ * incoming IPC calls to concrete driver methods.
+ *
+ * NOT used for:
+ * - `wasm` services — instantiated locally on each consumer (no IPC).
+ * - `main` services — dispatched in the Electron main process via its
+ *   own router, never reaches the worker.
  */
 
 import type { DriverKit } from "../driver_kit";
-import type { UiServiceInjectorMap } from "./service_injectors";
+import type { NodeServiceHandlerMap } from "./service_injectors";
 
-export function createUiServiceInjectors(driverKit: DriverKit): UiServiceInjectorMap {
+export function createNodeServiceHandlers(driverKit: DriverKit): NodeServiceHandlerMap {
   const { pFrameDriver } = driverKit;
   return {
     PFrame: {
@@ -22,6 +28,7 @@ export function createUiServiceInjectors(driverKit: DriverKit): UiServiceInjecto
       getShape: (handle) => pFrameDriver.getShape(handle),
       getSpec: (handle) => pFrameDriver.getSpec(handle),
       getData: (handle, columnIndices, range) => pFrameDriver.getData(handle, columnIndices, range),
+      writePTableToFs: (handle, options) => pFrameDriver.writePTableToFs(handle, options),
     },
   };
 }

package/src/services/service_declarations.ts

@@ -1,6 +1,11 @@
 /**
  * Service declarations — add new services here.
  *
+ * `modelMethods` / `uiMethods` lists are the single source of truth for
+ * method names exposed on each side. They drive SERVICE_METHOD_MAP (UI
+ * ServiceProxy forwarders) and MODEL_SERVICE_METHOD_MAP (workflow VM
+ * bridge), so node/main/wasm split no longer needs introspection stubs.
+ *
  * After adding a service, fix type errors in these files:
  *
  * Model side:
@@ -8,18 +13,70 @@
  * - lib/node/pl-middle-layer/src/middle_layer/middle_layer.ts — ModelServiceRegistry factory
  *
  * UI side:
- * - lib/model/common/src/services/service_injector_factory.ts — driver method wrappers (node services only)
+ * - lib/model/common/src/services/node_service_handlers.ts — driver method wrappers (node services only)
  * - sdk/ui-vue/src/internal/createAppV3.ts — UiServiceRegistry factory
  *
+ * Electron main side (only for `main` services):
+ * - platforma-desktop-app/packages/main/src/services/mainServices.ts — main-process dispatcher
+ *
  * Optional:
  * - sdk/model/src/services/block_service_flags.ts — only if default-required by all blocks
  */
 
+import type { DialogService } from "../dialog";
 import type { PFrameDriver, PFrameModelDriver } from "../drivers/pframe/driver";
 import type { PFrameSpecDriver } from "../drivers/pframe/spec_driver";
 import { service } from "./service_types";
 
 export const Services = {
-  PFrameSpec: service<PFrameSpecDriver, PFrameSpecDriver>()({ type: "wasm", name: "pframeSpec" }),
-  PFrame: service<PFrameModelDriver, PFrameDriver>()({ type: "node", name: "pframe" }),
+  PFrameSpec: service<PFrameSpecDriver, PFrameSpecDriver>()({
+    type: "wasm",
+    name: "pframeSpec",
+    modelMethods: [
+      "createSpecFrame",
+      "listColumns",
+      "discoverColumns",
+      "deleteColumn",
+      "evaluateQuery",
+      "buildQuery",
+      "expandAxes",
+      "collapseAxes",
+      "findAxis",
+      "findTableColumn",
+    ] as const,
+    uiMethods: [
+      "createSpecFrame",
+      "listColumns",
+      "discoverColumns",
+      "deleteColumn",
+      "evaluateQuery",
+      "buildQuery",
+      "expandAxes",
+      "collapseAxes",
+      "findAxis",
+      "findTableColumn",
+    ] as const,
+  }),
+  PFrame: service<PFrameModelDriver, PFrameDriver>()({
+    type: "node",
+    name: "pframe",
+    modelMethods: ["createPFrame", "createPTable", "createPTableV2"] as const,
+    uiMethods: [
+      "findColumns",
+      "getColumnSpec",
+      "listColumns",
+      "calculateTableData",
+      "getUniqueValues",
+      "getShape",
+      "getSpec",
+      "getData",
+      "writePTableToFs",
+    ] as const,
+  }),
+  Dialog: service<Record<string, never>, DialogService>()({
+    type: "main",
+    name: "dialog",
+    modelMethods: [] as const,
+    uiMethods: ["showSaveDialog"] as const,
+  }),
 };

package/src/services/service_injectors.ts

@@ -1,17 +1,21 @@
 /**
- * UI service injectors — auto-derived types, method map, and service info builder.
+ * Service dispatch glue — auto-derived types, method maps, and service info builder.
  *
- * The factory (createUiServiceInjectors) lives in service_injector_factory.ts —
- * that's the only file to edit when adding a new node service.
+ * The worker-side handler factory (createNodeServiceHandlers) lives in
+ * node_service_handlers.ts — that's the only file to edit when adding a
+ * new node service. Method-name registries for UI and model sides are
+ * derived directly from the `uiMethods` / `modelMethods` declarations in
+ * service_declarations.ts — no factory introspection, no stubs.
  */
 
 import type { InferServiceKind, InferServiceUi, ServiceBrand, ServiceName } from "./service_types";
 import type { DriverKit } from "../driver_kit";
 import { Services } from "./service_declarations";
-import { getMethodNames, resolveRequiredServices } from "./service_capabilities";
-import { createUiServiceInjectors } from "./service_injector_factory";
+import { getServiceModelMethods, getServiceUiMethods } from "./service_types";
+import { resolveRequiredServices } from "./service_capabilities";
+import { createNodeServiceHandlers } from "./node_service_handlers";
 
-export { createUiServiceInjectors } from "./service_injector_factory";
+export { createNodeServiceHandlers } from "./node_service_handlers";
 
 type NodeServiceKeys = {
   [K in keyof typeof Services]: InferServiceKind<ServiceBrand<(typeof Services)[K]>> extends "node"
@@ -19,54 +23,66 @@ type NodeServiceKeys = {
     : never;
 }[keyof typeof Services];
 
-/** Auto-derived map of node service keys to their UI-side driver interfaces. */
-export type UiServiceInjectorMap = {
+/**
+ * Auto-derived map of node service keys to their UI-facing interfaces.
+ * Fulfilled by real driver wrappers in the worker. Main services are
+ * dispatched by the Electron main-process router and never reach this
+ * map; wasm services are instantiated locally on each consumer.
+ */
+export type NodeServiceHandlerMap = {
   [K in NodeServiceKeys]: InferServiceUi<ServiceBrand<(typeof Services)[K]>>;
 };
 
 let cachedKit: DriverKit | undefined;
-let cachedInjectors: UiServiceInjectorMap | undefined;
+let cachedHandlers: NodeServiceHandlerMap | undefined;
 
-function getOrCreateInjectors(driverKit: DriverKit): UiServiceInjectorMap {
-  if (!cachedInjectors || cachedKit !== driverKit) {
+function getOrCreateHandlers(driverKit: DriverKit): NodeServiceHandlerMap {
+  if (!cachedHandlers || cachedKit !== driverKit) {
     cachedKit = driverKit;
-    cachedInjectors = createUiServiceInjectors(driverKit);
+    cachedHandlers = createNodeServiceHandlers(driverKit);
   }
-  return cachedInjectors;
+  return cachedHandlers;
 }
 
-/** Resolve the injector for a given service ID. Caches injectors per DriverKit reference. */
-export function resolveUiInjector(
+/**
+ * Resolve the worker-side handler object for a given service ID. Caches
+ * per DriverKit reference. Called from the worker's IPC dispatch path.
+ */
+export function resolveNodeServiceHandler(
   driverKit: DriverKit,
   serviceId: ServiceName,
-): UiServiceInjectorMap[keyof UiServiceInjectorMap] | null {
-  const injectors = getOrCreateInjectors(driverKit);
+): NodeServiceHandlerMap[keyof NodeServiceHandlerMap] | null {
+  const handlers = getOrCreateHandlers(driverKit);
   const key = Object.keys(Services).find(
     (k) => Services[k as keyof typeof Services] === serviceId,
   ) as NodeServiceKeys | undefined;
   if (!key) return null;
-  return injectors[key];
+  return handlers[key];
 }
 
-/**
- * Static map of ServiceName → method names, auto-derived from the injector shape.
- * Computed once at module load. The stub DriverKit is never called — it only
- * provides a target so the closures in createUiServiceInjectors have own-property
- * keys that getMethodNames can introspect.
- */
-export const SERVICE_METHOD_MAP: Readonly<Record<string, string[]>> = (() => {
-  const stubKit = new Proxy({} as DriverKit, {
-    get: () => new Proxy({}, { get: () => () => {} }),
-  });
-  const injectors = createUiServiceInjectors(stubKit);
+function buildMethodMap(
+  pick: (id: ServiceName) => readonly string[],
+): Readonly<Record<string, string[]>> {
   const result: Record<string, string[]> = {};
-  for (const key of Object.keys(Services) as (keyof typeof Services)[]) {
-    const serviceId = Services[key];
-    const injector = injectors[key as NodeServiceKeys];
-    result[serviceId] = injector ? getMethodNames(injector) : [];
+  for (const id of Object.values(Services)) {
+    result[id as string] = [...pick(id)];
   }
   return result;
-})();
+}
+
+/**
+ * UI-side method names per service. Drives ServiceProxy forwarder
+ * construction in the renderer.
+ */
+export const SERVICE_METHOD_MAP: Readonly<Record<string, string[]>> =
+  buildMethodMap(getServiceUiMethods);
+
+/**
+ * Model-side method names per service. Drives the workflow VM bridge
+ * (see pl-middle-layer js_render).
+ */
+export const MODEL_SERVICE_METHOD_MAP: Readonly<Record<string, string[]>> =
+  buildMethodMap(getServiceModelMethods);
 
 /** Build service info for a block from its feature flags. */
 export function buildServiceInfo(

package/src/services/service_types.ts

@@ -22,19 +22,36 @@ export type InferServiceKind<S extends ServiceTypesLike> =
 
 export type ServiceName<S extends ServiceTypesLike = ServiceTypesLike> = Branded<string, S>;
 
-export type ServiceType = "node" | "wasm";
+export type ServiceType = "node" | "wasm" | "main";
 
 const SERVICE_ID_PATTERN = /^[a-zA-Z][a-zA-Z0-9]*$/;
 
-export const { service, isNodeService } = (() => {
+export const {
+  service,
+  isNodeService,
+  isWasmService,
+  isMainService,
+  getServiceKind,
+  getServiceModelMethods,
+  getServiceUiMethods,
+} = (() => {
   const typeMap = new Map<string, ServiceType>();
+  const modelMethodsMap = new Map<string, readonly string[]>();
+  const uiMethodsMap = new Map<string, readonly string[]>();
   return {
     service<Model, Ui>() {
-      return <K extends ServiceType, N extends string>(options: {
+      return <
+        K extends ServiceType,
+        N extends string,
+        MM extends readonly (keyof Model & string)[],
+        UM extends readonly (keyof Ui & string)[],
+      >(options: {
         readonly type: K;
         readonly name: N;
+        readonly modelMethods: MM;
+        readonly uiMethods: UM;
       }): Branded<N, ServiceTypesLike<Model, Ui, K>> => {
-        const { name, type } = options;
+        const { name, type, modelMethods, uiMethods } = options;
         if (!SERVICE_ID_PATTERN.test(name)) {
           throw new ServiceInvalidIdError(
             `Invalid service ID "${name}": must match ${SERVICE_ID_PATTERN}`,
@@ -44,12 +61,29 @@ export const { service, isNodeService } = (() => {
           throw new ServiceAlreadyRegisteredError(`Service "${name}" already registered`);
         }
         typeMap.set(name, type);
+        modelMethodsMap.set(name, modelMethods);
+        uiMethodsMap.set(name, uiMethods);
         return name as Branded<N, ServiceTypesLike<Model, Ui, K>>;
       };
     },
     isNodeService(id: ServiceName): boolean {
       return typeMap.get(id) === "node";
     },
+    isWasmService(id: ServiceName): boolean {
+      return typeMap.get(id) === "wasm";
+    },
+    isMainService(id: ServiceName): boolean {
+      return typeMap.get(id) === "main";
+    },
+    getServiceKind(id: ServiceName): ServiceType | undefined {
+      return typeMap.get(id);
+    },
+    getServiceModelMethods(id: ServiceName): readonly string[] {
+      return modelMethodsMap.get(id) ?? [];
+    },
+    getServiceUiMethods(id: ServiceName): readonly string[] {
+      return uiMethodsMap.get(id) ?? [];
+    },
   };
 })();
 

package/dist/services/service_injector_factory.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"service_injector_factory.cjs","names":[],"sources":["../../src/services/service_injector_factory.ts"],"sourcesContent":["/**\n * UI service injector factory.\n *\n * When adding a new node service, add its method wrappers here.\n * Everything else (SERVICE_METHOD_MAP, buildServiceInfo, UiServiceInjectorMap)\n * auto-derives from this factory + Services in service_declarations.ts.\n */\n\nimport type { DriverKit } from \"../driver_kit\";\nimport type { UiServiceInjectorMap } from \"./service_injectors\";\n\nexport function createUiServiceInjectors(driverKit: DriverKit): UiServiceInjectorMap {\n  const { pFrameDriver } = driverKit;\n  return {\n    PFrame: {\n      findColumns: (handle, request) => pFrameDriver.findColumns(handle, request),\n      getColumnSpec: (handle, columnId) => pFrameDriver.getColumnSpec(handle, columnId),\n      listColumns: (handle) => pFrameDriver.listColumns(handle),\n      calculateTableData: (handle, request, range) =>\n        pFrameDriver.calculateTableData(handle, request, range),\n      getUniqueValues: (handle, request) => pFrameDriver.getUniqueValues(handle, request),\n      getShape: (handle) => pFrameDriver.getShape(handle),\n      getSpec: (handle) => pFrameDriver.getSpec(handle),\n      getData: (handle, columnIndices, range) => pFrameDriver.getData(handle, columnIndices, range),\n    },\n  };\n}\n"],"mappings":";AAWA,SAAgB,yBAAyB,WAA4C;CACnF,MAAM,EAAE,iBAAiB;AACzB,QAAO,EACL,QAAQ;EACN,cAAc,QAAQ,YAAY,aAAa,YAAY,QAAQ,QAAQ;EAC3E,gBAAgB,QAAQ,aAAa,aAAa,cAAc,QAAQ,SAAS;EACjF,cAAc,WAAW,aAAa,YAAY,OAAO;EACzD,qBAAqB,QAAQ,SAAS,UACpC,aAAa,mBAAmB,QAAQ,SAAS,MAAM;EACzD,kBAAkB,QAAQ,YAAY,aAAa,gBAAgB,QAAQ,QAAQ;EACnF,WAAW,WAAW,aAAa,SAAS,OAAO;EACnD,UAAU,WAAW,aAAa,QAAQ,OAAO;EACjD,UAAU,QAAQ,eAAe,UAAU,aAAa,QAAQ,QAAQ,eAAe,MAAM;EAC9F,EACF"}

package/dist/services/service_injector_factory.d.ts

@@ -1,8 +0,0 @@
-import { DriverKit } from "../driver_kit.js";
-import { UiServiceInjectorMap } from "./service_injectors.js";
-
-//#region src/services/service_injector_factory.d.ts
-declare function createUiServiceInjectors(driverKit: DriverKit): UiServiceInjectorMap;
-//#endregion
-export { createUiServiceInjectors };
-//# sourceMappingURL=service_injector_factory.d.ts.map

package/dist/services/service_injector_factory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"service_injector_factory.d.ts","names":[],"sources":["../../src/services/service_injector_factory.ts"],"mappings":";;;;iBAWgB,wBAAA,CAAyB,SAAA,EAAW,SAAA,GAAY,oBAAA"}

package/dist/services/service_injector_factory.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"service_injector_factory.js","names":[],"sources":["../../src/services/service_injector_factory.ts"],"sourcesContent":["/**\n * UI service injector factory.\n *\n * When adding a new node service, add its method wrappers here.\n * Everything else (SERVICE_METHOD_MAP, buildServiceInfo, UiServiceInjectorMap)\n * auto-derives from this factory + Services in service_declarations.ts.\n */\n\nimport type { DriverKit } from \"../driver_kit\";\nimport type { UiServiceInjectorMap } from \"./service_injectors\";\n\nexport function createUiServiceInjectors(driverKit: DriverKit): UiServiceInjectorMap {\n  const { pFrameDriver } = driverKit;\n  return {\n    PFrame: {\n      findColumns: (handle, request) => pFrameDriver.findColumns(handle, request),\n      getColumnSpec: (handle, columnId) => pFrameDriver.getColumnSpec(handle, columnId),\n      listColumns: (handle) => pFrameDriver.listColumns(handle),\n      calculateTableData: (handle, request, range) =>\n        pFrameDriver.calculateTableData(handle, request, range),\n      getUniqueValues: (handle, request) => pFrameDriver.getUniqueValues(handle, request),\n      getShape: (handle) => pFrameDriver.getShape(handle),\n      getSpec: (handle) => pFrameDriver.getSpec(handle),\n      getData: (handle, columnIndices, range) => pFrameDriver.getData(handle, columnIndices, range),\n    },\n  };\n}\n"],"mappings":";AAWA,SAAgB,yBAAyB,WAA4C;CACnF,MAAM,EAAE,iBAAiB;AACzB,QAAO,EACL,QAAQ;EACN,cAAc,QAAQ,YAAY,aAAa,YAAY,QAAQ,QAAQ;EAC3E,gBAAgB,QAAQ,aAAa,aAAa,cAAc,QAAQ,SAAS;EACjF,cAAc,WAAW,aAAa,YAAY,OAAO;EACzD,qBAAqB,QAAQ,SAAS,UACpC,aAAa,mBAAmB,QAAQ,SAAS,MAAM;EACzD,kBAAkB,QAAQ,YAAY,aAAa,gBAAgB,QAAQ,QAAQ;EACnF,WAAW,WAAW,aAAa,SAAS,OAAO;EACnD,UAAU,WAAW,aAAa,QAAQ,OAAO;EACjD,UAAU,QAAQ,eAAe,UAAU,aAAa,QAAQ,QAAQ,eAAe,MAAM;EAC9F,EACF"}