@jax-data-science/sci-image-visualizer 0.8.3 → 0.10.0

package/esm2022/lib/spatial/embedding-compute-coordinator.mjs

@@ -0,0 +1,239 @@
+import { BehaviorSubject } from 'rxjs';
+import { EmbeddingComputeRun } from './embedding-compute';
+import { Supersede } from '../util/supersede';
+const IDLE = { running: false, fraction: null, backend: null, message: null, error: null };
+/**
+ * Largest dataset a t-SNE is offered for in the browser.
+ *
+ * t-SNE is O(N²) per iteration — vectorised on the GPU, but not approximated — so the cost
+ * is quadratic in observations. Measured end to end in Firefox on WebGPU: 2,688 points took
+ * 95 s. That scales to roughly five and a half minutes at this threshold, and to about 76
+ * minutes at seqFISH's 19,416, which was also measured offline.
+ *
+ * Past this the option is WITHDRAWN rather than offered with a warning. An hour-long job
+ * started from a button is not a choice a reader can meaningfully consent to in a dialog,
+ * and a t-SNE that large belongs in the offline pipeline, where it can run once and be
+ * served to everyone.
+ */
+export const BROWSER_TSNE_MAX_OBSERVATIONS = 5000;
+/** Measured anchor for the estimate: seconds for 2,688 points on WebGPU. */
+const TSNE_SECONDS_AT = { seconds: 95, observations: 2688 };
+/**
+ * A t-SNE the dataset does not publish, offered so it can be computed here.
+ *
+ * A dropped-in `.h5ad` typically carries one UMAP and a PCA, and no t-SNE — the two views
+ * answer different questions, so having only one is a real gap. Computing it needs no
+ * expression data: t-SNE runs on the PCA scores, which is why this can happen in the
+ * browser at all while PCA cannot.
+ */
+export const COMPUTABLE_EMBEDDINGS = [
+    { name: 'local:tsne', label: 't-SNE (compute)', dims: 2, derived: true },
+    { name: 'local:tsne3d', label: 't-SNE 3D (compute)', dims: 3, derived: true },
+];
+/** The menu suffix that says a click will start work; not part of the name. */
+const COMPUTE_SUFFIX = ' (compute)';
+/** Roughly how long a t-SNE of `n` observations takes, in seconds, from the measured anchor. */
+export function tsneEstimateSeconds(n) {
+    const { seconds, observations } = TSNE_SECONDS_AT;
+    return Math.max(1, Math.round(seconds * (n / observations) ** 2));
+}
+/** A duration as something to put on a button: `~42s`, `~6 min`. */
+export function estimateLabel(seconds) {
+    if (seconds < 90)
+        return `~${seconds}s`;
+    return `~${Math.round(seconds / 60)} min`;
+}
+/**
+ * The browser-side embedding computation behind the charts' Embedding tab: which
+ * embeddings to offer for a dataset, the t-SNE run itself (PCA scores from the port, then a
+ * worker), its progress, and the results computed this session.
+ *
+ * A run is several awaits long — the PCA scores arrive over HTTP, then the worker takes a
+ * minute or more — and the dataset can change at any of them, including before the run
+ * exists to be terminated. Every await is checked against a {@link Supersede} that a
+ * dataset switch ({@link setDataset}) or teardown ({@link abandon}) cancels, so the scores
+ * fetched for one dataset are never embedded and drawn over another's observations.
+ *
+ * Plain class: the owner renders {@link state} (or {@link state$}).
+ */
+export class EmbeddingComputeCoordinator {
+    constructor() {
+        this.state$ = new BehaviorSubject(IDLE);
+        /** True when a t-SNE is missing but the dataset is too big to embed here. */
+        this.tooLarge = false;
+        /** Observations in the live dataset, kept for the cost estimate. */
+        this.observationCount = 0;
+        /** Coordinates computed in this browser, by name. Not persisted: a reload recomputes. */
+        this.computed = new Map();
+        /** The live run, when one is going. */
+        this.run = null;
+        this.load = new Supersede();
+    }
+    get state() {
+        return this.state$.value;
+    }
+    get running() {
+        return !!this.run?.running;
+    }
+    /**
+     * A new dataset: drop everything computed or computing for the previous one, and return
+     * the embeddings to offer — the published ones, plus a t-SNE to compute where the dataset
+     * has a PCA to embed, no t-SNE of its own, and is small enough. Otherwise the menu would
+     * advertise work that cannot start, or duplicate what is already served.
+     */
+    setDataset(published, observationCount) {
+        this.computed.clear();
+        this.abandon();
+        const hasPca = published.some((e) => /pca/i.test(e.label ?? e.name));
+        const hasTsne = published.some((e) => /tsne|t-sne/i.test(e.label ?? e.name));
+        this.observationCount = observationCount;
+        this.tooLarge = hasPca && !hasTsne && observationCount > BROWSER_TSNE_MAX_OBSERVATIONS;
+        return hasPca && !hasTsne && !this.tooLarge ? [...published, ...COMPUTABLE_EMBEDDINGS] : [...published];
+    }
+    /** Whether `meta` is one this browser would have to compute. */
+    isComputable(meta) {
+        return !!meta && meta.name.startsWith('local:');
+    }
+    /** Whether `meta` has already been computed this session. */
+    isComputed(meta) {
+        return !!meta && this.computed.has(meta.name);
+    }
+    /** The coordinates computed for `name`, if any. */
+    result(name) {
+        return this.computed.get(name);
+    }
+    /** Roughly how long a run would take here, in seconds. Shown before the click: a progress
+     *  bar tells you a job is going; only an estimate tells you whether to start it. */
+    get estimateSeconds() {
+        return tsneEstimateSeconds(this.observationCount);
+    }
+    /** {@link estimateSeconds} as something to put on a button. */
+    get estimateLabel() {
+        return estimateLabel(this.estimateSeconds);
+    }
+    /** Why the option is absent, when a dataset is past the threshold. */
+    get tooLargeNote() {
+        return (`t-SNE is not offered here for ${this.observationCount.toLocaleString()} observations — it is ` +
+            `quadratic, so it would take roughly ${this.estimateLabel} in the browser. ` +
+            'Compute it offline and serve it with the dataset.');
+    }
+    /**
+     * Compute `meta` here, in a worker, from the dataset's PCA among `embeddings`.
+     *
+     * The PCA scores come from the port as an ordinary embedding — the server derives them,
+     * because PCA needs the whole expression matrix (185 MB for a Visium dataset) while
+     * t-SNE needs only the scores (0.51 MB). Sending the matrix to the browser to save a few
+     * seconds of arithmetic would be a far slower answer.
+     *
+     * @returns the coordinates, to draw — or null when there is nothing to draw: cancelled,
+     *   abandoned, failed (see {@link state}), or already running.
+     */
+    async start(meta, embeddings, getEmbedding) {
+        if (this.running)
+            return null;
+        this.patch({ ...IDLE });
+        // Every early return and every await below is checked against this. `run` is held
+        // locally as well as on the instance: after an await `this.run` may already be a
+        // newer run's, and clearing or terminating that one is how a fresh computation gets
+        // killed by the tail of the one it replaced.
+        const current = this.load.next();
+        const superseded = () => !current();
+        let run = null;
+        try {
+            // Prefer the 3-D scores: they carry a third component for free, and t-SNE on more
+            // components than it needs is not better — the PCA basis is the input either way.
+            const source = await loadPcaScores(embeddings, getEmbedding);
+            if (superseded())
+                return null;
+            if (!source) {
+                this.patch({ error: 'This dataset serves no PCA to embed.' });
+                return null;
+            }
+            run = new EmbeddingComputeRun();
+            this.run = run;
+            this.patch({ running: true });
+            const result = await run.run({ scores: source.scores, nObs: source.nObs, nDims: source.nDims, dims: meta.dims }, { ...meta, label: (meta.label ?? meta.name).replace(COMPUTE_SUFFIX, '') }, (progress) => {
+                // Progress from a superseded run must not drive the bar a newer one is using.
+                if (superseded())
+                    return;
+                this.patch({
+                    fraction: progress.fraction,
+                    backend: progress.backend ?? this.state.backend,
+                    ...(progress.message ? { message: progress.message } : {}),
+                });
+            });
+            // A terminated run resolves null, so this covers abandonment as well as Cancel — but
+            // the token is still checked, because the dataset can change between the worker's
+            // `done` and this line.
+            if (!result || superseded())
+                return null;
+            this.computed.set(meta.name, result);
+            return result;
+        }
+        catch (err) {
+            if (!superseded())
+                this.patch({ error: err?.message ?? String(err) });
+            return null;
+        }
+        finally {
+            run?.terminate();
+            // Only if it is still ours: a dataset switch has already terminated this run and may
+            // have started another, and clearing here would orphan it — leaving a worker nothing
+            // can cancel and a Cancel button that does nothing.
+            if (this.run === run) {
+                this.run = null;
+                this.patch({ running: false, fraction: null });
+            }
+        }
+    }
+    /** The user's Cancel: ask the worker to stop. The run settles shortly after, with nothing. */
+    cancel() {
+        this.run?.cancel();
+    }
+    /**
+     * Drop any computation in progress, because what it is computing no longer applies.
+     *
+     * Distinct from {@link cancel}: this does not wait — the run is settled and the worker
+     * killed, so a dataset switch or a teardown cannot leave a t-SNE grinding on in the
+     * background over observations nothing is showing any more.
+     */
+    abandon() {
+        this.load.cancel();
+        this.run?.terminate();
+        this.run = null;
+        this.patch({ running: false, fraction: null, backend: null, message: null });
+    }
+    patch(p) {
+        this.state$.next({ ...this.state$.value, ...p });
+    }
+}
+/**
+ * The dataset's PCA, as row-major scores.
+ *
+ * Assembled from whichever PCA the source offers, widest first — a 3-D one gives t-SNE
+ * three components instead of two for the same request.
+ */
+export async function loadPcaScores(embeddings, getEmbedding) {
+    const candidates = embeddings
+        .filter((e) => /pca/i.test(e.label ?? e.name) && !e.name.startsWith('local:'))
+        .sort((a, b) => b.dims - a.dims);
+    for (const candidate of candidates) {
+        try {
+            const pca = await getEmbedding(candidate.name);
+            const planes = [pca.x, pca.y, ...(pca.z ? [pca.z] : [])];
+            const nObs = pca.x.length;
+            const nDims = planes.length;
+            const scores = new Float32Array(nObs * nDims);
+            for (let i = 0; i < nObs; i++) {
+                for (let d = 0; d < nDims; d++)
+                    scores[i * nDims + d] = planes[d][i];
+            }
+            return { scores, nObs, nDims };
+        }
+        catch {
+            // Try the next; a source may advertise one it cannot actually serve.
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"embedding-compute-coordinator.js","sourceRoot":"","sources":["../../../../src/lib/spatial/embedding-compute-coordinator.ts"],"names":[],"mappings":"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","sourcesContent":["import { BehaviorSubject } from 'rxjs';\n\nimport type { SpatialEmbedding, SpatialEmbeddingMeta } from '../contracts/spatial-dataset.contract';\nimport { ComputeProgress, EmbeddingComputeRun } from './embedding-compute';\nimport { Supersede } from '../util/supersede';\n\n/** Where a browser-side embedding computation stands, for the progress bar and messages. */\nexport interface EmbeddingComputeState {\n  /** True while a run is going. */\n  running: boolean;\n  /** 0..1 while running, or null before the first report. */\n  fraction: number | null;\n  /** Which backend the worker got — 'webgpu', 'wasm' or 'cpu'. */\n  backend: string | null;\n  message: string | null;\n  error: string | null;\n}\n\n/** Where the PCA scores come from: a port that serves embeddings by name. */\nexport type EmbeddingSource = (name: string) => Promise<SpatialEmbedding>;\n\nconst IDLE: EmbeddingComputeState = { running: false, fraction: null, backend: null, message: null, error: null };\n\n/**\n * Largest dataset a t-SNE is offered for in the browser.\n *\n * t-SNE is O(N²) per iteration — vectorised on the GPU, but not approximated — so the cost\n * is quadratic in observations. Measured end to end in Firefox on WebGPU: 2,688 points took\n * 95 s. That scales to roughly five and a half minutes at this threshold, and to about 76\n * minutes at seqFISH's 19,416, which was also measured offline.\n *\n * Past this the option is WITHDRAWN rather than offered with a warning. An hour-long job\n * started from a button is not a choice a reader can meaningfully consent to in a dialog,\n * and a t-SNE that large belongs in the offline pipeline, where it can run once and be\n * served to everyone.\n */\nexport const BROWSER_TSNE_MAX_OBSERVATIONS = 5000;\n\n/** Measured anchor for the estimate: seconds for 2,688 points on WebGPU. */\nconst TSNE_SECONDS_AT = { seconds: 95, observations: 2688 };\n\n/**\n * A t-SNE the dataset does not publish, offered so it can be computed here.\n *\n * A dropped-in `.h5ad` typically carries one UMAP and a PCA, and no t-SNE — the two views\n * answer different questions, so having only one is a real gap. Computing it needs no\n * expression data: t-SNE runs on the PCA scores, which is why this can happen in the\n * browser at all while PCA cannot.\n */\nexport const COMPUTABLE_EMBEDDINGS: readonly SpatialEmbeddingMeta[] = [\n  { name: 'local:tsne', label: 't-SNE (compute)', dims: 2, derived: true },\n  { name: 'local:tsne3d', label: 't-SNE 3D (compute)', dims: 3, derived: true },\n];\n\n/** The menu suffix that says a click will start work; not part of the name. */\nconst COMPUTE_SUFFIX = ' (compute)';\n\n/** Roughly how long a t-SNE of `n` observations takes, in seconds, from the measured anchor. */\nexport function tsneEstimateSeconds(n: number): number {\n  const { seconds, observations } = TSNE_SECONDS_AT;\n  return Math.max(1, Math.round(seconds * (n / observations) ** 2));\n}\n\n/** A duration as something to put on a button: `~42s`, `~6 min`. */\nexport function estimateLabel(seconds: number): string {\n  if (seconds < 90) return `~${seconds}s`;\n  return `~${Math.round(seconds / 60)} min`;\n}\n\n/**\n * The browser-side embedding computation behind the charts' Embedding tab: which\n * embeddings to offer for a dataset, the t-SNE run itself (PCA scores from the port, then a\n * worker), its progress, and the results computed this session.\n *\n * A run is several awaits long — the PCA scores arrive over HTTP, then the worker takes a\n * minute or more — and the dataset can change at any of them, including before the run\n * exists to be terminated. Every await is checked against a {@link Supersede} that a\n * dataset switch ({@link setDataset}) or teardown ({@link abandon}) cancels, so the scores\n * fetched for one dataset are never embedded and drawn over another's observations.\n *\n * Plain class: the owner renders {@link state} (or {@link state$}).\n */\nexport class EmbeddingComputeCoordinator {\n  readonly state$ = new BehaviorSubject<EmbeddingComputeState>(IDLE);\n\n  /** True when a t-SNE is missing but the dataset is too big to embed here. */\n  tooLarge = false;\n  /** Observations in the live dataset, kept for the cost estimate. */\n  observationCount = 0;\n\n  /** Coordinates computed in this browser, by name. Not persisted: a reload recomputes. */\n  private readonly computed = new Map<string, SpatialEmbedding>();\n  /** The live run, when one is going. */\n  private run: EmbeddingComputeRun | null = null;\n  private readonly load = new Supersede();\n\n  get state(): EmbeddingComputeState {\n    return this.state$.value;\n  }\n\n  get running(): boolean {\n    return !!this.run?.running;\n  }\n\n  /**\n   * A new dataset: drop everything computed or computing for the previous one, and return\n   * the embeddings to offer — the published ones, plus a t-SNE to compute where the dataset\n   * has a PCA to embed, no t-SNE of its own, and is small enough. Otherwise the menu would\n   * advertise work that cannot start, or duplicate what is already served.\n   */\n  setDataset(published: readonly SpatialEmbeddingMeta[], observationCount: number): SpatialEmbeddingMeta[] {\n    this.computed.clear();\n    this.abandon();\n    const hasPca = published.some((e) => /pca/i.test(e.label ?? e.name));\n    const hasTsne = published.some((e) => /tsne|t-sne/i.test(e.label ?? e.name));\n    this.observationCount = observationCount;\n    this.tooLarge = hasPca && !hasTsne && observationCount > BROWSER_TSNE_MAX_OBSERVATIONS;\n    return hasPca && !hasTsne && !this.tooLarge ? [...published, ...COMPUTABLE_EMBEDDINGS] : [...published];\n  }\n\n  /** Whether `meta` is one this browser would have to compute. */\n  isComputable(meta: SpatialEmbeddingMeta | null): boolean {\n    return !!meta && meta.name.startsWith('local:');\n  }\n\n  /** Whether `meta` has already been computed this session. */\n  isComputed(meta: SpatialEmbeddingMeta | null): boolean {\n    return !!meta && this.computed.has(meta.name);\n  }\n\n  /** The coordinates computed for `name`, if any. */\n  result(name: string): SpatialEmbedding | undefined {\n    return this.computed.get(name);\n  }\n\n  /** Roughly how long a run would take here, in seconds. Shown before the click: a progress\n   *  bar tells you a job is going; only an estimate tells you whether to start it. */\n  get estimateSeconds(): number {\n    return tsneEstimateSeconds(this.observationCount);\n  }\n\n  /** {@link estimateSeconds} as something to put on a button. */\n  get estimateLabel(): string {\n    return estimateLabel(this.estimateSeconds);\n  }\n\n  /** Why the option is absent, when a dataset is past the threshold. */\n  get tooLargeNote(): string {\n    return (\n      `t-SNE is not offered here for ${this.observationCount.toLocaleString()} observations — it is ` +\n      `quadratic, so it would take roughly ${this.estimateLabel} in the browser. ` +\n      'Compute it offline and serve it with the dataset.'\n    );\n  }\n\n  /**\n   * Compute `meta` here, in a worker, from the dataset's PCA among `embeddings`.\n   *\n   * The PCA scores come from the port as an ordinary embedding — the server derives them,\n   * because PCA needs the whole expression matrix (185 MB for a Visium dataset) while\n   * t-SNE needs only the scores (0.51 MB). Sending the matrix to the browser to save a few\n   * seconds of arithmetic would be a far slower answer.\n   *\n   * @returns the coordinates, to draw — or null when there is nothing to draw: cancelled,\n   *   abandoned, failed (see {@link state}), or already running.\n   */\n  async start(\n    meta: SpatialEmbeddingMeta,\n    embeddings: readonly SpatialEmbeddingMeta[],\n    getEmbedding: EmbeddingSource,\n  ): Promise<SpatialEmbedding | null> {\n    if (this.running) return null;\n    this.patch({ ...IDLE });\n\n    // Every early return and every await below is checked against this. `run` is held\n    // locally as well as on the instance: after an await `this.run` may already be a\n    // newer run's, and clearing or terminating that one is how a fresh computation gets\n    // killed by the tail of the one it replaced.\n    const current = this.load.next();\n    const superseded = () => !current();\n    let run: EmbeddingComputeRun | null = null;\n\n    try {\n      // Prefer the 3-D scores: they carry a third component for free, and t-SNE on more\n      // components than it needs is not better — the PCA basis is the input either way.\n      const source = await loadPcaScores(embeddings, getEmbedding);\n      if (superseded()) return null;\n      if (!source) {\n        this.patch({ error: 'This dataset serves no PCA to embed.' });\n        return null;\n      }\n      run = new EmbeddingComputeRun();\n      this.run = run;\n      this.patch({ running: true });\n      const result = await run.run(\n        { scores: source.scores, nObs: source.nObs, nDims: source.nDims, dims: meta.dims },\n        { ...meta, label: (meta.label ?? meta.name).replace(COMPUTE_SUFFIX, '') },\n        (progress: ComputeProgress) => {\n          // Progress from a superseded run must not drive the bar a newer one is using.\n          if (superseded()) return;\n          this.patch({\n            fraction: progress.fraction,\n            backend: progress.backend ?? this.state.backend,\n            ...(progress.message ? { message: progress.message } : {}),\n          });\n        },\n      );\n      // A terminated run resolves null, so this covers abandonment as well as Cancel — but\n      // the token is still checked, because the dataset can change between the worker's\n      // `done` and this line.\n      if (!result || superseded()) return null;\n      this.computed.set(meta.name, result);\n      return result;\n    } catch (err) {\n      if (!superseded()) this.patch({ error: (err as Error)?.message ?? String(err) });\n      return null;\n    } finally {\n      run?.terminate();\n      // Only if it is still ours: a dataset switch has already terminated this run and may\n      // have started another, and clearing here would orphan it — leaving a worker nothing\n      // can cancel and a Cancel button that does nothing.\n      if (this.run === run) {\n        this.run = null;\n        this.patch({ running: false, fraction: null });\n      }\n    }\n  }\n\n  /** The user's Cancel: ask the worker to stop. The run settles shortly after, with nothing. */\n  cancel(): void {\n    this.run?.cancel();\n  }\n\n  /**\n   * Drop any computation in progress, because what it is computing no longer applies.\n   *\n   * Distinct from {@link cancel}: this does not wait — the run is settled and the worker\n   * killed, so a dataset switch or a teardown cannot leave a t-SNE grinding on in the\n   * background over observations nothing is showing any more.\n   */\n  abandon(): void {\n    this.load.cancel();\n    this.run?.terminate();\n    this.run = null;\n    this.patch({ running: false, fraction: null, backend: null, message: null });\n  }\n\n  private patch(p: Partial<EmbeddingComputeState>): void {\n    this.state$.next({ ...this.state$.value, ...p });\n  }\n}\n\n/**\n * The dataset's PCA, as row-major scores.\n *\n * Assembled from whichever PCA the source offers, widest first — a 3-D one gives t-SNE\n * three components instead of two for the same request.\n */\nexport async function loadPcaScores(\n  embeddings: readonly SpatialEmbeddingMeta[],\n  getEmbedding: EmbeddingSource,\n): Promise<{ scores: Float32Array; nObs: number; nDims: number } | null> {\n  const candidates = embeddings\n    .filter((e) => /pca/i.test(e.label ?? e.name) && !e.name.startsWith('local:'))\n    .sort((a, b) => b.dims - a.dims);\n  for (const candidate of candidates) {\n    try {\n      const pca = await getEmbedding(candidate.name);\n      const planes = [pca.x, pca.y, ...(pca.z ? [pca.z] : [])];\n      const nObs = pca.x.length;\n      const nDims = planes.length;\n      const scores = new Float32Array(nObs * nDims);\n      for (let i = 0; i < nObs; i++) {\n        for (let d = 0; d < nDims; d++) scores[i * nDims + d] = planes[d][i];\n      }\n      return { scores, nObs, nDims };\n    } catch {\n      // Try the next; a source may advertise one it cannot actually serve.\n    }\n  }\n  return null;\n}\n"]}

package/esm2022/lib/spatial/embedding-compute.mjs

@@ -1,3 +1,7 @@
+/**
+ * One t-SNE run in its own worker: start it, follow its progress, cancel it. Single use —
+ * a new computation takes a new run.
+ */
 export class EmbeddingComputeRun {
     /**
      * `factory` is optional: without one the real worker module is imported on demand.
@@ -10,6 +14,17 @@ export class EmbeddingComputeRun {
         this.factory = factory;
         this.worker = null;
         this.settled = false;
+        /**
+         * Between `run()` being called and the worker existing.
+         *
+         * The default factory imports the worker module first, and a dataset switch or a
+         * teardown can call {@link terminate} in that window. With no worker yet there is
+         * nothing to kill, so terminating bumps {@link generation} instead and the run stops
+         * itself the moment the worker arrives, before posting it any work.
+         */
+        this.starting = false;
+        /** Bumped by {@link terminate}; a run that finds it changed across its await gives up. */
+        this.generation = 0;
         /**
          * Settles a run that is still waiting, set for as long as one is.
          *
@@ -29,14 +44,29 @@ export class EmbeddingComputeRun {
      * block is how a cancelled run ends up reported as a crash.
      */
     async run(request, meta, onProgress) {
-        if (this.worker)
+        if (this.worker || this.starting)
             throw new Error('a computation is already running');
-        const create = this.factory
-            ?? (await import('./tsne-worker')).createTsneWorker;
-        const worker = create();
-        this.worker = worker;
+        const generation = ++this.generation;
         this.settled = false;
-        const { scores, nObs, nDims, dims, perplexity = 30, iterations = 1000, seed = 0, } = request;
+        this.starting = true;
+        let worker;
+        try {
+            // Awaited only when it IS a promise: a synchronous factory keeps the worker
+            // receiving its start message in the same tick, as callers already rely on.
+            const made = this.factory ? this.factory() : import('./tsne-worker').then((m) => m.createTsneWorker());
+            worker = made instanceof Promise ? await made : made;
+        }
+        finally {
+            if (generation === this.generation)
+                this.starting = false;
+        }
+        // Terminated while the worker was being created: nothing may start computing now.
+        if (generation !== this.generation) {
+            worker.terminate();
+            return null;
+        }
+        this.worker = worker;
+        const { scores, nObs, nDims, dims, perplexity = 30, iterations = 1000, seed = 0 } = request;
         let backend = null;
         return new Promise((resolve, reject) => {
             const finish = (fn) => {
@@ -84,8 +114,8 @@ export class EmbeddingComputeRun {
                             meta: {
                                 ...meta,
                                 derived: true,
-                                params: `PCA(${nDims}) then t-SNE, perplexity ${data.perplexity}, `
-                                    + `${iterations} iterations, seed ${seed}`,
+                                params: `PCA(${nDims}) then t-SNE, perplexity ${data.perplexity}, ` +
+                                    `${iterations} iterations, seed ${seed}`,
                             },
                             x: planes[0],
                             y: planes[1],
@@ -129,6 +159,9 @@ export class EmbeddingComputeRun {
      * settled here, with null, because nothing is left to deliver the answer.
      */
     terminate() {
+        // Also reaches a run still waiting for its worker — see `starting`.
+        this.generation++;
+        this.starting = false;
         const abandon = this.abandon;
         this.abandon = null;
         this.worker?.terminate();
@@ -136,7 +169,7 @@ export class EmbeddingComputeRun {
         abandon?.();
     }
     get running() {
-        return this.worker !== null && !this.settled;
+        return (this.starting || this.worker !== null) && !this.settled;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"embedding-compute.js","sourceRoot":"","sources":["../../../../src/lib/spatial/embedding-compute.ts"],"names":[],"mappings":"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","sourcesContent":["import { SpatialEmbedding, SpatialEmbeddingMeta } from '../contracts/spatial-dataset.contract';\n\n/**\n * Run a t-SNE in a Web Worker and report progress.\n *\n * The panel offers this for a dataset that publishes no t-SNE — a dropped-in `.h5ad`\n * typically carries one UMAP and nothing else. The server reduces to PCA (it needs the\n * whole expression matrix, which the browser should not download); this takes those\n * scores and embeds them here, where the GPU is.\n *\n * A thin wrapper on purpose: no Angular, no store. It owns one worker and one run, so a\n * component can hold it, show a progress bar, and cancel — and so the whole thing can be\n * tested by substituting a worker.\n */\n\nexport interface ComputeProgress {\n  /** 0..1, or null before the first report — a run starts with kNN and P, not iterations. */\n  fraction: number | null;\n  /** 'webgpu', 'wasm' or 'cpu' once known: it changes what a long wait means. */\n  backend: string | null;\n  message: string | null;\n}\n\nexport interface ComputeRequest {\n  /** PCA scores, row-major `nObs x nDims`. */\n  scores: Float32Array;\n  nObs: number;\n  nDims: number;\n  dims: 2 | 3;\n  perplexity?: number;\n  iterations?: number;\n  seed?: number;\n}\n\n/** Factory, so a test can supply a worker without a bundler. */\nexport type WorkerFactory = () => Worker;\n\nexport class EmbeddingComputeRun {\n  private worker: Worker | null = null;\n\n  private settled = false;\n\n  /**\n   * Settles a run that is still waiting, set for as long as one is.\n   *\n   * `terminate()` is called from outside — a dataset switch, a component being destroyed —\n   * and killing the worker on its own leaves the promise `run()` returned pending FOR\n   * EVER, because the settlement it was waiting for arrives as a worker message. The\n   * awaiting closure, and everything it captured, is retained with it. So termination\n   * settles the run itself.\n   */\n  private abandon: (() => void) | null = null;\n\n  /**\n   * `factory` is optional: without one the real worker module is imported on demand.\n   *\n   * Dynamically, and that is not laziness for its own sake — the module holds an\n   * `import.meta.url`, which ts-jest's CommonJS compile rejects outright, so a static\n   * import here would break every spec that touches this file.\n   */\n  constructor(private readonly factory?: WorkerFactory) {}\n\n  /**\n   * Start a run. Resolves with the coordinates, or null if cancelled.\n   *\n   * Rejects only on a real failure. Cancellation is a NULL rather than a rejection: a user\n   * pressing Cancel is not an error, and making callers tell the two apart in a catch\n   * block is how a cancelled run ends up reported as a crash.\n   */\n  async run(\n    request: ComputeRequest,\n    meta: SpatialEmbeddingMeta,\n    onProgress: (progress: ComputeProgress) => void,\n  ): Promise<SpatialEmbedding | null> {\n    if (this.worker) throw new Error('a computation is already running');\n    const create = this.factory\n      ?? (await import('./tsne-worker')).createTsneWorker;\n    const worker = create();\n    this.worker = worker;\n    this.settled = false;\n\n    const {\n      scores, nObs, nDims, dims,\n      perplexity = 30, iterations = 1000, seed = 0,\n    } = request;\n    let backend: string | null = null;\n\n    return new Promise<SpatialEmbedding | null>((resolve, reject) => {\n      const finish = (fn: () => void) => {\n        if (this.settled) return;\n        this.settled = true;\n        // Cleared BEFORE terminating: `terminate()` calls it, and this is what keeps the\n        // two from calling each other round in a circle.\n        this.abandon = null;\n        this.terminate();\n        fn();\n      };\n      // An abandoned run resolves NULL, exactly as a cancelled one does. It is the same\n      // event from the caller's side — the answer was no longer wanted — and rejecting\n      // would make a routine dataset switch look like a failed computation.\n      this.abandon = () => finish(() => resolve(null));\n\n      worker.onmessage = (event: MessageEvent) => {\n        const data = event.data ?? {};\n        switch (data.type) {\n          case 'backend':\n            backend = data.backend;\n            onProgress({ fraction: null, backend, message: null });\n            break;\n          case 'warning':\n            onProgress({ fraction: null, backend, message: data.message });\n            break;\n          case 'progress':\n            onProgress({ fraction: data.done / data.total, backend, message: null });\n            break;\n          case 'cancelled':\n            finish(() => resolve(null));\n            break;\n          case 'done': {\n            const flat = new Float32Array(data.embedding);\n            // Struct of arrays, matching what the port serves, so the chart cannot tell a\n            // locally-computed embedding from a fetched one.\n            const planes: Float32Array[] = [];\n            for (let d = 0; d < data.dims; d++) {\n              const plane = new Float32Array(nObs);\n              for (let i = 0; i < nObs; i++) plane[i] = flat[i * data.dims + d];\n              planes.push(plane);\n            }\n            finish(() => resolve({\n              meta: {\n                ...meta,\n                derived: true,\n                params: `PCA(${nDims}) then t-SNE, perplexity ${data.perplexity}, `\n                  + `${iterations} iterations, seed ${seed}`,\n              },\n              x: planes[0],\n              y: planes[1],\n              ...(planes[2] ? { z: planes[2] } : {}),\n            }));\n            break;\n          }\n          case 'error':\n            finish(() => reject(new Error(data.message)));\n            break;\n          default:\n            break;\n        }\n      };\n      // A worker that dies takes the promise with it; without this the caller waits for\n      // ever on a progress bar that has stopped moving.\n      worker.onerror = (event) => finish(\n        () => reject(new Error(`embedding worker failed: ${event.message ?? 'unknown'}`)),\n      );\n\n      // Copied, then transferred: the caller keeps its scores, and the worker gets the\n      // buffer without a structured clone.\n      const payload = scores.slice();\n      worker.postMessage(\n        {\n          type: 'start',\n          scores: payload.buffer,\n          nObs,\n          nDims,\n          dims,\n          perplexity,\n          iterations,\n          seed,\n        },\n        [payload.buffer],\n      );\n    });\n  }\n\n  /** Ask the run to stop. It resolves with null shortly after. */\n  cancel(): void {\n    this.worker?.postMessage({ type: 'cancel' });\n  }\n\n  /**\n   * Stop immediately, abandoning any result. Safe to call twice.\n   *\n   * Unlike {@link cancel}, this does not wait for the worker to acknowledge — the run is\n   * settled here, with null, because nothing is left to deliver the answer.\n   */\n  terminate(): void {\n    const abandon = this.abandon;\n    this.abandon = null;\n    this.worker?.terminate();\n    this.worker = null;\n    abandon?.();\n  }\n\n  get running(): boolean {\n    return this.worker !== null && !this.settled;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"embedding-compute.js","sourceRoot":"","sources":["../../../../src/lib/spatial/embedding-compute.ts"],"names":[],"mappings":"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","sourcesContent":["import { SpatialEmbedding, SpatialEmbeddingMeta } from '../contracts/spatial-dataset.contract';\n\n/**\n * Run a t-SNE in a Web Worker and report progress.\n *\n * The panel offers this for a dataset that publishes no t-SNE — a dropped-in `.h5ad`\n * typically carries one UMAP and nothing else. The server reduces to PCA (it needs the\n * whole expression matrix, which the browser should not download); this takes those\n * scores and embeds them here, where the GPU is.\n *\n * A thin wrapper on purpose: no Angular, no store. It owns one worker and one run, so a\n * component can hold it, show a progress bar, and cancel — and so the whole thing can be\n * tested by substituting a worker.\n */\n\nexport interface ComputeProgress {\n  /** 0..1, or null before the first report — a run starts with kNN and P, not iterations. */\n  fraction: number | null;\n  /** 'webgpu', 'wasm' or 'cpu' once known: it changes what a long wait means. */\n  backend: string | null;\n  message: string | null;\n}\n\n/** One t-SNE to compute: the PCA scores to embed and the run's parameters. */\nexport interface ComputeRequest {\n  /** PCA scores, row-major `nObs x nDims`. */\n  scores: Float32Array;\n  nObs: number;\n  nDims: number;\n  dims: 2 | 3;\n  perplexity?: number;\n  iterations?: number;\n  seed?: number;\n}\n\n/**\n * Factory, so a test can supply a worker without a bundler. May be asynchronous, as the\n * default one is: it imports the worker module on demand.\n */\nexport type WorkerFactory = () => Worker | Promise<Worker>;\n\n/**\n * One t-SNE run in its own worker: start it, follow its progress, cancel it. Single use —\n * a new computation takes a new run.\n */\nexport class EmbeddingComputeRun {\n  private worker: Worker | null = null;\n\n  private settled = false;\n\n  /**\n   * Between `run()` being called and the worker existing.\n   *\n   * The default factory imports the worker module first, and a dataset switch or a\n   * teardown can call {@link terminate} in that window. With no worker yet there is\n   * nothing to kill, so terminating bumps {@link generation} instead and the run stops\n   * itself the moment the worker arrives, before posting it any work.\n   */\n  private starting = false;\n\n  /** Bumped by {@link terminate}; a run that finds it changed across its await gives up. */\n  private generation = 0;\n\n  /**\n   * Settles a run that is still waiting, set for as long as one is.\n   *\n   * `terminate()` is called from outside — a dataset switch, a component being destroyed —\n   * and killing the worker on its own leaves the promise `run()` returned pending FOR\n   * EVER, because the settlement it was waiting for arrives as a worker message. The\n   * awaiting closure, and everything it captured, is retained with it. So termination\n   * settles the run itself.\n   */\n  private abandon: (() => void) | null = null;\n\n  /**\n   * `factory` is optional: without one the real worker module is imported on demand.\n   *\n   * Dynamically, and that is not laziness for its own sake — the module holds an\n   * `import.meta.url`, which ts-jest's CommonJS compile rejects outright, so a static\n   * import here would break every spec that touches this file.\n   */\n  constructor(private readonly factory?: WorkerFactory) {}\n\n  /**\n   * Start a run. Resolves with the coordinates, or null if cancelled.\n   *\n   * Rejects only on a real failure. Cancellation is a NULL rather than a rejection: a user\n   * pressing Cancel is not an error, and making callers tell the two apart in a catch\n   * block is how a cancelled run ends up reported as a crash.\n   */\n  async run(\n    request: ComputeRequest,\n    meta: SpatialEmbeddingMeta,\n    onProgress: (progress: ComputeProgress) => void,\n  ): Promise<SpatialEmbedding | null> {\n    if (this.worker || this.starting) throw new Error('a computation is already running');\n    const generation = ++this.generation;\n    this.settled = false;\n    this.starting = true;\n    let worker: Worker;\n    try {\n      // Awaited only when it IS a promise: a synchronous factory keeps the worker\n      // receiving its start message in the same tick, as callers already rely on.\n      const made = this.factory ? this.factory() : import('./tsne-worker').then((m) => m.createTsneWorker());\n      worker = made instanceof Promise ? await made : made;\n    } finally {\n      if (generation === this.generation) this.starting = false;\n    }\n    // Terminated while the worker was being created: nothing may start computing now.\n    if (generation !== this.generation) {\n      worker.terminate();\n      return null;\n    }\n    this.worker = worker;\n\n    const { scores, nObs, nDims, dims, perplexity = 30, iterations = 1000, seed = 0 } = request;\n    let backend: string | null = null;\n\n    return new Promise<SpatialEmbedding | null>((resolve, reject) => {\n      const finish = (fn: () => void) => {\n        if (this.settled) return;\n        this.settled = true;\n        // Cleared BEFORE terminating: `terminate()` calls it, and this is what keeps the\n        // two from calling each other round in a circle.\n        this.abandon = null;\n        this.terminate();\n        fn();\n      };\n      // An abandoned run resolves NULL, exactly as a cancelled one does. It is the same\n      // event from the caller's side — the answer was no longer wanted — and rejecting\n      // would make a routine dataset switch look like a failed computation.\n      this.abandon = () => finish(() => resolve(null));\n\n      worker.onmessage = (event: MessageEvent) => {\n        const data = event.data ?? {};\n        switch (data.type) {\n          case 'backend':\n            backend = data.backend;\n            onProgress({ fraction: null, backend, message: null });\n            break;\n          case 'warning':\n            onProgress({ fraction: null, backend, message: data.message });\n            break;\n          case 'progress':\n            onProgress({ fraction: data.done / data.total, backend, message: null });\n            break;\n          case 'cancelled':\n            finish(() => resolve(null));\n            break;\n          case 'done': {\n            const flat = new Float32Array(data.embedding);\n            // Struct of arrays, matching what the port serves, so the chart cannot tell a\n            // locally-computed embedding from a fetched one.\n            const planes: Float32Array[] = [];\n            for (let d = 0; d < data.dims; d++) {\n              const plane = new Float32Array(nObs);\n              for (let i = 0; i < nObs; i++) plane[i] = flat[i * data.dims + d];\n              planes.push(plane);\n            }\n            finish(() =>\n              resolve({\n                meta: {\n                  ...meta,\n                  derived: true,\n                  params:\n                    `PCA(${nDims}) then t-SNE, perplexity ${data.perplexity}, ` +\n                    `${iterations} iterations, seed ${seed}`,\n                },\n                x: planes[0],\n                y: planes[1],\n                ...(planes[2] ? { z: planes[2] } : {}),\n              }),\n            );\n            break;\n          }\n          case 'error':\n            finish(() => reject(new Error(data.message)));\n            break;\n          default:\n            break;\n        }\n      };\n      // A worker that dies takes the promise with it; without this the caller waits for\n      // ever on a progress bar that has stopped moving.\n      worker.onerror = (event) =>\n        finish(() => reject(new Error(`embedding worker failed: ${event.message ?? 'unknown'}`)));\n\n      // Copied, then transferred: the caller keeps its scores, and the worker gets the\n      // buffer without a structured clone.\n      const payload = scores.slice();\n      worker.postMessage(\n        {\n          type: 'start',\n          scores: payload.buffer,\n          nObs,\n          nDims,\n          dims,\n          perplexity,\n          iterations,\n          seed,\n        },\n        [payload.buffer],\n      );\n    });\n  }\n\n  /** Ask the run to stop. It resolves with null shortly after. */\n  cancel(): void {\n    this.worker?.postMessage({ type: 'cancel' });\n  }\n\n  /**\n   * Stop immediately, abandoning any result. Safe to call twice.\n   *\n   * Unlike {@link cancel}, this does not wait for the worker to acknowledge — the run is\n   * settled here, with null, because nothing is left to deliver the answer.\n   */\n  terminate(): void {\n    // Also reaches a run still waiting for its worker — see `starting`.\n    this.generation++;\n    this.starting = false;\n    const abandon = this.abandon;\n    this.abandon = null;\n    this.worker?.terminate();\n    this.worker = null;\n    abandon?.();\n  }\n\n  get running(): boolean {\n    return (this.starting || this.worker !== null) && !this.settled;\n  }\n}\n"]}

package/esm2022/lib/spatial/gene-search.mjs

@@ -74,4 +74,4 @@ export function geneOptionsFor(names, query, selected = [], limit = GENE_OPTIONS
     const seen = new Set(selected);
     return [...selected, ...matches.filter((n) => !seen.has(n))];
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/spatial/glyphs.mjs

@@ -0,0 +1,97 @@
+/**
+ * Transcript "icon" mode: the marker shapes, and their outlines for the panel's previews.
+ * The napari view draws them as napari-js point symbols (`GLYPH_SYMBOLS` in
+ * `spatial-tiles/transcript-layers.ts`), with these outlines' proportions.
+ */
+/** Marker shapes for the transcript "icon" mode. */
+export const TRANSCRIPT_GLYPHS = [
+    'circle',
+    'star',
+    'triangle',
+    'square',
+    'diamond',
+    'cross',
+    'hexagon',
+    'triangle-down',
+    'pentagon',
+    'x',
+];
+// The view state names glyphs without importing this module; keep the two in step.
+const _glyphNamesMatch = true;
+void _glyphNamesMatch;
+/**
+ * Unit outline of a glyph, radius ≈ 1, centred on the origin, as `[x0, y0, x1, y1, …]` — the
+ * panel's preview of the point symbol the canvas draws.
+ */
+export function glyphOutline(glyph) {
+    const poly = (n, rot = -Math.PI / 2, r = 1) => {
+        const out = new Float32Array(n * 2);
+        for (let i = 0; i < n; i++) {
+            const a = rot + (i * 2 * Math.PI) / n;
+            out[2 * i] = Math.cos(a) * r;
+            out[2 * i + 1] = Math.sin(a) * r;
+        }
+        return out;
+    };
+    const star = (points, inner, rot = -Math.PI / 2) => {
+        const out = new Float32Array(points * 4);
+        for (let i = 0; i < points * 2; i++) {
+            const a = rot + (i * Math.PI) / points;
+            const r = i % 2 === 0 ? 1 : inner;
+            out[2 * i] = Math.cos(a) * r;
+            out[2 * i + 1] = Math.sin(a) * r;
+        }
+        return out;
+    };
+    // A plus built as a 12-gon: arms of half-width w.
+    const plus = (w, rotate) => {
+        const pts = [
+            [w, -1],
+            [w, -w],
+            [1, -w],
+            [1, w],
+            [w, w],
+            [w, 1],
+            [-w, 1],
+            [-w, w],
+            [-1, w],
+            [-1, -w],
+            [-w, -w],
+            [-w, -1],
+        ];
+        const out = new Float32Array(pts.length * 2);
+        const c = Math.SQRT1_2;
+        pts.forEach(([x, y], i) => {
+            out[2 * i] = rotate ? (x - y) * c : x;
+            out[2 * i + 1] = rotate ? (x + y) * c : y;
+        });
+        return out;
+    };
+    switch (glyph) {
+        case 'circle':
+            return poly(12);
+        case 'star':
+            return star(5, 0.45);
+        case 'triangle':
+            return poly(3);
+        case 'triangle-down':
+            return poly(3, Math.PI / 2);
+        case 'square':
+            return poly(4, Math.PI / 4, Math.SQRT2 * 0.8);
+        case 'diamond':
+            return poly(4, -Math.PI / 2);
+        case 'hexagon':
+            return poly(6, 0);
+        case 'pentagon':
+            return poly(5);
+        case 'cross':
+            return plus(0.32, false);
+        case 'x':
+            return plus(0.28, true);
+    }
+}
+/** The glyph a gene gets by default: by its position in the selected list. */
+export function defaultGlyphFor(slot) {
+    return TRANSCRIPT_GLYPHS[slot % TRANSCRIPT_GLYPHS.length];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"glyphs.js","sourceRoot":"","sources":["../../../../src/lib/spatial/glyphs.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Transcript \"icon\" mode: the marker shapes, and their outlines for the panel's previews.\n * The napari view draws them as napari-js point symbols (`GLYPH_SYMBOLS` in\n * `spatial-tiles/transcript-layers.ts`), with these outlines' proportions.\n */\n\nimport type { TranscriptGlyphName } from '../contracts/display-types';\n\n/** Marker shapes for the transcript \"icon\" mode. */\nexport const TRANSCRIPT_GLYPHS = [\n  'circle',\n  'star',\n  'triangle',\n  'square',\n  'diamond',\n  'cross',\n  'hexagon',\n  'triangle-down',\n  'pentagon',\n  'x',\n] as const;\n/** One of the marker shapes in {@link TRANSCRIPT_GLYPHS}. */\nexport type TranscriptGlyph = (typeof TRANSCRIPT_GLYPHS)[number];\n// The view state names glyphs without importing this module; keep the two in step.\nconst _glyphNamesMatch: TranscriptGlyph extends TranscriptGlyphName\n  ? TranscriptGlyphName extends TranscriptGlyph\n    ? true\n    : never\n  : never = true;\nvoid _glyphNamesMatch;\n\n/**\n * Unit outline of a glyph, radius ≈ 1, centred on the origin, as `[x0, y0, x1, y1, …]` — the\n * panel's preview of the point symbol the canvas draws.\n */\nexport function glyphOutline(glyph: TranscriptGlyph): Float32Array {\n  const poly = (n: number, rot = -Math.PI / 2, r = 1) => {\n    const out = new Float32Array(n * 2);\n    for (let i = 0; i < n; i++) {\n      const a = rot + (i * 2 * Math.PI) / n;\n      out[2 * i] = Math.cos(a) * r;\n      out[2 * i + 1] = Math.sin(a) * r;\n    }\n    return out;\n  };\n  const star = (points: number, inner: number, rot = -Math.PI / 2) => {\n    const out = new Float32Array(points * 4);\n    for (let i = 0; i < points * 2; i++) {\n      const a = rot + (i * Math.PI) / points;\n      const r = i % 2 === 0 ? 1 : inner;\n      out[2 * i] = Math.cos(a) * r;\n      out[2 * i + 1] = Math.sin(a) * r;\n    }\n    return out;\n  };\n  // A plus built as a 12-gon: arms of half-width w.\n  const plus = (w: number, rotate: boolean) => {\n    const pts = [\n      [w, -1],\n      [w, -w],\n      [1, -w],\n      [1, w],\n      [w, w],\n      [w, 1],\n      [-w, 1],\n      [-w, w],\n      [-1, w],\n      [-1, -w],\n      [-w, -w],\n      [-w, -1],\n    ];\n    const out = new Float32Array(pts.length * 2);\n    const c = Math.SQRT1_2;\n    pts.forEach(([x, y], i) => {\n      out[2 * i] = rotate ? (x - y) * c : x;\n      out[2 * i + 1] = rotate ? (x + y) * c : y;\n    });\n    return out;\n  };\n  switch (glyph) {\n    case 'circle':\n      return poly(12);\n    case 'star':\n      return star(5, 0.45);\n    case 'triangle':\n      return poly(3);\n    case 'triangle-down':\n      return poly(3, Math.PI / 2);\n    case 'square':\n      return poly(4, Math.PI / 4, Math.SQRT2 * 0.8);\n    case 'diamond':\n      return poly(4, -Math.PI / 2);\n    case 'hexagon':\n      return poly(6, 0);\n    case 'pentagon':\n      return poly(5);\n    case 'cross':\n      return plus(0.32, false);\n    case 'x':\n      return plus(0.28, true);\n  }\n}\n\n/** The glyph a gene gets by default: by its position in the selected list. */\nexport function defaultGlyphFor(slot: number): TranscriptGlyph {\n  return TRANSCRIPT_GLYPHS[slot % TRANSCRIPT_GLYPHS.length];\n}\n"]}