@milaboratories/pl-model-common 1.29.0 → 1.31.0

package/src/drivers/pframe/data_types.ts

@@ -26,7 +26,7 @@ export type PTableVectorTyped<DataType extends ValueType> = {
   /** Stored data type */
   readonly type: DataType;
 
-  /** Values for present positions, absent positions have NA values */
+  /** Values for present positions */
   readonly data: PVectorDataTyped<DataType>;
 
   /**
@@ -36,15 +36,10 @@ export type PTableVectorTyped<DataType extends ValueType> = {
    * */
   readonly isNA?: Uint8Array;
 
-  /**
-   * Encoded bit array marking some elements of this vector as absent,
-   * call {@link bitSet} to read the data.
-   * */
-  readonly absent: Uint8Array;
+  /** @deprecated Always empty. Kept for backwards compatibility with old blocks. */
+  readonly absent?: Uint8Array;
 };
-/** Table column data in comparison to the data stored in a separate PColumn
- * may have some of the values "absent", i.e. as a result of missing record in
- * outer join operation. This information is encoded in {@link absent} field. */
+/** Table column data */
 export type PTableVector = PTableVectorTyped<ValueType>;
 
 function isBitSet(bitVector: Uint8Array, offset: number): boolean {
@@ -53,10 +48,6 @@ function isBitSet(bitVector: Uint8Array, offset: number): boolean {
   return (bitVector[chunkIndex] & mask) > 0;
 }
 
-function isValueAbsent(vector: PTableVector, row: number): boolean {
-  return isBitSet(vector.absent, row);
-}
-
 function isValueNA(vector: PTableVector, row: number): boolean {
   if (vector.isNA) return isBitSet(vector.isNA, row);
 
@@ -81,14 +72,6 @@ function isValueNA(vector: PTableVector, row: number): boolean {
   }
 }
 
-export const PTableAbsent = { type: "absent" } as const;
-export type PTableAbsent = typeof PTableAbsent;
-
-/** Type guard for absent value */
-export function isPTableAbsent(value: unknown): value is PTableAbsent {
-  return typeof value === "object" && value !== null && "type" in value && value.type === "absent";
-}
-
 export const PTableNA = null;
 export type PTableNA = typeof PTableNA;
 
@@ -120,49 +103,21 @@ export type PTableValueDataBranded<DataType extends ValueTypeSupported> = Brande
   PTableValueData<DataType>,
   DataType
 >;
-export type PTableValue<
-  Absent = PTableAbsent,
-  NA = PTableNA,
-  DataType extends ValueTypeSupported = ValueTypeSupported,
-> = Absent | NA | PTableValueData<DataType>;
+export type PTableValue<NA = PTableNA, DataType extends ValueTypeSupported = ValueTypeSupported> =
+  | NA
+  | PTableValueData<DataType>;
 export type PTableValueBranded<
-  Absent = PTableAbsent,
   NA = PTableNA,
   DataType extends ValueTypeSupported = ValueTypeSupported,
-> = Absent | NA | PTableValueDataBranded<DataType>;
-
-export type PTableValueAxis<
-  Absent = PTableAbsent,
-  DataType extends ValueTypeSupported = ValueTypeSupported,
-> = PTableValue<Absent, never, DataType>;
+> = NA | PTableValueDataBranded<DataType>;
 
-export function isPTableValueAxis<Absent, NA, DataType extends ValueTypeSupported>(
-  value: PTableValue<Absent, NA, DataType>,
-  isNA: (value: PTableValue<Absent, NA, DataType>) => value is NA,
-): value is PTableValueAxis<Absent, DataType>;
-export function isPTableValueAxis<Absent, DataType extends ValueTypeSupported>(
-  value: PTableValue<Absent, PTableNA, DataType>,
-): value is PTableValueAxis<Absent, DataType>;
-export function isPTableValueAxis<
-  Absent = PTableAbsent,
-  NA = PTableNA,
-  DataType extends ValueTypeSupported = ValueTypeSupported,
->(
-  value: PTableValue<Absent, NA, DataType>,
-  isNA?: (value: PTableValue<Absent, NA, DataType>) => value is NA,
-): value is PTableValueAxis<Absent, DataType> {
-  return !(isNA ? isNA(value) : isPTableNA(value));
-}
+export type PTableValueAxis<DataType extends ValueTypeSupported = ValueTypeSupported> =
+  PTableValueData<DataType>;
 
-function pTableValueImpl<
-  FillAbsent = PTableAbsent,
-  FillNA = PTableNA,
-  DataType extends ValueType = ValueTypeSupported,
->(
+function pTableValueImpl<FillNA = PTableNA, DataType extends ValueType = ValueTypeSupported>(
   column: PTableVectorTyped<ValueType>,
   row: number,
   options?: {
-    absent?: FillAbsent;
     na?: FillNA;
     dataType?: DataType;
   },
@@ -181,10 +136,6 @@ function pTableValueImpl<
     throw Error(`expected column of type ${options.dataType}, got ${valueType}`);
   }
 
-  if (isValueAbsent(column, row)) {
-    return options?.absent !== undefined ? options.absent : PTableAbsent;
-  }
-
   if (isValueNA(column, row)) {
     return options?.na !== undefined ? options.na : PTableNA;
   }
@@ -208,37 +159,14 @@ function pTableValueImpl<
 export function pTableValue<DataType extends ValueType>(
   column: PTableVectorTyped<DataType>,
   row: number,
-): DataType extends ValueTypeSupported ? PTableValue<PTableAbsent, PTableNA, DataType> : never;
-export function pTableValue<FillAbsent, DataType extends ValueType>(
-  column: PTableVectorTyped<DataType>,
-  row: number,
-  options: {
-    absent: FillAbsent;
-  },
-): DataType extends ValueTypeSupported ? PTableValue<FillAbsent, PTableNA, DataType> : never;
+): DataType extends ValueTypeSupported ? PTableValue<PTableNA, DataType> : never;
 export function pTableValue<FillNA, DataType extends ValueType>(
   column: PTableVectorTyped<DataType>,
   row: number,
   options: {
     na: FillNA;
   },
-): DataType extends ValueTypeSupported ? PTableValue<PTableAbsent, FillNA, DataType> : never;
-export function pTableValue<FillNA, FillAbsent, DataType extends ValueType>(
-  column: PTableVectorTyped<DataType>,
-  row: number,
-  options: {
-    absent: FillAbsent;
-    na: FillNA;
-  },
-): DataType extends ValueTypeSupported ? PTableValue<FillAbsent, FillNA, DataType> : never;
-export function pTableValue<FillAbsent, DataType extends ValueTypeSupported>(
-  column: PTableVectorTyped<ValueType>,
-  row: number,
-  options: {
-    absent: FillAbsent;
-    dataType: DataType;
-  },
-): PTableValue<FillAbsent, PTableNA>;
+): DataType extends ValueTypeSupported ? PTableValue<FillNA, DataType> : never;
 export function pTableValue<FillNA, DataType extends ValueTypeSupported>(
   column: PTableVectorTyped<ValueType>,
   row: number,
@@ -246,25 +174,11 @@ export function pTableValue<FillNA, DataType extends ValueTypeSupported>(
     na: FillNA;
     dataType: DataType;
   },
-): PTableValue<PTableAbsent, FillNA, DataType>;
-export function pTableValue<FillNA, FillAbsent, DataType extends ValueTypeSupported>(
-  column: PTableVectorTyped<ValueType>,
-  row: number,
-  options: {
-    absent: FillAbsent;
-    na: FillNA;
-    dataType: DataType;
-  },
-): PTableValue<FillAbsent, FillNA, DataType>;
-export function pTableValue<
-  FillAbsent = PTableAbsent,
-  FillNA = PTableNA,
-  DataType extends ValueType = ValueTypeSupported,
->(
+): PTableValue<FillNA, DataType>;
+export function pTableValue<FillNA = PTableNA, DataType extends ValueType = ValueTypeSupported>(
   column: PTableVectorTyped<ValueType>,
   row: number,
   options?: {
-    absent?: FillAbsent;
     na?: FillNA;
     dataType?: DataType;
   },
@@ -275,39 +189,14 @@ export function pTableValue<
 export function pTableValueBranded<DataType extends ValueType>(
   column: PTableVectorTyped<DataType>,
   row: number,
-): DataType extends ValueTypeSupported
-  ? PTableValueBranded<PTableAbsent, PTableNA, DataType>
-  : never;
-export function pTableValueBranded<FillAbsent, DataType extends ValueType>(
-  column: PTableVectorTyped<DataType>,
-  row: number,
-  options: {
-    absent: FillAbsent;
-  },
-): DataType extends ValueTypeSupported ? PTableValueBranded<FillAbsent, PTableNA, DataType> : never;
+): DataType extends ValueTypeSupported ? PTableValueBranded<PTableNA, DataType> : never;
 export function pTableValueBranded<FillNA, DataType extends ValueType>(
   column: PTableVectorTyped<DataType>,
   row: number,
   options: {
     na: FillNA;
   },
-): DataType extends ValueTypeSupported ? PTableValueBranded<PTableAbsent, FillNA, DataType> : never;
-export function pTableValueBranded<FillNA, FillAbsent, DataType extends ValueType>(
-  column: PTableVectorTyped<DataType>,
-  row: number,
-  options: {
-    absent: FillAbsent;
-    na: FillNA;
-  },
-): DataType extends ValueTypeSupported ? PTableValueBranded<FillAbsent, FillNA, DataType> : never;
-export function pTableValueBranded<FillAbsent, DataType extends ValueTypeSupported>(
-  column: PTableVectorTyped<ValueType>,
-  row: number,
-  options: {
-    absent: FillAbsent;
-    dataType: DataType;
-  },
-): PTableValueBranded<FillAbsent, PTableNA>;
+): DataType extends ValueTypeSupported ? PTableValueBranded<FillNA, DataType> : never;
 export function pTableValueBranded<FillNA, DataType extends ValueTypeSupported>(
   column: PTableVectorTyped<ValueType>,
   row: number,
@@ -315,25 +204,14 @@ export function pTableValueBranded<FillNA, DataType extends ValueTypeSupported>(
     na: FillNA;
     dataType: DataType;
   },
-): PTableValueBranded<PTableAbsent, FillNA, DataType>;
-export function pTableValueBranded<FillNA, FillAbsent, DataType extends ValueTypeSupported>(
-  column: PTableVectorTyped<ValueType>,
-  row: number,
-  options: {
-    absent: FillAbsent;
-    na: FillNA;
-    dataType: DataType;
-  },
-): PTableValueBranded<FillAbsent, FillNA, DataType>;
+): PTableValueBranded<FillNA, DataType>;
 export function pTableValueBranded<
-  FillAbsent = PTableAbsent,
   FillNA = PTableNA,
   DataType extends ValueType = ValueTypeSupported,
 >(
   column: PTableVectorTyped<ValueType>,
   row: number,
   options?: {
-    absent?: FillAbsent;
     na?: FillNA;
     dataType?: DataType;
   },

package/src/drivers/pframe/driver.ts

@@ -1,6 +1,9 @@
 import type { Branded } from "../../branding";
 import type { PTable } from "./table";
-import type { PFrame } from "./pframe";
+import type { PFrame, PFrameDef } from "./pframe";
+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 { FindColumnsRequest, FindColumnsResponse } from "./find_columns";
@@ -16,6 +19,13 @@ export type PFrameHandle = Branded<string, "PFrame">;
 /** PFrame handle */
 export type PTableHandle = Branded<string, "PTable">;
 
+/** Model-side PFrame service — creates frames/tables from column definitions. */
+export interface PFrameModelDriver<Col = PColumn<string | PColumnValues | DataInfo<string>>> {
+  createPFrame(def: PFrameDef<Col>): PFrameHandle;
+  createPTable(def: PTableDef<Col>): PTableHandle;
+  createPTableV2(def: PTableDefV2<Col>): PTableHandle;
+}
+
 /** Allows to access main data layer features of platforma */
 export interface PFrameDriver {
   //

package/src/drivers/pframe/spec/spec.ts

@@ -508,8 +508,6 @@ export function getNormalizedAxesList(axes: AxisSpec[]): AxisSpecNormalized[] {
       modifiedAxis.parentAxesSpec = parents.some((p) => p === undefined)
         ? []
         : (parents as AxisSpecNormalized[]);
-
-      delete modifiedAxis.annotations?.[Annotation.Parents];
     }
   });
 
@@ -543,6 +541,22 @@ export function getDenormalizedAxesList(axesSpec: AxisSpecNormalized[]): AxisSpe
   });
 }
 
+/**
+ * Resolve annotation-based parents (`pl7.app/parents`) to numeric `parentAxes`
+ * on a column spec. Returns the spec unchanged if all axes already use numeric
+ * indices or have no parent annotations.
+ */
+export function resolveAnnotationParents(spec: PColumnSpec): PColumnSpec {
+  const hasAnnotationParents = spec.axesSpec.some(
+    (axis) => !!readAnnotationJson(axis, Annotation.Parents),
+  );
+  if (!hasAnnotationParents) return spec;
+
+  const normalized = getNormalizedAxesList(spec.axesSpec);
+  const denormalized = getDenormalizedAxesList(normalized);
+  return { ...spec, axesSpec: denormalized };
+}
+
 /** Common type representing spec for all the axes in a column */
 export type AxesSpec = AxisSpec[];
 

package/src/drivers/pframe/spec_driver.ts

@@ -1,4 +1,5 @@
 import type { Branded } from "@milaboratories/helpers";
+import type { PoolEntry } from "../../pool_entry";
 import type {
   AxisSpec,
   AxesSpec,
@@ -10,6 +11,7 @@ import type {
   ColumnValueType,
 } from "./spec";
 import type { PTableColumnId, PTableColumnSpec } from "./table_common";
+import { DataQuery, SpecQuery } from "./query";
 
 /** Matches a string value either exactly or by regex pattern */
 export type StringMatcher =
@@ -144,6 +146,33 @@ export interface DiscoverColumnsResponse {
   hits: DiscoverColumnsResponseHit[];
 }
 
+/** Request for deleting an entry from a given axes integration */
+export interface DeleteColumnRequest {
+  /** Already integrated axes with qualifications */
+  axes: ColumnAxesWithQualifications[];
+  /** Zero based index of the entry to be deleted */
+  delete: number;
+}
+
+/** Response from delete column */
+export interface DeleteColumnResponse {
+  axes: ColumnAxesWithQualifications[];
+}
+
+/** Response from evaluating a query against a PFrame. */
+export type EvaluateQueryResponse = {
+  /**
+   * The table specification describing the structure of the query result,
+   * including all axes and columns that will be present in the output.
+   */
+  tableSpec: PTableColumnSpec[];
+  /**
+   * The data layer query representation with numeric indices,
+   * suitable for execution by the data processing engine.
+   */
+  dataQuery: DataQuery;
+};
+
 /** Handle to a spec-only PFrame (no data, synchronous operations). */
 export type SpecFrameHandle = Branded<string, "SpecFrameHandle">;
 
@@ -155,17 +184,20 @@ export type SpecFrameHandle = Branded<string, "SpecFrameHandle">;
  * because the underlying WASM PFrame computes results immediately.
  */
 export interface PFrameSpecDriver {
-  /** Create a spec-only PFrame from column specs. Returns a handle. */
-  createSpecFrame(specs: Record<string, PColumnSpec>): SpecFrameHandle;
+  /** Create a spec-only PFrame from column specs. Returns a pool entry with handle and unref. */
+  createSpecFrame(specs: Record<string, PColumnSpec>): PoolEntry<SpecFrameHandle>;
 
   /** Discover columns compatible with given axes integration. */
-  specFrameDiscoverColumns(
+  discoverColumns(
     handle: SpecFrameHandle,
     request: DiscoverColumnsRequest,
   ): DiscoverColumnsResponse;
 
-  /** Dispose a spec frame, freeing WASM resources. */
-  disposeSpecFrame(handle: SpecFrameHandle): void;
+  /** Delete an entry from a given axes integration */
+  deleteColumn(handle: SpecFrameHandle, request: DeleteColumnRequest): DeleteColumnResponse;
+
+  /** Evaluates a query specification against this PFrame */
+  evaluateQuery(handle: SpecFrameHandle, request: SpecQuery): EvaluateQueryResponse;
 
   /** Expand index-based parentAxes in AxesSpec to resolved AxisId parents in AxesId. */
   expandAxes(spec: AxesSpec): AxesId;

package/src/drivers/pframe/table_calculate.ts

@@ -85,8 +85,7 @@ export interface InnerJoin<Col> {
 /**
  * Defines a join request tree node that will output all records present at
  * least in one of the child nodes ({@link entries}), values for those PColumns
- * that lacks corresponding combinations of axis values will be marked as absent,
- * see {@link PTableVector.absent}.
+ * that lack corresponding combinations of axis values will be null.
  * */
 export interface FullJoin<Col> {
   /** Node type discriminator */
@@ -100,8 +99,8 @@ export interface FullJoin<Col> {
  * Defines a join request tree node that will output all records present in
  * {@link primary} child node, and records from the {@link secondary} nodes will
  * be added to the output only if present, values for those PColumns from the
- * {@link secondary} list, that lacks corresponding combinations of axis values
- * will be marked as absent, see {@link PTableVector.absent}.
+ * {@link secondary} list, that lack corresponding combinations of axis values
+ * will be null.
  *
  * This node can be thought as a chain of SQL LEFT JOIN operations starting from
  * the {@link primary} node and adding {@link secondary} nodes one by one.

package/src/errors.ts

@@ -28,6 +28,59 @@ export function isAggregateError(error: unknown): error is AggregateError {
   return error instanceof Error && error.name === "AggregateError";
 }
 
+export class ServiceError extends Error {
+  name = "ServiceError";
+}
+
+export function isServiceError(error: unknown): error is ServiceError {
+  return (
+    error instanceof Error &&
+    (error.name === "ServiceError" || error.name.startsWith("ServiceError."))
+  );
+}
+
+export class ServiceInvalidIdError extends ServiceError {
+  name = "ServiceError.InvalidId";
+}
+
+export function isServiceInvalidIdError(error: unknown): error is ServiceInvalidIdError {
+  return error instanceof Error && error.name === "ServiceError.InvalidId";
+}
+
+export class ServiceAlreadyRegisteredError extends ServiceError {
+  name = "ServiceError.AlreadyRegistered";
+}
+
+export function isServiceAlreadyRegisteredError(
+  error: unknown,
+): error is ServiceAlreadyRegisteredError {
+  return error instanceof Error && error.name === "ServiceError.AlreadyRegistered";
+}
+
+export class ServiceInjectionError extends ServiceError {
+  name = "ServiceError.Injection";
+}
+
+export function isServiceInjectionError(error: unknown): error is ServiceInjectionError {
+  return error instanceof Error && error.name === "ServiceError.Injection";
+}
+
+export class ServiceNotRegisteredError extends ServiceError {
+  name = "ServiceError.NotRegistered";
+}
+
+export function isServiceNotRegisteredError(error: unknown): error is ServiceNotRegisteredError {
+  return error instanceof Error && error.name === "ServiceError.NotRegistered";
+}
+
+export class ServiceMethodNotFoundError extends ServiceError {
+  name = "ServiceError.MethodNotFound";
+}
+
+export function isServiceMethodNotFoundError(error: unknown): error is ServiceMethodNotFoundError {
+  return error instanceof Error && error.name === "ServiceError.MethodNotFound";
+}
+
 export class PFrameError extends Error {
   name = "PFrameError";
 }

package/src/flags/block_flags.ts

@@ -1,3 +1,4 @@
+import type { ServiceRequireFlags } from "../services";
 import type { ArrayTypeUnion, Assert, Is, IsSubtypeOf } from "./type_utils";
 
 /**
@@ -20,7 +21,7 @@ export type BlockCodeKnownFeatureFlags = {
   readonly requiresModelAPIVersion?: number;
   readonly requiresUIAPIVersion?: number;
   readonly requiresCreatePTable?: number;
-};
+} & ServiceRequireFlags;
 
 export const AllSupportsFeatureFlags = ["supportsLazyState", "supportsPframeQueryRanking"] as const;
 
@@ -42,9 +43,11 @@ type _KnownFlagsAreValidFlags = Assert<
 
 // This check ensures that all keys in BlockConfigV3FeatureFlags are covered in the arrays above.
 // It will produce a compile-time error if there's a mismatch.
+// Adding a service to Services automatically satisfies this assertion via ServiceRequireFlags.
 type _AllFlagsAreCovered = Assert<
   Is<
     keyof BlockCodeKnownFeatureFlags,
-    ArrayTypeUnion<typeof AllRequiresFeatureFlags, typeof AllSupportsFeatureFlags>
+    | ArrayTypeUnion<typeof AllRequiresFeatureFlags, typeof AllSupportsFeatureFlags>
+    | keyof ServiceRequireFlags
   >
 >;

package/src/index.ts

@@ -18,3 +18,5 @@ export * from "./base64";
 export * from "./util";
 export * from "./httpAuth";
 export * from "./resource_types";
+export * from "./services";
+export * from "./pool_entry";

package/src/pool_entry.ts

@@ -0,0 +1,42 @@
+export interface PoolEntry<K extends string = string, R extends {} = {}> extends Disposable {
+  /** Resource key, calculated using provided `calculateParamsKey` function */
+  readonly key: K;
+
+  /** Resource itself created by `createNewResource` function */
+  readonly resource: R;
+
+  /**
+   * Release the reference. Idempotent.
+   * Same as `[Symbol.dispose]()` — provided as a named function
+   * for use in callbacks (e.g. `addOnDestroy(entry.unref)`).
+   */
+  readonly unref: () => void;
+}
+
+/**
+ * Wraps a PoolEntry for use with `using`. Auto-calls `unref()` at end of scope
+ * unless `keep()` is called to transfer ownership to the caller.
+ */
+export class PoolEntryGuard<K extends string = string, R extends {} = {}> implements Disposable {
+  private kept = false;
+
+  constructor(readonly entry: PoolEntry<K, R>) {}
+
+  get key(): K {
+    return this.entry.key;
+  }
+
+  get resource(): R {
+    return this.entry.resource;
+  }
+
+  /** Disarm the guard — caller takes ownership of the entry. */
+  keep(): PoolEntry<K, R> {
+    this.kept = true;
+    return this.entry;
+  }
+
+  [Symbol.dispose](): void {
+    if (!this.kept) this.entry.unref();
+  }
+}

package/src/services/index.ts

@@ -0,0 +1,5 @@
+export * from "./service_types";
+export * from "./service_registry";
+export * from "./service_declarations";
+export * from "./service_capabilities";
+export * from "./service_injectors";

package/src/services/service_capabilities.test.ts

@@ -0,0 +1,119 @@
+import { describe, it, expect, vi } from "vitest";
+import {
+  SERVICE_CAPABILITY_FLAGS,
+  registerServiceCapabilities,
+  resolveRequiredServices,
+  getMethodNames,
+  isKnownServiceName,
+} from "./service_capabilities";
+import { Services } from "./service_declarations";
+
+describe("SERVICE_CAPABILITY_FLAGS", () => {
+  it("should have one flag per service", () => {
+    expect(SERVICE_CAPABILITY_FLAGS).toHaveLength(Object.keys(Services).length);
+  });
+
+  it("should derive requires* flag names from Services keys", () => {
+    for (const key of Object.keys(Services)) {
+      expect(SERVICE_CAPABILITY_FLAGS).toContain(`requires${key}`);
+    }
+  });
+});
+
+describe("registerServiceCapabilities", () => {
+  it("should call register once per service with (flag, true)", () => {
+    const register = vi.fn();
+    registerServiceCapabilities(register);
+    expect(register).toHaveBeenCalledTimes(Object.keys(Services).length);
+    for (const call of register.mock.calls) {
+      expect(call[0]).toMatch(/^requires[A-Z]/);
+      expect(call[1]).toBe(true);
+    }
+  });
+});
+
+describe("resolveRequiredServices", () => {
+  it("should return empty array for undefined flags", () => {
+    expect(resolveRequiredServices(undefined)).toEqual([]);
+  });
+
+  it("should return empty array for flags without requires*", () => {
+    expect(resolveRequiredServices({ supportsLazyState: true })).toEqual([]);
+  });
+
+  it("should return empty array when requires* is false", () => {
+    expect(resolveRequiredServices({ requiresPFrameSpec: false })).toEqual([]);
+  });
+
+  it("should resolve a single required service", () => {
+    const result = resolveRequiredServices({ requiresPFrameSpec: true });
+    expect(result).toEqual([Services.PFrameSpec]);
+  });
+
+  it("should resolve multiple required services", () => {
+    const result = resolveRequiredServices({
+      requiresPFrameSpec: true,
+      requiresPFrame: true,
+    });
+    expect(result).toContain(Services.PFrameSpec);
+    expect(result).toContain(Services.PFrame);
+    expect(result).toHaveLength(2);
+  });
+
+  it("should ignore non-boolean requires* values", () => {
+    const result = resolveRequiredServices({
+      requiresPFrameSpec: true,
+      requiresModelAPIVersion: 2,
+    });
+    expect(result).toEqual([Services.PFrameSpec]);
+  });
+});
+
+describe("isKnownServiceName", () => {
+  it("should return true for registered service names", () => {
+    for (const id of Object.values(Services)) {
+      expect(isKnownServiceName(id as string)).toBe(true);
+    }
+  });
+
+  it("should return false for unknown names", () => {
+    expect(isKnownServiceName("nonexistent")).toBe(false);
+  });
+});
+
+describe("getMethodNames", () => {
+  it("should return own method names", () => {
+    const obj = {
+      foo() {},
+      bar() {},
+      baz: 42,
+    };
+    const names = getMethodNames(obj as any);
+    expect(names).toContain("foo");
+    expect(names).toContain("bar");
+    expect(names).not.toContain("baz");
+  });
+
+  it("should include prototype methods", () => {
+    class Base {
+      baseMethod() {}
+    }
+    class Child extends Base {
+      childMethod() {}
+    }
+    const names = getMethodNames(new Child() as any);
+    expect(names).toContain("baseMethod");
+    expect(names).toContain("childMethod");
+    expect(names).not.toContain("constructor");
+  });
+
+  it("should not include getters", () => {
+    const obj = Object.create(null, {
+      method: { value: () => {}, enumerable: true },
+      getter: { get: () => 42, enumerable: true },
+    });
+    const names = getMethodNames(obj);
+    expect(names).toContain("method");
+    expect(names).not.toContain("getter");
+  });
+});