@jbrowse/core 5.0.0-beta.1 → 5.0.0-beta.11

package/esm/rpc/byteBudget.d.ts

@@ -1,14 +1,22 @@
 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
  * budget, or the save dialog's bound on the whole download.
  */
 export type ByteEstimateScope = 'largestRegion' | 'wholeRequest';
+/**
+ * The one spelling of a gated feature RPC's budget argument: the number the
+ * worker measures against, undefined when the gate declined to act and nothing
+ * is measured. A call-site argument, never part of `rpcProps`, because it
+ * swings at 20kb and on force-load.
+ */
+export interface GatedFetchArgs {
+    byteLimit?: number;
+}
 export interface ByteMeasurableAdapter {
     getRegionByteSize: (regions: AugmentedRegion[], opts?: {
-        stopToken?: StopToken;
+        signal?: AbortSignal;
         statusCallback?: StatusCallback;
     }) => Promise<number | undefined>;
 }
@@ -21,6 +29,8 @@ export interface RegionTooLargeResult {
     regionTooLarge: true;
     featureCount?: number;
     bytes?: number;
+    /** `bytes` is the max over the regions that reported — {@link measurementPartial} */
+    partial?: boolean;
 }
 export declare function isRegionRefused(result: unknown): result is RegionTooLargeResult;
 /** Undefined, never 0, when no region could be measured. */
@@ -30,19 +40,24 @@ export declare function adapterByteLimit(declared: unknown, fallback: number): n
 export declare function overByteBudget(bytes: number | undefined, byteLimit: number | undefined): bytes is number;
 /** The bytes a fetch result reports, payload or refusal; absent means unmeasured. */
 export declare function measuredBytes(result: unknown): number | undefined;
+/**
+ * Whether a result's `bytes` covers the whole region set it was asked about. A
+ * fan-out that stops at its first refusal reports whichever regions won the
+ * race, and `nextByteEstimate` takes no zoom evidence from one.
+ */
+export declare function measurementPartial(result: unknown): boolean;
 /**
  * The first await of every gated feature fetch: each region's index-only byte
  * estimate, judged by the largest because the budget is per region. `bytes`
  * 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);
 }
@@ -29,21 +29,32 @@ export function measuredBytes(result) {
         ? result.bytes
         : undefined;
 }
+/**
+ * Whether a result's `bytes` covers the whole region set it was asked about. A
+ * fan-out that stops at its first refusal reports whichever regions won the
+ * race, and `nextByteEstimate` takes no zoom evidence from one.
+ */
+export function measurementPartial(result) {
+    return (typeof result === 'object' &&
+        result !== null &&
+        'partial' in result &&
+        result.partial === true);
+}
 /**
  * The first await of every gated feature fetch: each region's index-only byte
  * estimate, judged by the largest because the budget is per region. `bytes`
  * 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,
+    const bytes = largestRegionBytes(await updateStatus('Downloading index', statusCallback, () => Promise.all(regions.map(region => dataAdapter.getRegionByteSize([region], {
+        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>, any>>;
 export default _default;

package/esm/rpc/coreRpcMethods.d.ts

@@ -2,8 +2,12 @@ export { default as CoreGetRefNames } from './methods/CoreGetRefNames.ts';
 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 CoreGetEncodedLayers } from './methods/CoreGetEncodedLayers.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 CoreLoadAdapterCode } from './methods/CoreLoadAdapterCode.ts';
 export { default as CoreGetRegionByteEstimate } from './methods/CoreGetRegionByteEstimate.ts';
+export { default as CoreGetFeatureDensity } from './methods/CoreGetFeatureDensity.ts';
 export { default as CoreGetRegions } from './methods/CoreGetRegions.ts';
 export { default as CoreGetExportData } from './methods/CoreGetExportData.ts';

package/esm/rpc/coreRpcMethods.js

@@ -2,8 +2,12 @@ export { default as CoreGetRefNames } from './methods/CoreGetRefNames.js';
 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 CoreGetEncodedLayers } from './methods/CoreGetEncodedLayers.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 CoreLoadAdapterCode } from './methods/CoreLoadAdapterCode.js';
 export { default as CoreGetRegionByteEstimate } from './methods/CoreGetRegionByteEstimate.js';
+export { default as CoreGetFeatureDensity } from './methods/CoreGetFeatureDensity.js';
 export { default as CoreGetRegions } from './methods/CoreGetRegions.js';
 export { default as CoreGetExportData } from './methods/CoreGetExportData.js';

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 `CoreGetEncodedLayers` answer: the same
+ * request run again, and the row of `layer`'s table 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,32 @@
+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 `CoreGetEncodedLayers` answer: the same
+ * request run again, and the row of `layer`'s table 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 { layer, featureIndex } = args;
+        const asked = args.layers[layer];
+        if (!asked) {
+            return undefined;
+        }
+        const { pluginManager } = this;
+        const dataAdapter = await getFeatureAdapterOrThrow({
+            ...args,
+            pluginManager,
+        });
+        // 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);
+        const table = layers[0]?.table;
+        return table && featureIndex < table.length
+            ? table.row(featureIndex).toJSON()
+            : undefined;
+    }
+}

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

@@ -0,0 +1,16 @@
+import RpcMethodTypeWithRenameRegion from '../../pluggableElementTypes/RpcMethodTypeWithRenameRegion.ts';
+import type { EncodedLayersResult } from '../../util/markEncoding.ts';
+import type { RpcExecuteArgs } from '../RpcRegistry.ts';
+/**
+ * Fetch a region's features once, run the shared transform steps over them,
+ * 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 mark 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 CoreGetEncodedLayers extends RpcMethodTypeWithRenameRegion<'CoreGetEncodedLayers'> {
+    name: 'CoreGetEncodedLayers';
+    execute(args: RpcExecuteArgs<'CoreGetEncodedLayers'>): Promise<import("../byteBudget.ts").RegionTooLargeResult | import("../RpcServer.ts").RpcResult<EncodedLayersResult>>;
+}

package/esm/rpc/methods/CoreGetEncodedLayers.js

@@ -0,0 +1,59 @@
+import { getFeatureAdapterOrThrow } from '../../data_adapters/getFeatureAdapter.js';
+import RpcMethodTypeWithRenameRegion from '../../pluggableElementTypes/RpcMethodTypeWithRenameRegion.js';
+import { rpcResult } from '../../util/librpc.js';
+import { encodeFeatures, encodedChannelTransferables, } from '../../util/markEncoding.js';
+import { createProgressReporter } from '../../util/progress.js';
+import { measureRegionBytes } from '../byteBudget.js';
+import { layerFeatures } from './layerFeatures.js';
+/**
+ * Fetch a region's features once, run the shared transform steps over them,
+ * 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 mark 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 CoreGetEncodedLayers extends RpcMethodTypeWithRenameRegion {
+    name = 'CoreGetEncodedLayers';
+    async execute(args) {
+        const { region, layers: requested, byteLimit, signal, statusCallback, } = args;
+        const { pluginManager } = this;
+        const dataAdapter = await getFeatureAdapterOrThrow({
+            ...args,
+            pluginManager,
+        });
+        const { bytes, tooLarge } = await measureRegionBytes({
+            dataAdapter,
+            regions: [region],
+            byteLimit,
+            signal,
+            statusCallback,
+        });
+        if (tooLarge) {
+            return tooLarge;
+        }
+        const { jexl } = pluginManager;
+        const { layers: layered, sections, zoomRange, notices, } = await layerFeatures(dataAdapter, args, jexl);
+        const layers = requested.map((request, i) => {
+            const { table, row } = layered[i];
+            return encodeFeatures(table, { ...request.encoding, row }, request.lanes, {
+                jexl,
+                report: createProgressReporter({
+                    label: 'Processing features',
+                    total: table.length,
+                    statusCallback,
+                    signal,
+                }),
+            });
+        });
+        const result = {
+            layers,
+            facet: sections,
+            bytes,
+            zoomRange,
+            ...(notices.length > 0 ? { notices } : {}),
+        };
+        return rpcResult(result, layers.flatMap(l => encodedChannelTransferables(l)));
+    }
+}

package/esm/rpc/methods/CoreGetExportData.js

@@ -3,11 +3,10 @@ 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 { regions, formatType, opts, signal, statusCallback } = args;
         const dataAdapter = await getFeatureAdapterOrThrow({
+            ...args,
             pluginManager: this.pluginManager,
-            sessionId,
-            adapterConfig,
         });
         // The handles go down to the adapter, which is the whole point of the
         // Save-track-data dialog having a cancel button and a progress label: an
@@ -22,7 +21,7 @@ export default class CoreGetExportData extends RpcMethodTypeWithRenameRegions {
         // empty file instead.
         return dataAdapter.getExportData(regions, formatType, {
             ...opts,
-            stopToken,
+            signal,
             statusCallback,
         });
     }

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

@@ -0,0 +1,11 @@
+import RpcMethodTypeWithRenameRegions from '../../pluggableElementTypes/RpcMethodTypeWithRenameRegions.ts';
+import type { RpcExecuteArgs } from '../RpcRegistry.ts';
+/**
+ * The density tier's read: features per bin at the view's bp/px for regions the
+ * region-too-large gate refused. Answers `undefined` for an adapter with no
+ * density source, and the display keeps the banner.
+ */
+export default class CoreGetFeatureDensity extends RpcMethodTypeWithRenameRegions<'CoreGetFeatureDensity'> {
+    name: 'CoreGetFeatureDensity';
+    execute(args: RpcExecuteArgs<'CoreGetFeatureDensity'>): Promise<import("../../data_adapters/BaseAdapter/featureDensity.ts").FeatureDensity[] | undefined>;
+}

package/esm/rpc/methods/CoreGetFeatureDensity.js

@@ -0,0 +1,22 @@
+import { isFeatureAdapter } from '../../data_adapters/BaseAdapter/index.js';
+import { getAdapter } from '../../data_adapters/dataAdapterCache.js';
+import RpcMethodTypeWithRenameRegions from '../../pluggableElementTypes/RpcMethodTypeWithRenameRegions.js';
+/**
+ * The density tier's read: features per bin at the view's bp/px for regions the
+ * region-too-large gate refused. Answers `undefined` for an adapter with no
+ * density source, and the display keeps the banner.
+ */
+export default class CoreGetFeatureDensity extends RpcMethodTypeWithRenameRegions {
+    name = 'CoreGetFeatureDensity';
+    async execute(args) {
+        const { adapterConfig, sessionId, regions, bpPerPx, signal } = args;
+        const { dataAdapter } = await getAdapter(this.pluginManager, sessionId, adapterConfig, args.sequenceAdapter);
+        return isFeatureAdapter(dataAdapter)
+            ? dataAdapter.getFeatureDensity(regions, {
+                bpPerPx,
+                signal,
+                statusCallback: args.statusCallback,
+            })
+            : undefined;
+    }
+}

package/esm/rpc/methods/CoreGetFeatures.js

@@ -10,18 +10,16 @@ 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, regions, opts } = args;
         const dataAdapter = await getFeatureAdapterOrThrow({
+            ...args,
             pluginManager: this.pluginManager,
-            sessionId,
-            adapterConfig,
-            sequenceAdapter,
         });
         const r = await firstValueFrom(dataAdapter
             .getFeaturesInMultipleRegions(regions, {
             ...opts,
             statusCallback,
-            stopToken,
+            signal,
         })
             .pipe(toArray()));
         return r.map(f => f.toJSON());

package/esm/rpc/methods/CoreGetRefNames.js

@@ -1,21 +1,11 @@
-import { isFeatureAdapter, isRefNameSource, } from '../../data_adapters/BaseAdapter/util.js';
+import { isRefNameSource } from '../../data_adapters/BaseAdapter/util.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) {
         const { sessionId, adapterConfig, sequenceAdapter } = args;
-        const { dataAdapter } = await getAdapter(this.pluginManager, sessionId, adapterConfig);
-        // Primes BEFORE it asks: a ReferenceScanAdapter answers `getRefNames` by
-        // asking the reference, and this line is what tells it where that is.
-        // Pinned by sequenceAdapterPriming.test.ts, because reversing the two left
-        // 3,015 tests green.
-        //
-        // The one call that still passes `sequenceAdapter` by hand — it is what
-        // `renameRegionsIfNeeded` CALLS, so the derivation cannot reach it.
-        if (isFeatureAdapter(dataAdapter)) {
-            dataAdapter.setSequenceAdapterConfig(sequenceAdapter);
-        }
+        const { dataAdapter } = await getAdapter(this.pluginManager, sessionId, adapterConfig, sequenceAdapter);
         // Gated on isRefNameSource rather than isFeatureAdapter: any adapter that
         // can name its own contigs needs them reconciled with the assembly's,
         // whether or not it serves features. PlinkLDTabixAdapter serves precomputed

package/esm/rpc/methods/CoreGetRegionByteEstimate.js

@@ -6,7 +6,7 @@ export default class CoreGetRegionByteEstimate extends RpcMethodTypeWithRenameRe
     name = 'CoreGetRegionByteEstimate';
     async execute(args) {
         const { adapterConfig, sessionId, regions, scope } = args;
-        const { dataAdapter } = await getAdapter(this.pluginManager, sessionId, adapterConfig);
+        const { dataAdapter } = await getAdapter(this.pluginManager, sessionId, adapterConfig, args.sequenceAdapter);
         // "Unmeasurable", not an error: the gate reads undefined as "no byte axis".
         if (!isFeatureAdapter(dataAdapter)) {
             return undefined;

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/CoreLoadAdapterCode.d.ts

@@ -0,0 +1,13 @@
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.ts';
+import type { RpcExecuteArgs } from '../RpcRegistry.ts';
+/**
+ * Load these adapter types' code in the worker a track is about to use. An
+ * adapter's class arrives by dynamic import on the track's first request
+ * otherwise, and that download waits for the view to lay out and the assembly
+ * to load.
+ */
+export default class CoreLoadAdapterCode extends RpcMethodType<'CoreLoadAdapterCode'> {
+    name: 'CoreLoadAdapterCode';
+    execute({ adapterTypes }: RpcExecuteArgs<'CoreLoadAdapterCode'>): Promise<void>;
+    serializeArguments(args: Record<string, unknown>): Promise<Record<string, unknown>>;
+}

package/esm/rpc/methods/CoreLoadAdapterCode.js

@@ -0,0 +1,16 @@
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.js';
+/**
+ * Load these adapter types' code in the worker a track is about to use. An
+ * adapter's class arrives by dynamic import on the track's first request
+ * otherwise, and that download waits for the view to lay out and the assembly
+ * to load.
+ */
+export default class CoreLoadAdapterCode extends RpcMethodType {
+    name = 'CoreLoadAdapterCode';
+    async execute({ adapterTypes }) {
+        await Promise.all(adapterTypes.map(type => this.pluginManager.getAdapterType(type).getAdapterClass()));
+    }
+    async serializeArguments(args) {
+        return args;
+    }
+}

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

@@ -0,0 +1,33 @@
+import type { BaseFeatureDataAdapter } from '../../data_adapters/BaseAdapter/index.ts';
+import type { FeatureTable } from '../../util/featureTable.ts';
+import type { JexlInstance } from '../../util/jexlStrings.ts';
+import type { CoreGetEncodedLayersArgs, FieldRef } from '../../util/markEncodingTypes.ts';
+import type { StatusCallback } from '../../util/progress.ts';
+/**
+ * One layer of a request as the encoder takes it: its rows, and the row of the
+ * plot each stands in — the field the layer reads, or under a facet each
+ * row's stacked row.
+ */
+export interface LayerFeatures {
+    table: FeatureTable;
+    row: FieldRef | ArrayLike<number> | undefined;
+}
+/**
+ * The table each layer of a `CoreGetEncodedLayers` 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 table, so the same request answers which row an instance is.
+ */
+export declare function layerFeatures(dataAdapter: BaseFeatureDataAdapter, args: Pick<CoreGetEncodedLayersArgs, 'region' | 'layers' | 'transform' | 'facet' | 'bpPerPx' | 'opts'> & {
+    signal?: AbortSignal;
+    statusCallback?: StatusCallback;
+}, jexl: JexlInstance): Promise<{
+    layers: {
+        table: FeatureTable;
+        row: FieldRef | Uint32Array | undefined;
+    }[];
+    sections: import("../../util/markEncodingTypes.ts").FacetSection[] | undefined;
+    zoomRange: import("../../data_adapters/BaseAdapter/zoomRange.ts").ZoomRange | undefined;
+    notices: string[];
+}>;

package/esm/rpc/methods/layerFeatures.js

@@ -0,0 +1,29 @@
+import { checkAbortSignal } from '../../util/aborting.js';
+import { layerTables } from '../../util/featureTransforms.js';
+import { updateStatus } from '../../util/progress.js';
+/**
+ * The table each layer of a `CoreGetEncodedLayers` 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 table, so the same request answers which row an instance is.
+ */
+export async function layerFeatures(dataAdapter, args, jexl) {
+    const { region, layers: requested, transform = [], facet, bpPerPx, opts, signal, statusCallback, } = args;
+    const notices = [];
+    const fetchOpts = { ...opts, bpPerPx, statusCallback, signal, notices };
+    const [fetched, zoomRange] = await updateStatus('Downloading features', statusCallback, () => Promise.all([
+        dataAdapter.getFeatureTable(region, fetchOpts),
+        dataAdapter.getZoomRange(fetchOpts),
+    ]));
+    checkAbortSignal(signal);
+    const { layers, sections } = layerTables(fetched, {
+        transform,
+        facet,
+        layers: requested.map(r => ({
+            transform: r.transform,
+            row: r.encoding.row,
+        })),
+    }, jexl);
+    return { layers, sections, zoomRange, notices };
+}

package/esm/svg/SvgExport.js

@@ -3,14 +3,14 @@ import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-run
 // the linear-genome-view plugin. Non-component members live in sibling files
 // (`constants.ts`, `svgReady.ts`) so this stays component-only for
 // react-refresh.
-import { useTheme } from '@mui/material';
-import { stripAlpha } from '../util/index.js';
+import { usePalette } from '../ui/PaletteContext.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.
 export function SVGBackground({ width, height, }) {
-    const theme = useTheme();
-    return (_jsx("rect", { width: width, height: height, fill: stripAlpha(theme.palette.background.default) }));
+    const palette = usePalette();
+    return (_jsx("rect", { width: width, height: height, fill: stripAlpha(palette.background.default) }));
 }
 // Root <svg> for an image export. Owns the xmlns/viewBox boilerplate, widens
 // the canvas by `margin` on each side, and paints the themed background.
@@ -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 }) }));
+}

package/esm/svg/exportViewSvg.d.ts

@@ -0,0 +1,28 @@
+import type { SvgRasterCanvasOpts } from '../util/createSvgRasterCanvas.ts';
+import type React from 'react';
+/** What every view's `exportSvg` accepts. A view with more extends it. */
+export interface ViewExportSvgOptions extends SvgRasterCanvasOpts {
+    rasterizeLayers?: boolean;
+    format?: 'svg' | 'png';
+    filename?: string;
+    /**
+     * Whether to hand the result to the browser's download path. Default true,
+     * which is the dialog. False returns the markup and writes nothing — the
+     * caller has somewhere of its own to put it, and a download it did not ask
+     * for would land beside that under a name it did not choose.
+     */
+    save?: boolean;
+    Wrapper?: React.FC<{
+        children: React.ReactNode;
+    }>;
+    /** a named theme; the session's active one when absent */
+    themeName?: string;
+    fontFamily?: string;
+}
+/**
+ * The body of every view's `exportSvg` action: load the view's lazy
+ * `renderToSvg`, render, save unless `save: false`, and return the markup.
+ */
+export declare function exportViewSvg<V, O extends ViewExportSvgOptions>(view: V, opts: O, load: () => Promise<{
+    renderToSvg: (view: V, opts: O) => Promise<string>;
+}>): Promise<string>;

package/esm/svg/exportViewSvg.js

@@ -0,0 +1,13 @@
+/**
+ * The body of every view's `exportSvg` action: load the view's lazy
+ * `renderToSvg`, render, save unless `save: false`, and return the markup.
+ */
+export async function exportViewSvg(view, opts, load) {
+    const { renderToSvg } = await load();
+    const html = await renderToSvg(view, opts);
+    if (opts.save !== false) {
+        const { saveSvgAsImage } = await import('./saveSvgAsImage.js');
+        await saveSvgAsImage(html, opts);
+    }
+    return html;
+}