@jax-data-science/sci-image-visualizer 0.2.8 → 0.2.10

package/esm2022/index.mjs

@@ -23,12 +23,16 @@ export * from './lib/contracts/display-types';
 export * from './lib/contracts/sam.contract';
 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';
 // ── 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';
 export { ImageConverterService } from './lib/processing/image-converter.service';
 // ── SAM model registry (host configures hosted ONNX URLs once available) ──
 export { SAM_MODELS, DEFAULT_SAM_MODEL_ID, getSamModel, isSamModelReady, setSamModelUrls, setDefaultSamModel, getDefaultSamModelId, } from './lib/toolbar/segmentation/sam-model-registry';
+// ── YOLO instance-segmentation model registry (same repointing story) ─────
+export { YOLO_MODELS, DEFAULT_YOLO_MODEL_ID, getYoloModel, isYoloModelReady, setYoloModelUrls, setDefaultYoloModel, getDefaultYoloModelId, } from './lib/toolbar/segmentation/yolo-model-registry';
 // ── onnxruntime-web WASM location (host overrides once, at app init) ───────
 export { setOrtWasmBase, getOrtWasmBase } from './lib/toolbar/segmentation/ort-runtime-config';
 // ── Neutral data models ──────────────────────────────────────────────────
@@ -49,4 +53,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,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

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

@@ -0,0 +1,12 @@
+import { InjectionToken, inject } from '@angular/core';
+import { YoloSegmenterService } from '../toolbar/segmentation/yolo-segmenter.service';
+/**
+ * DI token for the automatic instance segmenter. Defaults to the in-library
+ * {@link YoloSegmenterService} (yolo-segdetect-js, lazy-loaded); override it in
+ * the host to swap implementations — for example to delegate to the server.
+ */
+export const INSTANCE_SEGMENTER = new InjectionToken('INSTANCE_SEGMENTER', {
+    providedIn: 'root',
+    factory: () => inject(YoloSegmenterService),
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5zdGFuY2Utc2VnbWVudGVyLmNvbnRyYWN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2xpYi9jb250cmFjdHMvaW5zdGFuY2Utc2VnbWVudGVyLmNvbnRyYWN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRXZELE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLGdEQUFnRCxDQUFDO0FBK0h0Rjs7OztHQUlHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sa0JBQWtCLEdBQUcsSUFBSSxjQUFjLENBQXFCLG9CQUFvQixFQUFFO0lBQzdGLFVBQVUsRUFBRSxNQUFNO0lBQ2xCLE9BQU8sRUFBRSxHQUFHLEVBQUUsQ0FBQyxNQUFNLENBQUMsb0JBQW9CLENBQUM7Q0FDNUMsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4sIGluamVjdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBZb2xvU2VnbWVudGVyU2VydmljZSB9IGZyb20gJy4uL3Rvb2xiYXIvc2VnbWVudGF0aW9uL3lvbG8tc2VnbWVudGVyLnNlcnZpY2UnO1xuXG4vKipcbiAqIFBvcnQgZm9yIGFuIGF1dG9tYXRpYyAqKmluc3RhbmNlKiogc2VnbWVudGVyIOKAlCBvbmUgdGhhdCByZXR1cm5zIGRpc2NyZXRlLFxuICogY2xhc3NpZmllZCBvYmplY3RzIHJhdGhlciB0aGFuIGEgcGVyLXBpeGVsIGxhYmVsIG1hcC5cbiAqXG4gKiBUaGlzIGlzIGEgc2libGluZyBvZiB7QGxpbmsgSUNlbGxTZWdtZW50ZXJ9LCBub3QgYSByZXBsYWNlbWVudC4gQ2VsbHBvc2Utc3R5bGVcbiAqIHNlZ21lbnRlcnMgcHJvZHVjZSBvbmUgZXhjbHVzaXZlIGxhYmVsIHBlciBwaXhlbCwgd2hpY2ggaXMgZXhhY3RseSByaWdodCBmb3JcbiAqIGRlbnNlbHkgcGFja2VkIGNlbGxzOyBhIGRldGVjdG9yIGxpa2UgWU9MTyBwcm9kdWNlcyBvdmVybGFwcGluZyBpbnN0YW5jZXMsXG4gKiBlYWNoIHdpdGggaXRzIG93biBjbGFzcyBhbmQgY29uZmlkZW5jZSwgYW5kIGZsYXR0ZW5pbmcgdGhvc2UgaW50byBhIGxhYmVsIG1hcFxuICogd291bGQgc2lsZW50bHkgZGlzY2FyZCBib3RoIHRoZSBvdmVybGFwIGFuZCB0aGUgY2xhc3NpZmljYXRpb24uIFRoZSB0d29cbiAqIG91dHB1dHMgYXJlIGdlbnVpbmVseSBkaWZmZXJlbnQgc2hhcGVzLCBzbyB0aGV5IGdldCBkaWZmZXJlbnQgcG9ydHMuXG4gKlxuICogR2VvbWV0cnkgaXMgcmV0dXJuZWQgYXMgcG9seWdvbiByaW5ncyBpbiAqKmltYWdlIHBpeGVscyoqLCByZWFkeSB0byBiZWNvbWVcbiAqIHtAbGluayBSZWdpb259cyB3aXRob3V0IGEgc2Vjb25kIGNvbnZlcnNpb24gc3RlcC5cbiAqL1xuXG4vKiogQSBjbG9zZWQgcmluZzsgdGhlIGxhc3QgcG9pbnQgaXMgTk9UIGEgcmVwZWF0IG9mIHRoZSBmaXJzdC4gKi9cbmV4cG9ydCB0eXBlIEluc3RhbmNlUmluZyA9IEFycmF5PFtudW1iZXIsIG51bWJlcl0+O1xuXG4vKiogT25lIHBvbHlnb24gd2l0aCBvcHRpb25hbCBpbnRlcmlvciByaW5ncyAoZG9udXQgaG9sZXMpLiAqL1xuZXhwb3J0IGludGVyZmFjZSBJbnN0YW5jZVBvbHlnb24ge1xuICBleHRlcmlvcjogSW5zdGFuY2VSaW5nO1xuICBob2xlczogSW5zdGFuY2VSaW5nW107XG59XG5cbi8qKiBPbmUgZGV0ZWN0ZWQgb2JqZWN0LiAqL1xuZXhwb3J0IGludGVyZmFjZSBJbnN0YW5jZURldGVjdGlvbiB7XG4gIC8qKlxuICAgKiBPdXRsaW5lKHMpIG9mIHRoaXMgaW5zdGFuY2UuIFVzdWFsbHkgb25lLCBidXQgYSBtYXNrIHRoYXQgc3BsaXRzIHVuZGVyXG4gICAqIHRocmVzaG9sZGluZyB5aWVsZHMgc2V2ZXJhbCDigJQgdGhleSBhbGwgYmVsb25nIHRvIHRoZSBzYW1lIGRldGVjdGlvbi5cbiAgICovXG4gIHBvbHlnb25zOiBJbnN0YW5jZVBvbHlnb25bXTtcbiAgLyoqIGBbeDEsIHkxLCB4MiwgeTJdYCBpbiBpbWFnZSBwaXhlbHMuICovXG4gIGJveDogW251bWJlciwgbnVtYmVyLCBudW1iZXIsIG51bWJlcl07XG4gIC8qKiBNb2RlbCBjb25maWRlbmNlLCAwLi4xLiAqL1xuICBzY29yZTogbnVtYmVyO1xuICBjbGFzc0lkOiBudW1iZXI7XG4gIGNsYXNzTmFtZTogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIEluc3RhbmNlU2VnbWVudGF0aW9uIHtcbiAgZGV0ZWN0aW9uczogSW5zdGFuY2VEZXRlY3Rpb25bXTtcbiAgd2lkdGg6IG51bWJlcjtcbiAgaGVpZ2h0OiBudW1iZXI7XG4gIC8qKiBDbGFzcyBuYW1lcyBpbmRleGVkIGJ5IGNsYXNzIGlkLCBmcm9tIHRoZSBtb2RlbCdzIG93biBtZXRhZGF0YS4gKi9cbiAgY2xhc3NOYW1lczogc3RyaW5nW107XG59XG5cbi8qKlxuICogVHVuYWJsZXMgZm9yIG9uZSBydW4uXG4gKlxuICogVGhyZWUgc2VwYXJhdGUgdGhyZXNob2xkcyBhcmUgaW4gcGxheSBhbmQgdGhleSBhcmUgZWFzeSB0byBjb25mbGF0ZTpcbiAqIGBjb25maWRlbmNlYCBhbmQgYGlvdVRocmVzaG9sZGAgYWN0IHBlciB0aWxlLCB3aGlsZSBgbWVyZ2VUaHJlc2hvbGRgIGdvdmVybnNcbiAqIHRoZSBjcm9zcy10aWxlIHJlY29uY2lsaWF0aW9uLiBUaGV5IGNvbWUgZnJvbSBkaWZmZXJlbnQgc3RhZ2VzIG9mIHRoZVxuICogcGlwZWxpbmUgYW5kIGFyZSBub3QgaW50ZXJjaGFuZ2VhYmxlLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIEluc3RhbmNlU2VnbWVudE9wdGlvbnMge1xuICAvKiogV2hpY2ggcmVnaXN0ZXJlZCBtb2RlbCB0byBydW4uIERlZmF1bHRzIHRvIHRoZSByZWdpc3RyeSdzIGRlZmF1bHQuICovXG4gIG1vZGVsSWQ/OiBzdHJpbmc7XG4gIC8qKiBNaW5pbXVtIGRldGVjdGlvbiBjb25maWRlbmNlLCBwZXIgdGlsZS4gKi9cbiAgY29uZmlkZW5jZT86IG51bWJlcjtcbiAgLyoqIE5NUyBJb1Ugd2l0aGluIGEgc2luZ2xlIHRpbGUuICovXG4gIGlvdVRocmVzaG9sZD86IG51bWJlcjtcbiAgLyoqIEludGVyc2VjdGlvbi1vdmVyLXNtYWxsZXIgdGhyZXNob2xkIGZvciBtZXJnaW5nIGFjcm9zcyB0aWxlIHNlYW1zLiAqL1xuICBtZXJnZVRocmVzaG9sZD86IG51bWJlcjtcbiAgLyoqIFRpbGUgb3ZlcmxhcCwgcGVyY2VudC4gKi9cbiAgb3ZlcmxhcFg/OiBudW1iZXI7XG4gIG92ZXJsYXBZPzogbnVtYmVyO1xuICAvKiogUHJvYmFiaWxpdHkgYXQgd2hpY2ggYSBtYXNrIHBpeGVsIGNvdW50cyBhcyBpbnNpZGUuICovXG4gIG1hc2tUaHJlc2hvbGQ/OiBudW1iZXI7XG4gIC8qKiBDYXAgb24gZGV0ZWN0aW9ucyBwZXIgdGlsZS4gKi9cbiAgbWF4RGV0ZWN0aW9ucz86IG51bWJlcjtcbiAgLyoqIEtlZXAgb25seSB0aGVzZSBjbGFzcyBpZHM7IG9taXQgZm9yIGFsbCBjbGFzc2VzIHRoZSBtb2RlbCBkZWNsYXJlcy4gKi9cbiAgY2xhc3NGaWx0ZXI/OiBudW1iZXJbXTtcbiAgLyoqIERvdWdsYXMtUGV1Y2tlciB0b2xlcmFuY2UgaW4gcGl4ZWxzIGZvciBvdXRsaW5lIHNpbXBsaWZpY2F0aW9uOyAwIGRpc2FibGVzLiAqL1xuICBzaW1wbGlmeVRvbGVyYW5jZT86IG51bWJlcjtcbiAgLyoqIERyb3AgaW5zdGFuY2VzIHdob3NlIG91dGxpbmUgYXJlYSBpcyBiZWxvdyB0aGlzLCBpbiBzcXVhcmUgcGl4ZWxzLiAqL1xuICBtaW5BcmVhPzogbnVtYmVyO1xuICAvKipcbiAgICogU2V0IGZhbHNlIHRvIGRldGVjdCBib3hlcyB3aXRob3V0IGFzc2VtYmxpbmcgbWFza3Mg4oCUIHN1YnN0YW50aWFsbHkgZmFzdGVyLFxuICAgKiBzaW5jZSBtYXNrIGFzc2VtYmx5IGRvbWluYXRlcyB0aGUgY29zdCBvZiBhIHJ1bi4gRGV0ZWN0aW9ucyB0aGVuIGNhcnJ5IGFcbiAgICogYm94IGFuZCBjbGFzcyBidXQgbm8gb3V0bGluZSwgc28gbm90aGluZyBjYW4gYmUgY29tbWl0dGVkIGFzIGEgcmVnaW9uLlxuICAgKi9cbiAgd2l0aE1hc2tzPzogYm9vbGVhbjtcbiAgLyoqXG4gICAqIEFib3J0IGFuIGluLXByb2dyZXNzIHJ1bi5cbiAgICpcbiAgICogQ2FuY2VsbGF0aW9uIGlzIGNvb3BlcmF0aXZlIGFuZCBjaGVja2VkIGF0IHRpbGUgYm91bmRhcmllcywgc28gaXQgdGFrZXNcbiAgICogZWZmZWN0IHdpdGhpbiByb3VnaGx5IG9uZSB0aWxlIHJhdGhlciB0aGFuIGluc3RhbnRseSDigJQgYSBgc2Vzc2lvbi5ydW4oKWBcbiAgICogYWxyZWFkeSBpbiBmbGlnaHQgY2Fubm90IGJlIGludGVycnVwdGVkLlxuICAgKi9cbiAgc2lnbmFsPzogQWJvcnRTaWduYWw7XG59XG5cbi8qKlxuICogUHJvZ3Jlc3Mvc3RhdHVzIGNhbGxiYWNrcyAoYWxsIG9wdGlvbmFsKS5cbiAqXG4gKiBEZWxpYmVyYXRlbHkgbWlycm9ycyB7QGxpbmsgQ2VsbFNlZ21lbnRQcm9ncmVzc30gaW4gc2hhcGUgcmF0aGVyIHRoYW4gaW1wb3J0aW5nXG4gKiBpdCDigJQgdGhlIHR3byBjb250cmFjdHMgc3RheSBpbmRlcGVuZGVudGx5IHZlcnNpb25hYmxlLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIEluc3RhbmNlU2VnbWVudFByb2dyZXNzIHtcbiAgLyoqIE1vZGVsLWRvd25sb2FkIHByb2dyZXNzLCAwLi4xIChmaXJzdCBydW4gb25seSkuICovXG4gIG9uUHJvZ3Jlc3M/OiAoZnJhY3Rpb246IG51bWJlcikgPT4gdm9pZDtcbiAgLyoqXG4gICAqIFJhdyBkb3dubG9hZCBieXRlIGNvdW50cywgZm9yIGhvc3RzIHRoYXQgcmVuZGVyIGEgc2l6ZSAoXCIxNDIgLyAyODcgTUJcIilcbiAgICogcmF0aGVyIHRoYW4gYSBiYXJlIHBlcmNlbnRhZ2UuIGB0b3RhbGAgaXMgbnVsbCB3aGVuIHRoZSByZXNwb25zZSBjYXJyaWVkIG5vXG4gICAqIENvbnRlbnQtTGVuZ3RoLlxuICAgKlxuICAgKiBBIGZyYWN0aW9uIGFsb25lIGNhbm5vdCBiZSB0dXJuZWQgYmFjayBpbnRvIGJ5dGVzLCBzbyBhIGhvc3QgZ2l2ZW4gb25seVxuICAgKiB7QGxpbmsgb25Qcm9ncmVzc30gaGFzIHRvIGludmVudCB0aGUgbnVtYmVycyDigJQgd2hpY2ggcmVhZHMgYXMgXCIwIE1CIC8gMCBNQlwiXG4gICAqIHRoZSBtb21lbnQgaXQgZG9lcy5cbiAgICovXG4gIG9uQnl0ZXM/OiAobG9hZGVkOiBudW1iZXIsIHRvdGFsOiBudW1iZXIgfCBudWxsKSA9PiB2b2lkO1xuICAvKiogSHVtYW4tcmVhZGFibGUgcGhhc2UsIGUuZy4gJ1J1bm5pbmcgaW5mZXJlbmNlICh0aWxlIDMvOCnigKYnLiAqL1xuICBvblN0YXR1cz86IChzdGF0dXM6IHN0cmluZykgPT4gdm9pZDtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBJSW5zdGFuY2VTZWdtZW50ZXIge1xuICAvKiogRGV0ZWN0IGFuZCBvdXRsaW5lIGFsbCBpbnN0YW5jZXMgaW4gYW4gUkdCQSBpbWFnZS4gKi9cbiAgc2VnbWVudEluc3RhbmNlcyhcbiAgICBpbWFnZTogeyBkYXRhOiBVaW50OENsYW1wZWRBcnJheTsgd2lkdGg6IG51bWJlcjsgaGVpZ2h0OiBudW1iZXIgfSxcbiAgICBvcHRzPzogSW5zdGFuY2VTZWdtZW50T3B0aW9ucyxcbiAgICBwcm9ncmVzcz86IEluc3RhbmNlU2VnbWVudFByb2dyZXNzLFxuICApOiBQcm9taXNlPEluc3RhbmNlU2VnbWVudGF0aW9uPjtcbn1cblxuLyoqXG4gKiBESSB0b2tlbiBmb3IgdGhlIGF1dG9tYXRpYyBpbnN0YW5jZSBzZWdtZW50ZXIuIERlZmF1bHRzIHRvIHRoZSBpbi1saWJyYXJ5XG4gKiB7QGxpbmsgWW9sb1NlZ21lbnRlclNlcnZpY2V9ICh5b2xvLXNlZ2RldGVjdC1qcywgbGF6eS1sb2FkZWQpOyBvdmVycmlkZSBpdCBpblxuICogdGhlIGhvc3QgdG8gc3dhcCBpbXBsZW1lbnRhdGlvbnMg4oCUIGZvciBleGFtcGxlIHRvIGRlbGVnYXRlIHRvIHRoZSBzZXJ2ZXIuXG4gKi9cbmV4cG9ydCBjb25zdCBJTlNUQU5DRV9TRUdNRU5URVIgPSBuZXcgSW5qZWN0aW9uVG9rZW48SUluc3RhbmNlU2VnbWVudGVyPignSU5TVEFOQ0VfU0VHTUVOVEVSJywge1xuICBwcm92aWRlZEluOiAncm9vdCcsXG4gIGZhY3Rvcnk6ICgpID0+IGluamVjdChZb2xvU2VnbWVudGVyU2VydmljZSksXG59KTtcbiJdfQ==

package/esm2022/lib/toolbar/segmentation/yolo-model-registry.mjs

@@ -0,0 +1,99 @@
+/**
+ * Registry of YOLOv8-seg instance-segmentation models.
+ *
+ * Mirrors {@link SAM_MODELS}: public HF-hosted ONNX by default so the tool works
+ * out of the box in any host, repointable at private hosting via
+ * {@link setYoloModelUrls}.
+ *
+ * Each entry carries the per-model *defaults* the server-side worker uses for
+ * that checkpoint. These are properties of how the model was trained (object
+ * scale, expected crowding), not UI preferences — the embryo models want heavy
+ * 60% tile overlap and loose merge thresholds because their objects are large
+ * and touch, while the eye models were trained on sparse, downsampled fields.
+ * Keeping them here means a host that just picks a model gets sane behaviour
+ * without having to know any of that.
+ *
+ * Weights point at the `model.fp16w.onnx` variant deliberately. The `.fp16`
+ * variant accumulates in half precision on WebGPU and, at the x-scale these
+ * models use, produces materially wrong boxes; `fp16w` stores weights in fp16
+ * and computes in fp32, so it is half the download at identical accuracy.
+ *
+ * Export tooling: the sibling `browser-onnx-tools` project.
+ */
+const HF = 'https://huggingface.co/Ballon999';
+const EYE_DEFAULTS = {
+    confidence: 0.6,
+    iouThreshold: 0.5,
+    mergeThreshold: 0.3,
+    overlapX: 0,
+    overlapY: 0,
+};
+// Embryos are large, touch each other, and are imaged at native scale — hence
+// the heavy overlap and the far looser merge thresholds.
+const EMBRYO_DEFAULTS = {
+    confidence: 0.6,
+    iouThreshold: 0.8,
+    mergeThreshold: 0.8,
+    overlapX: 60,
+    overlapY: 60,
+};
+export const YOLO_MODELS = [
+    {
+        id: 'yolov8x-seg-opticnerve',
+        label: 'Optic nerve',
+        modelUrl: `${HF}/yolov8x-seg-opticnerve-onnx/resolve/main/model.fp16w.onnx`,
+        defaults: { ...EYE_DEFAULTS },
+    },
+    {
+        id: 'yolov8x-seg-retina',
+        label: 'Retina',
+        modelUrl: `${HF}/yolov8x-seg-retina-onnx/resolve/main/model.fp16w.onnx`,
+        defaults: { ...EYE_DEFAULTS },
+    },
+    {
+        id: 'yolov8x-seg-embryo-m2',
+        label: 'Embryo (M2)',
+        modelUrl: `${HF}/yolov8x-seg-embryo-m2-onnx/resolve/main/model.fp16w.onnx`,
+        defaults: { ...EMBRYO_DEFAULTS },
+    },
+    {
+        id: 'yolov8x-seg-embryo-m3',
+        label: 'Embryo (M3)',
+        modelUrl: `${HF}/yolov8x-seg-embryo-m3-onnx/resolve/main/model.fp16w.onnx`,
+        defaults: { ...EMBRYO_DEFAULTS },
+    },
+];
+export const DEFAULT_YOLO_MODEL_ID = 'yolov8x-seg-opticnerve';
+let defaultModelId = DEFAULT_YOLO_MODEL_ID;
+/** Look up a model definition by id. Returns undefined for an unknown id. */
+export function getYoloModel(id) {
+    return YOLO_MODELS.find((m) => m.id === id);
+}
+/** Whether a model has a usable weights URL configured. */
+export function isYoloModelReady(id) {
+    const m = getYoloModel(id);
+    return !!m && m.modelUrl.trim().length > 0;
+}
+/**
+ * Repoint a model at different hosting (e.g. a GCS bucket or a same-origin
+ * proxy). Call once at app init, before the first run. An empty `modelUrl`
+ * disables the model.
+ */
+export function setYoloModelUrls(id, urls) {
+    const m = getYoloModel(id);
+    if (!m)
+        return;
+    if (urls.modelUrl !== undefined)
+        m.modelUrl = urls.modelUrl;
+    if (urls.metaUrl !== undefined)
+        m.metaUrl = urls.metaUrl;
+}
+/** Change which model runs when a caller does not name one. */
+export function setDefaultYoloModel(id) {
+    if (getYoloModel(id))
+        defaultModelId = id;
+}
+export function getDefaultYoloModelId() {
+    return defaultModelId;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"yolo-model-registry.js","sourceRoot":"","sources":["../../../../../src/lib/toolbar/segmentation/yolo-model-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAsBH,MAAM,EAAE,GAAG,kCAAkC,CAAC;AAE9C,MAAM,YAAY,GAAG;IACnB,UAAU,EAAE,GAAG;IACf,YAAY,EAAE,GAAG;IACjB,cAAc,EAAE,GAAG;IACnB,QAAQ,EAAE,CAAC;IACX,QAAQ,EAAE,CAAC;CACZ,CAAC;AAEF,8EAA8E;AAC9E,yDAAyD;AACzD,MAAM,eAAe,GAAG;IACtB,UAAU,EAAE,GAAG;IACf,YAAY,EAAE,GAAG;IACjB,cAAc,EAAE,GAAG;IACnB,QAAQ,EAAE,EAAE;IACZ,QAAQ,EAAE,EAAE;CACb,CAAC;AAEF,MAAM,CAAC,MAAM,WAAW,GAAmB;IACzC;QACE,EAAE,EAAE,wBAAwB;QAC5B,KAAK,EAAE,aAAa;QACpB,QAAQ,EAAE,GAAG,EAAE,4DAA4D;QAC3E,QAAQ,EAAE,EAAE,GAAG,YAAY,EAAE;KAC9B;IACD;QACE,EAAE,EAAE,oBAAoB;QACxB,KAAK,EAAE,QAAQ;QACf,QAAQ,EAAE,GAAG,EAAE,wDAAwD;QACvE,QAAQ,EAAE,EAAE,GAAG,YAAY,EAAE;KAC9B;IACD;QACE,EAAE,EAAE,uBAAuB;QAC3B,KAAK,EAAE,aAAa;QACpB,QAAQ,EAAE,GAAG,EAAE,2DAA2D;QAC1E,QAAQ,EAAE,EAAE,GAAG,eAAe,EAAE;KACjC;IACD;QACE,EAAE,EAAE,uBAAuB;QAC3B,KAAK,EAAE,aAAa;QACpB,QAAQ,EAAE,GAAG,EAAE,2DAA2D;QAC1E,QAAQ,EAAE,EAAE,GAAG,eAAe,EAAE;KACjC;CACF,CAAC;AAEF,MAAM,CAAC,MAAM,qBAAqB,GAAG,wBAAwB,CAAC;AAE9D,IAAI,cAAc,GAAG,qBAAqB,CAAC;AAE3C,6EAA6E;AAC7E,MAAM,UAAU,YAAY,CAAC,EAAU;IACrC,OAAO,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;AAC9C,CAAC;AAED,2DAA2D;AAC3D,MAAM,UAAU,gBAAgB,CAAC,EAAU;IACzC,MAAM,CAAC,GAAG,YAAY,CAAC,EAAE,CAAC,CAAC;IAC3B,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC;AAC7C,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,EAAU,EAAE,IAA6C;IACxF,MAAM,CAAC,GAAG,YAAY,CAAC,EAAE,CAAC,CAAC;IAC3B,IAAI,CAAC,CAAC;QAAE,OAAO;IACf,IAAI,IAAI,CAAC,QAAQ,KAAK,SAAS;QAAE,CAAC,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;IAC5D,IAAI,IAAI,CAAC,OAAO,KAAK,SAAS;QAAE,CAAC,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;AAC3D,CAAC;AAED,+DAA+D;AAC/D,MAAM,UAAU,mBAAmB,CAAC,EAAU;IAC5C,IAAI,YAAY,CAAC,EAAE,CAAC;QAAE,cAAc,GAAG,EAAE,CAAC;AAC5C,CAAC;AAED,MAAM,UAAU,qBAAqB;IACnC,OAAO,cAAc,CAAC;AACxB,CAAC","sourcesContent":["/**\n * Registry of YOLOv8-seg instance-segmentation models.\n *\n * Mirrors {@link SAM_MODELS}: public HF-hosted ONNX by default so the tool works\n * out of the box in any host, repointable at private hosting via\n * {@link setYoloModelUrls}.\n *\n * Each entry carries the per-model *defaults* the server-side worker uses for\n * that checkpoint. These are properties of how the model was trained (object\n * scale, expected crowding), not UI preferences — the embryo models want heavy\n * 60% tile overlap and loose merge thresholds because their objects are large\n * and touch, while the eye models were trained on sparse, downsampled fields.\n * Keeping them here means a host that just picks a model gets sane behaviour\n * without having to know any of that.\n *\n * Weights point at the `model.fp16w.onnx` variant deliberately. The `.fp16`\n * variant accumulates in half precision on WebGPU and, at the x-scale these\n * models use, produces materially wrong boxes; `fp16w` stores weights in fp16\n * and computes in fp32, so it is half the download at identical accuracy.\n *\n * Export tooling: the sibling `browser-onnx-tools` project.\n */\n\nexport interface YoloModelDef {\n  id: string;\n  label: string;\n  /** URL of the `.onnx` weights. Empty disables the model. */\n  modelUrl: string;\n  /**\n   * URL of the `model.json` sidecar. Omit to use `model.json` alongside the\n   * weights, which is how every published repo is laid out.\n   */\n  metaUrl?: string;\n  /** Per-model defaults, from the server worker's model table. */\n  defaults: {\n    confidence: number;\n    iouThreshold: number;\n    mergeThreshold: number;\n    overlapX: number;\n    overlapY: number;\n  };\n}\n\nconst HF = 'https://huggingface.co/Ballon999';\n\nconst EYE_DEFAULTS = {\n  confidence: 0.6,\n  iouThreshold: 0.5,\n  mergeThreshold: 0.3,\n  overlapX: 0,\n  overlapY: 0,\n};\n\n// Embryos are large, touch each other, and are imaged at native scale — hence\n// the heavy overlap and the far looser merge thresholds.\nconst EMBRYO_DEFAULTS = {\n  confidence: 0.6,\n  iouThreshold: 0.8,\n  mergeThreshold: 0.8,\n  overlapX: 60,\n  overlapY: 60,\n};\n\nexport const YOLO_MODELS: YoloModelDef[] = [\n  {\n    id: 'yolov8x-seg-opticnerve',\n    label: 'Optic nerve',\n    modelUrl: `${HF}/yolov8x-seg-opticnerve-onnx/resolve/main/model.fp16w.onnx`,\n    defaults: { ...EYE_DEFAULTS },\n  },\n  {\n    id: 'yolov8x-seg-retina',\n    label: 'Retina',\n    modelUrl: `${HF}/yolov8x-seg-retina-onnx/resolve/main/model.fp16w.onnx`,\n    defaults: { ...EYE_DEFAULTS },\n  },\n  {\n    id: 'yolov8x-seg-embryo-m2',\n    label: 'Embryo (M2)',\n    modelUrl: `${HF}/yolov8x-seg-embryo-m2-onnx/resolve/main/model.fp16w.onnx`,\n    defaults: { ...EMBRYO_DEFAULTS },\n  },\n  {\n    id: 'yolov8x-seg-embryo-m3',\n    label: 'Embryo (M3)',\n    modelUrl: `${HF}/yolov8x-seg-embryo-m3-onnx/resolve/main/model.fp16w.onnx`,\n    defaults: { ...EMBRYO_DEFAULTS },\n  },\n];\n\nexport const DEFAULT_YOLO_MODEL_ID = 'yolov8x-seg-opticnerve';\n\nlet defaultModelId = DEFAULT_YOLO_MODEL_ID;\n\n/** Look up a model definition by id. Returns undefined for an unknown id. */\nexport function getYoloModel(id: string): YoloModelDef | undefined {\n  return YOLO_MODELS.find((m) => m.id === id);\n}\n\n/** Whether a model has a usable weights URL configured. */\nexport function isYoloModelReady(id: string): boolean {\n  const m = getYoloModel(id);\n  return !!m && m.modelUrl.trim().length > 0;\n}\n\n/**\n * Repoint a model at different hosting (e.g. a GCS bucket or a same-origin\n * proxy). Call once at app init, before the first run. An empty `modelUrl`\n * disables the model.\n */\nexport function setYoloModelUrls(id: string, urls: { modelUrl?: string; metaUrl?: string }): void {\n  const m = getYoloModel(id);\n  if (!m) return;\n  if (urls.modelUrl !== undefined) m.modelUrl = urls.modelUrl;\n  if (urls.metaUrl !== undefined) m.metaUrl = urls.metaUrl;\n}\n\n/** Change which model runs when a caller does not name one. */\nexport function setDefaultYoloModel(id: string): void {\n  if (getYoloModel(id)) defaultModelId = id;\n}\n\nexport function getDefaultYoloModelId(): string {\n  return defaultModelId;\n}\n"]}

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

@@ -0,0 +1,169 @@
+import { Injectable } from '@angular/core';
+import { getOrtWasmBase } from './ort-runtime-config';
+import { getDefaultYoloModelId, getYoloModel } from './yolo-model-registry';
+import * as i0 from "@angular/core";
+/**
+ * Default in-library {@link IInstanceSegmenter}, backed by yolo-segdetect-js
+ * (YOLOv8-seg on WebGPU, falling back to WASM).
+ *
+ * `yolo-segdetect-js` is a regular dependency but is **lazy-imported** on first
+ * use, so apps that never run YOLO pay nothing for it — or for onnxruntime-web —
+ * in their initial bundle. This mirrors {@link CellposeSegmenterService}.
+ *
+ * The one structural difference from the Cellpose service: there are four YOLO
+ * checkpoints, not one, so instances are cached **per model id** rather than as
+ * a single singleton. Each entry owns its own worker and ORT session, so a host
+ * that switches models pays a second load but keeps the first one warm. Nothing
+ * evicts automatically — these are ~144 MB each, so a host that cycles through
+ * all four should call {@link dispose} for the ones it is done with.
+ */
+export class YoloSegmenterService {
+    constructor() {
+        this.instances = new Map();
+        this.loading = new Map();
+    }
+    async segmentInstances(image, opts = {}, progress) {
+        const modelId = opts.modelId ?? getDefaultYoloModelId();
+        const def = this.requireModel(modelId);
+        let announcedDownload = false;
+        const seg = await this.getModel(modelId, (loaded, total) => {
+            if (total)
+                progress?.onProgress?.(loaded / total);
+            progress?.onBytes?.(loaded, total);
+            if (loaded > 0 && !announcedDownload) {
+                announcedDownload = true;
+                progress?.onStatus?.(`Downloading ${def.label} model…`);
+            }
+        }, (status) => progress?.onStatus?.(status));
+        progress?.onStatus?.('Running inference…');
+        const result = await seg.segment({ data: image.data, width: image.width, height: image.height }, {
+            confThreshold: opts.confidence ?? def.defaults.confidence,
+            iouThreshold: opts.iouThreshold ?? def.defaults.iouThreshold,
+            threshold: opts.mergeThreshold ?? def.defaults.mergeThreshold,
+            overlapX: opts.overlapX ?? def.defaults.overlapX,
+            overlapY: opts.overlapY ?? def.defaults.overlapY,
+            ...(opts.maskThreshold !== undefined ? { maskThreshold: opts.maskThreshold } : {}),
+            ...(opts.maxDetections !== undefined ? { maxDetections: opts.maxDetections } : {}),
+            ...(opts.classFilter ? { classFilter: opts.classFilter } : {}),
+            ...(opts.withMasks !== undefined ? { withMasks: opts.withMasks } : {}),
+            ...(opts.signal ? { signal: opts.signal } : {}),
+            // Only worth tracing when there are masks to trace.
+            tracePolygons: opts.withMasks !== false,
+            traceOptions: {
+                ...(opts.simplifyTolerance !== undefined ? { simplifyTolerance: opts.simplifyTolerance } : {}),
+                ...(opts.minArea !== undefined ? { minArea: opts.minArea } : {}),
+            },
+            onTileProgress: (done, total) => progress?.onStatus?.(done < total ? `Running inference (tile ${done}/${total})…` : 'Tracing outlines…'),
+        });
+        // 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}`,
+            });
+        }
+        return {
+            detections,
+            width: result.width,
+            height: result.height,
+            classNames: result.classNames,
+        };
+    }
+    /**
+     * The shared segmenter for a model id, created on first use and reused
+     * thereafter (deduped across concurrent callers). Exposed so a host's
+     * processing pipeline can drive richer `segment()` options on the same loaded
+     * session instead of loading the model twice.
+     */
+    getModel(modelId = getDefaultYoloModelId(), onProgress, onStatus) {
+        const existing = this.instances.get(modelId);
+        if (existing)
+            return Promise.resolve(existing);
+        const inFlight = this.loading.get(modelId);
+        if (inFlight)
+            return inFlight;
+        const def = this.requireModel(modelId);
+        const load = (async () => {
+            // Lazy: keep yolo-segdetect-js + its ORT runtime out of the initial bundle.
+            const { YoloSegmenter, configureOrt } = await import('yolo-segdetect-js');
+            configureOrt({ wasmPaths: getOrtWasmBase() });
+            const seg = await YoloSegmenter.fromPretrained(def.modelUrl, {
+                preload: true,
+                ...(def.metaUrl ? { metaUrl: def.metaUrl } : {}),
+                onProgress: ({ loaded, total }) => onProgress?.(loaded, total),
+                onStatus: (s) => onStatus?.(s),
+            });
+            this.instances.set(modelId, seg);
+            return seg;
+        })();
+        this.loading.set(modelId, load);
+        // A failed load must not poison the cache — the next caller should retry
+        // rather than inherit the rejected promise forever.
+        load.catch(() => this.loading.delete(modelId));
+        return load;
+    }
+    /** Whether a model is already loaded (warm). */
+    isLoaded(modelId = getDefaultYoloModelId()) {
+        return this.instances.has(modelId);
+    }
+    /**
+     * Release one model, or all of them. Safe to call on a model never loaded.
+     *
+     * In-flight loads are torn down too, not just warm ones. Simply dropping the
+     * pending promise and returning would let the load finish afterwards,
+     * re-populate {@link instances}, and strand a live worker and ORT session that
+     * nothing owns — disposal would have reported success while leaking. So a load
+     * that is still running is awaited and then released.
+     */
+    async dispose(modelId) {
+        const ids = modelId ? [modelId] : [...new Set([...this.instances.keys(), ...this.loading.keys()])];
+        await Promise.all(ids.map((id) => this.disposeOne(id)));
+    }
+    async disposeOne(id) {
+        const pending = this.loading.get(id);
+        const loaded = this.instances.get(id);
+        this.instances.delete(id);
+        this.loading.delete(id);
+        if (loaded)
+            await loaded.dispose();
+        if (!pending)
+            return;
+        // A pending load assigns instances[id] before its promise resolves, so by
+        // the time this await returns the entry is back. Clear it only if it still
+        // points at what *this* load produced — a newer load started in the
+        // meantime owns its own entry and must not be evicted.
+        const seg = await pending.catch(() => null);
+        if (!seg || seg === loaded)
+            return;
+        if (this.instances.get(id) === seg)
+            this.instances.delete(id);
+        await seg.dispose();
+    }
+    requireModel(modelId) {
+        const def = getYoloModel(modelId);
+        if (!def)
+            throw new Error(`Unknown YOLO model id "${modelId}".`);
+        if (!def.modelUrl.trim()) {
+            throw new Error(`YOLO model "${modelId}" is not configured — its modelUrl is empty.`);
+        }
+        return def;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: YoloSegmenterService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: YoloSegmenterService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: YoloSegmenterService, decorators: [{
+            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        onTileProgress: (done, total) =>\n          progress?.onStatus?.(done < total ? `Running inference (tile ${done}/${total})…` : 'Tracing outlines…'),\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"]}