@jax-data-science/sci-image-visualizer 0.2.11 → 0.2.13

package/esm2022/index.mjs

@@ -25,6 +25,7 @@ export * from './lib/contracts/cell-segmenter.contract';
 export { CellposeSegmenterService } from './lib/toolbar/segmentation/cellpose-segmenter.service';
 export * from './lib/contracts/instance-segmenter.contract';
 export { YoloSegmenterService } from './lib/toolbar/segmentation/yolo-segmenter.service';
+export { YoloDetectToolService } from './lib/toolbar/segmentation/yolo-detect-tool.service';
 // ── Generic client-side image utilities (shared with the host's pipeline) ──
 export { ProcessingImage } from './lib/processing/processing-image';
 export { cropImage } from './lib/processing/image-crop';
@@ -53,4 +54,4 @@ export { VisualizerComponent } from './lib/visualizer.component';
 export { RegionEditorComponent } from './lib/region-editor/region-editor.component';
 export { HexColorPickerComponent } from './lib/hex-color-picker/hex-color-picker.component';
 export { ChannelHistogramComponent } from './lib/channel-histogram/channel-histogram.component';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,4EAA4E;AAC5E,cAAc,qCAAqC,CAAC;AACpD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,wCAAwC,CAAC;AACvD,cAAc,wCAAwC,CAAC;AACvD,cAAc,sCAAsC,CAAC;AACrD,cAAc,wCAAwC,CAAC;AACvD,cAAc,gDAAgD,CAAC;AAC/D,cAAc,4BAA4B,CAAC;AAC3C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uCAAuC,CAAC;AACtD,cAAc,yCAAyC,CAAC;AACxD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,yCAAyC,CAAC;AACxD,OAAO,EAAE,wBAAwB,EAAE,MAAM,uDAAuD,CAAC;AACjG,cAAc,6CAA6C,CAAC;AAC5D,OAAO,EAAE,oBAAoB,EAAE,MAAM,mDAAmD,CAAC;AACzF,OAAO,EAAE,qBAAqB,EAAE,MAAM,qDAAqD,CAAC;AAE5F,8EAA8E;AAC9E,OAAO,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACpE,OAAO,EAAE,SAAS,EAAoB,MAAM,6BAA6B,CAAC;AAC1E,OAAO,EAAE,qBAAqB,EAAE,MAAM,0CAA0C,CAAC;AAEjF,6EAA6E;AAC7E,OAAO,EACL,UAAU,EAAE,oBAAoB,EAAE,WAAW,EAAE,eAAe,EAAE,eAAe,EAC/E,kBAAkB,EAAE,oBAAoB,GACzC,MAAM,+CAA+C,CAAC;AAEvD,6EAA6E;AAC7E,OAAO,EACL,WAAW,EAAE,qBAAqB,EAAE,YAAY,EAAE,gBAAgB,EAAE,gBAAgB,EACpF,mBAAmB,EAAE,qBAAqB,GAC3C,MAAM,gDAAgD,CAAC;AAExD,8EAA8E;AAC9E,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,+CAA+C,CAAC;AAE/F,4EAA4E;AAC5E,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEpD,4EAA4E;AAC5E,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAC5E,6EAA6E;AAC7E,mEAAmE;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,6EAA6E;AAC7E,0EAA0E;AAC1E,8EAA8E;AAC9E,6DAA6D;AAC7D,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,qBAAqB,EAAE,MAAM,6CAA6C,CAAC;AACpF,OAAO,EAAE,uBAAuB,EAAE,MAAM,mDAAmD,CAAC;AAC5F,OAAO,EAAE,yBAAyB,EAAE,MAAM,qDAAqD,CAAC","sourcesContent":["/**\n * Public API of the jax-image-visualization library. External consumers import\n * ONLY from here (`@jax-data-science/sci-image-visualizer`); everything else under `lib/` is\n * internal. The surface is contracts + tokens + neutral models + the Angular\n * module, plus the routing service the host's composition root binds the tokens\n * to (`useExisting`).\n */\n\n// ── Contracts & DI tokens ────────────────────────────────────────────────\nexport * from './lib/contracts/visualizer.contract';\nexport * from './lib/contracts/region-editor-api.contract';\nexport * from './lib/contracts/ports/image-state.port';\nexport * from './lib/contracts/ports/tile-access.port';\nexport * from './lib/contracts/ports/region-io.port';\nexport * from './lib/contracts/ports/preferences.port';\nexport * from './lib/contracts/channel-histogram-api.contract';\nexport * from './lib/contracts/viz-config';\nexport * from './lib/contracts/image.contract';\nexport * from './lib/contracts/plot-type';\nexport * from './lib/contracts/toolbar-config';\nexport * from './lib/contracts/capabilities.contract';\nexport * from './lib/contracts/region-overlay.contract';\nexport * from './lib/contracts/display-types';\nexport * from './lib/contracts/sam.contract';\nexport * from './lib/contracts/cell-segmenter.contract';\nexport { CellposeSegmenterService } from './lib/toolbar/segmentation/cellpose-segmenter.service';\nexport * from './lib/contracts/instance-segmenter.contract';\nexport { YoloSegmenterService } from './lib/toolbar/segmentation/yolo-segmenter.service';\nexport { YoloDetectToolService } from './lib/toolbar/segmentation/yolo-detect-tool.service';\n\n// ── Generic client-side image utilities (shared with the host's pipeline) ──\nexport { ProcessingImage } from './lib/processing/processing-image';\nexport { cropImage, CropImageOptions } from './lib/processing/image-crop';\nexport { ImageConverterService } from './lib/processing/image-converter.service';\n\n// ── SAM model registry (host configures hosted ONNX URLs once available) ──\nexport {\n  SAM_MODELS, DEFAULT_SAM_MODEL_ID, getSamModel, isSamModelReady, setSamModelUrls,\n  setDefaultSamModel, getDefaultSamModelId,\n} from './lib/toolbar/segmentation/sam-model-registry';\n\n// ── YOLO instance-segmentation model registry (same repointing story) ─────\nexport {\n  YOLO_MODELS, DEFAULT_YOLO_MODEL_ID, getYoloModel, isYoloModelReady, setYoloModelUrls,\n  setDefaultYoloModel, getDefaultYoloModelId, YoloModelDef,\n} from './lib/toolbar/segmentation/yolo-model-registry';\n\n// ── onnxruntime-web WASM location (host overrides once, at app init) ───────\nexport { setOrtWasmBase, getOrtWasmBase } from './lib/toolbar/segmentation/ort-runtime-config';\n\n// ── Neutral data models ──────────────────────────────────────────────────\nexport * from './lib/models/region';\nexport * from './lib/models/class-preset';\nexport { ShapeSelection } from './lib/models/shape';\n\n// ── Angular module + composition-root service ────────────────────────────\nexport { VisualizationModule } from './lib/visualization.module';\nexport { RoutingVisualizerService } from './lib/routing-visualizer.service';\n// Provider factory for an isolated, component-scoped viewer instance (e.g. a\n// modal that must not share the main viewer's region/image state).\nexport { provideVisualization } from './lib/provide-visualization';\n\n// ── Public components (exported by VisualizationModule) ───────────────────\n// ng-packagr requires module-exported components to be reachable from the\n// entry point so consumers get their types; these are the embeddable elements\n// (`<visualizer>`, `<region-editor>`, `<hex-color-picker>`).\nexport { VisualizerComponent } from './lib/visualizer.component';\nexport { RegionEditorComponent } from './lib/region-editor/region-editor.component';\nexport { HexColorPickerComponent } from './lib/hex-color-picker/hex-color-picker.component';\nexport { ChannelHistogramComponent } from './lib/channel-histogram/channel-histogram.component';\n"]}

package/esm2022/lib/contracts/instance-segmenter.contract.mjs

@@ -9,4 +9,4 @@ export const INSTANCE_SEGMENTER = new InjectionToken('INSTANCE_SEGMENTER', {
     providedIn: 'root',
     factory: () => inject(YoloSegmenterService),
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"instance-segmenter.contract.js","sourceRoot":"","sources":["../../../../src/lib/contracts/instance-segmenter.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAEvD,OAAO,EAAE,oBAAoB,EAAE,MAAM,gDAAgD,CAAC;AA0ItF;;;;GAIG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,IAAI,cAAc,CAAqB,oBAAoB,EAAE;IAC7F,UAAU,EAAE,MAAM;IAClB,OAAO,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,oBAAoB,CAAC;CAC5C,CAAC,CAAC","sourcesContent":["import { InjectionToken, inject } from '@angular/core';\n\nimport { YoloSegmenterService } from '../toolbar/segmentation/yolo-segmenter.service';\n\n/**\n * Port for an automatic **instance** segmenter — one that returns discrete,\n * classified objects rather than a per-pixel label map.\n *\n * This is a sibling of {@link ICellSegmenter}, not a replacement. Cellpose-style\n * segmenters produce one exclusive label per pixel, which is exactly right for\n * densely packed cells; a detector like YOLO produces overlapping instances,\n * each with its own class and confidence, and flattening those into a label map\n * would silently discard both the overlap and the classification. The two\n * outputs are genuinely different shapes, so they get different ports.\n *\n * Geometry is returned as polygon rings in **image pixels**, ready to become\n * {@link Region}s without a second conversion step.\n */\n\n/** A closed ring; the last point is NOT a repeat of the first. */\nexport type InstanceRing = Array<[number, number]>;\n\n/** One polygon with optional interior rings (donut holes). */\nexport interface InstancePolygon {\n  exterior: InstanceRing;\n  holes: InstanceRing[];\n}\n\n/** One detected object. */\nexport interface InstanceDetection {\n  /**\n   * Outline(s) of this instance. Usually one, but a mask that splits under\n   * thresholding yields several — they all belong to the same detection.\n   */\n  polygons: InstancePolygon[];\n  /** `[x1, y1, x2, y2]` in image pixels. */\n  box: [number, number, number, number];\n  /** Model confidence, 0..1. */\n  score: number;\n  classId: number;\n  className: string;\n}\n\nexport interface InstanceSegmentation {\n  detections: InstanceDetection[];\n  width: number;\n  height: number;\n  /** Class names indexed by class id, from the model's own metadata. */\n  classNames: string[];\n}\n\n/**\n * Tunables for one run.\n *\n * Three separate thresholds are in play and they are easy to conflate:\n * `confidence` and `iouThreshold` act per tile, while `mergeThreshold` governs\n * the cross-tile reconciliation. They come from different stages of the\n * pipeline and are not interchangeable.\n */\nexport interface InstanceSegmentOptions {\n  /** Which registered model to run. Defaults to the registry's default. */\n  modelId?: string;\n  /**\n   * Scale to run at, as a divisor of full resolution — the same meaning the\n   * server gives it.\n   *\n   * This is what puts objects at the size the checkpoint was trained on, and it\n   * matters more than any threshold: run a detector at the wrong object scale\n   * and it finds nothing. A caller that can re-crop the source (a tile-backed\n   * viewer) should honour it rather than accepting whatever the display happens\n   * to show.\n   */\n  downsamplingFactor?: number;\n  /** Minimum detection confidence, per tile. */\n  confidence?: number;\n  /** NMS IoU within a single tile. */\n  iouThreshold?: number;\n  /** Intersection-over-smaller threshold for merging across tile seams. */\n  mergeThreshold?: number;\n  /** Tile overlap, percent. */\n  overlapX?: number;\n  overlapY?: number;\n  /** Probability at which a mask pixel counts as inside. */\n  maskThreshold?: number;\n  /** Cap on detections per tile. */\n  maxDetections?: number;\n  /** Keep only these class ids; omit for all classes the model declares. */\n  classFilter?: number[];\n  /** Douglas-Peucker tolerance in pixels for outline simplification; 0 disables. */\n  simplifyTolerance?: number;\n  /** Drop instances whose outline area is below this, in square pixels. */\n  minArea?: number;\n  /**\n   * Set false to detect boxes without assembling masks — substantially faster,\n   * since mask assembly dominates the cost of a run. Detections then carry a\n   * box and class but no outline, so nothing can be committed as a region.\n   */\n  withMasks?: boolean;\n  /**\n   * Abort an in-progress run.\n   *\n   * Cancellation is cooperative and checked at tile boundaries, so it takes\n   * effect within roughly one tile rather than instantly — a `session.run()`\n   * already in flight cannot be interrupted.\n   */\n  signal?: AbortSignal;\n}\n\n/**\n * Progress/status callbacks (all optional).\n *\n * Deliberately mirrors {@link CellSegmentProgress} in shape rather than importing\n * it — the two contracts stay independently versionable.\n */\nexport interface InstanceSegmentProgress {\n  /** Model-download progress, 0..1 (first run only). */\n  onProgress?: (fraction: number) => void;\n  /**\n   * Raw download byte counts, for hosts that render a size (\"142 / 287 MB\")\n   * rather than a bare percentage. `total` is null when the response carried no\n   * Content-Length.\n   *\n   * A fraction alone cannot be turned back into bytes, so a host given only\n   * {@link onProgress} has to invent the numbers — which reads as \"0 MB / 0 MB\"\n   * the moment it does.\n   */\n  onBytes?: (loaded: number, total: number | null) => void;\n  /** Human-readable phase, e.g. 'Running inference (tile 3/8)…'. */\n  onStatus?: (status: string) => void;\n}\n\nexport interface IInstanceSegmenter {\n  /** Detect and outline all instances in an RGBA image. */\n  segmentInstances(\n    image: { data: Uint8ClampedArray; width: number; height: number },\n    opts?: InstanceSegmentOptions,\n    progress?: InstanceSegmentProgress,\n  ): Promise<InstanceSegmentation>;\n}\n\n/**\n * DI token for the automatic instance segmenter. Defaults to the in-library\n * {@link YoloSegmenterService} (yolo-segdetect-js, lazy-loaded); override it in\n * the host to swap implementations — for example to delegate to the server.\n */\nexport const INSTANCE_SEGMENTER = new InjectionToken<IInstanceSegmenter>('INSTANCE_SEGMENTER', {\n  providedIn: 'root',\n  factory: () => inject(YoloSegmenterService),\n});\n"]}

package/esm2022/lib/toolbar/segmentation/yolo-detect-tool.service.mjs

@@ -0,0 +1,180 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+import { BehaviorSubject, firstValueFrom } from 'rxjs';
+import { Region, Polygon } from '../../models/region';
+import { TILE_ACCESS_PORT } from '../../contracts/ports/tile-access.port';
+import * as i0 from "@angular/core";
+/**
+ * YOLO object detection over the current view.
+ *
+ * The complement to {@link CellSegmentToolService}: cellpose auto-segments cells
+ * inside a box you draw, whereas a detector is meant to find objects across a
+ * field. So this takes no prompt — it runs on whatever is on screen and turns
+ * every detection into a region.
+ *
+ * Detections come back in the displayed image's pixels; they are mapped onto
+ * the full-resolution image through the viewer's own source rect, so the regions
+ * land where the objects actually are rather than at view-local coordinates.
+ *
+ * Exposes the same `status$` / `busy$` / `progress$` surface as the cellpose
+ * tool so the host's shared segmentation toast drives it unchanged.
+ */
+export class YoloDetectToolService {
+    constructor(
+    /** Server-side crop, so detection can run at the model's scale rather than
+     *  the viewer's. Optional: without it the tool falls back to the displayed
+     *  pixels, which is correct but scale-dependent. */
+    tileAccess = null) {
+        this.tileAccess = tileAccess;
+        this.status$ = new BehaviorSubject('');
+        this.busy$ = new BehaviorSubject(false);
+        this.progress$ = new BehaviorSubject(-1);
+    }
+    /**
+     * Detect in the current view and append the results as regions.
+     *
+     * @returns the number of regions added.
+     */
+    async detectInView(viz, segmenter, opts = {}) {
+        const pixels = viz.getDisplayedPixelData?.();
+        if (!pixels || pixels.width === 0 || pixels.height === 0) {
+            this.status$.next('No image on screen to detect in.');
+            return 0;
+        }
+        this.busy$.next(true);
+        this.progress$.next(-1);
+        try {
+            const rect = viz.getDisplayedSourceRect?.() ?? null;
+            const target = Number(opts.downsamplingFactor ?? 0) || 0;
+            const viewFactor = rect && pixels.width > 0 ? rect.width / pixels.width : 1;
+            // Re-crop at the model's scale when the view is coarser than it wants.
+            // The image is tile-backed, so that detail exists server-side even though
+            // the displayed pixels have discarded it.
+            let source = { data: pixels.data, width: pixels.width, height: pixels.height };
+            if (rect && target > 0 && target < viewFactor * 0.98) {
+                this.status$.next('Fetching image at model resolution…');
+                const hi = await this.fetchCropAtScale(rect, target);
+                if (hi)
+                    source = hi;
+            }
+            const result = await segmenter.segmentInstances(source, opts, {
+                onProgress: (f) => this.progress$.next(f),
+                onStatus: (s) => this.status$.next(s),
+            });
+            // View pixels -> full-resolution image pixels. Without this every region
+            // would sit at view-local coordinates, i.e. the wrong place on the slide
+            // for any zoomed or panned view.
+            const offsetX = rect ? rect.x : 0;
+            const offsetY = rect ? rect.y : 0;
+            // Against the pixels actually inferred on, which may be the re-crop.
+            const ratioX = rect && source.width > 0 ? rect.width / source.width : 1;
+            const ratioY = rect && source.height > 0 ? rect.height / source.height : 1;
+            const added = [];
+            for (const det of result.detections) {
+                if (det.polygons.length > 0) {
+                    for (const poly of det.polygons) {
+                        if (poly.exterior.length < 3)
+                            continue;
+                        added.push(this.makeRegion(poly.exterior.map(([x]) => Math.round(offsetX + x * ratioX)), poly.exterior.map(([, y]) => Math.round(offsetY + y * ratioY)), det.className));
+                    }
+                    continue;
+                }
+                // Detection mode yields no outline; the box is still the result, and
+                // matches what the server writes as a "detection" feature.
+                const [x1, y1, x2, y2] = det.box;
+                if (x2 - x1 <= 0 || y2 - y1 <= 0)
+                    continue;
+                added.push(this.makeRegion([x1, x2, x2, x1].map((x) => Math.round(offsetX + x * ratioX)), [y1, y1, y2, y2].map((y) => Math.round(offsetY + y * ratioY)), det.className));
+            }
+            if (added.length === 0) {
+                this.status$.next('No objects detected.');
+                return 0;
+            }
+            // Append. A detection run must not discard annotations drawn by hand or
+            // produced by another tool.
+            viz.setRegions([...(viz.getRegions() ?? []), ...added]);
+            this.status$.next(`Added ${added.length} region(s).`);
+            return added.length;
+        }
+        catch (err) {
+            this.status$.next(err instanceof Error ? err.message : 'YOLO detection failed.');
+            return 0;
+        }
+        finally {
+            this.busy$.next(false);
+            this.progress$.next(-1);
+        }
+    }
+    /**
+     * Re-crop `rect` at `1/target` of full resolution. Returns null on any
+     * failure, so the caller falls back to the displayed pixels — a coarser crop
+     * beats a failed run.
+     */
+    async fetchCropAtScale(rect, target) {
+        if (!this.tileAccess)
+            return null;
+        let w = Math.round(rect.width / target);
+        let h = Math.round(rect.height / target);
+        // A factor of 1 over a whole-slide ROI would ask for hundreds of megapixels.
+        const MAX_PIXELS = 16_777_216; // 4096²
+        const pixels = w * h;
+        if (pixels > MAX_PIXELS) {
+            const k = Math.sqrt(MAX_PIXELS / pixels);
+            w = Math.round(w * k);
+            h = Math.round(h * k);
+        }
+        if (w < 64 || h < 64)
+            return null;
+        try {
+            const roi = {
+                x: Math.round(rect.x),
+                y: Math.round(rect.y),
+                width: Math.round(rect.width),
+                height: Math.round(rect.height),
+            };
+            const screen = { x: 0, y: 0, width: w, height: h };
+            const bytes = await firstValueFrom(this.tileAccess.zoomOnRegion(roi, screen, 0));
+            if (!bytes || bytes.byteLength === 0)
+                return null;
+            const bitmap = await createImageBitmap(new Blob([bytes]));
+            const canvas = document.createElement('canvas');
+            canvas.width = bitmap.width;
+            canvas.height = bitmap.height;
+            const ctx = canvas.getContext('2d');
+            if (!ctx)
+                return null;
+            ctx.drawImage(bitmap, 0, 0);
+            const out = ctx.getImageData(0, 0, bitmap.width, bitmap.height);
+            bitmap.close?.();
+            return { data: out.data, width: bitmap.width, height: bitmap.height };
+        }
+        catch {
+            return null;
+        }
+    }
+    makeRegion(xs, ys, className) {
+        const poly = new Polygon();
+        poly.npoints = xs.length;
+        poly.xpoints = xs;
+        poly.ypoints = ys;
+        poly.coordinates = xs.map((x, i) => [x, ys[i]]);
+        poly.closed = true;
+        const region = new Region();
+        region.bounds = poly;
+        // The class name drives preset colour resolution; leaving `color` unset lets
+        // an existing preset for this class win.
+        region.label = className;
+        return region;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: YoloDetectToolService, deps: [{ token: TILE_ACCESS_PORT, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: YoloDetectToolService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: YoloDetectToolService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [TILE_ACCESS_PORT]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"yolo-detect-tool.service.js","sourceRoot":"","sources":["../../../../../src/lib/toolbar/segmentation/yolo-detect-tool.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, Optional } from '@angular/core';\nimport { BehaviorSubject, firstValueFrom } from 'rxjs';\n\nimport { Region, Polygon, Rectangle } from '../../models/region';\nimport { TILE_ACCESS_PORT, type TileAccessPort } from '../../contracts/ports/tile-access.port';\nimport type { IVisualizer } from '../../contracts/visualizer.contract';\nimport type { IInstanceSegmenter, InstanceSegmentOptions } from '../../contracts/instance-segmenter.contract';\n\n/**\n * YOLO object detection over the current view.\n *\n * The complement to {@link CellSegmentToolService}: cellpose auto-segments cells\n * inside a box you draw, whereas a detector is meant to find objects across a\n * field. So this takes no prompt — it runs on whatever is on screen and turns\n * every detection into a region.\n *\n * Detections come back in the displayed image's pixels; they are mapped onto\n * the full-resolution image through the viewer's own source rect, so the regions\n * land where the objects actually are rather than at view-local coordinates.\n *\n * Exposes the same `status$` / `busy$` / `progress$` surface as the cellpose\n * tool so the host's shared segmentation toast drives it unchanged.\n */\n@Injectable({ providedIn: 'root' })\nexport class YoloDetectToolService {\n  readonly status$ = new BehaviorSubject<string>('');\n  readonly busy$ = new BehaviorSubject<boolean>(false);\n  readonly progress$ = new BehaviorSubject<number>(-1);\n\n  constructor(\n    /** Server-side crop, so detection can run at the model's scale rather than\n     *  the viewer's. Optional: without it the tool falls back to the displayed\n     *  pixels, which is correct but scale-dependent. */\n    @Optional() @Inject(TILE_ACCESS_PORT) private tileAccess: TileAccessPort | null = null,\n  ) {}\n\n  /**\n   * Detect in the current view and append the results as regions.\n   *\n   * @returns the number of regions added.\n   */\n  async detectInView(\n    viz: IVisualizer,\n    segmenter: IInstanceSegmenter,\n    opts: InstanceSegmentOptions = {},\n  ): Promise<number> {\n    const pixels = viz.getDisplayedPixelData?.();\n    if (!pixels || pixels.width === 0 || pixels.height === 0) {\n      this.status$.next('No image on screen to detect in.');\n      return 0;\n    }\n\n    this.busy$.next(true);\n    this.progress$.next(-1);\n    try {\n      const rect = viz.getDisplayedSourceRect?.() ?? null;\n      const target = Number(opts.downsamplingFactor ?? 0) || 0;\n      const viewFactor = rect && pixels.width > 0 ? rect.width / pixels.width : 1;\n\n      // Re-crop at the model's scale when the view is coarser than it wants.\n      // The image is tile-backed, so that detail exists server-side even though\n      // the displayed pixels have discarded it.\n      let source = { data: pixels.data, width: pixels.width, height: pixels.height };\n      if (rect && target > 0 && target < viewFactor * 0.98) {\n        this.status$.next('Fetching image at model resolution…');\n        const hi = await this.fetchCropAtScale(rect, target);\n        if (hi) source = hi;\n      }\n\n      const result = await segmenter.segmentInstances(source, opts, {\n        onProgress: (f) => this.progress$.next(f),\n        onStatus: (s) => this.status$.next(s),\n      });\n\n      // View pixels -> full-resolution image pixels. Without this every region\n      // would sit at view-local coordinates, i.e. the wrong place on the slide\n      // for any zoomed or panned view.\n      const offsetX = rect ? rect.x : 0;\n      const offsetY = rect ? rect.y : 0;\n      // Against the pixels actually inferred on, which may be the re-crop.\n      const ratioX = rect && source.width > 0 ? rect.width / source.width : 1;\n      const ratioY = rect && source.height > 0 ? rect.height / source.height : 1;\n\n      const added: Region[] = [];\n      for (const det of result.detections) {\n        if (det.polygons.length > 0) {\n          for (const poly of det.polygons) {\n            if (poly.exterior.length < 3) continue;\n            added.push(\n              this.makeRegion(\n                poly.exterior.map(([x]) => Math.round(offsetX + x * ratioX)),\n                poly.exterior.map(([, y]) => Math.round(offsetY + y * ratioY)),\n                det.className,\n              ),\n            );\n          }\n          continue;\n        }\n        // Detection mode yields no outline; the box is still the result, and\n        // matches what the server writes as a \"detection\" feature.\n        const [x1, y1, x2, y2] = det.box;\n        if (x2 - x1 <= 0 || y2 - y1 <= 0) continue;\n        added.push(\n          this.makeRegion(\n            [x1, x2, x2, x1].map((x) => Math.round(offsetX + x * ratioX)),\n            [y1, y1, y2, y2].map((y) => Math.round(offsetY + y * ratioY)),\n            det.className,\n          ),\n        );\n      }\n\n      if (added.length === 0) {\n        this.status$.next('No objects detected.');\n        return 0;\n      }\n\n      // Append. A detection run must not discard annotations drawn by hand or\n      // produced by another tool.\n      viz.setRegions([...(viz.getRegions() ?? []), ...added]);\n      this.status$.next(`Added ${added.length} region(s).`);\n      return added.length;\n    } catch (err) {\n      this.status$.next(err instanceof Error ? err.message : 'YOLO detection failed.');\n      return 0;\n    } finally {\n      this.busy$.next(false);\n      this.progress$.next(-1);\n    }\n  }\n\n  /**\n   * Re-crop `rect` at `1/target` of full resolution. Returns null on any\n   * failure, so the caller falls back to the displayed pixels — a coarser crop\n   * beats a failed run.\n   */\n  private async fetchCropAtScale(\n    rect: { x: number; y: number; width: number; height: number },\n    target: number,\n  ): Promise<{ data: Uint8ClampedArray; width: number; height: number } | null> {\n    if (!this.tileAccess) return null;\n    let w = Math.round(rect.width / target);\n    let h = Math.round(rect.height / target);\n\n    // A factor of 1 over a whole-slide ROI would ask for hundreds of megapixels.\n    const MAX_PIXELS = 16_777_216; // 4096²\n    const pixels = w * h;\n    if (pixels > MAX_PIXELS) {\n      const k = Math.sqrt(MAX_PIXELS / pixels);\n      w = Math.round(w * k);\n      h = Math.round(h * k);\n    }\n    if (w < 64 || h < 64) return null;\n\n    try {\n      const roi = {\n        x: Math.round(rect.x),\n        y: Math.round(rect.y),\n        width: Math.round(rect.width),\n        height: Math.round(rect.height),\n      } as Rectangle;\n      const screen = { x: 0, y: 0, width: w, height: h } as Rectangle;\n      const bytes = await firstValueFrom(this.tileAccess.zoomOnRegion(roi, screen, 0));\n      if (!bytes || bytes.byteLength === 0) return null;\n\n      const bitmap = await createImageBitmap(new Blob([bytes]));\n      const canvas = document.createElement('canvas');\n      canvas.width = bitmap.width;\n      canvas.height = bitmap.height;\n      const ctx = canvas.getContext('2d');\n      if (!ctx) return null;\n      ctx.drawImage(bitmap, 0, 0);\n      const out = ctx.getImageData(0, 0, bitmap.width, bitmap.height);\n      bitmap.close?.();\n      return { data: out.data, width: bitmap.width, height: bitmap.height };\n    } catch {\n      return null;\n    }\n  }\n\n  private makeRegion(xs: number[], ys: number[], className: string): Region {\n    const poly = new Polygon();\n    poly.npoints = xs.length;\n    poly.xpoints = xs;\n    poly.ypoints = ys;\n    poly.coordinates = xs.map((x, i) => [x, ys[i]]);\n    poly.closed = true;\n\n    const region = new Region();\n    region.bounds = poly;\n    // The class name drives preset colour resolution; leaving `color` unset lets\n    // an existing preset for this class win.\n    region.label = className;\n    return region;\n  }\n}\n"]}

package/esm2022/lib/toolbar/segmentation/yolo-segmenter.service.mjs

@@ -58,24 +58,24 @@ export class YoloSegmenterService {
             // status from tile counts here would just fight it.
             onStatus: (s) => progress?.onStatus?.(s),
         });
-        // Detections without geometry are dropped rather than surfaced as empty
-        // regions — a detection whose mask vanished under thresholding has nothing
-        // meaningful to draw or edit.
-        const detections = [];
-        for (const d of result.detections) {
-            if (!d.polygons || d.polygons.length === 0)
-                continue;
-            detections.push({
-                polygons: d.polygons.map((p) => ({
-                    exterior: p.exterior.map(([x, y]) => [x, y]),
-                    holes: p.holes.map((h) => h.map(([x, y]) => [x, y])),
-                })),
-                box: [d.box[0], d.box[1], d.box[2], d.box[3]],
-                score: d.score,
-                classId: d.classId,
-                className: d.className ?? `class${d.classId}`,
-            });
-        }
+        // A detection without an outline is still a detection.
+        //
+        // These used to be dropped, which quietly emptied the entire result in
+        // detection mode: no masks means no polygons, so every object was
+        // discarded and the caller saw nothing at all. The server does not work
+        // that way either — it always writes a box feature and only *adds*
+        // segmentation outlines when asked. Callers get the box and decide what to
+        // do with it.
+        const detections = result.detections.map((d) => ({
+            polygons: (d.polygons ?? []).map((p) => ({
+                exterior: p.exterior.map(([x, y]) => [x, y]),
+                holes: p.holes.map((h) => h.map(([x, y]) => [x, y])),
+            })),
+            box: [d.box[0], d.box[1], d.box[2], d.box[3]],
+            score: d.score,
+            classId: d.classId,
+            className: d.className ?? `class${d.classId}`,
+        }));
         return {
             detections,
             width: result.width,
@@ -169,4 +169,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImpor
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"yolo-segmenter.service.js","sourceRoot":"","sources":["../../../../../src/lib/toolbar/segmentation/yolo-segmenter.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { getOrtWasmBase } from './ort-runtime-config';\nimport { getDefaultYoloModelId, getYoloModel, type YoloModelDef } from './yolo-model-registry';\n\nimport type {\n  IInstanceSegmenter,\n  InstanceDetection,\n  InstanceSegmentation,\n  InstanceSegmentOptions,\n  InstanceSegmentProgress,\n} from '../../contracts/instance-segmenter.contract';\nimport type { YoloSegmenter } from 'yolo-segdetect-js';\n\n/**\n * Default in-library {@link IInstanceSegmenter}, backed by yolo-segdetect-js\n * (YOLOv8-seg on WebGPU, falling back to WASM).\n *\n * `yolo-segdetect-js` is a regular dependency but is **lazy-imported** on first\n * use, so apps that never run YOLO pay nothing for it — or for onnxruntime-web —\n * in their initial bundle. This mirrors {@link CellposeSegmenterService}.\n *\n * The one structural difference from the Cellpose service: there are four YOLO\n * checkpoints, not one, so instances are cached **per model id** rather than as\n * a single singleton. Each entry owns its own worker and ORT session, so a host\n * that switches models pays a second load but keeps the first one warm. Nothing\n * evicts automatically — these are ~144 MB each, so a host that cycles through\n * all four should call {@link dispose} for the ones it is done with.\n */\n@Injectable({ providedIn: 'root' })\nexport class YoloSegmenterService implements IInstanceSegmenter {\n  private readonly instances = new Map<string, YoloSegmenter>();\n  private readonly loading = new Map<string, Promise<YoloSegmenter>>();\n\n  async segmentInstances(\n    image: { data: Uint8ClampedArray; width: number; height: number },\n    opts: InstanceSegmentOptions = {},\n    progress?: InstanceSegmentProgress,\n  ): Promise<InstanceSegmentation> {\n    const modelId = opts.modelId ?? getDefaultYoloModelId();\n    const def = this.requireModel(modelId);\n\n    let announcedDownload = false;\n    const seg = await this.getModel(\n      modelId,\n      (loaded, total) => {\n        if (total) progress?.onProgress?.(loaded / total);\n        progress?.onBytes?.(loaded, total);\n        if (loaded > 0 && !announcedDownload) {\n          announcedDownload = true;\n          progress?.onStatus?.(`Downloading ${def.label} model…`);\n        }\n      },\n      (status) => progress?.onStatus?.(status),\n    );\n\n    progress?.onStatus?.('Running inference…');\n    const result = await seg.segment(\n      { data: image.data, width: image.width, height: image.height },\n      {\n        confThreshold: opts.confidence ?? def.defaults.confidence,\n        iouThreshold: opts.iouThreshold ?? def.defaults.iouThreshold,\n        threshold: opts.mergeThreshold ?? def.defaults.mergeThreshold,\n        overlapX: opts.overlapX ?? def.defaults.overlapX,\n        overlapY: opts.overlapY ?? def.defaults.overlapY,\n        ...(opts.maskThreshold !== undefined ? { maskThreshold: opts.maskThreshold } : {}),\n        ...(opts.maxDetections !== undefined ? { maxDetections: opts.maxDetections } : {}),\n        ...(opts.classFilter ? { classFilter: opts.classFilter } : {}),\n        ...(opts.withMasks !== undefined ? { withMasks: opts.withMasks } : {}),\n        ...(opts.signal ? { signal: opts.signal } : {}),\n        // Only worth tracing when there are masks to trace.\n        tracePolygons: opts.withMasks !== false,\n        traceOptions: {\n          ...(opts.simplifyTolerance !== undefined ? { simplifyTolerance: opts.simplifyTolerance } : {}),\n          ...(opts.minArea !== undefined ? { minArea: opts.minArea } : {}),\n        },\n        // The worker narrates its own phases — shader warm-up, per tile, merge,\n        // tracing — because only it knows which one it is in. Deriving a second\n        // status from tile counts here would just fight it.\n        onStatus: (s) => progress?.onStatus?.(s),\n      },\n    );\n\n    // Detections without geometry are dropped rather than surfaced as empty\n    // regions — a detection whose mask vanished under thresholding has nothing\n    // meaningful to draw or edit.\n    const detections: InstanceDetection[] = [];\n    for (const d of result.detections) {\n      if (!d.polygons || d.polygons.length === 0) continue;\n      detections.push({\n        polygons: d.polygons.map((p) => ({\n          exterior: p.exterior.map(([x, y]): [number, number] => [x, y]),\n          holes: p.holes.map((h) => h.map(([x, y]): [number, number] => [x, y])),\n        })),\n        box: [d.box[0], d.box[1], d.box[2], d.box[3]],\n        score: d.score,\n        classId: d.classId,\n        className: d.className ?? `class${d.classId}`,\n      });\n    }\n\n    return {\n      detections,\n      width: result.width,\n      height: result.height,\n      classNames: result.classNames,\n    };\n  }\n\n  /**\n   * The shared segmenter for a model id, created on first use and reused\n   * thereafter (deduped across concurrent callers). Exposed so a host's\n   * processing pipeline can drive richer `segment()` options on the same loaded\n   * session instead of loading the model twice.\n   */\n  getModel(\n    modelId: string = getDefaultYoloModelId(),\n    onProgress?: (loaded: number, total: number | null) => void,\n    onStatus?: (status: string) => void,\n  ): Promise<YoloSegmenter> {\n    const existing = this.instances.get(modelId);\n    if (existing) return Promise.resolve(existing);\n\n    const inFlight = this.loading.get(modelId);\n    if (inFlight) return inFlight;\n\n    const def = this.requireModel(modelId);\n    const load = (async () => {\n      // Lazy: keep yolo-segdetect-js + its ORT runtime out of the initial bundle.\n      const { YoloSegmenter, configureOrt } = await import('yolo-segdetect-js');\n      configureOrt({ wasmPaths: getOrtWasmBase() });\n      const seg = await YoloSegmenter.fromPretrained(def.modelUrl, {\n        preload: true,\n        ...(def.metaUrl ? { metaUrl: def.metaUrl } : {}),\n        onProgress: ({ loaded, total }) => onProgress?.(loaded, total),\n        onStatus: (s) => onStatus?.(s),\n      });\n      this.instances.set(modelId, seg);\n      return seg;\n    })();\n\n    this.loading.set(modelId, load);\n    // A failed load must not poison the cache — the next caller should retry\n    // rather than inherit the rejected promise forever.\n    load.catch(() => this.loading.delete(modelId));\n    return load;\n  }\n\n  /** Whether a model is already loaded (warm). */\n  isLoaded(modelId: string = getDefaultYoloModelId()): boolean {\n    return this.instances.has(modelId);\n  }\n\n  /**\n   * Release one model, or all of them. Safe to call on a model never loaded.\n   *\n   * In-flight loads are torn down too, not just warm ones. Simply dropping the\n   * pending promise and returning would let the load finish afterwards,\n   * re-populate {@link instances}, and strand a live worker and ORT session that\n   * nothing owns — disposal would have reported success while leaking. So a load\n   * that is still running is awaited and then released.\n   */\n  async dispose(modelId?: string): Promise<void> {\n    const ids = modelId ? [modelId] : [...new Set([...this.instances.keys(), ...this.loading.keys()])];\n    await Promise.all(ids.map((id) => this.disposeOne(id)));\n  }\n\n  private async disposeOne(id: string): Promise<void> {\n    const pending = this.loading.get(id);\n    const loaded = this.instances.get(id);\n    this.instances.delete(id);\n    this.loading.delete(id);\n\n    if (loaded) await loaded.dispose();\n    if (!pending) return;\n\n    // A pending load assigns instances[id] before its promise resolves, so by\n    // the time this await returns the entry is back. Clear it only if it still\n    // points at what *this* load produced — a newer load started in the\n    // meantime owns its own entry and must not be evicted.\n    const seg = await pending.catch(() => null);\n    if (!seg || seg === loaded) return;\n    if (this.instances.get(id) === seg) this.instances.delete(id);\n    await seg.dispose();\n  }\n\n  private requireModel(modelId: string): YoloModelDef {\n    const def = getYoloModel(modelId);\n    if (!def) throw new Error(`Unknown YOLO model id \"${modelId}\".`);\n    if (!def.modelUrl.trim()) {\n      throw new Error(`YOLO model \"${modelId}\" is not configured — its modelUrl is empty.`);\n    }\n    return def;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"yolo-segmenter.service.js","sourceRoot":"","sources":["../../../../../src/lib/toolbar/segmentation/yolo-segmenter.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { getOrtWasmBase } from './ort-runtime-config';\nimport { getDefaultYoloModelId, getYoloModel, type YoloModelDef } from './yolo-model-registry';\n\nimport type {\n  IInstanceSegmenter,\n  InstanceDetection,\n  InstanceSegmentation,\n  InstanceSegmentOptions,\n  InstanceSegmentProgress,\n} from '../../contracts/instance-segmenter.contract';\nimport type { YoloSegmenter } from 'yolo-segdetect-js';\n\n/**\n * Default in-library {@link IInstanceSegmenter}, backed by yolo-segdetect-js\n * (YOLOv8-seg on WebGPU, falling back to WASM).\n *\n * `yolo-segdetect-js` is a regular dependency but is **lazy-imported** on first\n * use, so apps that never run YOLO pay nothing for it — or for onnxruntime-web —\n * in their initial bundle. This mirrors {@link CellposeSegmenterService}.\n *\n * The one structural difference from the Cellpose service: there are four YOLO\n * checkpoints, not one, so instances are cached **per model id** rather than as\n * a single singleton. Each entry owns its own worker and ORT session, so a host\n * that switches models pays a second load but keeps the first one warm. Nothing\n * evicts automatically — these are ~144 MB each, so a host that cycles through\n * all four should call {@link dispose} for the ones it is done with.\n */\n@Injectable({ providedIn: 'root' })\nexport class YoloSegmenterService implements IInstanceSegmenter {\n  private readonly instances = new Map<string, YoloSegmenter>();\n  private readonly loading = new Map<string, Promise<YoloSegmenter>>();\n\n  async segmentInstances(\n    image: { data: Uint8ClampedArray; width: number; height: number },\n    opts: InstanceSegmentOptions = {},\n    progress?: InstanceSegmentProgress,\n  ): Promise<InstanceSegmentation> {\n    const modelId = opts.modelId ?? getDefaultYoloModelId();\n    const def = this.requireModel(modelId);\n\n    let announcedDownload = false;\n    const seg = await this.getModel(\n      modelId,\n      (loaded, total) => {\n        if (total) progress?.onProgress?.(loaded / total);\n        progress?.onBytes?.(loaded, total);\n        if (loaded > 0 && !announcedDownload) {\n          announcedDownload = true;\n          progress?.onStatus?.(`Downloading ${def.label} model…`);\n        }\n      },\n      (status) => progress?.onStatus?.(status),\n    );\n\n    progress?.onStatus?.('Running inference…');\n    const result = await seg.segment(\n      { data: image.data, width: image.width, height: image.height },\n      {\n        confThreshold: opts.confidence ?? def.defaults.confidence,\n        iouThreshold: opts.iouThreshold ?? def.defaults.iouThreshold,\n        threshold: opts.mergeThreshold ?? def.defaults.mergeThreshold,\n        overlapX: opts.overlapX ?? def.defaults.overlapX,\n        overlapY: opts.overlapY ?? def.defaults.overlapY,\n        ...(opts.maskThreshold !== undefined ? { maskThreshold: opts.maskThreshold } : {}),\n        ...(opts.maxDetections !== undefined ? { maxDetections: opts.maxDetections } : {}),\n        ...(opts.classFilter ? { classFilter: opts.classFilter } : {}),\n        ...(opts.withMasks !== undefined ? { withMasks: opts.withMasks } : {}),\n        ...(opts.signal ? { signal: opts.signal } : {}),\n        // Only worth tracing when there are masks to trace.\n        tracePolygons: opts.withMasks !== false,\n        traceOptions: {\n          ...(opts.simplifyTolerance !== undefined ? { simplifyTolerance: opts.simplifyTolerance } : {}),\n          ...(opts.minArea !== undefined ? { minArea: opts.minArea } : {}),\n        },\n        // The worker narrates its own phases — shader warm-up, per tile, merge,\n        // tracing — because only it knows which one it is in. Deriving a second\n        // status from tile counts here would just fight it.\n        onStatus: (s) => progress?.onStatus?.(s),\n      },\n    );\n\n    // A detection without an outline is still a detection.\n    //\n    // These used to be dropped, which quietly emptied the entire result in\n    // detection mode: no masks means no polygons, so every object was\n    // discarded and the caller saw nothing at all. The server does not work\n    // that way either — it always writes a box feature and only *adds*\n    // segmentation outlines when asked. Callers get the box and decide what to\n    // do with it.\n    const detections: InstanceDetection[] = result.detections.map((d) => ({\n      polygons: (d.polygons ?? []).map((p) => ({\n        exterior: p.exterior.map(([x, y]): [number, number] => [x, y]),\n        holes: p.holes.map((h) => h.map(([x, y]): [number, number] => [x, y])),\n      })),\n      box: [d.box[0], d.box[1], d.box[2], d.box[3]] as [number, number, number, number],\n      score: d.score,\n      classId: d.classId,\n      className: d.className ?? `class${d.classId}`,\n    }));\n\n    return {\n      detections,\n      width: result.width,\n      height: result.height,\n      classNames: result.classNames,\n    };\n  }\n\n  /**\n   * The shared segmenter for a model id, created on first use and reused\n   * thereafter (deduped across concurrent callers). Exposed so a host's\n   * processing pipeline can drive richer `segment()` options on the same loaded\n   * session instead of loading the model twice.\n   */\n  getModel(\n    modelId: string = getDefaultYoloModelId(),\n    onProgress?: (loaded: number, total: number | null) => void,\n    onStatus?: (status: string) => void,\n  ): Promise<YoloSegmenter> {\n    const existing = this.instances.get(modelId);\n    if (existing) return Promise.resolve(existing);\n\n    const inFlight = this.loading.get(modelId);\n    if (inFlight) return inFlight;\n\n    const def = this.requireModel(modelId);\n    const load = (async () => {\n      // Lazy: keep yolo-segdetect-js + its ORT runtime out of the initial bundle.\n      const { YoloSegmenter, configureOrt } = await import('yolo-segdetect-js');\n      configureOrt({ wasmPaths: getOrtWasmBase() });\n      const seg = await YoloSegmenter.fromPretrained(def.modelUrl, {\n        preload: true,\n        ...(def.metaUrl ? { metaUrl: def.metaUrl } : {}),\n        onProgress: ({ loaded, total }) => onProgress?.(loaded, total),\n        onStatus: (s) => onStatus?.(s),\n      });\n      this.instances.set(modelId, seg);\n      return seg;\n    })();\n\n    this.loading.set(modelId, load);\n    // A failed load must not poison the cache — the next caller should retry\n    // rather than inherit the rejected promise forever.\n    load.catch(() => this.loading.delete(modelId));\n    return load;\n  }\n\n  /** Whether a model is already loaded (warm). */\n  isLoaded(modelId: string = getDefaultYoloModelId()): boolean {\n    return this.instances.has(modelId);\n  }\n\n  /**\n   * Release one model, or all of them. Safe to call on a model never loaded.\n   *\n   * In-flight loads are torn down too, not just warm ones. Simply dropping the\n   * pending promise and returning would let the load finish afterwards,\n   * re-populate {@link instances}, and strand a live worker and ORT session that\n   * nothing owns — disposal would have reported success while leaking. So a load\n   * that is still running is awaited and then released.\n   */\n  async dispose(modelId?: string): Promise<void> {\n    const ids = modelId ? [modelId] : [...new Set([...this.instances.keys(), ...this.loading.keys()])];\n    await Promise.all(ids.map((id) => this.disposeOne(id)));\n  }\n\n  private async disposeOne(id: string): Promise<void> {\n    const pending = this.loading.get(id);\n    const loaded = this.instances.get(id);\n    this.instances.delete(id);\n    this.loading.delete(id);\n\n    if (loaded) await loaded.dispose();\n    if (!pending) return;\n\n    // A pending load assigns instances[id] before its promise resolves, so by\n    // the time this await returns the entry is back. Clear it only if it still\n    // points at what *this* load produced — a newer load started in the\n    // meantime owns its own entry and must not be evicted.\n    const seg = await pending.catch(() => null);\n    if (!seg || seg === loaded) return;\n    if (this.instances.get(id) === seg) this.instances.delete(id);\n    await seg.dispose();\n  }\n\n  private requireModel(modelId: string): YoloModelDef {\n    const def = getYoloModel(modelId);\n    if (!def) throw new Error(`Unknown YOLO model id \"${modelId}\".`);\n    if (!def.modelUrl.trim()) {\n      throw new Error(`YOLO model \"${modelId}\" is not configured — its modelUrl is empty.`);\n    }\n    return def;\n  }\n}\n"]}