@jbrowse/core 5.0.0-beta.8 → 5.0.0-beta.9

package/esm/rpc/WebWorkerRpcDriver.d.ts

@@ -4,14 +4,15 @@ import type { AnyConfigurationModel } from '../configuration/index.ts';
 import type RpcMethodType from '../pluggableElementTypes/RpcMethodType.ts';
 import type { PluginDefinition } from '../pluginDefinitions.ts';
 import type { StatusCallback } from '../util/progress.ts';
+import type { RpcHandles } from './RpcRegistry.ts';
 export interface WorkerHandle {
     destroy(): void;
     onError?(callback: () => void): void;
-    notifyStopToken?(id: string): void;
     on?(eventName: string, listener: (data: unknown) => void): void;
     postMessage?(message: unknown): void;
     call(functionName: string, args?: unknown, options?: {
         statusCallback?: StatusCallback;
+        signal?: AbortSignal;
     }): Promise<unknown>;
 }
 declare module '@jbrowse/core/PluginManager' {
@@ -43,7 +44,6 @@ export default class WebWorkerRpcDriver extends BaseRpcDriver {
     private lastWorkerAssignment;
     private workerAssignments;
     private workerPool?;
-    private unregisterBroadcaster;
     private destroyed;
     constructor(pluginManager: PluginManager, config: AnyConfigurationModel, options: WebWorkerRpcDriverOptions);
     /**
@@ -69,7 +69,7 @@ export default class WebWorkerRpcDriver extends BaseRpcDriver {
      * plugin's wrapper per RPC; once per boot has nothing to memoize.
      */
     extendWorker(worker: WorkerHandle): WorkerHandle;
-    protected transport(sessionId: string, rpcMethod: RpcMethodType, serializedArgs: Record<string, unknown>, statusCallback: StatusCallback | undefined): Promise<unknown>;
+    protected transport(sessionId: string, rpcMethod: RpcMethodType, serializedArgs: Record<string, unknown>, handles: RpcHandles): Promise<unknown>;
     /**
      * Boot one worker and run the configuration handshake. Overridable so a test
      * can hand the pool a fake handle without a `Worker`; nothing in the app does.

package/esm/rpc/WebWorkerRpcDriver.js

@@ -1,6 +1,5 @@
 import { readConfObject } from '../configuration/index.js';
 import { clamp } from '../util/index.js';
-import { registerStopTokenBroadcaster } from '../util/stopToken.js';
 import BaseRpcDriver, { CORE_FREE_RESOURCES } from './BaseRpcDriver.js';
 import RpcClient from './RpcClient.js';
 import { deserializeError } from './serializeError/index.js';
@@ -36,9 +35,6 @@ class WebWorkerHandle {
     onError(callback) {
         this.client.on('error', callback);
     }
-    notifyStopToken(id) {
-        this.client.notifyStopToken(id);
-    }
     // the two halves of {@link WorkerHandle}'s plugin-facing pair
     on(eventName, listener) {
         this.client.on(eventName, listener);
@@ -73,9 +69,9 @@ class WebWorkerHandle {
     // `Core-extendWorker` wrapper written against that interface may well call
     // `worker.call(name, args)` — which destructured `undefined` and threw
     opts = {}) {
-        const { statusCallback } = opts;
+        const { statusCallback, signal } = opts;
         if (!statusCallback) {
-            return this.client.call(funcName, args);
+            return this.client.call(funcName, args, signal);
         }
         const channel = `message-${++this.channelCount}`;
         // RpcClient is a generic event emitter (it also carries 'error' events), so
@@ -87,8 +83,7 @@ class WebWorkerHandle {
         };
         this.client.on(channel, listener);
         try {
-            const result = await this.client.call(funcName, { ...args, channel });
-            return result;
+            return await this.client.call(funcName, { ...args, channel }, signal);
         }
         finally {
             this.client.off(channel, listener);
@@ -151,24 +146,9 @@ class LazyWorker {
         this.workerP = undefined;
     }
     /**
-     * Forward a stopped token id, but never boot a worker to do it: an unbooted
-     * slot is running nothing to cancel. Routed through the same promise the
-     * dispatching call awaits, so a stop issued while this slot is still booting
-     * still lands after the call it means to cancel rather than ahead of the
-     * worker's message listener existing.
-     */
-    notifyStopToken(id) {
-        this.bootP
-            ?.then(worker => {
-            worker.notifyStopToken?.(id);
-        })
-            .catch(() => { });
-    }
-    /**
-     * Drop a session's cached adapters on this slot's worker — and, like
-     * {@link notifyStopToken}, never boot one to do it. A slot that never booted
-     * has no cache to free, and booting one there costs a whole worker bundle and
-     * every runtime plugin to say so.
+     * Drop a session's cached adapters on this slot's worker, and never boot one
+     * to do it. A slot that never booted has no cache to free, and booting one
+     * there costs a whole worker bundle and every runtime plugin to say so.
      *
      * Through the extended handle, because it is a `call`: a plugin that wraps
      * calls should see this one.
@@ -197,17 +177,6 @@ export default class WebWorkerRpcDriver extends BaseRpcDriver {
     // sessionId -> worker number
     workerAssignments = new Map();
     workerPool;
-    // a stopped token has to reach the thread actually running the work, and this
-    // is the seam that carries it. Broadcast rather than routed per call: one
-    // token is commonly in flight on several calls at once, and a worker holding
-    // nothing under that id ignores the frame.
-    //
-    // Registered with the POOL, not in the constructor, so that a driver which
-    // never boots a worker stays out of the module-global broadcaster set — and
-    // registered only once the pool exists to receive the broadcast, since a
-    // `createWorkerPool` that threw after registering left an entry no `destroy`
-    // could ever reach.
-    unregisterBroadcaster = () => { };
     // `destroy` is terminal: `getWorkerPool` refuses rather than letting its `??=`
     // build a second pool for a driver whose teardown already ran. ADR-086.
     destroyed = false;
@@ -233,7 +202,6 @@ export default class WebWorkerRpcDriver extends BaseRpcDriver {
     // discarding the driver so its worker threads don't outlive it
     destroy() {
         this.destroyed = true;
-        this.unregisterBroadcaster();
         for (const worker of this.workerPool ?? []) {
             worker.destroy();
         }
@@ -245,13 +213,7 @@ export default class WebWorkerRpcDriver extends BaseRpcDriver {
         // workerCount 0 (the config default) means "decide from hardware"
         const workerCount = readConfObject(this.config, 'workerCount') ||
             clamp(detectHardwareConcurrency() - 1, 1, 5);
-        const pool = Array.from({ length: workerCount }, () => new LazyWorker(this));
-        this.unregisterBroadcaster = registerStopTokenBroadcaster(id => {
-            for (const worker of pool) {
-                worker.notifyStopToken(id);
-            }
-        });
-        return pool;
+        return Array.from({ length: workerCount }, () => new LazyWorker(this));
     }
     getWorkerPool() {
         if (this.destroyed) {
@@ -285,9 +247,9 @@ export default class WebWorkerRpcDriver extends BaseRpcDriver {
         'Core-extendWorker', worker);
     }
     // get this session's sticky worker and hand off the already-serialized args
-    async transport(sessionId, rpcMethod, serializedArgs, statusCallback) {
+    async transport(sessionId, rpcMethod, serializedArgs, handles) {
         const worker = await this.getWorker(sessionId);
-        return worker.call(rpcMethod.name, serializedArgs, { statusCallback });
+        return worker.call(rpcMethod.name, serializedArgs, handles);
     }
     /**
      * Boot one worker and run the configuration handshake. Overridable so a test

package/esm/rpc/byteBudget.d.ts

@@ -1,5 +1,4 @@
 import type { StatusCallback } from '../util/progress.ts';
-import type { StopToken, StopTokenChecker } from '../util/stopToken.ts';
 import type { AugmentedRegion } from '../util/types/data.ts';
 /**
  * Which question a byte budget asks of a region set: the gate's per-region
@@ -17,7 +16,7 @@ export interface GatedFetchArgs {
 }
 export interface ByteMeasurableAdapter {
     getRegionByteSize: (regions: AugmentedRegion[], opts?: {
-        stopToken?: StopToken;
+        signal?: AbortSignal;
         statusCallback?: StatusCallback;
     }) => Promise<number | undefined>;
 }
@@ -45,13 +44,12 @@ export declare function measuredBytes(result: unknown): number | undefined;
  * comes back either way; when `tooLarge` is set the caller returns it and
  * fetches nothing. No budget means no measurement.
  */
-export declare function measureRegionBytes({ dataAdapter, regions, byteLimit, stopToken, statusCallback, stopTokenCheck, }: {
+export declare function measureRegionBytes({ dataAdapter, regions, byteLimit, signal, statusCallback, }: {
     dataAdapter: ByteMeasurableAdapter;
     regions: AugmentedRegion[];
     byteLimit: number | undefined;
-    stopToken?: StopToken;
+    signal?: AbortSignal;
     statusCallback?: StatusCallback;
-    stopTokenCheck?: StopTokenChecker;
 }): Promise<{
     bytes?: number;
     tooLarge?: RegionTooLargeResult;

package/esm/rpc/byteBudget.js

@@ -1,5 +1,5 @@
+import { checkAbortSignal } from '../util/aborting.js';
 import { updateStatus } from '../util/progress.js';
-import { checkStopTokenThrottled } from '../util/stopToken.js';
 export function isRegionRefused(result) {
     return (typeof result === 'object' && result !== null && 'regionTooLarge' in result);
 }
@@ -35,15 +35,15 @@ export function measuredBytes(result) {
  * comes back either way; when `tooLarge` is set the caller returns it and
  * fetches nothing. No budget means no measurement.
  */
-export async function measureRegionBytes({ dataAdapter, regions, byteLimit, stopToken, statusCallback, stopTokenCheck, }) {
+export async function measureRegionBytes({ dataAdapter, regions, byteLimit, signal, statusCallback, }) {
     if (byteLimit === undefined) {
         return {};
     }
     const bytes = largestRegionBytes(await updateStatus('Checking region size', statusCallback, () => Promise.all(regions.map(region => dataAdapter.getRegionByteSize([region], {
-        stopToken,
+        signal,
         statusCallback,
     })))));
-    checkStopTokenThrottled(stopTokenCheck);
+    checkAbortSignal(signal);
     return overByteBudget(bytes, byteLimit)
         ? { bytes, tooLarge: { regionTooLarge: true, bytes } }
         : { bytes };

package/esm/rpc/configSchema.d.ts

@@ -3,29 +3,15 @@
  * #category root
  */
 declare const _default: import("../configuration/configurationSchema.ts").ConfigurationSchemaType<{
-    /**
-     * #slot
-     * which RPC backend to use. Empty means "use the host application's
-     * default" (web/desktop default to the web worker driver, embedded/headless
-     * to the main thread). Every call in the session runs on the driver this
-     * names; there is no per-track or per-call override.
-     */
     readonly defaultDriver: {
-        readonly type: "string";
-        readonly description: "the RPC driver to run data fetching on: MainThreadRpcDriver or WebWorkerRpcDriver. Leave empty to use the default for this application";
-        readonly defaultValue: "";
-        readonly advanced: true;
+        type: "string";
+    } & {
+        defaultValue: string;
     };
-    /**
-     * #slot
-     * number of web workers to spawn for the web worker RPC driver. 0 lets
-     * JBrowse pick based on hardware concurrency.
-     */
     readonly workerCount: {
-        readonly type: "number";
-        readonly description: "The number of workers to use. If 0 (the default) JBrowse will decide how many workers to use.";
-        readonly defaultValue: 0;
-        readonly advanced: true;
+        type: "number";
+    } & {
+        defaultValue: number;
     };
-}, import("../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined>>;
+}, import("../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined, undefined, import("../configuration/requirements.ts").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>>>;
 export default _default;

package/esm/rpc/coreRpcMethods.d.ts

@@ -3,6 +3,7 @@ export { default as CoreGetMetadata } from './methods/CoreGetMetadata.ts';
 export { default as CoreGetInfo } from './methods/CoreGetInfo.ts';
 export { default as CoreGetFeatures } from './methods/CoreGetFeatures.ts';
 export { default as CoreEncodeFeatures } from './methods/CoreEncodeFeatures.ts';
+export { default as CoreGetEncodedFeature } from './methods/CoreGetEncodedFeature.ts';
 export { default as CoreGetSequence } from './methods/CoreGetSequence.ts';
 export { default as CoreFreeResources } from './methods/CoreFreeResources.ts';
 export { default as CoreGetRegionByteEstimate } from './methods/CoreGetRegionByteEstimate.ts';

package/esm/rpc/coreRpcMethods.js

@@ -3,6 +3,7 @@ export { default as CoreGetMetadata } from './methods/CoreGetMetadata.js';
 export { default as CoreGetInfo } from './methods/CoreGetInfo.js';
 export { default as CoreGetFeatures } from './methods/CoreGetFeatures.js';
 export { default as CoreEncodeFeatures } from './methods/CoreEncodeFeatures.js';
+export { default as CoreGetEncodedFeature } from './methods/CoreGetEncodedFeature.js';
 export { default as CoreGetSequence } from './methods/CoreGetSequence.js';
 export { default as CoreFreeResources } from './methods/CoreFreeResources.js';
 export { default as CoreGetRegionByteEstimate } from './methods/CoreGetRegionByteEstimate.js';

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

@@ -3,11 +3,12 @@ import type { EncodedFeaturesResult } from '../../util/markEncoding.ts';
 import type { RpcExecuteArgs } from '../RpcRegistry.ts';
 /**
  * Fetch a region's features once, run the shared transform steps over them,
- * then each layer's own, and evaluate the layer's encoding over what is left
- * in the worker, where the `Feature` objects are, filling the lanes its shape
- * reads. The colours come back packed, the scale tables resolved, and the
- * main thread reads the same table for its legend that the colours were
- * drawn from.
+ * split them by the facet where the request names one, run each layer's own
+ * steps (per section, under a facet), and evaluate the layer's encoding over
+ * what is left in the worker, where the `Feature` objects are, filling the
+ * lanes its shape reads. The colours come back packed, the scale tables
+ * resolved, and the main thread reads the same table for its legend that the
+ * colours were drawn from.
  */
 export default class CoreEncodeFeatures extends RpcMethodTypeWithRenameRegion<'CoreEncodeFeatures'> {
     name: 'CoreEncodeFeatures';

package/esm/rpc/methods/CoreEncodeFeatures.js

@@ -1,25 +1,24 @@
 import { getFeatureAdapterOrThrow } from '../../data_adapters/getFeatureAdapter.js';
 import RpcMethodTypeWithRenameRegion from '../../pluggableElementTypes/RpcMethodTypeWithRenameRegion.js';
-import { runTransforms } from '../../util/featureTransforms.js';
 import { rpcResult } from '../../util/librpc.js';
 import { encodeFeatures, encodedChannelTransferables, } from '../../util/markEncoding.js';
-import { createProgressReporter, updateStatus } from '../../util/progress.js';
-import { checkStopTokenThrottled, createStopTokenChecker, } from '../../util/stopToken.js';
+import { createProgressReporter } from '../../util/progress.js';
 import { measureRegionBytes } from '../byteBudget.js';
+import { layerFeatures, layerRow } from './layerFeatures.js';
 /**
  * Fetch a region's features once, run the shared transform steps over them,
- * then each layer's own, and evaluate the layer's encoding over what is left
- * in the worker, where the `Feature` objects are, filling the lanes its shape
- * reads. The colours come back packed, the scale tables resolved, and the
- * main thread reads the same table for its legend that the colours were
- * drawn from.
+ * split them by the facet where the request names one, run each layer's own
+ * steps (per section, under a facet), and evaluate the layer's encoding over
+ * what is left in the worker, where the `Feature` objects are, filling the
+ * lanes its shape reads. The colours come back packed, the scale tables
+ * resolved, and the main thread reads the same table for its legend that the
+ * colours were drawn from.
  */
 export default class CoreEncodeFeatures extends RpcMethodTypeWithRenameRegion {
     name = 'CoreEncodeFeatures';
     async execute(args) {
-        const { sessionId, adapterConfig, sequenceAdapter, region, layers: requested, transform = [], filters = [], byteLimit, stopToken, statusCallback, } = args;
+        const { sessionId, adapterConfig, sequenceAdapter, region, layers: requested, byteLimit, signal, statusCallback, } = args;
         const { pluginManager } = this;
-        const stopTokenCheck = createStopTokenChecker(stopToken);
         const dataAdapter = await getFeatureAdapterOrThrow({
             pluginManager,
             sessionId,
@@ -30,33 +29,29 @@ export default class CoreEncodeFeatures extends RpcMethodTypeWithRenameRegion {
             dataAdapter,
             regions: [region],
             byteLimit,
-            stopToken,
+            signal,
             statusCallback,
-            stopTokenCheck,
         });
         if (tooLarge) {
             return tooLarge;
         }
-        const fetched = await updateStatus('Downloading features', statusCallback, () => dataAdapter.getFeaturesArray(region, { statusCallback, stopToken }));
-        checkStopTokenThrottled(stopTokenCheck);
         const { jexl } = pluginManager;
-        const shared = runTransforms(fetched, [
-            ...filters.map(expr => ({ type: 'filter', expr })),
-            ...transform,
-        ], jexl);
-        const layers = requested.map(({ encoding, lanes, transform: own }) => {
-            const features = own ? runTransforms(shared, own, jexl) : shared;
-            return encodeFeatures(features, encoding, lanes, {
-                jexl,
-                report: createProgressReporter({
-                    label: 'Encoding features',
-                    total: features.length,
-                    statusCallback,
-                    stopTokenCheck,
-                }),
-            });
-        });
-        const result = { layers, bytes };
+        const { layers: features, rows, sections, zoomRange, } = await layerFeatures(dataAdapter, args, jexl);
+        const layers = requested.map((request, i) => encodeFeatures(features[i], { ...request.encoding, row: rows ? rows[i] : layerRow(request) }, request.lanes, {
+            jexl,
+            report: createProgressReporter({
+                label: 'Encoding features',
+                total: features[i].length,
+                statusCallback,
+                signal,
+            }),
+        }));
+        const result = {
+            layers,
+            facet: sections,
+            bytes,
+            zoomRange,
+        };
         return rpcResult(result, layers.flatMap(l => encodedChannelTransferables(l)));
     }
 }

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

@@ -0,0 +1,13 @@
+import RpcMethodTypeWithRenameRegion from '../../pluggableElementTypes/RpcMethodTypeWithRenameRegion.ts';
+import type { RpcExecuteArgs } from '../RpcRegistry.ts';
+/**
+ * The feature behind one instance of a `CoreEncodeFeatures` answer: the same
+ * request run again, and the entry of `layer`'s list the instance's
+ * `featureIndex` names. A display holds channels and no records, and two reads
+ * sharing a span, a run counted inside one facet section or a mark whose `x` is
+ * not `start` are each a feature no coordinate lookup finds.
+ */
+export default class CoreGetEncodedFeature extends RpcMethodTypeWithRenameRegion<'CoreGetEncodedFeature'> {
+    name: 'CoreGetEncodedFeature';
+    execute(args: RpcExecuteArgs<'CoreGetEncodedFeature'>): Promise<import("../../util/simpleFeature.ts").SimpleFeatureSerialized | undefined>;
+}

package/esm/rpc/methods/CoreGetEncodedFeature.js

@@ -0,0 +1,31 @@
+import { getFeatureAdapterOrThrow } from '../../data_adapters/getFeatureAdapter.js';
+import RpcMethodTypeWithRenameRegion from '../../pluggableElementTypes/RpcMethodTypeWithRenameRegion.js';
+import { layerFeatures } from './layerFeatures.js';
+/**
+ * The feature behind one instance of a `CoreEncodeFeatures` answer: the same
+ * request run again, and the entry of `layer`'s list the instance's
+ * `featureIndex` names. A display holds channels and no records, and two reads
+ * sharing a span, a run counted inside one facet section or a mark whose `x` is
+ * not `start` are each a feature no coordinate lookup finds.
+ */
+export default class CoreGetEncodedFeature extends RpcMethodTypeWithRenameRegion {
+    name = 'CoreGetEncodedFeature';
+    async execute(args) {
+        const { sessionId, adapterConfig, sequenceAdapter, layer, featureIndex } = args;
+        const asked = args.layers[layer];
+        if (!asked) {
+            return undefined;
+        }
+        const { pluginManager } = this;
+        const dataAdapter = await getFeatureAdapterOrThrow({
+            pluginManager,
+            sessionId,
+            adapterConfig,
+            sequenceAdapter,
+        });
+        // A layer's list does not depend on its neighbours, so only the one asked
+        // about runs its steps.
+        const { layers } = await layerFeatures(dataAdapter, { ...args, layers: [asked] }, pluginManager.jexl);
+        return layers[0]?.[featureIndex]?.toJSON();
+    }
+}

package/esm/rpc/methods/CoreGetExportData.js

@@ -3,7 +3,7 @@ import RpcMethodTypeWithRenameRegions from '../../pluggableElementTypes/RpcMetho
 export default class CoreGetExportData extends RpcMethodTypeWithRenameRegions {
     name = 'CoreGetExportData';
     async execute(args) {
-        const { sessionId, adapterConfig, regions, formatType, opts, stopToken, statusCallback, } = args;
+        const { sessionId, adapterConfig, regions, formatType, opts, signal, statusCallback, } = args;
         const dataAdapter = await getFeatureAdapterOrThrow({
             pluginManager: this.pluginManager,
             sessionId,
@@ -22,7 +22,7 @@ export default class CoreGetExportData extends RpcMethodTypeWithRenameRegions {
         // empty file instead.
         return dataAdapter.getExportData(regions, formatType, {
             ...opts,
-            stopToken,
+            signal,
             statusCallback,
         });
     }

package/esm/rpc/methods/CoreGetFeatureDensity.js

@@ -9,12 +9,12 @@ import RpcMethodTypeWithRenameRegions from '../../pluggableElementTypes/RpcMetho
 export default class CoreGetFeatureDensity extends RpcMethodTypeWithRenameRegions {
     name = 'CoreGetFeatureDensity';
     async execute(args) {
-        const { adapterConfig, sessionId, regions, bpPerPx, stopToken } = args;
+        const { adapterConfig, sessionId, regions, bpPerPx, signal } = args;
         const { dataAdapter } = await getAdapter(this.pluginManager, sessionId, adapterConfig);
         return isFeatureAdapter(dataAdapter)
             ? dataAdapter.getFeatureDensity(regions, {
                 bpPerPx,
-                stopToken,
+                signal,
                 statusCallback: args.statusCallback,
             })
             : undefined;

package/esm/rpc/methods/CoreGetFeatures.js

@@ -10,7 +10,7 @@ export default class CoreGetFeatures extends RpcMethodTypeWithRenameRegions {
         return unwrapRpcResult(feats).map(feat => new SimpleFeature(feat));
     }
     async execute(args) {
-        const { stopToken, statusCallback, sessionId, adapterConfig, sequenceAdapter, regions, opts, } = args;
+        const { signal, statusCallback, sessionId, adapterConfig, sequenceAdapter, regions, opts, } = args;
         const dataAdapter = await getFeatureAdapterOrThrow({
             pluginManager: this.pluginManager,
             sessionId,
@@ -21,7 +21,7 @@ export default class CoreGetFeatures extends RpcMethodTypeWithRenameRegions {
             .getFeaturesInMultipleRegions(regions, {
             ...opts,
             statusCallback,
-            stopToken,
+            signal,
         })
             .pipe(toArray()));
         return r.map(f => f.toJSON());

package/esm/rpc/methods/CoreGetSequence.js

@@ -6,11 +6,11 @@ import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.js';
 export default class CoreGetSequence extends RpcMethodType {
     name = 'CoreGetSequence';
     async execute(args) {
-        const { stopToken, statusCallback, sessionId, adapterConfig, region } = args;
+        const { signal, statusCallback, sessionId, adapterConfig, region } = args;
         const { dataAdapter } = await getAdapter(this.pluginManager, sessionId, adapterConfig);
         if (!isSequenceAdapter(dataAdapter)) {
             throw new Error('Adapter does not support retrieving sequences');
         }
-        return dataAdapter.getSequence(region, { stopToken, statusCallback });
+        return dataAdapter.getSequence(region, { signal, statusCallback });
     }
 }

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

@@ -0,0 +1,26 @@
+import type { BaseFeatureDataAdapter } from '../../data_adapters/BaseAdapter/index.ts';
+import type { JexlInstance } from '../../util/jexlStrings.ts';
+import type { CoreEncodeFeaturesArgs, FacetSection, LayerRequest } from '../../util/markEncodingTypes.ts';
+import type { StatusCallback } from '../../util/progress.ts';
+import type { Feature } from '../../util/simpleFeature.ts';
+/**
+ * The field a layer's `row` channel reads: the one its encoding names, else the
+ * one its own `pileup` writes, so a packed layer restates nothing.
+ */
+export declare function layerRow({ encoding, transform }: LayerRequest): string | undefined;
+/**
+ * The feature list each layer of a `CoreEncodeFeatures` request encodes: the
+ * region's features through the shared steps, split by the facet where the
+ * request names one, then through each layer's own steps, with each faceted
+ * layer's stacked rows beside it. An instance's `featureIndex` indexes its
+ * layer's list, so the same request answers which feature an instance is.
+ */
+export declare function layerFeatures(dataAdapter: BaseFeatureDataAdapter, args: Pick<CoreEncodeFeaturesArgs, 'region' | 'layers' | 'transform' | 'facet' | 'bpPerPx'> & {
+    signal?: AbortSignal;
+    statusCallback?: StatusCallback;
+}, jexl: JexlInstance): Promise<{
+    layers: (readonly Feature[])[];
+    rows: (readonly number[])[] | undefined;
+    sections: FacetSection[] | undefined;
+    zoomRange: import("../../data_adapters/BaseAdapter/zoomRange.ts").ZoomRange | undefined;
+}>;

package/esm/rpc/methods/layerFeatures.js

@@ -0,0 +1,40 @@
+import { checkAbortSignal } from '../../util/aborting.js';
+import { DEFAULT_PILEUP_AS, facetLayers, runTransforms, } from '../../util/featureTransforms.js';
+import { updateStatus } from '../../util/progress.js';
+/**
+ * The field a layer's `row` channel reads: the one its encoding names, else the
+ * one its own `pileup` writes, so a packed layer restates nothing.
+ */
+export function layerRow({ encoding, transform = [] }) {
+    const pileup = transform.find((s) => s.type === 'pileup');
+    return (encoding.row ??
+        (pileup === undefined ? undefined : (pileup.as ?? DEFAULT_PILEUP_AS)));
+}
+/**
+ * The feature list each layer of a `CoreEncodeFeatures` request encodes: the
+ * region's features through the shared steps, split by the facet where the
+ * request names one, then through each layer's own steps, with each faceted
+ * layer's stacked rows beside it. An instance's `featureIndex` indexes its
+ * layer's list, so the same request answers which feature an instance is.
+ */
+export async function layerFeatures(dataAdapter, args, jexl) {
+    const { region, layers: requested, transform = [], facet, bpPerPx, signal, statusCallback, } = args;
+    const fetchOpts = { bpPerPx, statusCallback, signal };
+    const [fetched, zoomRange] = await updateStatus('Downloading features', statusCallback, () => Promise.all([
+        dataAdapter.getFeaturesArray(region, fetchOpts),
+        dataAdapter.getZoomRange(fetchOpts),
+    ]));
+    checkAbortSignal(signal);
+    const shared = runTransforms(fetched, transform, jexl);
+    const faceted = facet
+        ? facetLayers(shared, facet.field, requested.map(r => ({ transform: r.transform, row: layerRow(r) })), jexl)
+        : undefined;
+    const layers = requested.map(({ transform: own }, i) => faceted
+        ? faceted.layers[i].features
+        : own
+            ? runTransforms(shared, own, jexl)
+            : shared);
+    const rows = faceted?.layers.map(l => l.rows);
+    const sections = faceted?.sections;
+    return { layers, rows, sections, zoomRange };
+}

package/esm/svg/SvgExport.js

@@ -4,7 +4,7 @@ import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-run
 // (`constants.ts`, `svgReady.ts`) so this stays component-only for
 // react-refresh.
 import { useTheme } from '@mui/material';
-import { stripAlpha } from '../util/index.js';
+import { stripAlpha } from '../util/svgColorProps.js';
 import { exportMargin } from './constants.js';
 import { svgSafeId } from './svgId.js';
 // Full-bleed background rect. `width`/`height` are the *total* SVG dimensions.
@@ -36,9 +36,8 @@ export function SVGMessageBox({ message, width, height, }) {
 // terminal state itself — a "region too large" message — and only paints the
 // children when the display has renderable data. The body is an ordinary child
 // component, so it never runs in a terminal state and no `renderSvg` re-detects
-// one from empty/absent data. The readiness wait stays an explicit
-// `await awaitSvgReady(model)` in each `renderSvg` (the one genuinely async
-// step), so this component is sync.
+// one from empty/absent data. The readiness wait happens before it, in
+// `renderDisplaySvg` (the one genuinely async step), so this component is sync.
 //
 // One terminal, not two, and the asymmetry is the point: over-budget is a state
 // the user navigated to on purpose, and a figure saying so is the honest export

package/esm/svg/SvgThemeProviders.d.ts

@@ -0,0 +1,12 @@
+import type { ThemeOptions } from '@mui/material';
+/**
+ * Both theme providers, from the export's theme options. An export renders
+ * outside every React tree the app mounted, so without them a `useTheme` body
+ * gets MUI's default theme and a `usePalette` or `makeStyles` one JBrowse's
+ * default light style theme — whatever theme the user picked. Every place an
+ * export tree is rendered mounts this: the file, a live figure, a ring strip.
+ */
+export declare function SvgThemeProviders({ theme, children, }: {
+    theme: ThemeOptions | undefined;
+    children: React.ReactNode;
+}): import("react").JSX.Element;

package/esm/svg/SvgThemeProviders.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ThemeProvider } from '@mui/material';
+import { StyleThemeProvider } from '../ui/PaletteContext.js';
+import { resolveStyleTheme } from '../ui/styleTheme.js';
+import { createJBrowseTheme } from '../ui/theme.js';
+/**
+ * Both theme providers, from the export's theme options. An export renders
+ * outside every React tree the app mounted, so without them a `useTheme` body
+ * gets MUI's default theme and a `usePalette` or `makeStyles` one JBrowse's
+ * default light style theme — whatever theme the user picked. Every place an
+ * export tree is rendered mounts this: the file, a live figure, a ring strip.
+ */
+export function SvgThemeProviders({ theme, children, }) {
+    return (_jsx(ThemeProvider, { theme: createJBrowseTheme(theme), children: _jsx(StyleThemeProvider, { theme: resolveStyleTheme({ configTheme: theme }), children: children }) }));
+}