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

package/README.md

@@ -149,12 +149,11 @@ default" action, which passes the slots it actually listed
 
 **`slots` is required, and an all-slots default is not the convenience it looks
 like.** It reaches further than any list a dialog can have shown: a promoted
-default the track _customized_ over, or one promoted to a value equal to
-`promotedBase`, is `inherited: false` and so appears in no row, yet still
-governs sibling tracks — so clearing it from a dialog that never showed it moves
-tracks other than the one whose badge was clicked. Clearing every promoted
-default at once is a preferences-scope action, and Preferences → "Reset to
-defaults" is where it lives (`clearPreferenceOverrides`).
+default the track _customized_ over is `inherited: false` and so appears in no
+row, yet still governs sibling tracks — so clearing it from a dialog that never
+showed it moves tracks other than the one whose badge was clicked. Clearing
+every promoted default at once is a preferences-scope action, and Preferences →
+"Reset to defaults" is where it lives (`clearPreferenceOverrides`).
 
 ```js
 // type signature
@@ -402,8 +401,11 @@ not be the thing that discovers this. Callers fall back to treating it as the
 plain object it is.
 
 Shares `TrackConfigurationReference`'s per-PluginManager cache, so hydrating the
-same entry twice returns the same node and a track that gets opened later reuses
-it.
+same entry twice returns the same node — and in admin/embedded sessions a track
+opened later resolves to that same node. A non-admin's open track does not: it
+resolves to the session's private working copy (ADR-032) and this is the
+pristine mirror beside it. The two agree in content, which is what the caller
+needs; `CopyConfigEntryPoints.test.ts` pins both halves.
 
 ```js
 // type signature
@@ -420,10 +422,10 @@ default" predicate for a promotable slot: comparing the resolved value to the
 base instead reads as at-default for a track merely _following_ a non-base
 promoted default, so the reset control lights up on a no-op.
 
-`SLOT` is constrained the way `getConf`'s is. A pin or a reset over a slot name
-the schema does not declare is inert and silent — `resolveSlot` answers about
-nothing, so the control draws outline forever — and a widened `self` switches
-the check off (`HostChecksSlotNames`).
+`SLOT` is constrained the way `getConf`'s is, and a widened `self` switches the
+check off (`HostChecksSlotNames`). A slot name the schema does not declare
+throws at the first read (`getSlotDefinition`), and a declared but
+non-promotable one throws in `resolveSlotIn`.
 
 ```js
 // type signature
@@ -432,22 +434,36 @@ the check off (`HostChecksSlotNames`).
 
 [Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/core/src/configuration/promotableDefaults.ts)
 
+### launchOrReplaceView
+
+`addOrReplaceView` for view types whose state model may be lazily loaded; the
+synchronous `addOrReplaceView` requires it loaded already.
+
+```js
+// type signature
+(args: { session: AbstractViewContainer; typeName: string; initialState?: Record<string, unknown> | undefined; replacing?: AbstractViewModel | undefined; }) => Promise<...>
+```
+
+[Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/core/src/util/mstUtils.ts)
+
 ### makePin
 
-The pin for one promotable slot: "apply this value to every open track of this
+The pin on a radio or slider row: "apply this value to every open track of this
 display type", and — via the snackbar it raises — "keep it as the default for
 the ones opened later".
 
 `value` chooses between the subsystem's two meanings, which are otherwise
 identical:
 
-- **Give it** for a per-value pin — "make _arcs_ the default" — independent of
-  what the track currently shows. Use on an always-visible pin so it can never
-  promote a meaningless value, and so two rows sharing one slot (arcs `'arc'` vs
-  read cloud `'cloud'`; sashimi `'down'` vs `'auto'`) stay independent.
+- **Give it** for a per-value pin — "make _compact_ the default" — independent
+  of what the track currently shows. Use on an always-visible pin so it can
+  never promote a meaningless value, and so two rows sharing one slot (sashimi
+  `'down'` vs `'auto'`) stay independent.
 - **Omit it** for "whatever I'm showing", resolved through the cascade. Use for
-  a symmetric or continuous setting where no fixed on-value makes sense (wiggle
-  point size, arc line width, `mismatchAlpha`).
+  a continuous setting where no fixed on-value makes sense (wiggle point size,
+  arc line width).
+
+A checkbox row takes neither: makeTogglePin.
 
 One function with an optional argument, rather than the two exported builders it
 replaces — a per-value one and a `…CurrentValue…` one, the second of which was
@@ -457,7 +473,32 @@ argument now says what the longer name said.
 
 ```js
 // type signature
-<CONFMODEL extends AnyConfigurationModel, SLOT extends ConfigurationSlotName<…>>(self: ResolvableDisplay<CONFMODEL>, slot: SLOT, ...value: [] | [...]) => Pin
+<CONFMODEL extends AnyConfigurationModel, SLOT extends ConfigurationSlotName<…>>(self: ResolvableDisplay<CONFMODEL>, slot: SLOT, ...value: [] | [...]) => ValuePin
+```
+
+[Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/core/src/configuration/promotableDefaults.ts)
+
+### makeTogglePin
+
+The pin on a checkbox row: the row's own checkbox, acting on every open track of
+the display type. `active` mirrors the row, so the pin draws filled exactly when
+the box is ticked; a click flips the row's state on every open track and offers
+the new state as the display type's default. It never clears a default the way
+makePin's filled pin does — flipping back and taking the offer promotes the
+other value, and promoting the base value clears the default
+(`applyAndOfferDefault`).
+
+Replaces a symmetric `makePin(self, slot)` on these rows, which carried the
+row's current state: beside an unchecked box that applied _off_ everywhere and
+visibly did nothing. It also replaces the per-value `makePin` a checkbox row
+over a shared enum slot used to carry, which gave two checkbox rows in one
+submenu two different pins: one filled when its value was promoted and clearing
+on a second click, the other filled when the box was ticked and flipping. With
+`states`, a checkbox row is always the toggle kind.
+
+```js
+// type signature
+<…>(self: ResolvableDisplay<CONFMODEL>, slot: SLOT, ...states: ConfigurationSlotValueResolved<...> extends boolean ? [] | [...] : [...]) => TogglePin
 ```
 
 [Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/core/src/configuration/promotableDefaults.ts)
@@ -490,28 +531,12 @@ each display whether it has anything to promote.
 ### Pin
 
 The "apply this to every open track of this type" affordance on a menu row — the
-trailing `PushPin`, bundled so the row consumes it as one prop. Built by
-makePin.
-
-`active` = this value is currently the session default (a filled pin), which is
-the state, not the click. `toggle` **applies the value to every open track of
-the display type** and raises a snackbar whose one action promotes it to the
-display type's default; on an already-promoted value it clears that default
-instead, touching no track (see `applyPinClick`).
-
-**`toggle` rather than an `apply`/`clear` pair**, which was tried and dropped:
-the sole renderer is a MUI `ToggleButton` whose `onChange` means exactly "flip",
-so splitting it adds a member _and_ a branch at the one call site that never
-needed one. `active` is already public for a caller that wants to state a
-direction. (The house preference for explicit setters over toggles is about MST
-actions, where a toggle destroys the ability to set a known state; nothing here
-stores a value.)
-
-Lives here, alone and with no imports, rather than beside `makePin` in
-`promotableDefaults.ts`: the menu types describe a pin without building one, and
-`MenuTypes.ts` taking this one interface from that module gave a React-free type
-file a type closure of 374 files. See
-`agent-docs/ideas/barrels-block-extraction.md` and `scripts/moduleClosure.ts`.
+trailing `PushPin`, bundled so the row consumes it as one prop.
+
+`kind` is what the adornment words itself from and what the row builders check:
+a checkbox row takes a TogglePin, a radio or slider row a ValuePin. The two used
+to be told apart by `typeof onValue === 'boolean'`, which let a value pin over a
+boolean slot compile and read as a toggle while clearing on its second click.
 
 [Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/core/src/configuration/promotablePin.ts)
 
@@ -648,6 +673,24 @@ at the point where the connection is cut.
 
 [Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/core/src/configuration/promotableDefaults.ts)
 
+### runLazyAfterAttach
+
+Run a display's `afterAttach` body from a module loaded on demand, so the
+autorun installers stay out of the display's eager bundle.
+
+One policy for the gap the `await` opens: a node torn down before the module
+lands installs nothing, and a module that fails to load is reported where the
+user can see it rather than onto the display's own error slot — that slot is
+what `reload()` clears, and nothing would re-run the install behind it. Three
+displays hand-rolled this IIFE and each drew the lines differently.
+
+```js
+// type signature
+<Self extends IStateTreeNode>(self: Self, load: () => Promise<(self: Self) => void>) => void
+```
+
+[Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/core/src/util/lazyAfterAttach.ts)
+
 ### sampleColorRamp
 
 The color at `t` in `[0, 1]` across a list of EVENLY SPACED stops, linearly
@@ -671,6 +714,12 @@ Make JBrowse follow the host's light/dark state — the whole of it, in one moun
 </SessionPaletteProvider>
 ```
 
+`mode` is optional. Left out, JBrowse follows `prefers-color-scheme` and
+re-themes when the OS preference changes, through the same session write an
+explicit mode takes — so a host whose dark mode _is_ the OS preference mounts
+this with a session and nothing else. Pass a mode as soon as the host has a
+toggle of its own, since the media query cannot see it.
+
 A component rather than a documented pair of calls because the pair has a half
 that can be left out with nothing to show for it. `PaletteProvider` is the name
 a host reaches for, and it colors the React side alone; the session write is
@@ -684,7 +733,7 @@ colors of its own mounts `PaletteProvider` directly instead.
 
 ```js
 // type signature
-({ session, mode, children, }: { session: ThemeModeSession; mode: "dark" | "light"; children: ReactNode; }) => Element
+({ session, mode, children, }: { session: ThemeModeSession; mode?: "dark" | "light" | undefined; children: ReactNode; }) => Element
 ```
 
 [Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/core/src/ui/PaletteContext.tsx)
@@ -757,6 +806,16 @@ never baked into the color string.
 
 [Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/core/src/util/colorRamp.ts)
 
+### TogglePin
+
+The pin on a checkbox row, built by makeTogglePin: the row's own checkbox over
+every open track of the display type. `active` mirrors the row, `onValue` is the
+state a click applies (the row's opposite), and `toggle` applies it everywhere
+and offers it as the default. It never clears a default on its own — promoting
+the slot's base value is what clears one.
+
+[Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/core/src/configuration/promotablePin.ts)
+
 ### TrackConfigWithPromotables
 
 A track config snapshot with every display's `promotable` slots resolved, plus
@@ -788,6 +847,16 @@ reader has promoted in their own browser. Pinned by
 
 [Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/core/src/configuration/promotableDefaults.ts)
 
+### ValuePin
+
+The pin on a radio or slider row, built by makePin: `onValue` is the row's own
+value, `active` means that value is the display type's promoted default, and
+`toggle` on an outline pin applies the value to every open track and offers it
+as the default, while on a filled pin it clears that default and touches no
+track (`applyAndOfferDefault` / `clearDefault`).
+
+[Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/core/src/configuration/promotablePin.ts)
+
 ### VIRIDIS_STOPS
 
 The 256 viridis stops, fully opaque. Feed them to buildColorRampLut for the

package/esm/BaseFeatureWidget/BaseFeatureDetail/FeatureDetails.d.ts

@@ -1,8 +1,7 @@
 import type { SimpleFeatureSerialized } from '../../util/index.ts';
-import type { Descriptors, FeatureFormatter } from '../types.tsx';
-import type { IAnyStateTreeNode } from '@jbrowse/mobx-state-tree';
+import type { Descriptors, FeatureDetailsModel, FeatureFormatter } from '../types.tsx';
 interface FeatureDetailsProps {
-    model: IAnyStateTreeNode;
+    model: FeatureDetailsModel;
     feature: SimpleFeatureSerialized;
     depth?: number;
     omit?: string[];

package/esm/BaseFeatureWidget/BaseFeatureDetail/ParentFeatureLine.d.ts

@@ -0,0 +1,4 @@
+import type { ParentFeatureSummary } from '../../util/index.ts';
+export default function ParentFeatureLine({ parentFeature, }: {
+    parentFeature: ParentFeatureSummary;
+}): import("react").JSX.Element;

package/esm/BaseFeatureWidget/BaseFeatureDetail/ParentFeatureLine.js

@@ -0,0 +1,17 @@
+import { jsxs as _jsxs } from "react/jsx-runtime";
+import { Typography } from '@mui/material';
+import { makeStyles } from '../../util/tss-react/index.js';
+const useStyles = makeStyles()(theme => ({
+    line: {
+        padding: theme.spacing(0.5, 1, 0),
+    },
+}));
+// Which gene a transcript came out of, above the card naming the transcript.
+// The panel is opened on the exact isoform the click resolved to, and that
+// isoform's own record is regularly the only place its accession appears --
+// nothing in `NM_004006.2 - mRNA` says DMD.
+export default function ParentFeatureLine({ parentFeature, }) {
+    const { classes } = useStyles();
+    const { name, type } = parentFeature;
+    return (_jsxs(Typography, { variant: "body2", color: "textSecondary", className: classes.line, "data-testid": "parent-feature-line", children: ["in ", type ? `${type} ` : '', name] }));
+}

package/esm/BaseFeatureWidget/BaseFeatureDetail/index.js

@@ -1,11 +1,12 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { observer } from 'mobx-react';
 import { ErrorBanner } from '../../ui/index.js';
 import FeatureDetails from './FeatureDetails.js';
 import FeatureWash from './FeatureWash.js';
+import ParentFeatureLine from './ParentFeatureLine.js';
 import { isEmpty } from './util.js';
 const BaseFeatureDetail = observer(function BaseFeatureDetail({ model, }) {
-    const { error, featureData } = model;
+    const { error, featureData, parentFeature } = model;
     // annotated to shed the MST node brand types.frozen() carries on the instance
     const descriptions = model.descriptions;
     // A field is hidden by a formatDetails callback returning undefined (jexl
@@ -19,7 +20,7 @@ const BaseFeatureDetail = observer(function BaseFeatureDetail({ model, }) {
         return null;
     }
     else {
-        return (_jsx(FeatureWash, { uniqueId: featureData.uniqueId, children: _jsx(FeatureDetails, { model: model, feature: featureData, descriptions: descriptions }) }));
+        return (_jsxs(FeatureWash, { uniqueId: featureData.uniqueId, children: [parentFeature ? (_jsx(ParentFeatureLine, { parentFeature: parentFeature })) : null, _jsx(FeatureDetails, { model: model, feature: featureData, descriptions: descriptions })] }));
     }
 });
 export default BaseFeatureDetail;

package/esm/BaseFeatureWidget/SequenceFeatureDetails/SequenceFeaturePanel.d.ts

@@ -1,7 +1,7 @@
 import type { SimpleFeatureSerialized } from '../../util/index.ts';
-import type { BaseFeatureWidgetModel } from '../stateModelFactory.ts';
+import type { FeatureDetailsModel } from '../types.tsx';
 declare const SequenceFeaturePanel: ({ model, feature, }: {
-    model: BaseFeatureWidgetModel;
+    model: FeatureDetailsModel;
     feature: SimpleFeatureSerialized;
 }) => import("react").JSX.Element;
 export default SequenceFeaturePanel;

package/esm/BaseFeatureWidget/SequenceFeatureDetails/test_data/NCDN.d.ts

@@ -48,9 +48,9 @@ declare const _default: {
             uniqueId: string;
             parentId: string;
             id?: undefined;
+            name?: undefined;
             note?: undefined;
             protein_id?: undefined;
-            name?: undefined;
         } | {
             transcript_id?: undefined;
             source: string;
@@ -94,6 +94,7 @@ declare const _default: {
         transcript_id: string;
         subfeatures: ({
             id?: undefined;
+            name?: undefined;
             note?: undefined;
             protein_id?: undefined;
             source: string;
@@ -111,7 +112,6 @@ declare const _default: {
             transcript_id: string;
             uniqueId: string;
             parentId: string;
-            name?: undefined;
         } | {
             transcript_id?: undefined;
             source: string;

package/esm/BaseFeatureWidget/index.d.ts

@@ -1,5 +1,5 @@
 export { configSchema } from './configSchema.ts';
-export type { Descriptors, MaybeSerializedFeat } from './types.tsx';
+export type { Descriptors, FeatureDetailsModel, MaybeSerializedFeat, } from './types.tsx';
 export type { SequenceHoverPosition, ShowCoordinatesMode, } from './SequenceFeatureDetails/model.ts';
 export { stateModelFactory } from './stateModelFactory.ts';
 export type { BaseFeatureWidgetModel, BaseFeatureWidgetStateModel, } from './stateModelFactory.ts';

package/esm/BaseFeatureWidget/stateModelFactory.d.ts

@@ -1,5 +1,5 @@
 import type PluginManager from '../PluginManager.ts';
-import type { SimpleFeatureSerialized } from '../util/index.ts';
+import type { ParentFeatureSummary, SimpleFeatureSerialized } from '../util/index.ts';
 import type { SequenceHoverPosition } from './SequenceFeatureDetails/model.ts';
 import type { Descriptors, MaybeSerializedFeat } from './types.tsx';
 import type { Instance } from '@jbrowse/mobx-state-tree';
@@ -69,6 +69,12 @@ export declare function stateModelFactory(pluginManager: PluginManager): import(
      * #property
      */
     descriptions: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IType<Descriptors | undefined, Descriptors | undefined, Descriptors | undefined>, [undefined]>;
+    /**
+     * #property
+     * names the feature this one was reached through, when it was reached
+     * through one -- a transcript clicked inside its gene
+     */
+    parentFeature: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IType<ParentFeatureSummary | undefined, ParentFeatureSummary | undefined, ParentFeatureSummary | undefined>, [undefined]>;
 }, {
     error: unknown;
     sequenceHoverPosition: SequenceHoverPosition | undefined;
@@ -113,6 +119,7 @@ export declare function stateModelFactory(pluginManager: PluginManager): import(
     maxDepth: number | undefined;
     sequenceFeatureDetails: import("@jbrowse/mobx-state-tree").ModelSnapshotType<{}>;
     descriptions: Descriptors | undefined;
+    parentFeature: ParentFeatureSummary | undefined;
     finalizedFeatureData: any;
 }>;
 export type BaseFeatureWidgetStateModel = ReturnType<typeof stateModelFactory>;

package/esm/BaseFeatureWidget/stateModelFactory.js

@@ -59,6 +59,12 @@ export function stateModelFactory(pluginManager) {
          * #property
          */
         descriptions: types.optional(types.frozen(), undefined),
+        /**
+         * #property
+         * names the feature this one was reached through, when it was reached
+         * through one -- a transcript clicked inside its gene
+         */
+        parentFeature: types.optional(types.frozen(), undefined),
     })
         .volatile(() => ({
         /**

package/esm/BaseFeatureWidget/types.d.ts

@@ -1,6 +1,14 @@
 import type { SimpleFeatureSerialized } from '../util/simpleFeature.ts';
-import type { BaseFeatureWidgetModel } from './stateModelFactory.ts';
+import type { SequenceFeatureDetailsModel, SequenceHoverTarget } from './SequenceFeatureDetails/model.ts';
+import type { IStateTreeNode } from '@jbrowse/mobx-state-tree';
 import type React from 'react';
+export interface FeatureDetailsModel extends IStateTreeNode, SequenceHoverTarget {
+    maxDepth: number | undefined;
+    sequenceFeatureDetails: SequenceFeatureDetailsModel;
+    view: {
+        assemblyNames: string[];
+    } | undefined;
+}
 export interface Descriptors {
     [key: string]: React.ReactNode | Descriptors;
 }
@@ -9,7 +17,7 @@ export interface BaseProps extends BaseCardProps {
     feature: SimpleFeatureSerialized;
     formatter?: FeatureFormatter;
     descriptions?: Descriptors;
-    model?: BaseFeatureWidgetModel;
+    model?: FeatureDetailsModel;
 }
 export interface BaseCardProps {
     title?: string;

package/esm/PluginLoader.d.ts

@@ -12,6 +12,7 @@ export interface PluginLoadFailure {
     definition: PluginDefinition;
     error: unknown;
 }
+export declare function workerScriptLoadMessage(scriptUrl: string, error: unknown): string;
 export default class PluginLoader {
     definitions: PluginDefinition[];
     fetchESM?: (url: string) => Promise<LoadedPlugin>;

package/esm/PluginLoader.js

@@ -1,5 +1,6 @@
+import { enableContractReports } from '@jbrowse/render-core/contractReports';
 import { setReExportRegistry } from './ReExports/registry.js';
-import { isCJSPluginDefinition, isESMPluginDefinition, isUMDPluginDefinition, pluginDescriptionString, } from './pluginDefinitions.js';
+import { isCJSPluginDefinition, isESMPluginDefinition, isUMDPluginDefinition, maybePluginUrl, pluginDescriptionString, } from './pluginDefinitions.js';
 import { isElectron } from './util/index.js';
 import { isWebWorker } from './util/isWebWorker.js';
 /**
@@ -45,6 +46,19 @@ function promisifiedLoadScript(src, integrity) {
 function hasImportScripts(scope) {
     return 'importScripts' in scope;
 }
+// A *module* worker has importScripts on its global but throws from it — the
+// spec forbids it there, and the browser says so ("Module scripts don't support
+// importScripts"). That is the whole failure for a UMD plugin in a bundler
+// configured for module workers (Vite's `worker.format: 'es'`), and it reads as
+// a broken plugin unless named. Every other throw is the script's own — a 404,
+// or a bundle that dereferences `window` in a realm that has none — and the
+// script's words are the diagnosis, so they are kept rather than replaced.
+export function workerScriptLoadMessage(scriptUrl, error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return /module script/i.test(detail)
+        ? `Failed to load ${scriptUrl} in the worker. A UMD plugin is loaded there via importScripts, which module workers do not support — either build the worker as a classic worker, or use a plugin published as ESM.`
+        : `Failed to load ${scriptUrl} in the worker: ${detail}`;
+}
 async function loadScript(scriptUrl, integrity) {
     const scope = globalThis;
     if (!isWebWorker()) {
@@ -55,12 +69,9 @@ async function loadScript(scriptUrl, integrity) {
             scope.importScripts(scriptUrl);
         }
         catch (error) {
-            // A *module* worker has importScripts on its global but throws from it —
-            // the spec forbids it there. That is the whole failure for a UMD plugin
-            // in a bundler configured for module workers (Vite's `worker.format:
-            // 'es'`), and the raw TypeError names none of it, so it reads as a broken
-            // plugin rather than an incompatible pairing.
-            throw new Error(`Failed to load ${scriptUrl} in the worker. A UMD plugin is loaded there via importScripts, which module workers do not support — either build the worker as a classic worker, or use a plugin published as ESM.`, { cause: error });
+            throw new Error(workerScriptLoadMessage(scriptUrl, error), {
+                cause: error,
+            });
         }
         return;
     }
@@ -97,6 +108,34 @@ function resolvePluginUrl(spec, base) {
     }
     return url;
 }
+// A plugin served from the developer's own machine into an app built for
+// production is the one arrangement that can only be a plugin under
+// development: a shipped site serves its plugins from its own origin, and a
+// developer running the app itself from source already has a development build.
+// So it is the evidence that arms the contract channel without anything for the
+// author to know about first — which is the whole difficulty the channel had,
+// since the population it is written for is the one with nobody to ask. See
+// `@jbrowse/render-core/contractReports`.
+function armIfUnderDevelopment(def) {
+    const url = maybePluginUrl(def);
+    if (url !== undefined && servedFromThisMachine(url)) {
+        enableContractReports(`the plugin at ${url} is served from this machine`);
+    }
+}
+function servedFromThisMachine(url) {
+    try {
+        const { hostname, protocol } = new URL(url);
+        return ((protocol === 'http:' || protocol === 'https:') &&
+            (hostname === 'localhost' ||
+                hostname === '127.0.0.1' ||
+                hostname === '[::1]'));
+    }
+    catch {
+        // a relative url is a plugin shipped beside this index.html, which is the
+        // site's own rather than one under development
+        return false;
+    }
+}
 function addCacheBuster(url) {
     if (!('__jbrowseCacheBuster' in globalThis)) {
         return url;
@@ -155,6 +194,7 @@ export default class PluginLoader {
     }
     async loadPlugin(def, baseUri) {
         assertSingleKind(def);
+        armIfUnderDevelopment(def);
         let plugin;
         if (isCJSPluginDefinition(def)) {
             if (!isElectron) {
@@ -198,7 +238,11 @@ export default class PluginLoader {
         if (!target) {
             return;
         }
-        const { default: ReExports } = await import('./ReExports/index.js');
+        // a worker never renders: the same keys, with the UI ones stubbed, so a
+        // plugin bundle evaluates there without fetching react-dom and Material UI
+        const { default: ReExports } = isWebWorker()
+            ? await import('./ReExports/workerModules.js')
+            : await import('./ReExports/index.js');
         target.JBrowseExports = {
             ...ReExports,
         };