@jax-data-science/sci-image-visualizer 0.4.0 → 0.6.0

package/esm2022/lib/contracts/toolbar-tool.contract.mjs

@@ -35,6 +35,17 @@
  * than an escape hatch that returns a component — the moment one tool draws
  * itself, the toolbar stops being able to lay tools out consistently.
  *
+ * DIALOG TOOLS
+ * Some tools are not "set parameters, run once" but an interactive session: the
+ * user paints, the tool retrains and redraws, over and over (DIANNE). A schema
+ * cannot describe that, so {@link ToolbarDialogToolContribution} is the one
+ * variant that renders its own body. The toolbar still owns the button, its
+ * placement and the dialog chrome; the tool only fills the dialog, with plain
+ * DOM (`mount`), so it needs neither Angular nor this library's PrimeNG version.
+ * Its button sits with the host's own actions at the start of the toolbar, and
+ * shows only in the Image view, the view its context ({@link ToolDialogContext})
+ * draws over.
+ *
  * WHY AN EMPTY MODEL LIST HIDES THE TOOL
  * {@link ToolbarToolContribution.models} returning `[]` removes the tool from
  * the toolbar entirely. This preserves the behaviour the built-in tools already
@@ -43,8 +54,14 @@
  * not require unregistering the provider.
  */
 import { InjectionToken } from '@angular/core';
+/** Whether a contribution is a {@link ToolbarDialogToolContribution}. */
+export function isDialogToolContribution(c) {
+    return !!c && c.kind === 'dialog';
+}
 /**
- * Multi-provider token for contributed tools.
+ * Multi-provider token for contributed tools: run tools
+ * ({@link ToolbarToolContribution}) and, since 0.6.0, dialog tools
+ * ({@link ToolbarDialogToolContribution}).
  *
  * Deliberately has no `factory`: unregistered means no tools, which is what
  * makes this library shippable without the closed model packages. Inject it
@@ -57,8 +74,33 @@ export function sortToolContributions(tools) {
     // provider order without having to invent numbers.
     return tools.map((t, i) => ({ t, i })).sort((a, b) => (a.t.order ?? 100) - (b.t.order ?? 100) || a.i - b.i).map(({ t }) => t);
 }
-/** The tools a toolbar should actually show: those with at least one model. */
+/** The run tools a toolbar should actually show: those with at least one model.
+ *  Dialog tools are left out (see {@link dialogToolContributions}). */
 export function visibleToolContributions(tools) {
-    return sortToolContributions(tools ?? []).filter((t) => t.models().length > 0);
+    const run = (tools ?? []).filter((t) => !isDialogToolContribution(t) && typeof t?.models === 'function');
+    return sortToolContributions(run).filter((t) => t.models().length > 0);
+}
+/**
+ * The dialog tools, in display order. A malformed one (no string `id`, no
+ * `activate` or `mount` function) or a repeated `id` is dropped with a warning
+ * rather than breaking the toolbar.
+ */
+export function dialogToolContributions(tools, log = console) {
+    const seen = new Set();
+    const out = [];
+    for (const t of (tools ?? []).filter(isDialogToolContribution)) {
+        if (typeof t.id !== 'string' || !t.id || typeof t.activate !== 'function'
+            || typeof t.mount !== 'function') {
+            log.warn('[visualizer] dialog tool ignored: it needs a string `id` and `activate` and `mount` functions.', t);
+            continue;
+        }
+        if (seen.has(t.id)) {
+            log.warn(`[visualizer] dialog tool '${t.id}' ignored: another dialog tool already uses that id.`);
+            continue;
+        }
+        seen.add(t.id);
+        out.push(t);
+    }
+    return sortToolContributions(out);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"toolbar-tool.contract.js","sourceRoot":"","sources":["../../../../src/lib/contracts/toolbar-tool.contract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AA4I/C;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,IAAI,cAAc,CAAqC,eAAe,CAAC,CAAC;AAErG,iDAAiD;AACjD,MAAM,UAAU,qBAAqB,CACnC,KAAyC;IAEzC,6EAA6E;IAC7E,mDAAmD;IACnD,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CACnD,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CACrD,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;AACtB,CAAC;AAED,+EAA+E;AAC/E,MAAM,UAAU,wBAAwB,CACtC,KAA4D;IAE5D,OAAO,qBAAqB,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;AACjF,CAAC","sourcesContent":["/**\n * How a tool gets into the toolbar without this library knowing what it is.\n *\n * WHY THIS EXISTS\n * The YOLO detector and the retinal-layer segmenter used to be built in: their\n * buttons were hardcoded in the toolbar template, their model registries named\n * JAX checkpoints, and the `INSTANCE_SEGMENTER` / `SEMANTIC_SEGMENTER` tokens\n * defaulted to in-library services that imported `yolo-segdetect-js` and\n * `jax-ai-js`. Those default factories were the only thing pulling either\n * package into the bundle — the contracts themselves were already clean.\n *\n * That arrangement cannot ship in an open library while the models are closed.\n * So the tools move out, into a package that depends on this one, and arrive\n * back through {@link TOOLBAR_TOOLS}. This library keeps the contracts, the\n * chrome and the region plumbing; it no longer knows that YOLO exists.\n *\n * A host registers tools with a multi-provider:\n *\n *     { provide: TOOLBAR_TOOLS, useExisting: YoloToolContribution, multi: true }\n *\n * Register nothing and the toolbar has no segmentation tools, the help dialog\n * lists none, and neither model package is in the graph.\n *\n * WHY PARAMS ARE DECLARED, NOT RENDERED\n * A contribution describes its parameters ({@link ToolParamSpec}) instead of\n * supplying a component to draw them. The toolbar renders one generic dialog\n * from that description. The alternative — each plugin shipping its own dialog\n * component — would make every plugin depend on this library's exact PrimeNG\n * version and styling internals to look like the rest of the toolbar, and the\n * two dialogs that exist today are entirely numbers and one checkbox. A schema\n * covers them, and it is the same shape jit-ui already uses for its pipeline\n * step parameters, so the vocabulary is familiar.\n *\n * If a tool ever needs a control this cannot express, add a variant here rather\n * than an escape hatch that returns a component — the moment one tool draws\n * itself, the toolbar stops being able to lay tools out consistently.\n *\n * WHY AN EMPTY MODEL LIST HIDES THE TOOL\n * {@link ToolbarToolContribution.models} returning `[]` removes the tool from\n * the toolbar entirely. This preserves the behaviour the built-in tools already\n * had (their buttons were `*ngIf`'d on a filtered registry), and it gives a host\n * one switch for \"the weights are not configured in this deployment\" that does\n * not require unregistering the provider.\n */\nimport { InjectionToken } from '@angular/core';\nimport type { Observable } from 'rxjs';\n\nimport type { IVisualizer } from './visualizer.contract';\n\n/** A number field. Rendered as a stepper, matching the built-in dialogs. */\nexport interface NumberParamSpec {\n  id: string;\n  label: string;\n  type: 'number';\n  min?: number;\n  max?: number;\n  step?: number;\n  /** Decimal places to show. Omit for integers. */\n  fractionDigits?: number;\n  /** Hover help. Plain text; it is not rendered as HTML. */\n  tooltip?: string;\n}\n\n/** A checkbox. `label` sits beside it and may run to a sentence or two. */\nexport interface BooleanParamSpec {\n  id: string;\n  label: string;\n  type: 'boolean';\n  tooltip?: string;\n}\n\n/** A fixed set of choices. */\nexport interface SelectParamSpec {\n  id: string;\n  label: string;\n  type: 'select';\n  options: { label: string; value: string | number }[];\n  tooltip?: string;\n}\n\nexport type ToolParamSpec = NumberParamSpec | BooleanParamSpec | SelectParamSpec;\n\n/** One selectable checkpoint. */\nexport interface ToolModelOption {\n  id: string;\n  label: string;\n  /**\n   * Describes the checkpoint in the picker's hover tooltip — size, speed,\n   * training domain, accuracy. **Rendered as HTML**, so it is trusted content\n   * from the contributing package, never anything user-supplied.\n   */\n  info?: string;\n  /**\n   * Parameter values this checkpoint wants, merged over\n   * {@link ToolbarToolContribution.defaultParams} when it is selected. Defaults\n   * belong to the model rather than the tool — a detector trained on native 40x\n   * patches wants different tiling from one trained on thumbnails.\n   */\n  defaults?: Record<string, unknown>;\n}\n\n/**\n * The `status$` / `busy$` / `progress$` surface the toolbar drives its sticky\n * toast and progress bar from. `progress$` is a 0..1 fraction, or -1 for\n * indeterminate.\n */\nexport interface ToolProgress {\n  status$: Observable<string>;\n  busy$: Observable<boolean>;\n  progress$: Observable<number>;\n}\n\n/** Toolbar icon: a published asset, or a PrimeIcon class name. */\nexport type ToolIcon = { src: string; pi?: never } | { pi: string; src?: never };\n\n/**\n * A tool contributed to the toolbar.\n *\n * Implement it on an `@Injectable()` service in the contributing package, so it\n * can inject its own segmenter and model registry — this library provides\n * neither and must not learn to.\n */\nexport interface ToolbarToolContribution {\n  /** Stable identity, used for tracking and persisted preferences. */\n  id: string;\n  /** Short name, used in the toast and the help dialog heading. */\n  label: string;\n  icon: ToolIcon;\n\n  /** Tooltip on the run button — say what it does to the current view. */\n  runTooltip: string;\n  /** Tooltip on the checkpoint picker. Defaults to \"Pick the model\". */\n  modelTooltip?: string;\n  /** Tooltip on the parameters button. Defaults to \"Parameters\". */\n  paramsTooltip?: string;\n\n  /**\n   * Where it sits among the segmentation tools. Lower sorts first; ties fall\n   * back to registration order. The built-in prompted tools occupy 0-99, so\n   * contributed tools should start at 100 to land after them.\n   */\n  order?: number;\n\n  /** Selectable checkpoints. **Empty hides the tool.** */\n  models(): ToolModelOption[];\n  /** Which checkpoint runs when the user has not chosen. */\n  defaultModelId(): string;\n  /**\n   * Called when the user picks a checkpoint, before parameters are re-seeded.\n   * Use it to record the choice in the contributing package's own registry.\n   */\n  onModelChange?(modelId: string): void;\n\n  /** Parameter fields, in dialog order. Empty hides the parameters button. */\n  params: ToolParamSpec[];\n  /**\n   * Baseline parameter values for a checkpoint. Called on first use and again\n   * on \"Reset to model defaults\", so it must be pure and must return every key\n   * the tool reads — a parameter the dialog shows but this omits renders as\n   * empty and reaches `run` as undefined.\n   */\n  defaultParams(modelId: string): Record<string, unknown>;\n\n  /**\n   * Entry for the help dialog's tool list. `body` is rendered as HTML and may\n   * reference published assets (e.g. the tool's own icon).\n   */\n  help?: { body: string };\n\n  /** Progress surface for the toast. */\n  progress: ToolProgress;\n\n  /**\n   * Run over what is currently displayed, and write whatever it finds through\n   * `viz`. Resolves with the number of regions added.\n   *\n   * Everything the tool needs is on {@link IVisualizer}, which is part of this\n   * library's public surface — a contribution never reaches into internals.\n   * Region writes go through the same path the built-in tools use, so the\n   * index-based overlays and the Regions table stay consistent.\n   */\n  run(viz: IVisualizer, params: Record<string, unknown>): Promise<number>;\n}\n\n/**\n * Multi-provider token for contributed tools.\n *\n * Deliberately has no `factory`: unregistered means no tools, which is what\n * makes this library shippable without the closed model packages. Inject it\n * `{ optional: true }` and treat null as empty.\n */\nexport const TOOLBAR_TOOLS = new InjectionToken<readonly ToolbarToolContribution[]>('TOOLBAR_TOOLS');\n\n/** Sort contributed tools into display order. */\nexport function sortToolContributions(\n  tools: readonly ToolbarToolContribution[],\n): ToolbarToolContribution[] {\n  // Stable: equal `order` keeps registration order, so a host controls ties by\n  // provider order without having to invent numbers.\n  return tools.map((t, i) => ({ t, i })).sort((a, b) =>\n    (a.t.order ?? 100) - (b.t.order ?? 100) || a.i - b.i,\n  ).map(({ t }) => t);\n}\n\n/** The tools a toolbar should actually show: those with at least one model. */\nexport function visibleToolContributions(\n  tools: readonly ToolbarToolContribution[] | null | undefined,\n): ToolbarToolContribution[] {\n  return sortToolContributions(tools ?? []).filter((t) => t.models().length > 0);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"toolbar-tool.contract.js","sourceRoot":"","sources":["../../../../src/lib/contracts/toolbar-tool.contract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAiM/C,yEAAyE;AACzE,MAAM,UAAU,wBAAwB,CAAC,CAAU;IACjD,OAAO,CAAC,CAAC,CAAC,IAAK,CAAwB,CAAC,IAAI,KAAK,QAAQ,CAAC;AAC5D,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,IAAI,cAAc,CAAiC,eAAe,CAAC,CAAC;AAEjG,iDAAiD;AACjD,MAAM,UAAU,qBAAqB,CACnC,KAAmB;IAEnB,6EAA6E;IAC7E,mDAAmD;IACnD,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CACnD,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CACrD,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;AACtB,CAAC;AAED;uEACuE;AACvE,MAAM,UAAU,wBAAwB,CACtC,KAAwD;IAExD,MAAM,GAAG,GAAG,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,MAAM,CAC9B,CAAC,CAAC,EAAgC,EAAE,CAClC,CAAC,wBAAwB,CAAC,CAAC,CAAC,IAAI,OAAQ,CAA6B,EAAE,MAAM,KAAK,UAAU,CAC/F,CAAC;IACF,OAAO,qBAAqB,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;AACzE,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,uBAAuB,CACrC,KAAwD,EACxD,MAA0C,OAAO;IAEjD,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,MAAM,GAAG,GAAoC,EAAE,CAAC;IAChD,KAAK,MAAM,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,wBAAwB,CAAC,EAAE,CAAC;QAC/D,IAAI,OAAO,CAAC,CAAC,EAAE,KAAK,QAAQ,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,OAAO,CAAC,CAAC,QAAQ,KAAK,UAAU;eAClE,OAAO,CAAC,CAAC,KAAK,KAAK,UAAU,EAAE,CAAC;YACrC,GAAG,CAAC,IAAI,CAAC,gGAAgG,EAAE,CAAC,CAAC,CAAC;YAC9G,SAAS;QACX,CAAC;QACD,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC;YACnB,GAAG,CAAC,IAAI,CAAC,6BAA6B,CAAC,CAAC,EAAE,sDAAsD,CAAC,CAAC;YAClG,SAAS;QACX,CAAC;QACD,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QACf,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACd,CAAC;IACD,OAAO,qBAAqB,CAAC,GAAG,CAAC,CAAC;AACpC,CAAC","sourcesContent":["/**\n * How a tool gets into the toolbar without this library knowing what it is.\n *\n * WHY THIS EXISTS\n * The YOLO detector and the retinal-layer segmenter used to be built in: their\n * buttons were hardcoded in the toolbar template, their model registries named\n * JAX checkpoints, and the `INSTANCE_SEGMENTER` / `SEMANTIC_SEGMENTER` tokens\n * defaulted to in-library services that imported `yolo-segdetect-js` and\n * `jax-ai-js`. Those default factories were the only thing pulling either\n * package into the bundle — the contracts themselves were already clean.\n *\n * That arrangement cannot ship in an open library while the models are closed.\n * So the tools move out, into a package that depends on this one, and arrive\n * back through {@link TOOLBAR_TOOLS}. This library keeps the contracts, the\n * chrome and the region plumbing; it no longer knows that YOLO exists.\n *\n * A host registers tools with a multi-provider:\n *\n *     { provide: TOOLBAR_TOOLS, useExisting: YoloToolContribution, multi: true }\n *\n * Register nothing and the toolbar has no segmentation tools, the help dialog\n * lists none, and neither model package is in the graph.\n *\n * WHY PARAMS ARE DECLARED, NOT RENDERED\n * A contribution describes its parameters ({@link ToolParamSpec}) instead of\n * supplying a component to draw them. The toolbar renders one generic dialog\n * from that description. The alternative — each plugin shipping its own dialog\n * component — would make every plugin depend on this library's exact PrimeNG\n * version and styling internals to look like the rest of the toolbar, and the\n * two dialogs that exist today are entirely numbers and one checkbox. A schema\n * covers them, and it is the same shape jit-ui already uses for its pipeline\n * step parameters, so the vocabulary is familiar.\n *\n * If a tool ever needs a control this cannot express, add a variant here rather\n * than an escape hatch that returns a component — the moment one tool draws\n * itself, the toolbar stops being able to lay tools out consistently.\n *\n * DIALOG TOOLS\n * Some tools are not \"set parameters, run once\" but an interactive session: the\n * user paints, the tool retrains and redraws, over and over (DIANNE). A schema\n * cannot describe that, so {@link ToolbarDialogToolContribution} is the one\n * variant that renders its own body. The toolbar still owns the button, its\n * placement and the dialog chrome; the tool only fills the dialog, with plain\n * DOM (`mount`), so it needs neither Angular nor this library's PrimeNG version.\n * Its button sits with the host's own actions at the start of the toolbar, and\n * shows only in the Image view, the view its context ({@link ToolDialogContext})\n * draws over.\n *\n * WHY AN EMPTY MODEL LIST HIDES THE TOOL\n * {@link ToolbarToolContribution.models} returning `[]` removes the tool from\n * the toolbar entirely. This preserves the behaviour the built-in tools already\n * had (their buttons were `*ngIf`'d on a filtered registry), and it gives a host\n * one switch for \"the weights are not configured in this deployment\" that does\n * not require unregistering the provider.\n */\nimport { InjectionToken } from '@angular/core';\nimport type { Observable } from 'rxjs';\n\nimport type { IVisualizer } from './visualizer.contract';\nimport type { PlotModeContext, PlotModeSession, PlotModeTools } from './plot-type-contribution.contract';\n\n/** A number field. Rendered as a stepper, matching the built-in dialogs. */\nexport interface NumberParamSpec {\n  id: string;\n  label: string;\n  type: 'number';\n  min?: number;\n  max?: number;\n  step?: number;\n  /** Decimal places to show. Omit for integers. */\n  fractionDigits?: number;\n  /** Hover help. Plain text; it is not rendered as HTML. */\n  tooltip?: string;\n}\n\n/** A checkbox. `label` sits beside it and may run to a sentence or two. */\nexport interface BooleanParamSpec {\n  id: string;\n  label: string;\n  type: 'boolean';\n  tooltip?: string;\n}\n\n/** A fixed set of choices. */\nexport interface SelectParamSpec {\n  id: string;\n  label: string;\n  type: 'select';\n  options: { label: string; value: string | number }[];\n  tooltip?: string;\n}\n\nexport type ToolParamSpec = NumberParamSpec | BooleanParamSpec | SelectParamSpec;\n\n/** One selectable checkpoint. */\nexport interface ToolModelOption {\n  id: string;\n  label: string;\n  /**\n   * Describes the checkpoint in the picker's hover tooltip — size, speed,\n   * training domain, accuracy. **Rendered as HTML**, so it is trusted content\n   * from the contributing package, never anything user-supplied.\n   */\n  info?: string;\n  /**\n   * Parameter values this checkpoint wants, merged over\n   * {@link ToolbarToolContribution.defaultParams} when it is selected. Defaults\n   * belong to the model rather than the tool — a detector trained on native 40x\n   * patches wants different tiling from one trained on thumbnails.\n   */\n  defaults?: Record<string, unknown>;\n}\n\n/**\n * The `status$` / `busy$` / `progress$` surface the toolbar drives its sticky\n * toast and progress bar from. `progress$` is a 0..1 fraction, or -1 for\n * indeterminate.\n */\nexport interface ToolProgress {\n  status$: Observable<string>;\n  busy$: Observable<boolean>;\n  progress$: Observable<number>;\n}\n\n/** Toolbar icon: a published asset, or a PrimeIcon class name. */\nexport type ToolIcon = { src: string; pi?: never } | { pi: string; src?: never };\n\n/**\n * A tool contributed to the toolbar.\n *\n * Implement it on an `@Injectable()` service in the contributing package, so it\n * can inject its own segmenter and model registry — this library provides\n * neither and must not learn to.\n */\nexport interface ToolbarToolContribution {\n  /** Stable identity, used for tracking and persisted preferences. */\n  id: string;\n  /** Short name, used in the toast and the help dialog heading. */\n  label: string;\n  icon: ToolIcon;\n\n  /** Tooltip on the run button — say what it does to the current view. */\n  runTooltip: string;\n  /** Tooltip on the checkpoint picker. Defaults to \"Pick the model\". */\n  modelTooltip?: string;\n  /** Tooltip on the parameters button. Defaults to \"Parameters\". */\n  paramsTooltip?: string;\n\n  /**\n   * Where it sits among the segmentation tools. Lower sorts first; ties fall\n   * back to registration order. The built-in prompted tools occupy 0-99, so\n   * contributed tools should start at 100 to land after them.\n   */\n  order?: number;\n\n  /** Selectable checkpoints. **Empty hides the tool.** */\n  models(): ToolModelOption[];\n  /** Which checkpoint runs when the user has not chosen. */\n  defaultModelId(): string;\n  /**\n   * Called when the user picks a checkpoint, before parameters are re-seeded.\n   * Use it to record the choice in the contributing package's own registry.\n   */\n  onModelChange?(modelId: string): void;\n\n  /** Parameter fields, in dialog order. Empty hides the parameters button. */\n  params: ToolParamSpec[];\n  /**\n   * Baseline parameter values for a checkpoint. Called on first use and again\n   * on \"Reset to model defaults\", so it must be pure and must return every key\n   * the tool reads — a parameter the dialog shows but this omits renders as\n   * empty and reaches `run` as undefined.\n   */\n  defaultParams(modelId: string): Record<string, unknown>;\n\n  /**\n   * Entry for the help dialog's tool list. `body` is rendered as HTML and may\n   * reference published assets (e.g. the tool's own icon).\n   */\n  help?: { body: string };\n\n  /** Progress surface for the toast. */\n  progress: ToolProgress;\n\n  /**\n   * Run over what is currently displayed, and write whatever it finds through\n   * `viz`. Resolves with the number of regions added.\n   *\n   * Everything the tool needs is on {@link IVisualizer}, which is part of this\n   * library's public surface — a contribution never reaches into internals.\n   * Region writes go through the same path the built-in tools use, so the\n   * index-based overlays and the Regions table stay consistent.\n   */\n  run(viz: IVisualizer, params: Record<string, unknown>): Promise<number>;\n}\n\n/**\n * What a dialog tool gets while its dialog is open: the same surface a\n * contributed plot mode gets (the public visualizer, the Image view's viewport\n * and the current image), with the toolbar tools always present.\n */\nexport type ToolDialogContext = PlotModeContext & { tools: PlotModeTools };\n\n/** A live dialog-tool session. `deactivate()` runs exactly once, after the body's teardown. */\nexport type ToolDialogSession = PlotModeSession;\n\n/**\n * A toolbar tool that opens a dialog instead of running once (see DIALOG TOOLS\n * above). Clicking its button opens the dialog and starts a session; clicking it\n * again, or closing the dialog, ends it.\n *\n * The session is bound to the Image view on screen. When that view is re-rendered\n * (another image, another slice) the session ends and, with the dialog still\n * open, a fresh one starts once the new view is ready. Leaving the Image view\n * closes the dialog. As with plot modes, nothing the tool throws or rejects\n * escapes: a failed start closes the dialog with a warning.\n */\nexport interface ToolbarDialogToolContribution {\n  kind: 'dialog';\n  /** Stable identity. Must not clash with another toolbar tool. */\n  id: string;\n  /** Short name; the dialog title unless `dialog.title` is set. */\n  label: string;\n  icon: ToolIcon;\n  /** Tooltip on the button. */\n  tooltip: string;\n  /** Order among the dialog tools. Lower sorts first; ties keep registration order. */\n  order?: number;\n  dialog?: {\n    title?: string;\n    /** CSS width of the dialog. Default `'22rem'`. */\n    width?: string;\n  };\n  /** Entry for the help dialog's tool list, rendered as HTML (trusted content). */\n  help?: { body: string };\n  /** Start a session, once the Image view's viewport is ready. */\n  activate(ctx: ToolDialogContext): ToolDialogSession | Promise<ToolDialogSession>;\n  /**\n   * Render the dialog body into `host`; return its teardown (called before\n   * `deactivate()`). Called after `activate` resolves, once the dialog has rendered and\n   * `host` is in the document, so the body can measure itself.\n   */\n  mount(host: HTMLElement, ctx: ToolDialogContext, session: ToolDialogSession): () => void;\n}\n\n/** Anything provided on {@link TOOLBAR_TOOLS}. A run tool has no `kind`. */\nexport type ToolbarContribution = ToolbarToolContribution | ToolbarDialogToolContribution;\n\n/** Whether a contribution is a {@link ToolbarDialogToolContribution}. */\nexport function isDialogToolContribution(c: unknown): c is ToolbarDialogToolContribution {\n  return !!c && (c as { kind?: unknown }).kind === 'dialog';\n}\n\n/**\n * Multi-provider token for contributed tools: run tools\n * ({@link ToolbarToolContribution}) and, since 0.6.0, dialog tools\n * ({@link ToolbarDialogToolContribution}).\n *\n * Deliberately has no `factory`: unregistered means no tools, which is what\n * makes this library shippable without the closed model packages. Inject it\n * `{ optional: true }` and treat null as empty.\n */\nexport const TOOLBAR_TOOLS = new InjectionToken<readonly ToolbarContribution[]>('TOOLBAR_TOOLS');\n\n/** Sort contributed tools into display order. */\nexport function sortToolContributions<T extends { order?: number }>(\n  tools: readonly T[],\n): T[] {\n  // Stable: equal `order` keeps registration order, so a host controls ties by\n  // provider order without having to invent numbers.\n  return tools.map((t, i) => ({ t, i })).sort((a, b) =>\n    (a.t.order ?? 100) - (b.t.order ?? 100) || a.i - b.i,\n  ).map(({ t }) => t);\n}\n\n/** The run tools a toolbar should actually show: those with at least one model.\n *  Dialog tools are left out (see {@link dialogToolContributions}). */\nexport function visibleToolContributions(\n  tools: readonly ToolbarContribution[] | null | undefined,\n): ToolbarToolContribution[] {\n  const run = (tools ?? []).filter(\n    (t): t is ToolbarToolContribution =>\n      !isDialogToolContribution(t) && typeof (t as ToolbarToolContribution)?.models === 'function',\n  );\n  return sortToolContributions(run).filter((t) => t.models().length > 0);\n}\n\n/**\n * The dialog tools, in display order. A malformed one (no string `id`, no\n * `activate` or `mount` function) or a repeated `id` is dropped with a warning\n * rather than breaking the toolbar.\n */\nexport function dialogToolContributions(\n  tools: readonly ToolbarContribution[] | null | undefined,\n  log: { warn(...args: unknown[]): void } = console,\n): ToolbarDialogToolContribution[] {\n  const seen = new Set<string>();\n  const out: ToolbarDialogToolContribution[] = [];\n  for (const t of (tools ?? []).filter(isDialogToolContribution)) {\n    if (typeof t.id !== 'string' || !t.id || typeof t.activate !== 'function'\n        || typeof t.mount !== 'function') {\n      log.warn('[visualizer] dialog tool ignored: it needs a string `id` and `activate` and `mount` functions.', t);\n      continue;\n    }\n    if (seen.has(t.id)) {\n      log.warn(`[visualizer] dialog tool '${t.id}' ignored: another dialog tool already uses that id.`);\n      continue;\n    }\n    seen.add(t.id);\n    out.push(t);\n  }\n  return sortToolContributions(out);\n}\n"]}

package/esm2022/lib/contracts/visualizer.contract.mjs

@@ -7,4 +7,4 @@ import { InjectionToken } from '@angular/core';
  * the routing/fallback implementation can change without touching constructors.
  */
 export const VISUALIZER = new InjectionToken('VISUALIZER');
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"visualizer.contract.js","sourceRoot":"","sources":["../../../../src/lib/contracts/visualizer.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAkd/C;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,IAAI,cAAc,CAAc,YAAY,CAAC,CAAC","sourcesContent":["import { InjectionToken } from '@angular/core';\nimport { Observable } from 'rxjs';\nimport { Image } from 'image-js';\n\nimport { IImageInfo, IImageMetadata } from './image.contract';\nimport { Region } from '../models/region';\nimport { PlotType, PlotTypeDescriptor } from './plot-type';\nimport { ViewerCapabilities } from './capabilities.contract';\nimport { IRegionOverlay } from './region-overlay.contract';\nimport { IHistogram } from './channel-histogram-api.contract';\nimport { ColormapNode, IWandOptions, IBrushOptions, SpatialViewState, SpatialColorBy } from './display-types';\nimport {\n  SpatialDataset,\n  SpatialEmbedding,\n} from './spatial-dataset.contract';\nimport { SpatialSelectionMask } from '../spatial/spatial-selection';\n\n/**\n * Backend-neutral visualization contract. Plotly is one implementation;\n * OpenSeadragon is another (for the image plot type). The abstraction renders\n * data — a raster image OR a scientific plot (heatmap, surface, contour,\n * scatter, line, isosurface) — draws regions on it, and drives on-canvas tools.\n *\n * Split into role interfaces so a consumer can depend only on the slice it\n * uses, then composed into `IVisualizer`.\n *\n * Types are intentionally permissive (`any` where the current Plotly service\n * is untyped) so `PlotlyService` satisfies the contract without a typing\n * rewrite — tightening is a follow-up, not part of standing the interface up.\n */\n\n/** Pixel readback shape returned by `getDisplayedPixelData`. */\nexport interface PixelData {\n  width: number;\n  height: number;\n  channels: number;\n  data: Uint8ClampedArray;\n}\n\n/** Intensity sampled along a line ROI (PlotType.LINE over image data). */\nexport interface IntensityProfile {\n  /** Distance along the line. In microns when the image carries a physical\n   *  pixel size (mpp); otherwise in image pixels. See {@link unit}. */\n  positions: number[];\n  /** Sampled intensity (grayscale value or RGB luminance). */\n  values: number[];\n  /** Unit of {@link positions}: 'µm' when scaled by the image's mpp, else 'px'. */\n  unit?: 'µm' | 'px';\n  /** Stable id of the line ROI this profile came from (multi-line support). */\n  id?: number;\n  /** Colour of the line ROI — the inset trace is drawn in the same colour. */\n  color?: string;\n}\n\n/**\n * The render/viewport role: load data, render it (image or plot), and handle\n * zoom, stack navigation, and pixel readback.\n */\nexport interface IDataRenderer {\n  load(imageInfo: IImageInfo, zIndex: number): Promise<any>;\n  /** `imageLoaded` is the backend-specific handle returned by `load()` —\n   *  treat it as opaque and pass it straight through. */\n  plot(plotDiv: string, imageLoaded: unknown, imageInfo: IImageInfo, screenHeight: number,\n       plotType: PlotType, inPlace?: boolean): Promise<boolean>;\n  /** @deprecated Plotly-specific re-render; the OSD backend no-ops it. The host\n   *  re-drives `plot()` from its image stream instead. */\n  reloadAndPlot(): void;\n  reset(): void;\n  relayout(trueImageSize?: number[]): void;\n  /** @deprecated Plotly-specific (axis reset); the OSD backend no-ops it. Gate\n   *  on {@link ViewerCapabilities} before calling. */\n  resetAxes(): void;\n  /** @deprecated Plotly-specific (autoscale); the OSD backend no-ops it. Gate\n   *  on {@link ViewerCapabilities} before calling. */\n  autoscale(): void;\n  zoomIn(): void;\n  zoomOut(): void;\n  setDragMode(mode: string | false): void;\n  /** Show/hide the overview navigator (the minimap). OpenSeadragon only — Plotly\n   *  no-ops it (it has no navigator). Applied when the viewer is (re)created, and\n   *  toggled live when one is already mounted. */\n  setNavigatorVisible(visible: boolean): void;\n  /** Image smoothing (bilinear interpolation). `false` = nearest-neighbour, so\n   *  zooming past 1:1 shows crisp pixel blocks (pixel-level inspection).\n   *  OpenSeadragon only — Plotly no-ops it. Applied at viewer creation and live\n   *  (with a redraw) when one is mounted. */\n  setImageSmoothingEnabled(enabled: boolean): void;\n\n  setShowStack(showstack: boolean): void;\n  setZIndex(zIndex: number): void;\n  setStackLoading(stackLoading: boolean): void;\n  isStackLoading(): Observable<boolean>;\n  getStackLoadingProgress(): Observable<number>;\n  /** Cancel any in-flight multi-frame loading (volume-assembly / surface preload) so it stops\n   *  fetching more frames and clears the loading state. Optional — only backends that stream a\n   *  z-stack (napari-js WebGPU) do real work here; others no-op. */\n  cancelLoading?(): void;\n\n  getTrueImageSize(): { width: number; height: number } | null;\n  getCurrentImage(): Promise<Image | null>;\n  getDisplayedPixelData(): PixelData | null;\n  /**\n   * The region of the original, full-resolution image that the pixels returned\n   * by {@link getDisplayedPixelData} currently cover — `{ x, y, width, height }`\n   * in full-image pixel coordinates. When zoomed/panned into a sub-area this is\n   * the crop's origin + extent; when zoomed out/panned beyond the edges, the\n   * rectangle may extend outside the image bounds (matching the pixel readback\n   * canvas). Lets a consumer map displayed-pixel coordinates back to the original\n   * image via `origin + displayedPx * (extent / displayedDim)`. \n   *\n   * Returns `null` when the viewport isn't laid out yet or the backend can't\n   * report it — callers should then fall back to the full-image scale (treat\n   * the displayed pixels as a downsample of the whole image).\n   */\n  getDisplayedSourceRect(): { x: number; y: number; width: number; height: number } | null;\n  downloadImage(): void;\n\n  setPlotType(plotType: PlotType): void;\n  /** Set the napari 3D decimate factor (1 = full … 8 = ⅛). Optional — only the napari-js WebGPU\n   *  backend honors it; changing it re-loads the current 3D plot at the coarser/finer sampling. */\n  setResolutionScale?(scale: number): void;\n  /** The current napari 3D decimate factor (to initialize the Resolution control). Optional. */\n  getResolutionScale?(): number;\n  /** @deprecated Use `getSurface3dControls()` — 3D scene controls only exist on\n   *  a backend that renders 3D plot types; this method silently no-ops on OSD. */\n  setSurfaceDragMode(mode: string): void;\n  /** @deprecated Use `getSurface3dControls()` — see {@link setSurfaceDragMode}. */\n  resetSurfaceCamera(): void;\n\n  getAutoscaleEvent(): Observable<any>;\n\n  /** Plot types this backend advertises (drives the UI selector). */\n  getPlotTypeDescriptors(): PlotTypeDescriptor[];\n\n  /** Intensity along the line ROIs; emits the full set as any line is added,\n   *  moved, or removed (PlotType.LINE). One entry per line ROI. */\n  getIntensityProfile$(): Observable<IntensityProfile[]>;\n\n  /** Render the floating intensity-profile inset chart into `divId` from the\n   *  given profiles (one trace per line ROI, coloured to match its line).\n   *  Owned by the backend so consumers never reach a charting library directly. */\n  renderIntensityInset(divId: string, profiles: IntensityProfile[]): void;\n}\n\n/** Region/shape state: CRUD, selection, classification colours, GeoJSON I/O. */\nexport interface IRegionStore {\n  setRegions(regions: Region[], showRegionLabel?: boolean, isRegionSaveOn?: boolean,\n             fillColor?: string, append?: boolean): void;\n  /** Framework-neutral accessor — the canonical way to read current regions. */\n  getRegions(): Region[];\n  getRegionPolygons(): any[];\n  getRegionUpdateEvent(): Observable<any[]>;\n\n  setSelectedShapeIndices(indices: number[]): void;\n  getSelectedShapeIndices$(): Observable<number[]>;\n  /** Select a specific region (by identity), highlighting it on whichever\n   *  backend is rendering — Plotly sets its active-shape handles, OpenSeadragon\n   *  highlights the SVG element. No-op if the region isn't in the store. */\n  selectRegion(region: Region): void;\n  deleteActiveShape(): void;\n\n  getShowShapeLabel(): boolean;\n  getShapeColor(): string;\n  getFillColor(): string;\n  getClassificationColors(): Map<string, string>;\n  setClassificationColor(label: string, color: string): void;\n\n  plotPreviousShapes(): void;\n  setPreviousShapes(shapes: any[]): void;\n  getPreviousShapes(): any[];\n\n  /** Undo the most recent region action (jit-ui#85). Restores the region set to\n   *  the state before that action; up to a small fixed depth (10) is retained,\n   *  so it can be invoked up to 10 times in a row. No-op when nothing is left to\n   *  undo. */\n  undo(): void;\n  /** Re-apply the most recently undone region action. No-op when there's\n   *  nothing to redo (any fresh region action clears the redo future). */\n  redo(): void;\n  /** Synchronous read of {@link getCanUndo$}. */\n  canUndo(): boolean;\n  /** Synchronous read of {@link getCanRedo$}. */\n  canRedo(): boolean;\n  /** Emits whether an undo step is currently available — drives the toolbar\n   *  Undo button's enabled (greyed-out) state. */\n  getCanUndo$(): Observable<boolean>;\n  /** Emits whether a redo step is currently available — drives the toolbar\n   *  Redo button's enabled (greyed-out) state. */\n  getCanRedo$(): Observable<boolean>;\n  /** Clear the undo/redo history (e.g. on image load/switch). */\n  resetUndoHistory(): void;\n\n  importRegions(geoJsonStr: string): Region[];\n  exportRegions(regions: Region[]): void;\n  getGeoJsonString(regions: Region[]): string;\n\n  /** Begin a per-slice z-stack region session (jit-ui#93). `slices` maps each\n   *  zero-based slice index to that slice's regions; the store shows `initialZ`\n   *  live while holding the rest, so scrubbing swaps region sets and edits on a\n   *  slice persist. `saveLayout` records how the stack persists — `combined`\n   *  (one z-indexed geojson, single-file z-stack) or `per-slice-file` (folder\n   *  stack). See {@link setDisplaySlice}, {@link getSliceRegions}. */\n  enterStackMode(slices: Map<number, Region[]>, initialZ?: number,\n                 saveLayout?: 'combined' | 'per-slice-file'): void;\n  /** End the per-slice session (single-plane image, or the stack was closed). */\n  exitStackMode(): void;\n  /** True while a per-slice z-stack session is active. */\n  isStackMode(): boolean;\n  /** How the current stack persists to disk (jit-ui#93). */\n  getStackSaveLayout(): 'combined' | 'per-slice-file';\n  /** Swap the live region set to slice `z` (stack mode only), capturing the\n   *  current slice's edits first. Called on every committed slice scrub. */\n  setDisplaySlice(z: number): void;\n  /** Every slice's regions for save/export, each tagged with its zero-based\n   *  {@link Region.z}; the flat set outside stack mode. */\n  getSliceRegions(): Region[];\n  /** Slices to write on a per-slice-file save (folder stack, jit-ui#93): each\n   *  slice with regions, plus slices cleared since load (empty, to overwrite).\n   *  Keyed by zero-based slice index; regions tagged with their z. */\n  getStackSaveSlices(): Map<number, Region[]>;\n}\n\n/** On-canvas tool modes (wand, brush, vertex eraser, zoom-to-box). */\nexport interface IToolController {\n  setWandMode(active: boolean, options?: IWandOptions): void;\n  setWandOptions(options: IWandOptions): void;\n  clearActiveWandRegion(): void;\n  /** Brush region tool. `size` (matrix-pixel diameter) sizes the painted disc. */\n  setBrushMode(active: boolean, options?: IBrushOptions): void;\n  setBrushOptions(options: IBrushOptions): void;\n  setVertexEraserMode(active: boolean): void;\n  setVertexEraserRadius(radius: number): void;\n  setZoomToBoxMode(active: boolean): void;\n  /** Box-prompted SAM segmentation: segment every rectangle region into masks.\n   *  Returns the number of mask regions added. (jit-ui#90) */\n  segmentRectangles(): Promise<number>;\n  /** Cellpose-on-crop: client slide-crop each rectangle and segment cells in it\n   *  (cellpose-SAM via the host's CELL_SEGMENTER). Returns regions added. */\n  segmentRectanglesCellpose(): Promise<number>;\n  /** Choose the registered SAM model the segment tools use (jit-ui#90 P1). */\n  setSamModel(id: string): void;\n  /** Toggle the interactive SAM point-prompt tool (click = +point, Shift = -). */\n  setSamPointMode(active: boolean): void;\n  /** Finalise / discard the in-progress SAM point object. */\n  commitSamPoints(): void;\n  clearSamPoints(): void;\n}\n\n/**\n * Controls specific to the ISOSURFACE plot type. Optional and capability-gated\n * (`ViewerFeature.Isosurface`): only a backend that renders isosurfaces exposes\n * it, via `IVisualizer.getIsosurfaceControls()`. Kept off the always-on\n * contract so consumers never call a control that's meaningless for the current\n * plot type / backend.\n */\nexport interface IIsosurfaceControls {\n  /** Live-update the isosurface intensity band [isomin, isomax] over 0–255. */\n  setIsoRange(isoMin: number, isoMax: number): void;\n}\n\n/**\n * Controls specific to the 3D plot types (SURFACE / SCATTER3D / ISOSURFACE\n * scenes). Capability-gated like {@link IIsosurfaceControls}: only a backend\n * that renders 3D scenes exposes it, via `IVisualizer.getSurface3dControls()` —\n * the deprecated top-level `setSurfaceDragMode`/`resetSurfaceCamera` silently\n * no-op on 2D-only backends.\n */\nexport interface ISurface3dControls {\n  /** Switch the 3D scene interaction mode (orbit / turntable / pan / zoom). */\n  setSurfaceDragMode(mode: string): void;\n  /** Reset the 3D scene camera to its default eye position. */\n  resetSurfaceCamera(): void;\n  /** Toggle the 3D coordinate-axes / scale gizmo on/off. Optional — only the napari-js WebGPU\n   *  volume/isosurface backend renders one (jit-ui#102). */\n  setAxesVisible?(visible: boolean): void;\n  /** Whether the axes gizmo is currently shown (for initializing the toggle UI). Optional. */\n  axesVisible?(): boolean;\n  /** Render the surface as a wireframe (edges) instead of a filled surface. Optional — only the\n   *  napari-js WebGPU surface backend supports it (jit-ui#102). */\n  setWireframe?(on: boolean): void;\n  /** Whether the surface is currently drawn as a wireframe (for initializing the toggle UI). */\n  wireframe?(): boolean;\n}\n\n/**\n * Controls specific to the LINE (intensity-profile) plot type. Capability-gated\n * like {@link IIsosurfaceControls}: only a backend that renders the line-ROI /\n * inset exposes it, via `IVisualizer.getIntensityControls()`.\n */\nexport interface IIntensityControls {\n  /** Add another line ROI (next bright palette colour) and its inset trace.\n   *  Returns the created region so the caller can select it on the active\n   *  backend, or null if no image extent is known yet. */\n  addProfileLine(): Region | null;\n}\n\n/** A categorical column resolved for charting: labels, codes and map colours. */\nexport interface SpatialCategoricalView {\n  name: string;\n  categories: string[];\n  /** `#rrggbb` per category, index-aligned with {@link categories}. */\n  colors: string[];\n  /** Per-observation category index, or `NO_CATEGORY`. */\n  codes: Uint16Array;\n}\n\n/**\n * Controls for the SPATIAL_OMICS plot type: what the observation markers are\n * coloured by, and how they are drawn. Capability-gated like\n * {@link IIsosurfaceControls} — `getSpatialControls()` returns null unless a\n * host has bound `SPATIAL_DATA_PORT`.\n *\n * The view state is backend-neutral (it lives in the shared store, like the\n * colormap), so these controls work whichever backend is on screen.\n */\nexport interface ISpatialControls {\n  /** The dataset being visualized, or null. Drives the column/gene pickers and\n   *  the legend. */\n  getDataset$(): Observable<SpatialDataset | null>;\n  /** Current display state (colour source, point scale, opacity, scaling). */\n  getViewState$(): Observable<SpatialViewState>;\n  /** Synchronous read, for seeding a control's initial value. */\n  viewState(): SpatialViewState;\n  /** Patch the display state; the markers rebuild without remounting the scene. */\n  setViewState(partial: Partial<SpatialViewState>): void;\n  /** Colour by an annotation column. Rejects for an unknown column. */\n  colorByColumn(name: string): void;\n  /** Colour by a gene; its vector is fetched on demand. */\n  colorByFeature(name: string): void;\n  /** Clear the colour source — every observation renders in one neutral colour. */\n  clearColorBy(): void;\n  /** Typeahead over feature names, for datasets too wide to inline the list. */\n  searchFeatures(query: string, limit?: number): Promise<string[]>;\n  /** Per-category display colours for a categorical column, index-aligned with\n   *  its `categories` — the legend's swatches, resolved the same way the\n   *  renderer resolves them so the two cannot disagree. */\n  categoryColors(name: string): Promise<string[]>;\n\n  // ── values, for the 1-D charts ────────────────────────────────────────\n  /**\n   * The values behind a colour source, index-aligned with the observations.\n   * Rejects for a categorical column — there is nothing continuous to chart.\n   */\n  continuousValues(source: SpatialColorBy): Promise<Float32Array>;\n  /**\n   * A categorical column's categories, per-observation codes and display\n   * colours — everything a grouped violin/box needs, with the colours resolved\n   * the same way the map resolves them.\n   */\n  categoricalView(column: string): Promise<SpatialCategoricalView>;\n\n  /**\n   * One embedding's coordinates — a UMAP, t-SNE or PCA plane over the same observations.\n   *\n   * Optional, and absent when the data source serves none: `SpatialDataPort.getEmbedding`\n   * is itself optional, so a panel must be able to ask whether this exists rather than\n   * calling it and catching.\n   */\n  getEmbedding?(name: string): Promise<SpatialEmbedding>;\n  /** Names of the categorical columns available to group by. */\n  categoricalColumns(): string[];\n  /**\n   * The z positions of the sections the dataset was imaged at, ascending — or\n   * null when its z is continuous rather than sectioned (so there are no sections\n   * to offer) or when there is no dataset.\n   *\n   * Lets a panel offer \"one section at a time\" for the 3D cloud only where that\n   * means something, and label the chosen one. Scanned once per dataset.\n   */\n  sampledSections(): Float32Array | null;\n\n  // ── selection ─────────────────────────────────────────────────────────\n  /** The current selection. Empty means \"nothing selected\", in which case the\n   *  whole tissue renders normally rather than everything being muted. */\n  getSelection$(): Observable<SpatialSelectionMask>;\n  /**\n   * Select every observation inside the currently-drawn regions (their union).\n   * Reuses the existing ROI tools — rectangle, polygon, freehand, wand, brush —\n   * so there is no separate marquee to learn. Returns how many were selected.\n   */\n  selectFromRegions(): number;\n  /** Select every observation in one category of a categorical column — the\n   *  legend click. Rejects for an unknown or continuous column. */\n  selectCategory(column: string, categoryIndex: number): Promise<number>;\n\n  /**\n   * Select an explicit set of observations, replacing any current selection.\n   *\n   * For a linked plot: lassoing points in an embedding is a selection OF observations,\n   * and every other view — the map, the distributions — reads the same mask, so brushing\n   * one lights up the rest. Returns how many were selected.\n   */\n  selectIndices(indices: Iterable<number>): number;\n  clearSelection(): void;\n}\n\n/** Display options (colormap/LUT, reverse scale, image metadata). */\nexport interface IDisplayOptions {\n  getColormap(): Observable<ColormapNode | null>;\n  setColormap(colormap: ColormapNode): void;\n  getColormapOptions(): ColormapNode[];\n  getReverseScale(): Observable<boolean>;\n  setReverseScale(reverscale: any): void;\n  setImageMeta(imageMeta: IImageMetadata[]): void;\n  getImageMeta(): Observable<IImageMetadata[]>;\n}\n\n/**\n * Intensity-profile sampling (PlotType.LINE). The sampling *source* lives in the\n * Plotly backend (it owns pixel readback); OpenSeadragon contributes only the\n * viewport-change signal that drives re-sampling at the current zoom. Each\n * backend implements the part it owns and no-ops the rest — mirroring the\n * deprecated no-op pattern on {@link IDataRenderer} — so the contract is uniform\n * and a consumer can depend on `IVisualizer` alone (no concrete-type reach-in).\n */\nexport interface IIntensitySampling {\n  /** Populate the intensity-sampling cache for the current image/slice so the\n   *  line-ROI profiles have pixel data. Real on Plotly; no-op on OSD. */\n  ensureIntensitySampling(imageInfo: IImageInfo, zIndex: number): Promise<void>;\n  /** Re-sample the profiles from a fresh crop of the given image-pixel ROI at\n   *  display resolution. Real on Plotly; no-op on OSD. */\n  refreshIntensitySamplingForRoi(x: number, y: number, width: number, height: number,\n                                 zIndex: number): void;\n  /** Visible-region changes (image-pixel coords), emitted when the view settles,\n   *  so the inset can re-sample at the current zoom. Real on OSD; empty on Plotly\n   *  (its high-def zoom updates the sampling cache inline instead). */\n  getViewportChange$(): Observable<{ x: number; y: number; width: number; height: number }>;\n}\n\n/** Composite contract a visualization backend implements. */\nexport interface IVisualizer extends IDataRenderer, IRegionStore, IToolController, IDisplayOptions,\n  IIntensitySampling {\n  readonly capabilities: ViewerCapabilities;\n  /** This backend's region renderer. May be null until a plot is mounted\n   *  (OpenSeadragon). Drives region draw/select modes uniformly. */\n  getRegionOverlay(): IRegionOverlay | null;\n  /** Isosurface controls when this backend advertises `ViewerFeature.Isosurface`,\n   *  else null — so consumers gate on the returned object, not a no-op method. */\n  getIsosurfaceControls(): IIsosurfaceControls | null;\n  /** Intensity (line-ROI) controls when the backend renders the LINE plot type,\n   *  else null. */\n  getIntensityControls(): IIntensityControls | null;\n  /** 3D scene controls when this backend renders 3D plot types, else null —\n   *  the capability-gated replacement for the deprecated top-level\n   *  `setSurfaceDragMode`/`resetSurfaceCamera`. */\n  getSurface3dControls(): ISurface3dControls | null;\n  /** Spatial-omics controls when a `SPATIAL_DATA_PORT` is bound, else null.\n   *  Optional: only the routing service implements it, since the state is shared\n   *  rather than owned by any one backend. */\n  getSpatialControls?(): ISpatialControls | null;\n  /** Binned intensity histogram for a channel from the currently-displayed\n   *  pixels, or null when none are available. Feeds the Channels & Histogram\n   *  pane. */\n  getHistogram(channelIndex: number, bins: number): IHistogram | null;\n  /** Async histogram stream — native bit depth for >8-bit images (server), else\n   *  the 8-bit client histogram. */\n  getHistogram$(channelIndex: number, bins: number): Observable<IHistogram | null>;\n  /** Export the displayed image, composited with the current display settings,\n   *  as a publication-ready PNG download. */\n  exportComposite(): void;\n  /** Export the underlying image data as a data-preserving multi-band TIFF\n   *  (native bit depth). No-op on backends that can't provide it. */\n  exportData(): void;\n  unsubscribe(): void;\n}\n\n/**\n * DI token for the active visualization backend. Bind it (`useExisting`) to the\n * `RoutingVisualizerService`, which selects Plotly vs OpenSeadragon per plot\n * type. Consumers — including this library's own `VisualizerComponent` —\n * inject `IVisualizer` through this token rather than the concrete router, so\n * the routing/fallback implementation can change without touching constructors.\n */\nexport const VISUALIZER = new InjectionToken<IVisualizer>('VISUALIZER');\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"visualizer.contract.js","sourceRoot":"","sources":["../../../../src/lib/contracts/visualizer.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAud/C;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,IAAI,cAAc,CAAc,YAAY,CAAC,CAAC","sourcesContent":["import { InjectionToken } from '@angular/core';\nimport { Observable } from 'rxjs';\nimport { Image } from 'image-js';\n\nimport { IImageInfo, IImageMetadata } from './image.contract';\nimport { Region } from '../models/region';\nimport { PlotType, PlotTypeDescriptor } from './plot-type';\nimport { ViewerCapabilities } from './capabilities.contract';\nimport { IRegionOverlay } from './region-overlay.contract';\nimport { IHistogram } from './channel-histogram-api.contract';\nimport { ColormapNode, IWandOptions, IBrushOptions, SpatialViewState, SpatialColorBy } from './display-types';\nimport {\n  SpatialDataset,\n  SpatialEmbedding,\n} from './spatial-dataset.contract';\nimport { SpatialSelectionMask } from '../spatial/spatial-selection';\nimport type { PlotModeViewport } from './plot-type-contribution.contract';\n\n/**\n * Backend-neutral visualization contract. Plotly is one implementation;\n * OpenSeadragon is another (for the image plot type). The abstraction renders\n * data — a raster image OR a scientific plot (heatmap, surface, contour,\n * scatter, line, isosurface) — draws regions on it, and drives on-canvas tools.\n *\n * Split into role interfaces so a consumer can depend only on the slice it\n * uses, then composed into `IVisualizer`.\n *\n * Types are intentionally permissive (`any` where the current Plotly service\n * is untyped) so `PlotlyService` satisfies the contract without a typing\n * rewrite — tightening is a follow-up, not part of standing the interface up.\n */\n\n/** Pixel readback shape returned by `getDisplayedPixelData`. */\nexport interface PixelData {\n  width: number;\n  height: number;\n  channels: number;\n  data: Uint8ClampedArray;\n}\n\n/** Intensity sampled along a line ROI (PlotType.LINE over image data). */\nexport interface IntensityProfile {\n  /** Distance along the line. In microns when the image carries a physical\n   *  pixel size (mpp); otherwise in image pixels. See {@link unit}. */\n  positions: number[];\n  /** Sampled intensity (grayscale value or RGB luminance). */\n  values: number[];\n  /** Unit of {@link positions}: 'µm' when scaled by the image's mpp, else 'px'. */\n  unit?: 'µm' | 'px';\n  /** Stable id of the line ROI this profile came from (multi-line support). */\n  id?: number;\n  /** Colour of the line ROI — the inset trace is drawn in the same colour. */\n  color?: string;\n}\n\n/**\n * The render/viewport role: load data, render it (image or plot), and handle\n * zoom, stack navigation, and pixel readback.\n */\nexport interface IDataRenderer {\n  load(imageInfo: IImageInfo, zIndex: number): Promise<any>;\n  /** `imageLoaded` is the backend-specific handle returned by `load()` —\n   *  treat it as opaque and pass it straight through. */\n  plot(plotDiv: string, imageLoaded: unknown, imageInfo: IImageInfo, screenHeight: number,\n       plotType: PlotType, inPlace?: boolean): Promise<boolean>;\n  /** @deprecated Plotly-specific re-render; the OSD backend no-ops it. The host\n   *  re-drives `plot()` from its image stream instead. */\n  reloadAndPlot(): void;\n  reset(): void;\n  relayout(trueImageSize?: number[]): void;\n  /** @deprecated Plotly-specific (axis reset); the OSD backend no-ops it. Gate\n   *  on {@link ViewerCapabilities} before calling. */\n  resetAxes(): void;\n  /** @deprecated Plotly-specific (autoscale); the OSD backend no-ops it. Gate\n   *  on {@link ViewerCapabilities} before calling. */\n  autoscale(): void;\n  zoomIn(): void;\n  zoomOut(): void;\n  setDragMode(mode: string | false): void;\n  /** Show/hide the overview navigator (the minimap). OpenSeadragon only — Plotly\n   *  no-ops it (it has no navigator). Applied when the viewer is (re)created, and\n   *  toggled live when one is already mounted. */\n  setNavigatorVisible(visible: boolean): void;\n  /** Image smoothing (bilinear interpolation). `false` = nearest-neighbour, so\n   *  zooming past 1:1 shows crisp pixel blocks (pixel-level inspection).\n   *  OpenSeadragon only — Plotly no-ops it. Applied at viewer creation and live\n   *  (with a redraw) when one is mounted. */\n  setImageSmoothingEnabled(enabled: boolean): void;\n\n  setShowStack(showstack: boolean): void;\n  setZIndex(zIndex: number): void;\n  setStackLoading(stackLoading: boolean): void;\n  isStackLoading(): Observable<boolean>;\n  getStackLoadingProgress(): Observable<number>;\n  /** Cancel any in-flight multi-frame loading (volume-assembly / surface preload) so it stops\n   *  fetching more frames and clears the loading state. Optional — only backends that stream a\n   *  z-stack (napari-js WebGPU) do real work here; others no-op. */\n  cancelLoading?(): void;\n\n  getTrueImageSize(): { width: number; height: number } | null;\n  getCurrentImage(): Promise<Image | null>;\n  getDisplayedPixelData(): PixelData | null;\n  /**\n   * The region of the original, full-resolution image that the pixels returned\n   * by {@link getDisplayedPixelData} currently cover — `{ x, y, width, height }`\n   * in full-image pixel coordinates. When zoomed/panned into a sub-area this is\n   * the crop's origin + extent; when zoomed out/panned beyond the edges, the\n   * rectangle may extend outside the image bounds (matching the pixel readback\n   * canvas). Lets a consumer map displayed-pixel coordinates back to the original\n   * image via `origin + displayedPx * (extent / displayedDim)`. \n   *\n   * Returns `null` when the viewport isn't laid out yet or the backend can't\n   * report it — callers should then fall back to the full-image scale (treat\n   * the displayed pixels as a downsample of the whole image).\n   */\n  getDisplayedSourceRect(): { x: number; y: number; width: number; height: number } | null;\n  downloadImage(): void;\n\n  setPlotType(plotType: PlotType): void;\n  /** Set the napari 3D decimate factor (1 = full … 8 = ⅛). Optional — only the napari-js WebGPU\n   *  backend honors it; changing it re-loads the current 3D plot at the coarser/finer sampling. */\n  setResolutionScale?(scale: number): void;\n  /** The current napari 3D decimate factor (to initialize the Resolution control). Optional. */\n  getResolutionScale?(): number;\n  /** @deprecated Use `getSurface3dControls()` — 3D scene controls only exist on\n   *  a backend that renders 3D plot types; this method silently no-ops on OSD. */\n  setSurfaceDragMode(mode: string): void;\n  /** @deprecated Use `getSurface3dControls()` — see {@link setSurfaceDragMode}. */\n  resetSurfaceCamera(): void;\n\n  getAutoscaleEvent(): Observable<any>;\n\n  /** Plot types this backend advertises (drives the UI selector). */\n  getPlotTypeDescriptors(): PlotTypeDescriptor[];\n\n  /** Intensity along the line ROIs; emits the full set as any line is added,\n   *  moved, or removed (PlotType.LINE). One entry per line ROI. */\n  getIntensityProfile$(): Observable<IntensityProfile[]>;\n\n  /** Render the floating intensity-profile inset chart into `divId` from the\n   *  given profiles (one trace per line ROI, coloured to match its line).\n   *  Owned by the backend so consumers never reach a charting library directly. */\n  renderIntensityInset(divId: string, profiles: IntensityProfile[]): void;\n}\n\n/** Region/shape state: CRUD, selection, classification colours, GeoJSON I/O. */\nexport interface IRegionStore {\n  setRegions(regions: Region[], showRegionLabel?: boolean, isRegionSaveOn?: boolean,\n             fillColor?: string, append?: boolean): void;\n  /** Framework-neutral accessor — the canonical way to read current regions. */\n  getRegions(): Region[];\n  getRegionPolygons(): any[];\n  getRegionUpdateEvent(): Observable<any[]>;\n\n  setSelectedShapeIndices(indices: number[]): void;\n  getSelectedShapeIndices$(): Observable<number[]>;\n  /** Select a specific region (by identity), highlighting it on whichever\n   *  backend is rendering — Plotly sets its active-shape handles, OpenSeadragon\n   *  highlights the SVG element. No-op if the region isn't in the store. */\n  selectRegion(region: Region): void;\n  deleteActiveShape(): void;\n\n  getShowShapeLabel(): boolean;\n  getShapeColor(): string;\n  getFillColor(): string;\n  getClassificationColors(): Map<string, string>;\n  setClassificationColor(label: string, color: string): void;\n\n  plotPreviousShapes(): void;\n  setPreviousShapes(shapes: any[]): void;\n  getPreviousShapes(): any[];\n\n  /** Undo the most recent region action (jit-ui#85). Restores the region set to\n   *  the state before that action; up to a small fixed depth (10) is retained,\n   *  so it can be invoked up to 10 times in a row. No-op when nothing is left to\n   *  undo. */\n  undo(): void;\n  /** Re-apply the most recently undone region action. No-op when there's\n   *  nothing to redo (any fresh region action clears the redo future). */\n  redo(): void;\n  /** Synchronous read of {@link getCanUndo$}. */\n  canUndo(): boolean;\n  /** Synchronous read of {@link getCanRedo$}. */\n  canRedo(): boolean;\n  /** Emits whether an undo step is currently available — drives the toolbar\n   *  Undo button's enabled (greyed-out) state. */\n  getCanUndo$(): Observable<boolean>;\n  /** Emits whether a redo step is currently available — drives the toolbar\n   *  Redo button's enabled (greyed-out) state. */\n  getCanRedo$(): Observable<boolean>;\n  /** Clear the undo/redo history (e.g. on image load/switch). */\n  resetUndoHistory(): void;\n\n  importRegions(geoJsonStr: string): Region[];\n  exportRegions(regions: Region[]): void;\n  getGeoJsonString(regions: Region[]): string;\n\n  /** Begin a per-slice z-stack region session (jit-ui#93). `slices` maps each\n   *  zero-based slice index to that slice's regions; the store shows `initialZ`\n   *  live while holding the rest, so scrubbing swaps region sets and edits on a\n   *  slice persist. `saveLayout` records how the stack persists — `combined`\n   *  (one z-indexed geojson, single-file z-stack) or `per-slice-file` (folder\n   *  stack). See {@link setDisplaySlice}, {@link getSliceRegions}. */\n  enterStackMode(slices: Map<number, Region[]>, initialZ?: number,\n                 saveLayout?: 'combined' | 'per-slice-file'): void;\n  /** End the per-slice session (single-plane image, or the stack was closed). */\n  exitStackMode(): void;\n  /** True while a per-slice z-stack session is active. */\n  isStackMode(): boolean;\n  /** How the current stack persists to disk (jit-ui#93). */\n  getStackSaveLayout(): 'combined' | 'per-slice-file';\n  /** Swap the live region set to slice `z` (stack mode only), capturing the\n   *  current slice's edits first. Called on every committed slice scrub. */\n  setDisplaySlice(z: number): void;\n  /** Every slice's regions for save/export, each tagged with its zero-based\n   *  {@link Region.z}; the flat set outside stack mode. */\n  getSliceRegions(): Region[];\n  /** Slices to write on a per-slice-file save (folder stack, jit-ui#93): each\n   *  slice with regions, plus slices cleared since load (empty, to overwrite).\n   *  Keyed by zero-based slice index; regions tagged with their z. */\n  getStackSaveSlices(): Map<number, Region[]>;\n}\n\n/** On-canvas tool modes (wand, brush, vertex eraser, zoom-to-box). */\nexport interface IToolController {\n  setWandMode(active: boolean, options?: IWandOptions): void;\n  setWandOptions(options: IWandOptions): void;\n  clearActiveWandRegion(): void;\n  /** Brush region tool. `size` (matrix-pixel diameter) sizes the painted disc. */\n  setBrushMode(active: boolean, options?: IBrushOptions): void;\n  setBrushOptions(options: IBrushOptions): void;\n  setVertexEraserMode(active: boolean): void;\n  setVertexEraserRadius(radius: number): void;\n  setZoomToBoxMode(active: boolean): void;\n  /** Box-prompted SAM segmentation: segment every rectangle region into masks.\n   *  Returns the number of mask regions added. (jit-ui#90) */\n  segmentRectangles(): Promise<number>;\n  /** Cellpose-on-crop: client slide-crop each rectangle and segment cells in it\n   *  (cellpose-SAM via the host's CELL_SEGMENTER). Returns regions added. */\n  segmentRectanglesCellpose(): Promise<number>;\n  /** Choose the registered SAM model the segment tools use (jit-ui#90 P1). */\n  setSamModel(id: string): void;\n  /** Toggle the interactive SAM point-prompt tool (click = +point, Shift = -). */\n  setSamPointMode(active: boolean): void;\n  /** Finalise / discard the in-progress SAM point object. */\n  commitSamPoints(): void;\n  clearSamPoints(): void;\n}\n\n/**\n * Controls specific to the ISOSURFACE plot type. Optional and capability-gated\n * (`ViewerFeature.Isosurface`): only a backend that renders isosurfaces exposes\n * it, via `IVisualizer.getIsosurfaceControls()`. Kept off the always-on\n * contract so consumers never call a control that's meaningless for the current\n * plot type / backend.\n */\nexport interface IIsosurfaceControls {\n  /** Live-update the isosurface intensity band [isomin, isomax] over 0–255. */\n  setIsoRange(isoMin: number, isoMax: number): void;\n}\n\n/**\n * Controls specific to the 3D plot types (SURFACE / SCATTER3D / ISOSURFACE\n * scenes). Capability-gated like {@link IIsosurfaceControls}: only a backend\n * that renders 3D scenes exposes it, via `IVisualizer.getSurface3dControls()` —\n * the deprecated top-level `setSurfaceDragMode`/`resetSurfaceCamera` silently\n * no-op on 2D-only backends.\n */\nexport interface ISurface3dControls {\n  /** Switch the 3D scene interaction mode (orbit / turntable / pan / zoom). */\n  setSurfaceDragMode(mode: string): void;\n  /** Reset the 3D scene camera to its default eye position. */\n  resetSurfaceCamera(): void;\n  /** Toggle the 3D coordinate-axes / scale gizmo on/off. Optional — only the napari-js WebGPU\n   *  volume/isosurface backend renders one (jit-ui#102). */\n  setAxesVisible?(visible: boolean): void;\n  /** Whether the axes gizmo is currently shown (for initializing the toggle UI). Optional. */\n  axesVisible?(): boolean;\n  /** Render the surface as a wireframe (edges) instead of a filled surface. Optional — only the\n   *  napari-js WebGPU surface backend supports it (jit-ui#102). */\n  setWireframe?(on: boolean): void;\n  /** Whether the surface is currently drawn as a wireframe (for initializing the toggle UI). */\n  wireframe?(): boolean;\n}\n\n/**\n * Controls specific to the LINE (intensity-profile) plot type. Capability-gated\n * like {@link IIsosurfaceControls}: only a backend that renders the line-ROI /\n * inset exposes it, via `IVisualizer.getIntensityControls()`.\n */\nexport interface IIntensityControls {\n  /** Add another line ROI (next bright palette colour) and its inset trace.\n   *  Returns the created region so the caller can select it on the active\n   *  backend, or null if no image extent is known yet. */\n  addProfileLine(): Region | null;\n}\n\n/** A categorical column resolved for charting: labels, codes and map colours. */\nexport interface SpatialCategoricalView {\n  name: string;\n  categories: string[];\n  /** `#rrggbb` per category, index-aligned with {@link categories}. */\n  colors: string[];\n  /** Per-observation category index, or `NO_CATEGORY`. */\n  codes: Uint16Array;\n}\n\n/**\n * Controls for the SPATIAL_OMICS plot type: what the observation markers are\n * coloured by, and how they are drawn. Capability-gated like\n * {@link IIsosurfaceControls} — `getSpatialControls()` returns null unless a\n * host has bound `SPATIAL_DATA_PORT`.\n *\n * The view state is backend-neutral (it lives in the shared store, like the\n * colormap), so these controls work whichever backend is on screen.\n */\nexport interface ISpatialControls {\n  /** The dataset being visualized, or null. Drives the column/gene pickers and\n   *  the legend. */\n  getDataset$(): Observable<SpatialDataset | null>;\n  /** Current display state (colour source, point scale, opacity, scaling). */\n  getViewState$(): Observable<SpatialViewState>;\n  /** Synchronous read, for seeding a control's initial value. */\n  viewState(): SpatialViewState;\n  /** Patch the display state; the markers rebuild without remounting the scene. */\n  setViewState(partial: Partial<SpatialViewState>): void;\n  /** Colour by an annotation column. Rejects for an unknown column. */\n  colorByColumn(name: string): void;\n  /** Colour by a gene; its vector is fetched on demand. */\n  colorByFeature(name: string): void;\n  /** Clear the colour source — every observation renders in one neutral colour. */\n  clearColorBy(): void;\n  /** Typeahead over feature names, for datasets too wide to inline the list. */\n  searchFeatures(query: string, limit?: number): Promise<string[]>;\n  /** Per-category display colours for a categorical column, index-aligned with\n   *  its `categories` — the legend's swatches, resolved the same way the\n   *  renderer resolves them so the two cannot disagree. */\n  categoryColors(name: string): Promise<string[]>;\n\n  // ── values, for the 1-D charts ────────────────────────────────────────\n  /**\n   * The values behind a colour source, index-aligned with the observations.\n   * Rejects for a categorical column — there is nothing continuous to chart.\n   */\n  continuousValues(source: SpatialColorBy): Promise<Float32Array>;\n  /**\n   * A categorical column's categories, per-observation codes and display\n   * colours — everything a grouped violin/box needs, with the colours resolved\n   * the same way the map resolves them.\n   */\n  categoricalView(column: string): Promise<SpatialCategoricalView>;\n\n  /**\n   * One embedding's coordinates — a UMAP, t-SNE or PCA plane over the same observations.\n   *\n   * Optional, and absent when the data source serves none: `SpatialDataPort.getEmbedding`\n   * is itself optional, so a panel must be able to ask whether this exists rather than\n   * calling it and catching.\n   */\n  getEmbedding?(name: string): Promise<SpatialEmbedding>;\n  /** Names of the categorical columns available to group by. */\n  categoricalColumns(): string[];\n  /**\n   * The z positions of the sections the dataset was imaged at, ascending — or\n   * null when its z is continuous rather than sectioned (so there are no sections\n   * to offer) or when there is no dataset.\n   *\n   * Lets a panel offer \"one section at a time\" for the 3D cloud only where that\n   * means something, and label the chosen one. Scanned once per dataset.\n   */\n  sampledSections(): Float32Array | null;\n\n  // ── selection ─────────────────────────────────────────────────────────\n  /** The current selection. Empty means \"nothing selected\", in which case the\n   *  whole tissue renders normally rather than everything being muted. */\n  getSelection$(): Observable<SpatialSelectionMask>;\n  /**\n   * Select every observation inside the currently-drawn regions (their union).\n   * Reuses the existing ROI tools — rectangle, polygon, freehand, wand, brush —\n   * so there is no separate marquee to learn. Returns how many were selected.\n   */\n  selectFromRegions(): number;\n  /** Select every observation in one category of a categorical column — the\n   *  legend click. Rejects for an unknown or continuous column. */\n  selectCategory(column: string, categoryIndex: number): Promise<number>;\n\n  /**\n   * Select an explicit set of observations, replacing any current selection.\n   *\n   * For a linked plot: lassoing points in an embedding is a selection OF observations,\n   * and every other view — the map, the distributions — reads the same mask, so brushing\n   * one lights up the rest. Returns how many were selected.\n   */\n  selectIndices(indices: Iterable<number>): number;\n  clearSelection(): void;\n}\n\n/** Display options (colormap/LUT, reverse scale, image metadata). */\nexport interface IDisplayOptions {\n  getColormap(): Observable<ColormapNode | null>;\n  setColormap(colormap: ColormapNode): void;\n  getColormapOptions(): ColormapNode[];\n  getReverseScale(): Observable<boolean>;\n  setReverseScale(reverscale: any): void;\n  setImageMeta(imageMeta: IImageMetadata[]): void;\n  getImageMeta(): Observable<IImageMetadata[]>;\n}\n\n/**\n * Intensity-profile sampling (PlotType.LINE). The sampling *source* lives in the\n * Plotly backend (it owns pixel readback); OpenSeadragon contributes only the\n * viewport-change signal that drives re-sampling at the current zoom. Each\n * backend implements the part it owns and no-ops the rest — mirroring the\n * deprecated no-op pattern on {@link IDataRenderer} — so the contract is uniform\n * and a consumer can depend on `IVisualizer` alone (no concrete-type reach-in).\n */\nexport interface IIntensitySampling {\n  /** Populate the intensity-sampling cache for the current image/slice so the\n   *  line-ROI profiles have pixel data. Real on Plotly; no-op on OSD. */\n  ensureIntensitySampling(imageInfo: IImageInfo, zIndex: number): Promise<void>;\n  /** Re-sample the profiles from a fresh crop of the given image-pixel ROI at\n   *  display resolution. Real on Plotly; no-op on OSD. */\n  refreshIntensitySamplingForRoi(x: number, y: number, width: number, height: number,\n                                 zIndex: number): void;\n  /** Visible-region changes (image-pixel coords), emitted when the view settles,\n   *  so the inset can re-sample at the current zoom. Real on OSD; empty on Plotly\n   *  (its high-def zoom updates the sampling cache inline instead). */\n  getViewportChange$(): Observable<{ x: number; y: number; width: number; height: number }>;\n}\n\n/** Composite contract a visualization backend implements. */\nexport interface IVisualizer extends IDataRenderer, IRegionStore, IToolController, IDisplayOptions,\n  IIntensitySampling {\n  readonly capabilities: ViewerCapabilities;\n  /** This backend's region renderer. May be null until a plot is mounted\n   *  (OpenSeadragon). Drives region draw/select modes uniformly. */\n  getRegionOverlay(): IRegionOverlay | null;\n  /** Isosurface controls when this backend advertises `ViewerFeature.Isosurface`,\n   *  else null — so consumers gate on the returned object, not a no-op method. */\n  getIsosurfaceControls(): IIsosurfaceControls | null;\n  /** Intensity (line-ROI) controls when the backend renders the LINE plot type,\n   *  else null. */\n  getIntensityControls(): IIntensityControls | null;\n  /** 3D scene controls when this backend renders 3D plot types, else null —\n   *  the capability-gated replacement for the deprecated top-level\n   *  `setSurfaceDragMode`/`resetSurfaceCamera`. */\n  getSurface3dControls(): ISurface3dControls | null;\n  /** Spatial-omics controls when a `SPATIAL_DATA_PORT` is bound, else null.\n   *  Optional: only the routing service implements it, since the state is shared\n   *  rather than owned by any one backend. */\n  getSpatialControls?(): ISpatialControls | null;\n  /** The viewport a contributed plot mode draws over, when the backend on\n   *  screen can provide one (OpenSeadragon), else null. Optional: backends that\n   *  no contributed mode rides on need not implement it. */\n  getPlotModeViewport?(): PlotModeViewport | null;\n  /** Binned intensity histogram for a channel from the currently-displayed\n   *  pixels, or null when none are available. Feeds the Channels & Histogram\n   *  pane. */\n  getHistogram(channelIndex: number, bins: number): IHistogram | null;\n  /** Async histogram stream — native bit depth for >8-bit images (server), else\n   *  the 8-bit client histogram. */\n  getHistogram$(channelIndex: number, bins: number): Observable<IHistogram | null>;\n  /** Export the displayed image, composited with the current display settings,\n   *  as a publication-ready PNG download. */\n  exportComposite(): void;\n  /** Export the underlying image data as a data-preserving multi-band TIFF\n   *  (native bit depth). No-op on backends that can't provide it. */\n  exportData(): void;\n  unsubscribe(): void;\n}\n\n/**\n * DI token for the active visualization backend. Bind it (`useExisting`) to the\n * `RoutingVisualizerService`, which selects Plotly vs OpenSeadragon per plot\n * type. Consumers — including this library's own `VisualizerComponent` —\n * inject `IVisualizer` through this token rather than the concrete router, so\n * the routing/fallback implementation can change without touching constructors.\n */\nexport const VISUALIZER = new InjectionToken<IVisualizer>('VISUALIZER');\n"]}