@jbrowse/core 3.7.0 → 4.0.0

package/esm/rpc/RpcManager.d.ts

@@ -0,0 +1,35 @@
+import MainThreadRpcDriver from './MainThreadRpcDriver.ts';
+import WebWorkerRpcDriver from './WebWorkerRpcDriver.ts';
+import type BaseRpcDriver from './BaseRpcDriver.ts';
+import type PluginManager from '../PluginManager.ts';
+import type { AnyConfigurationModel } from '../configuration/index.ts';
+type DriverClass = BaseRpcDriver;
+interface BackendConfigurations {
+    WebWorkerRpcDriver?: Omit<ConstructorParameters<typeof WebWorkerRpcDriver>[0], 'config'>;
+    MainThreadRpcDriver?: Omit<ConstructorParameters<typeof MainThreadRpcDriver>[0], 'config'>;
+    [key: string]: unknown;
+}
+export type RpcDriverFactory = (config: AnyConfigurationModel, backendConfig: unknown, pluginManager: PluginManager) => BaseRpcDriver;
+export default class RpcManager {
+    pluginManager: PluginManager;
+    mainConfiguration: AnyConfigurationModel;
+    backendConfigurations: BackendConfigurations;
+    static configSchema: import("../configuration/configurationSchema.ts").ConfigurationSchemaType<{
+        defaultDriver: {
+            type: string;
+            description: string;
+            defaultValue: string;
+        };
+        drivers: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IMapType<import("@jbrowse/mobx-state-tree").ITypeUnion<import("@jbrowse/mobx-state-tree").ModelCreationType<import("@jbrowse/mobx-state-tree/dist/internal").ExtractCFromProps<Record<string, any>>> | undefined, import("@jbrowse/mobx-state-tree").ModelSnapshotType<Record<string, any>>, ({} & Partial<import("@jbrowse/mobx-state-tree/dist/internal").ExtractCFromProps<Record<string, any>>> & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject) | undefined>>, [undefined]>;
+    }, import("../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined>>;
+    driverObjects: Map<string, DriverClass>;
+    driverFactories: Map<string, RpcDriverFactory>;
+    constructor(pluginManager: PluginManager, mainConfiguration: AnyConfigurationModel, backendConfigurations: BackendConfigurations);
+    registerDriverFactory(name: string, factory: RpcDriverFactory): void;
+    getDriver(backendName: string): BaseRpcDriver;
+    getDriverForCall(_sessionId: string, _functionName: string, args: {
+        rpcDriverName?: string;
+    }): Promise<BaseRpcDriver>;
+    call(sessionId: string, functionName: string, args: Record<string, unknown>, opts?: {}): Promise<unknown>;
+}
+export {};

package/esm/rpc/RpcManager.js

@@ -0,0 +1,63 @@
+import MainThreadRpcDriver from "./MainThreadRpcDriver.js";
+import WebWorkerRpcDriver from "./WebWorkerRpcDriver.js";
+import rpcConfigSchema from "./configSchema.js";
+import { readConfObject } from "../configuration/index.js";
+export default class RpcManager {
+    pluginManager;
+    mainConfiguration;
+    backendConfigurations;
+    static configSchema = rpcConfigSchema;
+    driverObjects;
+    driverFactories;
+    constructor(pluginManager, mainConfiguration, backendConfigurations) {
+        this.pluginManager = pluginManager;
+        this.mainConfiguration = mainConfiguration;
+        this.backendConfigurations = backendConfigurations;
+        this.driverObjects = new Map();
+        this.driverFactories = new Map();
+        this.registerDriverFactory('MainThreadRpcDriver', (config, backendConfig) => new MainThreadRpcDriver({
+            ...backendConfig,
+            config,
+        }));
+        this.registerDriverFactory('WebWorkerRpcDriver', (config, backendConfig, pm) => new WebWorkerRpcDriver({
+            ...backendConfig,
+            config,
+        }, {
+            plugins: pm.runtimePluginDefinitions,
+            windowHref: typeof window !== 'undefined' ? window.location.href : '',
+        }));
+    }
+    registerDriverFactory(name, factory) {
+        this.driverFactories.set(name, factory);
+    }
+    getDriver(backendName) {
+        const existingDriver = this.driverObjects.get(backendName);
+        if (existingDriver) {
+            return existingDriver;
+        }
+        const factory = this.driverFactories.get(backendName);
+        if (!factory) {
+            throw new Error(`RPC driver "${backendName}" is not registered`);
+        }
+        const backendConfig = this.backendConfigurations[backendName];
+        if (!backendConfig) {
+            throw new Error(`RPC driver "${backendName}" is missing configuration`);
+        }
+        const config = this.mainConfiguration.drivers.get('WebWorkerRpcDriver');
+        const newDriver = factory(config, backendConfig, this.pluginManager);
+        this.driverObjects.set(backendName, newDriver);
+        return newDriver;
+    }
+    async getDriverForCall(_sessionId, _functionName, args) {
+        const backendName = args.rpcDriverName ||
+            readConfObject(this.mainConfiguration, 'defaultDriver');
+        return this.getDriver(backendName);
+    }
+    async call(sessionId, functionName, args, opts = {}) {
+        if (!sessionId) {
+            throw new Error('sessionId is required');
+        }
+        const driverForCall = await this.getDriverForCall(sessionId, functionName, args);
+        return driverForCall.call(this.pluginManager, sessionId, functionName, args, opts);
+    }
+}

package/esm/rpc/WebWorkerRpcDriver.d.ts

@@ -0,0 +1,31 @@
+import BaseRpcDriver from './BaseRpcDriver.ts';
+import type { RpcDriverConstructorArgs } from './BaseRpcDriver.ts';
+import type { PluginDefinition } from '../PluginLoader.ts';
+interface WebWorkerRpcDriverConstructorArgs extends RpcDriverConstructorArgs {
+    makeWorkerInstance: () => Worker;
+}
+interface Options {
+    statusCallback?: (arg0: unknown) => void;
+    rpcDriverClassName: string;
+}
+declare class WebWorkerHandle {
+    worker: Worker;
+    private client;
+    constructor(worker: Worker);
+    destroy(): void;
+    call(funcName: string, args: Record<string, unknown>, opts: Options): Promise<unknown>;
+}
+export default class WebWorkerRpcDriver extends BaseRpcDriver {
+    workerBootConfiguration: {
+        plugins: PluginDefinition[];
+        windowHref: string;
+    };
+    name: string;
+    makeWorkerInstance: () => Worker;
+    constructor(args: WebWorkerRpcDriverConstructorArgs, workerBootConfiguration: {
+        plugins: PluginDefinition[];
+        windowHref: string;
+    });
+    makeWorker(): Promise<WebWorkerHandle>;
+}
+export {};

package/esm/rpc/WebWorkerRpcDriver.js

@@ -0,0 +1,77 @@
+import BaseRpcDriver from "./BaseRpcDriver.js";
+import { RpcClient, deserializeError } from "../util/librpc.js";
+import { nanoid } from "../util/nanoid.js";
+class WebWorkerHandle {
+    worker;
+    client;
+    constructor(worker) {
+        this.worker = worker;
+        this.client = new RpcClient(worker);
+        this.client.on('error', error => {
+            console.error('[WebWorker RPC Error]', error);
+        });
+    }
+    destroy() {
+        this.worker.terminate();
+    }
+    async call(funcName, args, opts) {
+        const { statusCallback, rpcDriverClassName } = opts;
+        const channel = `message-${nanoid()}`;
+        const listener = (message) => {
+            statusCallback?.(message);
+        };
+        this.client.on(channel, listener);
+        try {
+            const result = await this.client.call(funcName, {
+                ...args,
+                channel,
+                rpcDriverClassName,
+            });
+            return result;
+        }
+        finally {
+            this.client.off(channel, listener);
+        }
+    }
+}
+export default class WebWorkerRpcDriver extends BaseRpcDriver {
+    workerBootConfiguration;
+    name = 'WebWorkerRpcDriver';
+    makeWorkerInstance;
+    constructor(args, workerBootConfiguration) {
+        super(args);
+        this.workerBootConfiguration = workerBootConfiguration;
+        this.makeWorkerInstance = args.makeWorkerInstance;
+    }
+    async makeWorker() {
+        const instance = this.makeWorkerInstance();
+        const handle = new WebWorkerHandle(instance);
+        const isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+        if (isSafari) {
+            console.log('console logging the webworker handle avoids the track going into an infinite loading state, this is a hacky workaround for safari', instance);
+        }
+        return new Promise((resolve, reject) => {
+            const listener = (e) => {
+                switch (e.data.message) {
+                    case 'ready': {
+                        resolve(handle);
+                        instance.removeEventListener('message', listener);
+                        break;
+                    }
+                    case 'readyForConfig': {
+                        instance.postMessage({
+                            message: 'config',
+                            config: this.workerBootConfiguration,
+                        });
+                        break;
+                    }
+                    case 'error': {
+                        reject(deserializeError(e.data.error));
+                        break;
+                    }
+                }
+            };
+            instance.addEventListener('message', listener);
+        });
+    }
+}

package/esm/rpc/baseRpcConfig.d.ts

@@ -0,0 +1,8 @@
+declare const BaseRpcDriverConfigSchema: import("../configuration/configurationSchema.ts").ConfigurationSchemaType<{
+    workerCount: {
+        type: string;
+        description: string;
+        defaultValue: number;
+    };
+}, import("../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined>>;
+export default BaseRpcDriverConfigSchema;

package/esm/rpc/baseRpcConfig.js

@@ -0,0 +1,10 @@
+import { ConfigurationSchema } from "../configuration/index.js";
+function x() { }
+const BaseRpcDriverConfigSchema = ConfigurationSchema('BaseRpcDriver', {
+    workerCount: {
+        type: 'number',
+        description: 'The number of workers to use. If 0 (the default) JBrowse will decide how many workers to use.',
+        defaultValue: 0,
+    },
+}, { explicitlyTyped: true });
+export default BaseRpcDriverConfigSchema;

package/esm/rpc/configSchema.d.ts

@@ -0,0 +1,9 @@
+declare const _default: import("../configuration/configurationSchema.ts").ConfigurationSchemaType<{
+    defaultDriver: {
+        type: string;
+        description: string;
+        defaultValue: string;
+    };
+    drivers: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IMapType<import("@jbrowse/mobx-state-tree").ITypeUnion<import("@jbrowse/mobx-state-tree").ModelCreationType<import("@jbrowse/mobx-state-tree/dist/internal").ExtractCFromProps<Record<string, any>>> | undefined, import("@jbrowse/mobx-state-tree").ModelSnapshotType<Record<string, any>>, ({} & Partial<import("@jbrowse/mobx-state-tree/dist/internal").ExtractCFromProps<Record<string, any>>> & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject) | undefined>>, [undefined]>;
+}, import("../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined>>;
+export default _default;

package/esm/rpc/configSchema.js

@@ -0,0 +1,22 @@
+import { types } from '@jbrowse/mobx-state-tree';
+import MainThreadRpcDriverConfigSchema from "./mainThreadRpcConfig.js";
+import WebWorkerRpcDriverConfigSchema from "./webWorkerRpcConfig.js";
+import { ConfigurationSchema } from "../configuration/index.js";
+function x() { }
+export default ConfigurationSchema('RpcOptions', {
+    defaultDriver: {
+        type: 'string',
+        description: 'the RPC driver to use for tracks and tasks that are not configured to use a specific RPC backend',
+        defaultValue: 'MainThreadRpcDriver',
+    },
+    drivers: types.optional(types.map(types.union(MainThreadRpcDriverConfigSchema, WebWorkerRpcDriverConfigSchema)), {
+        MainThreadRpcDriver: { type: 'MainThreadRpcDriver' },
+        WebWorkerRpcDriver: { type: 'WebWorkerRpcDriver' },
+    }),
+}, {
+    actions: (self) => ({
+        addDriverConfig(configName, configSnapshot) {
+            self.drivers.set(configName, configSnapshot);
+        },
+    }),
+});

package/esm/rpc/coreRpcMethods.d.ts

@@ -0,0 +1,12 @@
+export { default as CoreGetRefNames } from './methods/CoreGetRefNames.ts';
+export { default as CoreGetFeatureDetails } from './methods/CoreGetFeatureDetails.ts';
+export { default as CoreGetMetadata } from './methods/CoreGetMetadata.ts';
+export { default as CoreGetFileInfo } from './methods/CoreGetFileInfo.ts';
+export { default as CoreGetFeatures } from './methods/CoreGetFeatures.ts';
+export { default as CoreGetSequence } from './methods/CoreGetSequence.ts';
+export { default as CoreRender } from './methods/CoreRender.ts';
+export { default as CoreFreeResources } from './methods/CoreFreeResources.ts';
+export { default as CoreGetFeatureDensityStats } from './methods/CoreGetFeatureDensityStats.ts';
+export { default as CoreGetRegions } from './methods/CoreGetRegions.ts';
+export { default as CoreGetExportData } from './methods/CoreGetExportData.ts';
+export { type RenderArgs } from './methods/util.ts';

package/esm/rpc/coreRpcMethods.js

@@ -0,0 +1,12 @@
+export { default as CoreGetRefNames } from "./methods/CoreGetRefNames.js";
+export { default as CoreGetFeatureDetails } from "./methods/CoreGetFeatureDetails.js";
+export { default as CoreGetMetadata } from "./methods/CoreGetMetadata.js";
+export { default as CoreGetFileInfo } from "./methods/CoreGetFileInfo.js";
+export { default as CoreGetFeatures } from "./methods/CoreGetFeatures.js";
+export { default as CoreGetSequence } from "./methods/CoreGetSequence.js";
+export { default as CoreRender } from "./methods/CoreRender.js";
+export { default as CoreFreeResources } from "./methods/CoreFreeResources.js";
+export { default as CoreGetFeatureDensityStats } from "./methods/CoreGetFeatureDensityStats.js";
+export { default as CoreGetRegions } from "./methods/CoreGetRegions.js";
+export { default as CoreGetExportData } from "./methods/CoreGetExportData.js";
+export {} from "./methods/util.js";

package/esm/rpc/mainThreadRpcConfig.d.ts

@@ -0,0 +1,8 @@
+declare const MainThreadRpcDriverConfigSchema: import("../configuration/configurationSchema.ts").ConfigurationSchemaType<{}, import("../configuration/configurationSchema.ts").ConfigurationSchemaOptions<import("../configuration/configurationSchema.ts").ConfigurationSchemaType<{
+    workerCount: {
+        type: string;
+        description: string;
+        defaultValue: number;
+    };
+}, import("../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined>>, undefined>>;
+export default MainThreadRpcDriverConfigSchema;

package/esm/rpc/mainThreadRpcConfig.js

@@ -0,0 +1,8 @@
+import BaseRpcDriverConfigSchema from "./baseRpcConfig.js";
+import { ConfigurationSchema } from "../configuration/index.js";
+function x() { }
+const MainThreadRpcDriverConfigSchema = ConfigurationSchema('MainThreadRpcDriver', {}, {
+    baseConfiguration: BaseRpcDriverConfigSchema,
+    explicitlyTyped: true,
+});
+export default MainThreadRpcDriverConfigSchema;

package/esm/rpc/methods/CoreFreeResources.d.ts

@@ -0,0 +1,6 @@
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.ts';
+export default class CoreFreeResources extends RpcMethodType {
+    name: string;
+    execute(args: Record<string, unknown>): Promise<void>;
+    serializeArguments(args: Record<string, unknown>, _rpcDriver: string): Promise<Record<string, unknown>>;
+}

package/esm/rpc/methods/CoreFreeResources.js

@@ -0,0 +1,14 @@
+import { freeAdapterResources } from "../../data_adapters/dataAdapterCache.js";
+import RpcMethodType from "../../pluggableElementTypes/RpcMethodType.js";
+export default class CoreFreeResources extends RpcMethodType {
+    name = 'CoreFreeResources';
+    async execute(args) {
+        await freeAdapterResources(args);
+        for (const renderer of this.pluginManager.getRendererTypes()) {
+            renderer.freeResources(args);
+        }
+    }
+    async serializeArguments(args, _rpcDriver) {
+        return args;
+    }
+}

package/esm/rpc/methods/CoreGetExportData.d.ts

@@ -0,0 +1,19 @@
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.ts';
+import type { Region } from '../../util/index.ts';
+export default class CoreGetExportData extends RpcMethodType {
+    name: string;
+    serializeArguments(args: {
+        sessionId: string;
+        regions: Region[];
+        adapterConfig: Record<string, unknown>;
+        formatType: string;
+        opts?: any;
+    }, rpcDriver: string): Promise<Record<string, unknown>>;
+    execute(args: {
+        sessionId: string;
+        regions: Region[];
+        adapterConfig: Record<string, unknown>;
+        formatType: string;
+        opts?: any;
+    }, rpcDriver: string): Promise<string>;
+}

package/esm/rpc/methods/CoreGetExportData.js

@@ -0,0 +1,18 @@
+import { getAdapter } from "../../data_adapters/dataAdapterCache.js";
+import RpcMethodType from "../../pluggableElementTypes/RpcMethodType.js";
+import { renameRegionsIfNeeded } from "../../util/index.js";
+export default class CoreGetExportData extends RpcMethodType {
+    name = 'CoreGetExportData';
+    async serializeArguments(args, rpcDriver) {
+        const { rootModel } = this.pluginManager;
+        const assemblyManager = rootModel.session.assemblyManager;
+        const renamedArgs = await renameRegionsIfNeeded(assemblyManager, args);
+        return super.serializeArguments(renamedArgs, rpcDriver);
+    }
+    async execute(args, rpcDriver) {
+        const { sessionId, adapterConfig, regions, formatType, opts } = await this.deserializeArguments(args, rpcDriver);
+        const dataAdapter = (await getAdapter(this.pluginManager, sessionId, adapterConfig)).dataAdapter;
+        const result = await dataAdapter.getExportData(regions, formatType, opts);
+        return result || '';
+    }
+}

package/esm/rpc/methods/CoreGetFeatureDensityStats.d.ts

@@ -0,0 +1,17 @@
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.ts';
+import type { RenderArgs } from './util.ts';
+import type { Region } from '../../util/index.ts';
+export default class CoreGetFeatureDensityStats extends RpcMethodType {
+    name: string;
+    serializeArguments(args: RenderArgs & {
+        stopToken?: string;
+        statusCallback?: (arg: string) => void;
+    }, rpcDriver: string): Promise<Record<string, unknown>>;
+    execute(args: {
+        adapterConfig: Record<string, unknown>;
+        regions: Region[];
+        stopToken?: string;
+        headers?: Record<string, string>;
+        sessionId: string;
+    }, rpcDriver: string): Promise<import("../../data_adapters/BaseAdapter/types.ts").FeatureDensityStats>;
+}

package/esm/rpc/methods/CoreGetFeatureDensityStats.js

@@ -0,0 +1,25 @@
+import { isFeatureAdapter } from "../../data_adapters/BaseAdapter/index.js";
+import { getAdapter } from "../../data_adapters/dataAdapterCache.js";
+import RpcMethodType from "../../pluggableElementTypes/RpcMethodType.js";
+import { renameRegionsIfNeeded } from "../../util/index.js";
+export default class CoreGetFeatureDensityStats extends RpcMethodType {
+    name = 'CoreGetFeatureDensityStats';
+    async serializeArguments(args, rpcDriver) {
+        const { rootModel } = this.pluginManager;
+        const assemblyManager = rootModel.session.assemblyManager;
+        const renamedArgs = await renameRegionsIfNeeded(assemblyManager, {
+            ...args,
+            filters: args.filters?.toJSON().filters,
+        });
+        return super.serializeArguments(renamedArgs, rpcDriver);
+    }
+    async execute(args, rpcDriver) {
+        const deserializedArgs = await this.deserializeArguments(args, rpcDriver);
+        const { adapterConfig, sessionId, regions } = deserializedArgs;
+        const { dataAdapter } = await getAdapter(this.pluginManager, sessionId, adapterConfig);
+        if (!isFeatureAdapter(dataAdapter)) {
+            throw new Error('Adapter does not support retrieving features');
+        }
+        return dataAdapter.getMultiRegionFeatureDensityStats(regions, deserializedArgs);
+    }
+}

package/esm/rpc/methods/CoreGetFeatureDetails.d.ts

@@ -0,0 +1,11 @@
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.ts';
+import type { RenderArgs, RenderArgsSerialized } from './util.ts';
+export default class CoreGetFeatureDetails extends RpcMethodType {
+    name: string;
+    serializeArguments(args: RenderArgs, rpcDriver: string): Promise<any>;
+    execute(args: RenderArgsSerialized & {
+        stopToken?: string;
+    }, rpcDriver: string): Promise<{
+        feature: any;
+    }>;
+}

package/esm/rpc/methods/CoreGetFeatureDetails.js

@@ -0,0 +1,24 @@
+import RpcMethodType from "../../pluggableElementTypes/RpcMethodType.js";
+import { renameRegionsIfNeeded } from "../../util/index.js";
+export default class CoreGetFeatureDetails extends RpcMethodType {
+    name = 'CoreGetFeatureDetails';
+    async serializeArguments(args, rpcDriver) {
+        const { rootModel } = this.pluginManager;
+        const assemblyManager = rootModel.session.assemblyManager;
+        const renamedArgs = await renameRegionsIfNeeded(assemblyManager, args);
+        const superArgs = (await super.serializeArguments(renamedArgs, rpcDriver));
+        const { rendererType } = args;
+        const RendererType = this.pluginManager.getRendererType(rendererType);
+        return RendererType.serializeArgsInClient(superArgs);
+    }
+    async execute(args, rpcDriver) {
+        const deserializedArgs = await this.deserializeArguments(args, rpcDriver);
+        const { rendererType, featureId } = deserializedArgs;
+        const RendererType = this.pluginManager.getRendererType(rendererType);
+        return {
+            feature: RendererType.getLayoutSession(args)
+                ?.cachedLayout.layout.getDataByID(featureId)
+                ?.toJSON(),
+        };
+    }
+}

package/esm/rpc/methods/CoreGetFeatures.d.ts

@@ -0,0 +1,18 @@
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.ts';
+import SimpleFeature from '../../util/simpleFeature.ts';
+import type { RenderArgs } from './util.ts';
+import type { Region } from '../../util/index.ts';
+import type { SimpleFeatureSerialized } from '../../util/simpleFeature.ts';
+export default class CoreGetFeatures extends RpcMethodType {
+    name: string;
+    deserializeReturn(feats: SimpleFeatureSerialized[], args: unknown, rpcDriver: string): Promise<SimpleFeature[]>;
+    serializeArguments(args: RenderArgs, rpcDriver: string): Promise<RenderArgs>;
+    execute(args: {
+        sessionId: string;
+        regions: Region[];
+        adapterConfig: Record<string, unknown>;
+        statusCallback: (arg: string) => void;
+        stopToken?: string;
+        opts?: any;
+    }, rpcDriver: string): Promise<SimpleFeatureSerialized[]>;
+}

package/esm/rpc/methods/CoreGetFeatures.js

@@ -0,0 +1,31 @@
+import { firstValueFrom } from 'rxjs';
+import { toArray } from 'rxjs/operators';
+import { getAdapter } from "../../data_adapters/dataAdapterCache.js";
+import RpcMethodType from "../../pluggableElementTypes/RpcMethodType.js";
+import { renameRegionsIfNeeded } from "../../util/index.js";
+import SimpleFeature from "../../util/simpleFeature.js";
+export default class CoreGetFeatures extends RpcMethodType {
+    name = 'CoreGetFeatures';
+    async deserializeReturn(feats, args, rpcDriver) {
+        const superDeserialized = (await super.deserializeReturn(feats, args, rpcDriver));
+        return superDeserialized.map(feat => new SimpleFeature(feat));
+    }
+    async serializeArguments(args, rpcDriver) {
+        const { rootModel } = this.pluginManager;
+        const assemblyManager = rootModel.session.assemblyManager;
+        const renamedArgs = await renameRegionsIfNeeded(assemblyManager, args);
+        return super.serializeArguments(renamedArgs, rpcDriver);
+    }
+    async execute(args, rpcDriver) {
+        const { stopToken, statusCallback, sessionId, adapterConfig, regions, opts, } = await this.deserializeArguments(args, rpcDriver);
+        const dataAdapter = (await getAdapter(this.pluginManager, sessionId, adapterConfig)).dataAdapter;
+        const r = await firstValueFrom(dataAdapter
+            .getFeaturesInMultipleRegions(regions, {
+            ...opts,
+            statusCallback,
+            stopToken,
+        })
+            .pipe(toArray()));
+        return r.map(f => f.toJSON());
+    }
+}

package/esm/rpc/methods/CoreGetFileInfo.d.ts

@@ -0,0 +1,9 @@
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.ts';
+export default class CoreGetFileInfo extends RpcMethodType {
+    name: string;
+    execute(args: {
+        sessionId: string;
+        stopToken?: string;
+        adapterConfig: Record<string, unknown>;
+    }, rpcDriver: string): Promise<unknown>;
+}

package/esm/rpc/methods/CoreGetFileInfo.js

@@ -0,0 +1,15 @@
+import { isFeatureAdapter } from "../../data_adapters/BaseAdapter/index.js";
+import { getAdapter } from "../../data_adapters/dataAdapterCache.js";
+import RpcMethodType from "../../pluggableElementTypes/RpcMethodType.js";
+export default class CoreGetFileInfo extends RpcMethodType {
+    name = 'CoreGetInfo';
+    async execute(args, rpcDriver) {
+        const pm = this.pluginManager;
+        const deserializedArgs = await this.deserializeArguments(args, rpcDriver);
+        const { sessionId, adapterConfig } = deserializedArgs;
+        const { dataAdapter } = await getAdapter(pm, sessionId, adapterConfig);
+        return isFeatureAdapter(dataAdapter)
+            ? dataAdapter.getHeader(deserializedArgs)
+            : null;
+    }
+}

package/esm/rpc/methods/CoreGetMetadata.d.ts

@@ -0,0 +1,9 @@
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.ts';
+export default class CoreGetMetadata extends RpcMethodType {
+    name: string;
+    execute(args: {
+        sessionId: string;
+        stopToken?: string;
+        adapterConfig: Record<string, unknown>;
+    }, rpcDriver: string): Promise<unknown>;
+}

package/esm/rpc/methods/CoreGetMetadata.js

@@ -0,0 +1,15 @@
+import { isFeatureAdapter } from "../../data_adapters/BaseAdapter/index.js";
+import { getAdapter } from "../../data_adapters/dataAdapterCache.js";
+import RpcMethodType from "../../pluggableElementTypes/RpcMethodType.js";
+export default class CoreGetMetadata extends RpcMethodType {
+    name = 'CoreGetMetadata';
+    async execute(args, rpcDriver) {
+        const pm = this.pluginManager;
+        const deserializedArgs = await this.deserializeArguments(args, rpcDriver);
+        const { sessionId, adapterConfig } = deserializedArgs;
+        const { dataAdapter } = await getAdapter(pm, sessionId, adapterConfig);
+        return isFeatureAdapter(dataAdapter)
+            ? dataAdapter.getMetadata(deserializedArgs)
+            : null;
+    }
+}

package/esm/rpc/methods/CoreGetRefNames.d.ts

@@ -0,0 +1,10 @@
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.ts';
+export default class CoreGetRefNames extends RpcMethodType {
+    name: string;
+    execute(args: {
+        sessionId: string;
+        stopToken?: string;
+        adapterConfig: Record<string, unknown>;
+        sequenceAdapter?: Record<string, unknown>;
+    }, rpcDriver: string): Promise<string[]>;
+}

package/esm/rpc/methods/CoreGetRefNames.js

@@ -0,0 +1,19 @@
+import { isFeatureAdapter } from "../../data_adapters/BaseAdapter/index.js";
+import { getAdapter } from "../../data_adapters/dataAdapterCache.js";
+import RpcMethodType from "../../pluggableElementTypes/RpcMethodType.js";
+export default class CoreGetRefNames extends RpcMethodType {
+    name = 'CoreGetRefNames';
+    async execute(args, rpcDriver) {
+        const pm = this.pluginManager;
+        const deserializedArgs = await this.deserializeArguments(args, rpcDriver);
+        const { sessionId, adapterConfig, sequenceAdapter } = deserializedArgs;
+        const { dataAdapter } = await getAdapter(pm, sessionId, adapterConfig);
+        if (!isFeatureAdapter(dataAdapter)) {
+            return [];
+        }
+        if (sequenceAdapter && !dataAdapter.sequenceAdapterConfig) {
+            dataAdapter.setSequenceAdapterConfig(sequenceAdapter);
+        }
+        return dataAdapter.getRefNames(deserializedArgs);
+    }
+}

package/esm/rpc/methods/CoreGetRegions.d.ts

@@ -0,0 +1,8 @@
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.ts';
+export default class CoreGetRegions extends RpcMethodType {
+    name: string;
+    execute(args: {
+        sessionId: string;
+        adapterConfig: Record<string, unknown>;
+    }, rpcDriver: string): Promise<never[] | import("../../util/index.ts").NoAssemblyRegion[]>;
+}

package/esm/rpc/methods/CoreGetRegions.js

@@ -0,0 +1,15 @@
+import { isRegionsAdapter } from "../../data_adapters/BaseAdapter/index.js";
+import { getAdapter } from "../../data_adapters/dataAdapterCache.js";
+import RpcMethodType from "../../pluggableElementTypes/RpcMethodType.js";
+export default class CoreGetRegions extends RpcMethodType {
+    name = 'CoreGetRegions';
+    async execute(args, rpcDriver) {
+        const pm = this.pluginManager;
+        const deserializedArgs = await this.deserializeArguments(args, rpcDriver);
+        const { sessionId, adapterConfig } = deserializedArgs;
+        const { dataAdapter } = await getAdapter(pm, sessionId, adapterConfig);
+        return isRegionsAdapter(dataAdapter)
+            ? dataAdapter.getRegions(deserializedArgs)
+            : [];
+    }
+}

package/esm/rpc/methods/CoreGetSequence.d.ts

@@ -0,0 +1,13 @@
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.ts';
+import type { RenderArgs } from './util.ts';
+import type { Region } from '../../util/index.ts';
+export default class CoreGetSequence extends RpcMethodType {
+    name: string;
+    serializeArguments(args: RenderArgs, rpcDriver: string): Promise<RenderArgs>;
+    execute(args: {
+        sessionId: string;
+        region: Region;
+        adapterConfig: Record<string, unknown>;
+        stopToken?: string;
+    }, rpcDriver: string): Promise<string | undefined>;
+}