@jbrowse/core 4.2.1 → 5.0.0-beta.1

package/esm/util/localStorage.js

@@ -0,0 +1,137 @@
+// localStorage: the guarded primitives from webStorage.ts (read that file for
+// the three ways a Web Storage store fails and why every accessor here is
+// total), plus the typed reads and the key subscription, which only this store
+// has callers for.
+import { guardedLocalStorage } from './webStorage.js';
+export const { available: localStorageAvailable, getItem: localStorageGetItem, setItem: localStorageSetItem, removeItem: localStorageRemoveItem, } = guardedLocalStorage;
+// Watchers of a key, and the one `storage` listener they share.
+//
+// Two different events reach them, which is why this is not simply a `storage`
+// listener at each call site. Another TAB writing the key raises `storage` —
+// but never in the tab that wrote it, so a write from THIS tab reaches nobody
+// and has to be announced by hand. Missing that half is what let two components
+// on one key show different values until one of them remounted.
+//
+// Announcing is deliberately not folded into localStorageSetItem. The
+// grid-bookmark widget persists its list from an autorun over the list, so a
+// write that called its own subscriber back would re-enter that autorun and
+// write again, forever. A writer says when its write is news.
+const listeners = new Map();
+// Installed on the first subscription rather than at module scope, so importing
+// this file from a worker or a test never touches `window`.
+let storageListenerInstalled = false;
+function installStorageListener() {
+    if (storageListenerInstalled || typeof window === 'undefined') {
+        return;
+    }
+    storageListenerInstalled = true;
+    window.addEventListener('storage', e => {
+        // sessionStorage raises the same event on the same window, and jbrowse-web
+        // mirrors whole sessions into it
+        if (e.storageArea !== window.localStorage) {
+            return;
+        }
+        if (e.key === null) {
+            // a clear(): a factory reset, a test's teardown. Every key at once
+            for (const k of [...listeners.keys()]) {
+                notifyLocalStorageKey(k);
+            }
+        }
+        else if (listeners.has(e.key)) {
+            notifyLocalStorageKey(e.key);
+        }
+    });
+}
+/**
+ * Call `fn` whenever `key` changes — in another tab, or here via
+ * {@link notifyLocalStorageKey}. Returns the unsubscribe.
+ *
+ * `fn` takes no argument on purpose: it is told that the key changed, and reads
+ * the store itself. A payload would be a second copy of the value, and a
+ * `clear()` has none to hand over.
+ */
+export function subscribeToLocalStorageKey(key, fn) {
+    installStorageListener();
+    let set = listeners.get(key);
+    if (!set) {
+        set = new Set();
+        listeners.set(key, set);
+    }
+    set.add(fn);
+    return () => {
+        set.delete(fn);
+        if (!set.size) {
+            listeners.delete(key);
+        }
+    };
+}
+/** Announce a write made in this tab, which `storage` never reports back. */
+export function notifyLocalStorageKey(key) {
+    for (const fn of listeners.get(key) ?? []) {
+        fn();
+    }
+}
+export function localStorageGetNumber(key, defaultVal) {
+    const stored = localStorageGetItem(key);
+    // rejected before the coercion rather than after it: `+''` is 0, so an entry
+    // written as the empty string would otherwise read back as a real 0 instead
+    // of falling back. isFinite rather than !isNaN so 'Infinity' falls back too —
+    // every one of these is a pixel width or a base-pair count.
+    if (!stored) {
+        return defaultVal;
+    }
+    const parsed = +stored;
+    return Number.isFinite(parsed) ? parsed : defaultVal;
+}
+export function localStorageGetJSON(key, defaultVal) {
+    const stored = localStorageGetItem(key);
+    if (stored) {
+        try {
+            return JSON.parse(stored);
+        }
+        catch (e) {
+            console.warn(`Invalid localStorage value for ${key}:`, stored, e);
+        }
+    }
+    return defaultVal;
+}
+/**
+ * The list of strings at `key` — absent, unreadable, malformed, or holding
+ * anything else all read as empty.
+ *
+ * The element filter is the part {@link localStorageGetJSON} cannot do: a
+ * stored array of the wrong element type parses fine and then behaves as a list
+ * of values that match nothing, which looks the same as an empty list except
+ * that it is never noticed. Three keys wanted exactly this and each spelled it
+ * out — hidden facet columns, trusted plugin URLs, and the desktop safe-mode
+ * marker, which additionally has to survive the bare `1` older builds wrote
+ * there.
+ */
+export function localStorageGetStringArray(key) {
+    const parsed = localStorageGetJSON(key, []);
+    return Array.isArray(parsed) ? parsed.filter(x => typeof x === 'string') : [];
+}
+/**
+ * Writes `val` as JSON, except when it is null/undefined — those are skipped
+ * rather than stored, so a tri-state setting whose "unset" value means "follow
+ * the config" leaves whatever was there instead of pinning `null` over it.
+ */
+export function localStorageSetJSON(key, val) {
+    if (val !== undefined && val !== null) {
+        localStorageSetItem(key, JSON.stringify(val));
+    }
+}
+export function localStorageGetBoolean(key, defaultVal) {
+    const stored = localStorageGetJSON(key, defaultVal);
+    // falls back rather than coercing when the key holds something that is not a
+    // boolean (an older build's format, a hand-edited value). `Boolean(null)` is
+    // false, which would silently override a `true` default — which is what most
+    // of these are.
+    return typeof stored === 'boolean' ? stored : defaultVal;
+}
+export function localStorageSetBoolean(key, value) {
+    localStorageSetItem(key, JSON.stringify(value));
+}
+export function localStorageSetNumber(key, value) {
+    localStorageSetItem(key, JSON.stringify(value));
+}

package/esm/util/makeAssembly.d.ts

@@ -0,0 +1,54 @@
+export interface MakeAssemblyOptions {
+    /** URL to a FASTA (`.fa`/`.fasta`, optionally bgzipped) or a `.2bit` file */
+    fastaUri: string;
+    /** defaults to the file's base name, e.g. `hg38.fa.gz` -> `hg38` */
+    name?: string;
+    faiUri?: string;
+    gziUri?: string;
+    aliases?: string[];
+    refNameAliasesUri?: string;
+}
+/** true when a string names a sequence file (vs. a hub name like `hg38`) */
+export declare function isSequenceUri(uri: string): boolean;
+/** strip path and sequence extension: `.../hg19.fa.gz` -> `hg19` */
+export declare function assemblyNameFromUri(uri: string): string;
+/**
+ * Build an assembly config for a sequence file (indexed FASTA, bgzipped FASTA,
+ * or `.2bit`) — the boilerplate you'd otherwise write by hand. In the common
+ * case it is the flat `{ name, uri }` shorthand: jbrowse-core's assembly config
+ * picks the concrete adapter type (`IndexedFastaAdapter`/`BgzipFastaAdapter`/
+ * `TwoBitAdapter`) from the extension, derives the `.fai`/`.gzi` siblings, and
+ * fills in the `ReferenceSequenceTrack` at load time, so no adapter-type
+ * knowledge lives here. A non-sibling index (`faiUri`/`gziUri`) widens `sequence`
+ * to its adapter form, the only shape with a slot for the override.
+ * `refNameAliasesUri` points at a tab-separated aliases file (as UCSC publishes)
+ * so a track whose reference names differ from the sequence (e.g. a BAM using
+ * `chr1` against a `1`-named reference) still lines up.
+ */
+export declare function makeAssembly(opts: MakeAssemblyOptions): {
+    name: string;
+    aliases: string[];
+    sequence: {
+        type: string;
+        trackId: string;
+        adapter: {
+            uri: string;
+            faiLocation?: {
+                uri: string;
+            } | undefined;
+            gziLocation?: {
+                uri: string;
+            } | undefined;
+        };
+    };
+    refNameAliases?: {
+        uri: string;
+    } | undefined;
+} | {
+    name: string;
+    aliases: string[];
+    uri: string;
+    refNameAliases?: {
+        uri: string;
+    } | undefined;
+};

package/esm/util/makeAssembly.js

@@ -0,0 +1,52 @@
+// sequence extensions core's own guesser recognizes (plugins/sequence)
+const SEQUENCE_EXT_RE = /\.(fa|fasta|fas|fna|mfa|2bit)(\.b?gz)?$/i;
+function cleanUri(uri) {
+    return uri.split(/[?#]/)[0] ?? uri;
+}
+/** true when a string names a sequence file (vs. a hub name like `hg38`) */
+export function isSequenceUri(uri) {
+    return SEQUENCE_EXT_RE.test(cleanUri(uri));
+}
+/** strip path and sequence extension: `.../hg19.fa.gz` -> `hg19` */
+export function assemblyNameFromUri(uri) {
+    const file = cleanUri(uri).split('/').at(-1) ?? uri;
+    return file.replace(SEQUENCE_EXT_RE, '');
+}
+/**
+ * Build an assembly config for a sequence file (indexed FASTA, bgzipped FASTA,
+ * or `.2bit`) — the boilerplate you'd otherwise write by hand. In the common
+ * case it is the flat `{ name, uri }` shorthand: jbrowse-core's assembly config
+ * picks the concrete adapter type (`IndexedFastaAdapter`/`BgzipFastaAdapter`/
+ * `TwoBitAdapter`) from the extension, derives the `.fai`/`.gzi` siblings, and
+ * fills in the `ReferenceSequenceTrack` at load time, so no adapter-type
+ * knowledge lives here. A non-sibling index (`faiUri`/`gziUri`) widens `sequence`
+ * to its adapter form, the only shape with a slot for the override.
+ * `refNameAliasesUri` points at a tab-separated aliases file (as UCSC publishes)
+ * so a track whose reference names differ from the sequence (e.g. a BAM using
+ * `chr1` against a `1`-named reference) still lines up.
+ */
+export function makeAssembly(opts) {
+    const { fastaUri, name = assemblyNameFromUri(fastaUri), faiUri, gziUri, aliases = [], refNameAliasesUri, } = opts;
+    return {
+        name,
+        aliases,
+        // flat { name, uri } shorthand; a non-sibling index has no home there, so it
+        // widens to the sequence.adapter form (the bare uri still infers the type)
+        ...(faiUri || gziUri
+            ? {
+                sequence: {
+                    type: 'ReferenceSequenceTrack',
+                    trackId: `${name}-ReferenceSequenceTrack`,
+                    adapter: {
+                        uri: fastaUri,
+                        ...(faiUri ? { faiLocation: { uri: faiUri } } : {}),
+                        ...(gziUri ? { gziLocation: { uri: gziUri } } : {}),
+                    },
+                },
+            }
+            : { uri: fastaUri }),
+        ...(refNameAliasesUri
+            ? { refNameAliases: { uri: refNameAliasesUri } }
+            : {}),
+    };
+}

package/esm/util/makeTrackId.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Build a track id from a track name, shared by the add-track workflows so the
+ * slug rule lives in one place. `timestamp` defaults to now but can be pinned so
+ * a batch of tracks shares it; `index` then disambiguates ids within that batch
+ * when several files share a name. Admin-vs-session is not encoded in the id —
+ * it follows from where the session stores the track (`sessionTracks` vs the
+ * base config), which is also what drives the selector's "Session tracks" group
+ * (see generateHierarchy).
+ */
+export declare function makeTrackId({ name, timestamp, index, }: {
+    name: string;
+    timestamp?: number;
+    index?: number;
+}): string;

package/esm/util/makeTrackId.js

@@ -0,0 +1,14 @@
+/**
+ * Build a track id from a track name, shared by the add-track workflows so the
+ * slug rule lives in one place. `timestamp` defaults to now but can be pinned so
+ * a batch of tracks shares it; `index` then disambiguates ids within that batch
+ * when several files share a name. Admin-vs-session is not encoded in the id —
+ * it follows from where the session stores the track (`sessionTracks` vs the
+ * base config), which is also what drives the selector's "Session tracks" group
+ * (see generateHierarchy).
+ */
+export function makeTrackId({ name, timestamp = Date.now(), index, }) {
+    const slug = name.trim().toLowerCase().replaceAll(' ', '_');
+    const suffix = index === undefined ? '' : `-${index}`;
+    return `${slug}-${timestamp}${suffix}`;
+}

package/esm/util/matchTrackId.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Test whether a `trackId` matches any of the given patterns, exactly as
+ * written. A session copy of a track carries a timestamp suffix on its id (see
+ * {@link makeTrackId} / {@link copyTrackSnapshot}), so a plain string misses
+ * the user's copies and matching them means passing a `RegExp` yourself.
+ *
+ * To scope an extension point contribution to a track, use
+ * `matchesTrackSelector` from `@jbrowse/core/ui` instead: it takes the same
+ * patterns and normalizes the copy suffix, which is the part nobody remembers.
+ */
+export declare function matchTrackId(trackId: string | undefined, patterns: (string | RegExp)[]): boolean;

package/esm/util/matchTrackId.js

@@ -0,0 +1,14 @@
+/**
+ * Test whether a `trackId` matches any of the given patterns, exactly as
+ * written. A session copy of a track carries a timestamp suffix on its id (see
+ * {@link makeTrackId} / {@link copyTrackSnapshot}), so a plain string misses
+ * the user's copies and matching them means passing a `RegExp` yourself.
+ *
+ * To scope an extension point contribution to a track, use
+ * `matchesTrackSelector` from `@jbrowse/core/ui` instead: it takes the same
+ * patterns and normalizes the copy suffix, which is the part nobody remembers.
+ */
+export function matchTrackId(trackId, patterns) {
+    return (trackId !== undefined &&
+        patterns.some(pattern => typeof pattern === 'string' ? pattern === trackId : pattern.test(trackId)));
+}

package/esm/util/measureText.d.ts

@@ -0,0 +1,24 @@
+export declare function measureText(str: unknown, fontSize?: number, fontFamily?: string): number;
+export interface MeasuredFont {
+    /** assign to `ctx.font` */
+    css: string;
+    /** width of `text` in that same font, in px */
+    measure: (text: string) => number;
+}
+/**
+ * A CSS font string and its own measurement, built from one set of inputs so a
+ * caller cannot paint in one font and reserve room in another.
+ *
+ * Two files describing one font is the normal shape — something measures to
+ * decide whether a label fits, something else sets `ctx.font` and draws it — and
+ * the two drift silently, because a label that overflows its box by a pixel
+ * looks like a label. plugin-maf drew its deletion count in `bold 10px Courier
+ * New,monospace` and measured it here without naming the family, so a monospace
+ * label was answered from the Helvetica table above: 0.55px short per digit,
+ * which its 2px of padding covered for exactly three digits and no more.
+ *
+ * `weight` reaches the CSS and not the measurement, which is right for the
+ * digits these callers measure — monospace bold and regular share an advance,
+ * and Helvetica's ten digits are one width in either.
+ */
+export declare function measuredFont(fontSize: number, fontFamily: string, weight?: string): MeasuredFont;

package/esm/util/measureText.js

@@ -0,0 +1,51 @@
+// prettier-ignore
+const widths = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.2796875, 0.2765625, 0.3546875, 0.5546875, 0.5546875, 0.8890625, 0.665625, 0.190625, 0.3328125, 0.3328125, 0.3890625, 0.5828125, 0.2765625, 0.3328125, 0.2765625, 0.3015625, 0.5546875, 0.5546875, 0.5546875, 0.5546875, 0.5546875, 0.5546875, 0.5546875, 0.5546875, 0.5546875, 0.5546875, 0.2765625, 0.2765625, 0.584375, 0.5828125, 0.584375, 0.5546875, 1.0140625, 0.665625, 0.665625, 0.721875, 0.721875, 0.665625, 0.609375, 0.7765625, 0.721875, 0.2765625, 0.5, 0.665625, 0.5546875, 0.8328125, 0.721875, 0.7765625, 0.665625, 0.7765625, 0.721875, 0.665625, 0.609375, 0.721875, 0.665625, 0.94375, 0.665625, 0.665625, 0.609375, 0.2765625, 0.3546875, 0.2765625, 0.4765625, 0.5546875, 0.3328125, 0.5546875, 0.5546875, 0.5, 0.5546875, 0.5546875, 0.2765625, 0.5546875, 0.5546875, 0.221875, 0.240625, 0.5, 0.221875, 0.8328125, 0.5546875, 0.5546875, 0.5546875, 0.5546875, 0.3328125, 0.5, 0.2765625, 0.5546875, 0.5, 0.721875, 0.5, 0.5, 0.5, 0.3546875, 0.259375, 0.353125, 0.5890625];
+const avgWidth = 0.5279276315789471;
+// Advance width of one monospace glyph, in em — the same for every character,
+// which is what makes the table above unusable for one: it is Helvetica, where
+// `i` is 0.22em and `m` is 0.94em, so a monospace string of narrow letters
+// measures far too small and one of wide letters far too large. The mainstream
+// faces cluster tightly here (Courier and DejaVu Sans Mono 0.600, Menlo 0.602,
+// Liberation Mono 0.600, Consolas 0.550), and rounding *up* is the safe
+// direction for every caller: all of them measure to reserve room.
+const MONOSPACE_EM = 0.61;
+// xref https://gist.github.com/tophtucker/62f93a4658387bb61e4510c37e2e97cf
+//
+// `fontFamily` is only consulted to pick monospace, which is a different metric
+// rather than a different table. Proportional families are all measured against
+// the Helvetica table: it is what the app renders in, and for the two other
+// families the SVG export can be asked for it is close (system-ui) or narrower
+// (serif, which over-reserves — the harmless direction).
+export function measureText(str, fontSize = 10, fontFamily) {
+    const s = String(str);
+    if (fontFamily?.includes('monospace')) {
+        return s.length * MONOSPACE_EM * fontSize;
+    }
+    let total = 0;
+    for (let i = 0, l = s.length; i < l; i++) {
+        total += widths[s.charCodeAt(i)] ?? avgWidth;
+    }
+    return total * fontSize;
+}
+/**
+ * A CSS font string and its own measurement, built from one set of inputs so a
+ * caller cannot paint in one font and reserve room in another.
+ *
+ * Two files describing one font is the normal shape — something measures to
+ * decide whether a label fits, something else sets `ctx.font` and draws it — and
+ * the two drift silently, because a label that overflows its box by a pixel
+ * looks like a label. plugin-maf drew its deletion count in `bold 10px Courier
+ * New,monospace` and measured it here without naming the family, so a monospace
+ * label was answered from the Helvetica table above: 0.55px short per digit,
+ * which its 2px of padding covered for exactly three digits and no more.
+ *
+ * `weight` reaches the CSS and not the measurement, which is right for the
+ * digits these callers measure — monospace bold and regular share an advance,
+ * and Helvetica's ten digits are one width in either.
+ */
+export function measuredFont(fontSize, fontFamily, weight) {
+    return {
+        css: `${weight ? `${weight} ` : ''}${fontSize}px ${fontFamily}`,
+        measure: text => measureText(text, fontSize, fontFamily),
+    };
+}

package/esm/util/mst-reflection.d.ts

@@ -1,11 +1,21 @@
-import type { IAnyComplexType, IAnyType, IModelReflectionPropertiesData, ISimpleType, UnionStringArray } from '@jbrowse/mobx-state-tree';
+import type { IAnyType, IModelReflectionPropertiesData, ISimpleType, UnionStringArray } from '@jbrowse/mobx-state-tree';
 export interface ILiteralType<T> extends ISimpleType<T> {
     value: T;
 }
+/**
+ * get the inner type of an MST optional, refinement, array, map, or late type
+ */
 export declare function getSubType(type: IAnyType): IAnyType;
-export declare function getUnionSubTypes(unionType: IAnyType): IAnyType[];
+/**
+ * get the type of one of the properties of the given MST model type
+ */
 export declare function getPropertyType(type: IModelReflectionPropertiesData, propertyName: string): IAnyType;
+/**
+ * get the default value out of an MST optional type
+ */
 export declare function getDefaultValue(type: IAnyType): any;
 export type IEnumerationType<T extends string> = ISimpleType<UnionStringArray<T[]>>;
-export declare function getEnumerationValues(type: IAnyComplexType): string[];
-export declare function resolveLateType(maybeLate: IAnyType): any;
+/** get the string values of an MST enumeration type */
+export declare function getEnumerationValues(type: IAnyType): string[];
+export declare function resolveLateType(maybeLate: IAnyType): IAnyType;
+export { getUnionSubtypes as getUnionSubTypes } from '@jbrowse/mobx-state-tree';

package/esm/util/mst-reflection.js

@@ -1,54 +1,55 @@
-import { isArrayType, isLateType, isMapType, isOptionalType, isUnionType, } from '@jbrowse/mobx-state-tree';
-export function getSubType(type) {
-    let t;
-    if (isOptionalType(type)) {
-        t = type._subtype || type.type;
-    }
-    else if (isArrayType(type) || isMapType(type)) {
-        t = type._subtype || type._subType || type.subType;
-    }
-    else if (typeof type.getSubType === 'function') {
-        return type.getSubType();
-    }
-    else {
-        throw new TypeError('unsupported mst type');
-    }
-    if (!t) {
-        throw new Error('failed to get subtype');
-    }
-    return t;
+import { getUnionSubtypes, isArrayType, isLateType, isMapType, isOptionalType, isUnionType, } from '@jbrowse/mobx-state-tree';
+// MST's getSubTypes() returns this sentinel string when a type can't report a
+// single subtype. It isn't exported by name, so we detect it structurally: a
+// real subtype is an IAnyType object, never a string or null.
+function isSubtype(t) {
+    return typeof t === 'object' && t !== null;
 }
-export function getUnionSubTypes(unionType) {
-    if (!isUnionType(unionType)) {
-        throw new TypeError('not an MST union type');
+/**
+ * get the inner type of an MST optional, refinement, array, map, or late type
+ */
+export function getSubType(type) {
+    // optional/refinement/late report their wrapped type here; union returns an
+    // array (handled by getUnionSubTypes) and array/map return null
+    const sub = type.getSubTypes();
+    if (isSubtype(sub)) {
+        return sub;
     }
-    const t = unionType._types ||
-        unionType.types ||
-        getSubType(unionType)._types ||
-        getSubType(unionType).types;
-    if (!t) {
-        throw new Error('failed to extract subtypes from mst union');
+    if (isArrayType(type) || isMapType(type)) {
+        return type.getChildType();
     }
-    return t;
+    throw new TypeError('unsupported mst type');
 }
+/**
+ * get the type of one of the properties of the given MST model type
+ */
 export function getPropertyType(type, propertyName) {
     return type.properties[propertyName];
 }
+/**
+ * get the default value out of an MST optional type
+ */
 export function getDefaultValue(type) {
     if (!isOptionalType(type)) {
         throw new TypeError('type must be an optional type');
     }
-    return type._defaultValue || type.defaultValue;
+    // isOptionalType is a same-type guard, so narrow to the optional interface
+    // that publishes getDefaultInstanceOrSnapshot
+    return type.getDefaultInstanceOrSnapshot();
 }
+/** get the string values of an MST enumeration type */
 export function getEnumerationValues(type) {
-    const subtypes = getUnionSubTypes(type);
+    const subtypes = getUnionSubtypes(type);
+    // the subtypes should all be literals with a value member
     return subtypes.map(t => t.value);
 }
 export function resolveLateType(maybeLate) {
     if (!isUnionType(maybeLate) &&
         !isArrayType(maybeLate) &&
         isLateType(maybeLate)) {
-        return maybeLate.getSubType();
+        const sub = maybeLate.getSubTypes();
+        return isSubtype(sub) ? sub : maybeLate;
     }
     return maybeLate;
 }
+export { getUnionSubtypes as getUnionSubTypes } from '@jbrowse/mobx-state-tree';

package/esm/util/mstUtils.d.ts

@@ -0,0 +1,89 @@
+import type PluginManager from '../PluginManager.ts';
+import type { AbstractDisplayModel, AbstractSessionModel, AbstractTrackModel, AbstractViewModel } from './types/index.ts';
+import type { AssemblyHost, RenderingServices } from './types/renderingServices.ts';
+import type { IAnyStateTreeNode } from '@jbrowse/mobx-state-tree';
+export { findParentThat, findParentThatIs, getRpcSessionId, } from './parentWalk.ts';
+/**
+ * #api core/util
+ * Returns the JBrowse session model for any node in the state tree. Throws if
+ * the node has no session ancestor.
+ */
+export declare function getSession(node: IAnyStateTreeNode): AbstractSessionModel;
+/**
+ * #api core/util
+ * Returns the view model that contains the given node. Throws if the node has no
+ * containing view.
+ */
+export declare function getContainingView(node: IAnyStateTreeNode): AbstractViewModel;
+/**
+ * #api core/util
+ * Returns the track model that contains the given node. Throws if the node has
+ * no containing track.
+ */
+export declare function getContainingTrack(node: IAnyStateTreeNode): AbstractTrackModel;
+/**
+ * #api core/util
+ * Returns the display model that contains the given node. Throws if the node has
+ * no containing display.
+ */
+export declare function getContainingDisplay(node: IAnyStateTreeNode): AbstractDisplayModel;
+/**
+ * #api core/util
+ * The host's assembly manager, for a module that resolves names and nothing
+ * else.
+ *
+ * Unlike the accessors in `sessionServices.ts` this one buys the caller no
+ * smaller type graph — an `AssemblyManager` is an MST model a `PluginManager`
+ * built, so naming it costs what naming a session costs. It is here to say
+ * which service is wanted, and because that cost is the finding: the assembly
+ * manager is the one thing on `AbstractSessionModel` a third-party host cannot
+ * simply implement.
+ */
+export declare function getAssemblyHost(node: IAnyStateTreeNode): AssemblyHost;
+/**
+ * #api core/util
+ * Everything a display needs of its host in order to draw a region: the
+ * assemblies, the RPC entry point and the colors.
+ */
+export declare function getRenderingServices(node: IAnyStateTreeNode): RenderingServices;
+/**
+ * #api core/util
+ * Resolve user-authored refName text against the assembly of the view
+ * containing `node` — the one normalization layer, which resolves aliases and
+ * casing together. Falls back to the input when the assembly is absent or its
+ * aliases have not loaded.
+ *
+ * Keyed off the VIEW's assembly rather than the track's, because the view is
+ * what the comparison is against: displayed regions, loaded regions and blocks
+ * all carry the refNames the view laid out.
+ *
+ * Reach for this wherever a refName a *person* wrote is about to be compared
+ * against regions, features or blocks, which carry the assembly's canonical
+ * name. A refName a display copied off a region is canonical already and needs
+ * nothing; one that arrived in a session spec, a config slot or a URL is
+ * whatever the author read out of the location box.
+ *
+ * Skipping it fails silently and, worse, assembly-dependently: `chr12` matches
+ * on an assembly canonicalized `chr12` and matches nothing on one canonicalized
+ * `12`, so the same spec key works on one config and quietly does nothing on
+ * the next, with no error for anyone to act on.
+ *
+ * Resolves through `getCanonicalRefName2`, whose fallback is what keeps a spec
+ * read before the alias file has loaded from throwing — and the getters that
+ * read user specs do run from the first render.
+ *
+ * Takes a refName, not a spec that might hold one: the resolver reads
+ * `refName.toLowerCase()`, so anything else throws once the aliases are there,
+ * and a caller reading an untyped `frozen` slot has to establish that it names
+ * a refName at all before this is the right question to ask of it.
+ */
+export declare function canonicalizeViewRefName(node: IAnyStateTreeNode, refName: string): string;
+/**
+ * #api core/util
+ * Returns the MST environment for a node, which carries the `pluginManager`.
+ */
+export declare function getEnv(obj: IAnyStateTreeNode): {
+    pluginManager: PluginManager;
+};
+export declare function hashCode(str: string): number;
+export declare function objectHash(obj: object): string;