@jbrowse/product-core 4.2.1 → 5.0.0-beta.1

package/esm/pruneUnbuildableNodes.js

@@ -0,0 +1,568 @@
+import { pluggableElementTypeGroups } from '@jbrowse/core/PluginManager';
+import { getPropertyMembers, getUnionSubtypes, isArrayType, isMapType, isModelType, isReferenceType, isType, isUnionType, } from '@jbrowse/mobx-state-tree';
+import { isRecord } from './snapshotUtils.js';
+const HELD_NODES_KEY = 'heldForMissingPlugins';
+// The registered elements a `pluggableMstType` union is built from. Mirrors
+// that function's own filter: a registered type whose `stateModel` is not a
+// model type is left out of the union, so a snapshot naming it fails the same
+// way one naming nothing at all does.
+//
+// Typed structurally rather than as `PluggableElementBase`, which is not a
+// published `@jbrowse/core` subpath — adding one just to name a type here would
+// widen the plugin ABI for nothing.
+function buildableElements(pluginManager, group) {
+    return pluginManager.getElementTypesInGroup(group).filter(t => {
+        const { stateModel } = t;
+        return isType(stateModel) && isModelType(stateModel);
+    });
+}
+// optional/stripDefault/late/snapshotProcessor all report the type they wrap,
+// so one loop reaches the array, map, model or union a property really declares.
+function unwrapType(type) {
+    let current = type;
+    for (let i = 0; i < 16; i++) {
+        const sub = current.getSubTypes();
+        if (!sub ||
+            typeof sub !== 'object' ||
+            Array.isArray(sub) ||
+            sub === current) {
+            return current;
+        }
+        current = sub;
+    }
+    return current;
+}
+function containerType(type) {
+    if (isUnionType(type)) {
+        for (const member of getUnionSubtypes(type)) {
+            const found = containerType(unwrapType(member));
+            if (found) {
+                return found;
+            }
+        }
+        return undefined;
+    }
+    return isArrayType(type) || isMapType(type) ? type : undefined;
+}
+// One prune's view of the plugin manager. The unions are built on first use, so
+// a session naming only registered types — every session this build produced
+// itself — never constructs one.
+class Registry {
+    pluginManager;
+    names = new Map();
+    aliases = new Map();
+    unions = new Map();
+    groups;
+    discriminants = new Map();
+    constructor(pluginManager) {
+        this.pluginManager = pluginManager;
+    }
+    /**
+     * The group a container holds, or undefined for a container of anything else.
+     * Identified by member identity rather than by the union object, which
+     * `pluggableMstType` rebuilds on every call: the members *are* the registered
+     * `stateModel`s.
+     */
+    groupOf(elementType) {
+        if (isReferenceType(elementType) || !isUnionType(elementType)) {
+            return undefined;
+        }
+        this.groups ??= new Map(pluggableElementTypeGroups.flatMap(group => buildableElements(this.pluginManager, group).map(t => [t.stateModel, group])));
+        for (const member of getUnionSubtypes(elementType)) {
+            const group = this.groups.get(member);
+            if (group) {
+                return group;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * The name this build registers the node's type under — itself, or the
+     * element that declares it as an alias — or undefined if neither does.
+     */
+    canonicalName(group, type) {
+        return this.namesFor(group).has(type)
+            ? type
+            : this.aliasesFor(group).get(type);
+    }
+    /**
+     * The union member a node's type names, so the walk can descend into what
+     * that concrete model declares. A type the registry cannot name has no
+     * member to find; the node is then judged whole by `accepts`.
+     */
+    memberFor(elementType, type) {
+        for (const member of getUnionSubtypes(elementType)) {
+            if (this.discriminantOf(member) === type) {
+                return member;
+            }
+        }
+        return undefined;
+    }
+    /** Whether the real MST union takes this snapshot. */
+    accepts(node, group) {
+        let union = this.unions.get(group);
+        if (!union) {
+            union = this.pluginManager.pluggableMstType(group, 'stateModel');
+            this.unions.set(group, union);
+        }
+        return union.is(node);
+    }
+    discriminantOf(member) {
+        if (this.discriminants.has(member)) {
+            return this.discriminants.get(member);
+        }
+        const literal = isModelType(member)
+            ? getPropertyMembers(member).properties.type
+            : undefined;
+        const value = typeof literal?.value === 'string' ? literal.value : undefined;
+        this.discriminants.set(member, value);
+        return value;
+    }
+    namesFor(group) {
+        let names = this.names.get(group);
+        if (!names) {
+            names = new Set(buildableElements(this.pluginManager, group).map(t => t.name));
+            this.names.set(group, names);
+        }
+        return names;
+    }
+    aliasesFor(group) {
+        let aliases = this.aliases.get(group);
+        if (!aliases) {
+            aliases = new Map(buildableElements(this.pluginManager, group).flatMap(t => t.aliases?.map(alias => [alias, t.name]) ?? []));
+            this.aliases.set(group, aliases);
+        }
+        return aliases;
+    }
+}
+function describe(node, group) {
+    const type = isRecord(node) ? node.type : undefined;
+    return { group, type: typeof type === 'string' ? type : 'unknown' };
+}
+function readId(node) {
+    const id = isRecord(node) ? node.id : undefined;
+    return typeof id === 'string' ? id : undefined;
+}
+function readHeld(snapshot) {
+    const held = snapshot[HELD_NODES_KEY];
+    return Array.isArray(held) ? held : [];
+}
+function anchorKey(group, parent) {
+    return `${group}/${parent ?? ''}`;
+}
+function collectIds(value, into) {
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            collectIds(item, into);
+        }
+    }
+    else if (isRecord(value)) {
+        if (typeof value.id === 'string') {
+            into.add(value.id);
+        }
+        for (const child of Object.values(value)) {
+            collectIds(child, into);
+        }
+    }
+}
+class Walk {
+    registry;
+    dropped = [];
+    held = [];
+    /** ids of nodes taken out, so a reference container can drop the danglers */
+    removed = new Set();
+    pending = new Map();
+    // a node restored on this same call is walked like any other, so its own
+    // unbuildable children come out again — but the user is told nothing, or a
+    // held track whose displays are still missing warns on every load forever.
+    silence = 0;
+    emptied = 0;
+    constructor(registry) {
+        this.registry = registry;
+    }
+    // counted rather than flagged, so the track that owns a display container
+    // reads a difference across its own walk and needs no save-and-restore
+    emptiedDisplays() {
+        this.emptied++;
+    }
+    emptiedDisplayCount() {
+        return this.emptied;
+    }
+    offer(entry) {
+        const key = anchorKey(entry.held.group, entry.held.parent);
+        const list = this.pending.get(key);
+        if (list) {
+            list.push(entry);
+        }
+        else {
+            this.pending.set(key, [entry]);
+        }
+    }
+    take(group, parent) {
+        const key = anchorKey(group, parent);
+        const taken = this.pending.get(key);
+        this.pending.delete(key);
+        return taken ?? [];
+    }
+    /**
+     * Entries no container claimed. A node whose subtree the walk descended into
+     * is one the registry can name, and so one it admits — the single exception
+     * is a track the cascade takes, which needs its display list to have come out
+     * empty and so to have claimed nothing. Nothing a container takes can
+     * therefore be discarded with the node around it.
+     */
+    unplaced() {
+        return new Set([...this.pending.values()].flat().map(p => p.held));
+    }
+    drop(node) {
+        if (this.silence === 0) {
+            this.dropped.push(node);
+        }
+    }
+    quietly(quiet, run) {
+        this.silence += quiet ? 1 : 0;
+        try {
+            return run();
+        }
+        finally {
+            this.silence -= quiet ? 1 : 0;
+        }
+    }
+}
+/**
+ * Children first, then the node itself: the union's `is` validates a whole
+ * subtree, so a view still holding an unbuildable track would be refused as a
+ * whole and taken down with it. Returns undefined for a node this build cannot
+ * hold, which the container then holds whole and unpruned.
+ */
+function pruneNode(node, group, elementType, parent, walk) {
+    if (!isRecord(node)) {
+        // MST reports a node with no readable type precisely; guessing at a repair
+        // here would hide it
+        return node;
+    }
+    const type = node.type;
+    if (typeof type !== 'string') {
+        return node;
+    }
+    const canonical = walk.registry.canonicalName(group, type);
+    const named = canonical === undefined || canonical === type
+        ? node
+        : { ...node, type: canonical };
+    // only for a name the registry knows, which is exactly the set `accepts`
+    // waves through: a node whose subtree the walk descends into is one it can
+    // put back
+    const model = canonical === undefined
+        ? undefined
+        : walk.registry.memberFor(elementType, canonical);
+    const emptied = walk.emptiedDisplayCount();
+    const pruned = model
+        ? walkModel(model, named, readId(named) ?? parent, walk)
+        : named;
+    const cascaded = group === 'track' && walk.emptiedDisplayCount() > emptied;
+    // A display type can go missing while its track type stays — a plugin
+    // contributing one more display to an existing track type is the ordinary
+    // case. A track left with none of them goes too: an empty `displays` array is
+    // valid MST, so nothing downstream would refuse it, and `activeDisplay` reads
+    // `displays[0]` on the promise that a shown track always has one.
+    if (cascaded) {
+        walk.drop({ ...describe(node, group), cascade: true });
+        return undefined;
+    }
+    // a registered name is admitted without asking the union, so a **malformed**
+    // snapshot of a type this build does have still reaches MST and throws there
+    if (canonical !== undefined || walk.registry.accepts(pruned, group)) {
+        return pruned;
+    }
+    walk.drop(describe(node, group));
+    return undefined;
+}
+// Returns the same list by identity when nothing moved, so a session this build
+// produced itself comes back out of the whole walk as the object that went in.
+function pruneArray(value, group, elementType, parent, walk) {
+    const list = Array.isArray(value) ? value : undefined;
+    const restoring = walk.take(group, parent);
+    if (!list && restoring.length === 0) {
+        return undefined;
+    }
+    // ascending index, so a run of restores into one list lands in the order it
+    // came out of it
+    const merged = (list ?? []).map(node => ({ node, restored: false }));
+    for (const entry of restoring.sort((a, b) => (a.held.index ?? 0) - (b.held.index ?? 0))) {
+        merged.splice(Math.min(entry.held.index ?? merged.length, merged.length), 0, {
+            node: entry.snapshot,
+            restored: true,
+        });
+    }
+    const out = [];
+    let changed = merged.length !== (list?.length ?? 0);
+    for (const [index, { node, restored }] of merged.entries()) {
+        const mark = walk.held.length;
+        const pruned = walk.quietly(restored, () => pruneNode(node, group, elementType, parent, walk));
+        if (pruned !== undefined || !isRecord(node)) {
+            changed ||= pruned !== node;
+            out.push(pruned);
+            continue;
+        }
+        // held whole and unpruned, and the entries its own children produced are
+        // rolled back — so a dropped view's tracks are inside the copy of the view,
+        // not separate entries anchored to a view that is no longer in the tree
+        walk.held.length = mark;
+        walk.held.push({ group, parent, index, snapshot: node });
+        const id = readId(node);
+        if (id !== undefined) {
+            walk.removed.add(id);
+        }
+        changed = true;
+    }
+    // read by the track this container belongs to: a track left with none of its
+    // displays goes too
+    if (group === 'display' && out.length === 0 && (list?.length ?? 0) > 0) {
+        walk.emptiedDisplays();
+    }
+    return changed || !list ? out : list;
+}
+function pruneMap(value, group, elementType, parent, walk) {
+    const map = isRecord(value) ? value : undefined;
+    const restoring = walk.take(group, parent);
+    if (!map && restoring.length === 0) {
+        return undefined;
+    }
+    const out = {};
+    let changed = false;
+    for (const [key, node] of Object.entries(map ?? {})) {
+        const mark = walk.held.length;
+        const pruned = pruneNode(node, group, elementType, parent, walk);
+        if (pruned !== undefined || !isRecord(node)) {
+            changed ||= pruned !== node;
+            out[key] = pruned;
+            continue;
+        }
+        walk.held.length = mark;
+        walk.held.push({ group, key, parent, snapshot: node });
+        walk.removed.add(readId(node) ?? key);
+        changed = true;
+    }
+    for (const entry of restoring) {
+        const key = entry.held.key;
+        if (key === undefined) {
+            // `take` has already claimed it, and a map places by key alone — so
+            // holding it again is the only thing here that is not a silent delete
+            walk.held.push(entry.held);
+            changed = true;
+            continue;
+        }
+        const mark = walk.held.length;
+        const pruned = walk.quietly(true, () => pruneNode(entry.snapshot, group, elementType, parent, walk));
+        if (pruned === undefined) {
+            walk.held.length = mark;
+            walk.held.push({ group, key, parent, snapshot: entry.snapshot });
+        }
+        else {
+            out[key] = pruned;
+        }
+        changed = true;
+    }
+    return changed || !map ? out : map;
+}
+function pruneContainer(type, elementType, group, value, parent, walk) {
+    return isMapType(type)
+        ? pruneMap(value, group, elementType, parent, walk)
+        : pruneArray(value, group, elementType, parent, walk);
+}
+// The model a record's snapshot is an instance of. A union that is not a
+// pluggable one — `types.maybe(SomeModel)` — still has to resolve to the member
+// the snapshot names, or the walk stops at a node whose children it could have
+// reached.
+function concreteModel(type, value) {
+    if (isUnionType(type)) {
+        const members = getUnionSubtypes(type).filter(m => isModelType(m) && !isUnionType(m));
+        if (members.length === 1) {
+            return members[0];
+        }
+        return members.find(m => getPropertyMembers(m).properties.type?.value === value.type);
+    }
+    return isModelType(type) ? type : undefined;
+}
+function walkValue(declared, value, parent, walk) {
+    const type = unwrapType(declared);
+    const container = containerType(type);
+    if (container) {
+        const elementType = unwrapType(container.getChildType());
+        const group = walk.registry.groupOf(elementType);
+        if (group) {
+            return (pruneContainer(container, elementType, group, value, parent, walk) ??
+                value);
+        }
+        if (Array.isArray(value)) {
+            const out = value.map(item => walkValue(elementType, item, parent, walk));
+            return out.some((item, i) => item !== value[i]) ? out : value;
+        }
+        if (isRecord(value)) {
+            const entries = Object.entries(value).map(([key, item]) => [key, walkValue(elementType, item, parent, walk)]);
+            return entries.some(([key, item]) => item !== value[key])
+                ? Object.fromEntries(entries)
+                : value;
+        }
+        return value;
+    }
+    if (isRecord(value)) {
+        const model = concreteModel(type, value);
+        if (model) {
+            return walkModel(model, value, readId(value) ?? parent, walk);
+        }
+    }
+    return value;
+}
+/**
+ * Every property the model declares, not every key the snapshot has: a
+ * container whose key MST stripped — `widgets` is `stripDefault(map(...), {})`,
+ * so an empty drawer has no key at all — still has to be reached, or a held
+ * widget has nowhere to come back to.
+ */
+function walkModel(model, node, parent, walk) {
+    const { properties } = getPropertyMembers(model);
+    let out = node;
+    const write = (key, value) => {
+        if (out === node) {
+            out = { ...node };
+        }
+        out[key] = value;
+    };
+    const references = [];
+    for (const [key, declared] of Object.entries(properties)) {
+        const type = unwrapType(declared);
+        const container = containerType(type);
+        if (container) {
+            const elementType = unwrapType(container.getChildType());
+            if (isReferenceType(elementType)) {
+                references.push(key);
+                continue;
+            }
+            const group = walk.registry.groupOf(elementType);
+            if (group) {
+                const next = pruneContainer(container, elementType, group, node[key], parent, walk);
+                if (next !== undefined && next !== node[key]) {
+                    write(key, next);
+                }
+                continue;
+            }
+        }
+        const value = node[key];
+        if (value === undefined) {
+            continue;
+        }
+        const next = walkValue(type, value, parent, walk);
+        if (next !== value) {
+            write(key, next);
+        }
+    }
+    // After the value properties, so a reference into a sibling container sees
+    // what that container dropped. `activeWidgets` holds safeReferences, which do
+    // drop themselves when their target is gone, but only once something resolves
+    // them — clearing them here keeps the pruned snapshot internally consistent
+    // rather than relying on that. Deliberately not restored alongside their
+    // target: a drawer panel that comes back closed costs a click, where a widget
+    // that comes back missing costs the work in it.
+    for (const key of references) {
+        const value = out[key];
+        if (!isRecord(value) || walk.removed.size === 0) {
+            continue;
+        }
+        const entries = Object.entries(value).filter(([, id]) => typeof id !== 'string' || !walk.removed.has(id));
+        if (entries.length !== Object.keys(value).length) {
+            write(key, Object.fromEntries(entries));
+        }
+    }
+    return out;
+}
+/**
+ * Takes the session-snapshot nodes whose pluggable type this plugin manager
+ * cannot build out of the tree and holds them under `heldForMissingPlugins`,
+ * and puts back the ones already held that it now can build — in one walk of
+ * the session type, so the two can never disagree about where a node lives.
+ * Returns the snapshot unchanged (by identity) when there is nothing to do
+ * either way, which is every session this build produced itself.
+ */
+export function pruneUnbuildableNodes(snapshot, pluginManager, sessionModelType) {
+    const registry = new Registry(pluginManager);
+    const model = concreteModel(unwrapType(sessionModelType), snapshot);
+    if (!model) {
+        return { snapshot, dropped: [] };
+    }
+    const walk = new Walk(registry);
+    const incoming = readHeld(snapshot);
+    const restorable = new Set();
+    for (const entry of incoming) {
+        // canonicalized on the way back in, so a held node whose type has since
+        // been renamed comes back under the name this build registers
+        const type = isRecord(entry.snapshot) ? entry.snapshot.type : undefined;
+        if (typeof type !== 'string') {
+            continue;
+        }
+        const canonical = registry.canonicalName(entry.group, type);
+        if (canonical === undefined &&
+            !registry.accepts(entry.snapshot, entry.group)) {
+            continue;
+        }
+        restorable.add(entry);
+        walk.offer({
+            held: entry,
+            snapshot: canonical === undefined || canonical === type
+                ? entry.snapshot
+                : { ...entry.snapshot, type: canonical },
+        });
+    }
+    const pruned = walkModel(model, snapshot, undefined, walk);
+    // An entry whose container the recipient deleted is collected here rather than
+    // riding along in every autosave and every share link forever — `HeldNode`
+    // says such a node is not restorable and is not meant to be.
+    //
+    // The test is that the container is GONE, never that the walk failed to reach
+    // the anchor. `ElementId` is `types.optional(types.identifier, …)`, so a
+    // container the session was authored without an id for is anchored by its
+    // parent instead, MST mints it one, and the autosave then answers a different
+    // key — which reads as a deletion and loses the node the message just promised
+    // back. A container that is itself held counts as present: its snapshot is in
+    // this session too, just not in the tree.
+    const presentIds = new Set();
+    if (incoming.length > 0) {
+        collectIds(pruned, presentIds);
+        for (const entry of walk.held) {
+            collectIds(entry.snapshot, presentIds);
+        }
+    }
+    const unplaced = walk.unplaced();
+    const stillHeld = incoming.filter(entry => (!restorable.has(entry) || unplaced.has(entry)) &&
+        (entry.parent === undefined || presentIds.has(entry.parent)));
+    const held = [...stillHeld, ...walk.held];
+    if (pruned === snapshot &&
+        walk.held.length === 0 &&
+        stillHeld.length === incoming.length) {
+        return { snapshot, dropped: walk.dropped };
+    }
+    const out = { ...pruned };
+    if (held.length > 0) {
+        out[HELD_NODES_KEY] = held;
+    }
+    else {
+        delete out[HELD_NODES_KEY];
+    }
+    return { snapshot: out, dropped: walk.dropped };
+}
+/**
+ * The user-facing summary of one prune, or undefined when nothing was dropped.
+ * Names the missing types rather than counting nodes: the plugin a person has to
+ * install is the actionable half, and one missing display type can take several
+ * nodes with it. Says what a person can do about it, because the nodes are not
+ * gone — they ride along under `heldForMissingPlugins` and come back the moment
+ * a build that has the plugin opens the session.
+ */
+export function describeUnbuildableNodes(dropped) {
+    const types = [
+        ...new Set(dropped.flatMap(d => (d.cascade ? [] : [d.type]))),
+    ].join(', ');
+    return types
+        ? `Kept but not shown, pending plugins this JBrowse does not have: ${types}. Install them and reload to get them back.`
+        : undefined;
+}

package/esm/resolveAssemblies.d.ts

@@ -0,0 +1,44 @@
+export type AssemblyConfig = Record<string, unknown>;
+export interface TextSearchAdapterConfig {
+    textSearchAdapterId: string;
+    [key: string]: unknown;
+}
+type SearchAdapters = TextSearchAdapterConfig[] | undefined;
+/**
+ * The shapes an assembly can take, discriminated at resolve time: a sequence
+ * file URL (`'.../hg38.fa.gz'`, `.2bit`, ...) built into an assembly via
+ * `makeAssembly`; a hub name (`'hg38'`, `'GCF_...'`) fetched from jbrowse.org;
+ * a full hub config (as `fetchHub` returns); or a bare assembly config (e.g.
+ * from `makeAssembly`) — the latter two both being plain config objects.
+ */
+export type AssemblyInput = string | AssemblyConfig;
+export interface ResolvedAssembly {
+    assembly: AssemblyConfig;
+    /** whatever search adapters the hub this came from carried */
+    aggregateTextSearchAdapters?: SearchAdapters;
+}
+export interface ResolvedAssemblies {
+    assemblies: AssemblyConfig[];
+    /** whatever search adapters the resolved hubs carried, merged */
+    aggregateTextSearchAdapters?: SearchAdapters;
+}
+/** One assembly in any of the four accepted shapes. */
+export declare function resolveAssembly(input: AssemblyInput): Promise<ResolvedAssembly>;
+/**
+ * Resolve a whole list of assembly inputs, so a multi-assembly product takes
+ * the same vocabulary the single-view one does — `['hg38', 'mm39']` as readily
+ * as two hand-written configs.
+ *
+ * Exported because the resolution is async and `createApp` is not: an engine
+ * that resolved its own genomes would have to hand back a controller whose
+ * `viewState` is undefined until the fetches land, which is most of what makes
+ * the single-view controller four times the size. A host builds its options
+ * asynchronously already (runtime plugins), so this belongs in that step.
+ *
+ * Without it every host reimplements it — jbrowse-anywidget carried a
+ * line-for-line Python translation of core's hubUrl/fetchHub/addRelativeUris,
+ * GenArk regex and all, purely because the multi-view product could not take a
+ * hub name.
+ */
+export declare function resolveAssemblies(inputs: AssemblyInput[]): Promise<ResolvedAssemblies>;
+export {};

package/esm/resolveAssemblies.js

@@ -0,0 +1,55 @@
+import { fetchHub } from '@jbrowse/core/util/fetchHub';
+import { isSequenceUri, makeAssembly } from '@jbrowse/core/util/makeAssembly';
+// A hub's config arrives off the network, so its search adapters are untyped
+// there. Keep the ones that carry the id everything downstream references,
+// rather than casting the lot: an entry without one cannot be referred to by a
+// config anyway, so dropping it loses nothing and keeps this cast-free.
+function searchAdaptersOf(hub) {
+    const found = (hub.aggregateTextSearchAdapters ?? []).filter((a) => typeof a.textSearchAdapterId === 'string');
+    return found.length ? found : undefined;
+}
+function fromHubConfig(hub) {
+    const assembly = hub.assemblies?.[0];
+    if (!assembly) {
+        throw new Error('hub config has no assemblies');
+    }
+    return { assembly, aggregateTextSearchAdapters: searchAdaptersOf(hub) };
+}
+/** One assembly in any of the four accepted shapes. */
+export async function resolveAssembly(input) {
+    if (typeof input === 'string') {
+        return isSequenceUri(input)
+            ? { assembly: makeAssembly({ fastaUri: input }) }
+            : fromHubConfig(await fetchHub(input));
+    }
+    else if ('assemblies' in input) {
+        return fromHubConfig(input);
+    }
+    else {
+        return { assembly: input };
+    }
+}
+/**
+ * Resolve a whole list of assembly inputs, so a multi-assembly product takes
+ * the same vocabulary the single-view one does — `['hg38', 'mm39']` as readily
+ * as two hand-written configs.
+ *
+ * Exported because the resolution is async and `createApp` is not: an engine
+ * that resolved its own genomes would have to hand back a controller whose
+ * `viewState` is undefined until the fetches land, which is most of what makes
+ * the single-view controller four times the size. A host builds its options
+ * asynchronously already (runtime plugins), so this belongs in that step.
+ *
+ * Without it every host reimplements it — jbrowse-anywidget carried a
+ * line-for-line Python translation of core's hubUrl/fetchHub/addRelativeUris,
+ * GenArk regex and all, purely because the multi-view product could not take a
+ * hub name.
+ */
+export async function resolveAssemblies(inputs) {
+    const resolved = await Promise.all(inputs.map(resolveAssembly));
+    const adapters = resolved.flatMap(r => r.aggregateTextSearchAdapters ?? []);
+    return {
+        assemblies: resolved.map(r => r.assembly),
+        aggregateTextSearchAdapters: adapters.length ? adapters : undefined,
+    };
+}