@jax-data-science/sci-image-visualizer 0.1.0

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

@@ -0,0 +1,108 @@
+/**
+ * Registry of promptable SAM models for the browser segment tool.
+ *
+ * micro-sam (microscopy-finetuned, promptable) and patho-sam (histopathology-
+ * finetuned) are entries; SAM3 slots in here once its quantized ONNX export and
+ * a `variant: 'sam3'` decoder path are published. The
+ * automatic cellpose-SAM model is intentionally NOT here — it's not promptable
+ * and lives in the processing-pipeline's cellpose engine as the automatic tool.
+ *
+ * `encoderUrl` / `decoderUrl` point at the public HF-hosted ONNX pairs by
+ * default, so the segment tools work out of the box in any host (mirroring the
+ * cellpose default). A host can repoint them at its own hosting (e.g. a GCS
+ * bucket) at runtime via {@link setSamModelUrls}; an empty URL disables a model
+ * (the session throws a clear "not configured" error). Export/quantization
+ * tooling: the sibling `browser-onnx-tools` project; see docs/sam-segmentation-design.md.
+ */
+export const SAM_MODELS = [
+    {
+        id: 'microsam-vit-t-lm',
+        label: 'micro-sam ViT-T',
+        encoderUrl: 'https://huggingface.co/Ballon999/microsam-vit-t-lm-onnx/resolve/main/encoder.fp16.onnx',
+        decoderUrl: 'https://huggingface.co/Ballon999/microsam-vit-t-lm-onnx/resolve/main/decoder.onnx',
+        variant: 'sam1',
+        inputSize: 1024,
+        microscopy: true,
+        // TinyViT's fp16 attention overflows on the onnxruntime-web WebGPU EP and
+        // returns an empty mask ("No masks found"); it's numerically correct on
+        // WASM, and the encoder is tiny (~14 MB) so WASM is plenty fast.
+        encoderProviders: ['wasm'],
+        // Small enough to run in-process on the main thread — avoids the Web
+        // Worker's spawn / second-ORT-runtime / round-trip overhead, which made it
+        // noticeably slower to load and segment.
+        inProcess: true,
+    },
+    {
+        id: 'microsam-vit-b-lm',
+        label: 'micro-sam ViT-B',
+        encoderUrl: 'https://huggingface.co/Ballon999/microsam-vit-b-lm-onnx/resolve/main/encoder.fp16.onnx',
+        decoderUrl: 'https://huggingface.co/Ballon999/microsam-vit-b-lm-onnx/resolve/main/decoder.onnx',
+        variant: 'sam1',
+        inputSize: 1024,
+        microscopy: true,
+    },
+    {
+        id: 'patho-sam-vit-b',
+        label: 'patho-sam ViT-B',
+        encoderUrl: 'https://huggingface.co/Ballon999/patho-sam-vit-b-onnx/resolve/main/encoder.fp16.onnx',
+        decoderUrl: 'https://huggingface.co/Ballon999/patho-sam-vit-b-onnx/resolve/main/decoder.onnx',
+        variant: 'sam1',
+        inputSize: 1024,
+        microscopy: true,
+    },
+    {
+        id: 'patho-sam-vit-b-int8',
+        label: 'patho-sam ViT-B (int8)',
+        encoderUrl: 'https://huggingface.co/Ballon999/patho-sam-vit-b-onnx/resolve/main/encoder.int8.onnx',
+        decoderUrl: 'https://huggingface.co/Ballon999/patho-sam-vit-b-onnx/resolve/main/decoder.onnx',
+        variant: 'sam1',
+        inputSize: 1024,
+        microscopy: true,
+        // int8 dynamic-quantized encoder (~100 MB vs ~180 MB fp16, IoU ~0.99 on the
+        // sanity test). onnxruntime-web's WebGPU EP doesn't support int8 matmul, so
+        // it runs on WASM — smaller download, slower encode than the fp16 entry.
+        encoderProviders: ['wasm'],
+    },
+];
+/** Initial default model id (overridden at runtime once the host configures a
+ *  hosted model via {@link setSamModelUrls}). */
+export const DEFAULT_SAM_MODEL_ID = SAM_MODELS[0].id;
+/** The active default — updated when the host configures a model's ONNX URLs,
+ *  so the tool uses the model that's actually hosted (not just the first entry). */
+let activeDefaultId = DEFAULT_SAM_MODEL_ID;
+/** Look up a model by id; falls back to the active default when id is
+ *  unknown/absent. */
+export function getSamModel(id) {
+    const wanted = id ?? activeDefaultId;
+    return SAM_MODELS.find((m) => m.id === wanted) ?? SAM_MODELS[0];
+}
+/** The active default model id (what the tools/picker use when unset). */
+export function getDefaultSamModelId() {
+    return activeDefaultId;
+}
+/** Set the active default model id (must be a registered model). */
+export function setDefaultSamModel(id) {
+    if (SAM_MODELS.some((m) => m.id === id))
+        activeDefaultId = id;
+}
+/** True when a model has both ONNX URLs configured (i.e. it can actually run). */
+export function isSamModelReady(model) {
+    return !!model.encoderUrl && !!model.decoderUrl;
+}
+/**
+ * Point a registered model at its hosted ONNX pair (HF / GCS). Called by the
+ * host's composition root once hosting is decided, keeping deployment URLs out
+ * of the library.
+ */
+export function setSamModelUrls(id, encoderUrl, decoderUrl) {
+    const m = SAM_MODELS.find((x) => x.id === id);
+    if (m) {
+        m.encoderUrl = encoderUrl;
+        m.decoderUrl = decoderUrl;
+        // The configured (hosted) model becomes the active default, so the tools
+        // use it rather than the first registry entry (which may be unhosted).
+        if (encoderUrl && decoderUrl)
+            activeDefaultId = id;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sam-model-registry.js","sourceRoot":"","sources":["../../../../../src/lib/toolbar/segmentation/sam-model-registry.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,UAAU,GAAkB;IACvC;QACE,EAAE,EAAE,mBAAmB;QACvB,KAAK,EAAE,iBAAiB;QACxB,UAAU,EAAE,wFAAwF;QACpG,UAAU,EAAE,mFAAmF;QAC/F,OAAO,EAAE,MAAM;QACf,SAAS,EAAE,IAAI;QACf,UAAU,EAAE,IAAI;QAChB,0EAA0E;QAC1E,wEAAwE;QACxE,iEAAiE;QACjE,gBAAgB,EAAE,CAAC,MAAM,CAAC;QAC1B,qEAAqE;QACrE,2EAA2E;QAC3E,yCAAyC;QACzC,SAAS,EAAE,IAAI;KAChB;IACD;QACE,EAAE,EAAE,mBAAmB;QACvB,KAAK,EAAE,iBAAiB;QACxB,UAAU,EAAE,wFAAwF;QACpG,UAAU,EAAE,mFAAmF;QAC/F,OAAO,EAAE,MAAM;QACf,SAAS,EAAE,IAAI;QACf,UAAU,EAAE,IAAI;KACjB;IACD;QACE,EAAE,EAAE,iBAAiB;QACrB,KAAK,EAAE,iBAAiB;QACxB,UAAU,EAAE,sFAAsF;QAClG,UAAU,EAAE,iFAAiF;QAC7F,OAAO,EAAE,MAAM;QACf,SAAS,EAAE,IAAI;QACf,UAAU,EAAE,IAAI;KACjB;IACD;QACE,EAAE,EAAE,sBAAsB;QAC1B,KAAK,EAAE,wBAAwB;QAC/B,UAAU,EAAE,sFAAsF;QAClG,UAAU,EAAE,iFAAiF;QAC7F,OAAO,EAAE,MAAM;QACf,SAAS,EAAE,IAAI;QACf,UAAU,EAAE,IAAI;QAChB,4EAA4E;QAC5E,4EAA4E;QAC5E,yEAAyE;QACzE,gBAAgB,EAAE,CAAC,MAAM,CAAC;KAC3B;CACF,CAAC;AAEF;iDACiD;AACjD,MAAM,CAAC,MAAM,oBAAoB,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;AAErD;oFACoF;AACpF,IAAI,eAAe,GAAG,oBAAoB,CAAC;AAE3C;sBACsB;AACtB,MAAM,UAAU,WAAW,CAAC,EAAW;IACrC,MAAM,MAAM,GAAG,EAAE,IAAI,eAAe,CAAC;IACrC,OAAO,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,MAAM,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC;AAClE,CAAC;AAED,0EAA0E;AAC1E,MAAM,UAAU,oBAAoB;IAClC,OAAO,eAAe,CAAC;AACzB,CAAC;AAED,oEAAoE;AACpE,MAAM,UAAU,kBAAkB,CAAC,EAAU;IAC3C,IAAI,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC;QAAE,eAAe,GAAG,EAAE,CAAC;AAChE,CAAC;AAED,kFAAkF;AAClF,MAAM,UAAU,eAAe,CAAC,KAAkB;IAChD,OAAO,CAAC,CAAC,KAAK,CAAC,UAAU,IAAI,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC;AAClD,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAAC,EAAU,EAAE,UAAkB,EAAE,UAAkB;IAChF,MAAM,CAAC,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;IAC9C,IAAI,CAAC,EAAE,CAAC;QACN,CAAC,CAAC,UAAU,GAAG,UAAU,CAAC;QAC1B,CAAC,CAAC,UAAU,GAAG,UAAU,CAAC;QAC1B,yEAAyE;QACzE,uEAAuE;QACvE,IAAI,UAAU,IAAI,UAAU;YAAE,eAAe,GAAG,EAAE,CAAC;IACrD,CAAC;AACH,CAAC","sourcesContent":["import { SamModelDef } from '../../contracts/sam.contract';\n\n/**\n * Registry of promptable SAM models for the browser segment tool.\n *\n * micro-sam (microscopy-finetuned, promptable) and patho-sam (histopathology-\n * finetuned) are entries; SAM3 slots in here once its quantized ONNX export and\n * a `variant: 'sam3'` decoder path are published. The\n * automatic cellpose-SAM model is intentionally NOT here — it's not promptable\n * and lives in the processing-pipeline's cellpose engine as the automatic tool.\n *\n * `encoderUrl` / `decoderUrl` point at the public HF-hosted ONNX pairs by\n * default, so the segment tools work out of the box in any host (mirroring the\n * cellpose default). A host can repoint them at its own hosting (e.g. a GCS\n * bucket) at runtime via {@link setSamModelUrls}; an empty URL disables a model\n * (the session throws a clear \"not configured\" error). Export/quantization\n * tooling: the sibling `browser-onnx-tools` project; see docs/sam-segmentation-design.md.\n */\nexport const SAM_MODELS: SamModelDef[] = [\n  {\n    id: 'microsam-vit-t-lm',\n    label: 'micro-sam ViT-T',\n    encoderUrl: 'https://huggingface.co/Ballon999/microsam-vit-t-lm-onnx/resolve/main/encoder.fp16.onnx',\n    decoderUrl: 'https://huggingface.co/Ballon999/microsam-vit-t-lm-onnx/resolve/main/decoder.onnx',\n    variant: 'sam1',\n    inputSize: 1024,\n    microscopy: true,\n    // TinyViT's fp16 attention overflows on the onnxruntime-web WebGPU EP and\n    // returns an empty mask (\"No masks found\"); it's numerically correct on\n    // WASM, and the encoder is tiny (~14 MB) so WASM is plenty fast.\n    encoderProviders: ['wasm'],\n    // Small enough to run in-process on the main thread — avoids the Web\n    // Worker's spawn / second-ORT-runtime / round-trip overhead, which made it\n    // noticeably slower to load and segment.\n    inProcess: true,\n  },\n  {\n    id: 'microsam-vit-b-lm',\n    label: 'micro-sam ViT-B',\n    encoderUrl: 'https://huggingface.co/Ballon999/microsam-vit-b-lm-onnx/resolve/main/encoder.fp16.onnx',\n    decoderUrl: 'https://huggingface.co/Ballon999/microsam-vit-b-lm-onnx/resolve/main/decoder.onnx',\n    variant: 'sam1',\n    inputSize: 1024,\n    microscopy: true,\n  },\n  {\n    id: 'patho-sam-vit-b',\n    label: 'patho-sam ViT-B',\n    encoderUrl: 'https://huggingface.co/Ballon999/patho-sam-vit-b-onnx/resolve/main/encoder.fp16.onnx',\n    decoderUrl: 'https://huggingface.co/Ballon999/patho-sam-vit-b-onnx/resolve/main/decoder.onnx',\n    variant: 'sam1',\n    inputSize: 1024,\n    microscopy: true,\n  },\n  {\n    id: 'patho-sam-vit-b-int8',\n    label: 'patho-sam ViT-B (int8)',\n    encoderUrl: 'https://huggingface.co/Ballon999/patho-sam-vit-b-onnx/resolve/main/encoder.int8.onnx',\n    decoderUrl: 'https://huggingface.co/Ballon999/patho-sam-vit-b-onnx/resolve/main/decoder.onnx',\n    variant: 'sam1',\n    inputSize: 1024,\n    microscopy: true,\n    // int8 dynamic-quantized encoder (~100 MB vs ~180 MB fp16, IoU ~0.99 on the\n    // sanity test). onnxruntime-web's WebGPU EP doesn't support int8 matmul, so\n    // it runs on WASM — smaller download, slower encode than the fp16 entry.\n    encoderProviders: ['wasm'],\n  },\n];\n\n/** Initial default model id (overridden at runtime once the host configures a\n *  hosted model via {@link setSamModelUrls}). */\nexport const DEFAULT_SAM_MODEL_ID = SAM_MODELS[0].id;\n\n/** The active default — updated when the host configures a model's ONNX URLs,\n *  so the tool uses the model that's actually hosted (not just the first entry). */\nlet activeDefaultId = DEFAULT_SAM_MODEL_ID;\n\n/** Look up a model by id; falls back to the active default when id is\n *  unknown/absent. */\nexport function getSamModel(id?: string): SamModelDef {\n  const wanted = id ?? activeDefaultId;\n  return SAM_MODELS.find((m) => m.id === wanted) ?? SAM_MODELS[0];\n}\n\n/** The active default model id (what the tools/picker use when unset). */\nexport function getDefaultSamModelId(): string {\n  return activeDefaultId;\n}\n\n/** Set the active default model id (must be a registered model). */\nexport function setDefaultSamModel(id: string): void {\n  if (SAM_MODELS.some((m) => m.id === id)) activeDefaultId = id;\n}\n\n/** True when a model has both ONNX URLs configured (i.e. it can actually run). */\nexport function isSamModelReady(model: SamModelDef): boolean {\n  return !!model.encoderUrl && !!model.decoderUrl;\n}\n\n/**\n * Point a registered model at its hosted ONNX pair (HF / GCS). Called by the\n * host's composition root once hosting is decided, keeping deployment URLs out\n * of the library.\n */\nexport function setSamModelUrls(id: string, encoderUrl: string, decoderUrl: string): void {\n  const m = SAM_MODELS.find((x) => x.id === id);\n  if (m) {\n    m.encoderUrl = encoderUrl;\n    m.decoderUrl = decoderUrl;\n    // The configured (hosted) model becomes the active default, so the tools\n    // use it rather than the first registry entry (which may be unhosted).\n    if (encoderUrl && decoderUrl) activeDefaultId = id;\n  }\n}\n"]}

package/esm2022/lib/toolbar/segmentation/sam-onnx-core.mjs

@@ -0,0 +1,159 @@
+import * as ort from 'onnxruntime-web';
+/**
+ * Shared, DOM-free SAM inference primitives used by BOTH inference backends:
+ * the in-process session (`OnnxSamSession`, main thread) and the dedicated
+ * Web Worker (`onnx-sam.worker`). Keeping these here avoids duplicating the
+ * preprocessing / decoder-prompt math and keeps the worker DOM-free (it can't
+ * import sam-prompt.ts, which pulls in DOM types).
+ */
+export const PIXEL_MEAN = [123.675, 116.28, 103.53];
+export const PIXEL_STD = [58.395, 57.12, 57.375];
+const MODEL_CACHE = 'sam-onnx';
+/** Fetch a model as an ArrayBuffer, streaming progress and caching in the Cache
+ *  API (so it isn't re-downloaded). Cache hit → progress jumps to 1. Works on
+ *  the main thread and in a worker (both have `fetch` + `caches`). */
+export async function fetchModel(url, onProgress) {
+    const cache = typeof caches !== 'undefined' ? await caches.open(MODEL_CACHE).catch(() => null) : null;
+    const hit = cache ? await cache.match(url) : null;
+    if (hit) {
+        onProgress?.(1);
+        return await hit.arrayBuffer();
+    }
+    const resp = await fetch(url);
+    if (!resp.ok)
+        throw new Error(`fetch ${url} failed: HTTP ${resp.status}`);
+    const total = Number(resp.headers.get('content-length')) || 0;
+    if (!resp.body || !total) {
+        const buf = await resp.arrayBuffer();
+        onProgress?.(1);
+        if (cache)
+            await cache.put(url, new Response(buf)).catch(() => undefined);
+        return buf;
+    }
+    const reader = resp.body.getReader();
+    const chunks = [];
+    let received = 0;
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        chunks.push(value);
+        received += value.length;
+        onProgress?.(received / total);
+    }
+    const out = new Uint8Array(received);
+    let off = 0;
+    for (const c of chunks) {
+        out.set(c, off);
+        off += c.length;
+    }
+    if (cache) {
+        await cache.put(url, new Response(out.slice(), { headers: { 'content-length': String(received) } }))
+            .catch(() => undefined);
+    }
+    onProgress?.(1);
+    return out.buffer;
+}
+/** Resize (long side → size, bilinear), pad to size×size, SAM-normalize → CHW float32. */
+export function preprocess(data, width, height, size, scale) {
+    const newW = Math.round(width * scale);
+    const newH = Math.round(height * scale);
+    const chw = new Float32Array(3 * size * size); // zero-padded
+    for (let y = 0; y < newH; y++) {
+        const sy = Math.min(height - 1, y / scale);
+        const y0 = Math.floor(sy);
+        const fy = sy - y0;
+        const y1 = Math.min(height - 1, y0 + 1);
+        for (let x = 0; x < newW; x++) {
+            const sx = Math.min(width - 1, x / scale);
+            const x0 = Math.floor(sx);
+            const fx = sx - x0;
+            const x1 = Math.min(width - 1, x0 + 1);
+            for (let c = 0; c < 3; c++) {
+                const p00 = data[(y0 * width + x0) * 4 + c];
+                const p01 = data[(y0 * width + x1) * 4 + c];
+                const p10 = data[(y1 * width + x0) * 4 + c];
+                const p11 = data[(y1 * width + x1) * 4 + c];
+                const top = p00 + (p01 - p00) * fx;
+                const bot = p10 + (p11 - p10) * fx;
+                const v = top + (bot - top) * fy;
+                chw[c * size * size + y * size + x] = (v - PIXEL_MEAN[c]) / PIXEL_STD[c];
+            }
+        }
+    }
+    return chw;
+}
+/** Assemble decoder `point_coords`/`point_labels` from a prompt, in encoder
+ *  (resized) space. Box = two points labelled 2/3; points use 1/0; a points-only
+ *  prompt pads the absent box slot with `[0,0]` labelled -1. */
+export function buildDecoderPrompt(prompt, scale) {
+    const coords = [];
+    const labels = [];
+    for (const p of prompt.points ?? []) {
+        coords.push(p.x * scale, p.y * scale);
+        labels.push(p.label);
+    }
+    if (prompt.box) {
+        const b = prompt.box;
+        coords.push(b.x0 * scale, b.y0 * scale);
+        labels.push(2);
+        coords.push(b.x1 * scale, b.y1 * scale);
+        labels.push(3);
+    }
+    else if (labels.length > 0) {
+        coords.push(0, 0);
+        labels.push(-1);
+    }
+    return {
+        pointCoords: Float32Array.from(coords),
+        pointLabels: Float32Array.from(labels),
+        numPoints: labels.length,
+    };
+}
+/** Binarize mask logits (`> threshold`) into a 0/1 mask. */
+export function binarizeMask(logits, threshold = 0) {
+    const out = new Uint8Array(logits.length);
+    for (let i = 0; i < logits.length; i++)
+        out[i] = logits[i] > threshold ? 1 : 0;
+    return out;
+}
+/** Index of the highest-scoring mask in a multimask decoder output. */
+export function bestMaskIndex(iou) {
+    let best = 0;
+    for (let i = 1; i < iou.length; i++)
+        if (iou[i] > iou[best])
+            best = i;
+    return best;
+}
+/** Run the encoder on an RGBA image → a reusable embedding. */
+export async function runEncoder(encoder, data, width, height, inputSize) {
+    const scale = inputSize / Math.max(width, height);
+    const input = preprocess(data, width, height, inputSize, scale);
+    const out = await encoder.run({
+        [encoder.inputNames[0]]: new ort.Tensor('float32', input, [1, 3, inputSize, inputSize]),
+    });
+    const emb = out[encoder.outputNames[0]];
+    return {
+        data: emb.data, dims: emb.dims,
+        scale, imageWidth: width, imageHeight: height,
+    };
+}
+/** Run the decoder for one prompt against a cached embedding → a binary mask. */
+export async function runDecoder(decoder, e, prompt) {
+    const { pointCoords, pointLabels, numPoints } = buildDecoderPrompt(prompt, e.scale);
+    const out = await decoder.run({
+        image_embeddings: new ort.Tensor('float32', e.data, e.dims),
+        point_coords: new ort.Tensor('float32', pointCoords, [1, numPoints, 2]),
+        point_labels: new ort.Tensor('float32', pointLabels, [1, numPoints]),
+        mask_input: new ort.Tensor('float32', new Float32Array(256 * 256), [1, 1, 256, 256]),
+        has_mask_input: new ort.Tensor('float32', Float32Array.from([0]), [1]),
+        orig_im_size: new ort.Tensor('float32', Float32Array.from([e.imageHeight, e.imageWidth]), [2]),
+    });
+    const masks = out['masks'] ?? out[decoder.outputNames[0]];
+    const iou = out['iou_predictions']?.data ?? Float32Array.from([1]);
+    const [, m, h, w] = masks.dims;
+    const idx = bestMaskIndex(iou.slice(0, m));
+    const logits = masks.data.subarray(idx * h * w, (idx + 1) * h * w);
+    return { mask: binarizeMask(logits), width: w, height: h, iou: iou[idx] ?? 1 };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sam-onnx-core.js","sourceRoot":"","sources":["../../../../../src/lib/toolbar/segmentation/sam-onnx-core.ts"],"names":[],"mappings":"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","sourcesContent":["import * as ort from 'onnxruntime-web';\n\nimport type { SamPrompt } from '../../contracts/sam.contract';\n\n/**\n * Shared, DOM-free SAM inference primitives used by BOTH inference backends:\n * the in-process session (`OnnxSamSession`, main thread) and the dedicated\n * Web Worker (`onnx-sam.worker`). Keeping these here avoids duplicating the\n * preprocessing / decoder-prompt math and keeps the worker DOM-free (it can't\n * import sam-prompt.ts, which pulls in DOM types).\n */\n\nexport const PIXEL_MEAN = [123.675, 116.28, 103.53];\nexport const PIXEL_STD = [58.395, 57.12, 57.375];\nconst MODEL_CACHE = 'sam-onnx';\n\n/** Encoder output for one image, reused across prompts. */\nexport interface CoreEmbedding {\n  data: Float32Array;\n  dims: number[];\n  scale: number;\n  imageWidth: number;\n  imageHeight: number;\n}\n\n/** Decoder output: a binary mask at original-image resolution. */\nexport interface CoreMask {\n  mask: Uint8Array;\n  width: number;\n  height: number;\n  iou: number;\n}\n\n/** Fetch a model as an ArrayBuffer, streaming progress and caching in the Cache\n *  API (so it isn't re-downloaded). Cache hit → progress jumps to 1. Works on\n *  the main thread and in a worker (both have `fetch` + `caches`). */\nexport async function fetchModel(url: string, onProgress?: (f: number) => void): Promise<ArrayBuffer> {\n  const cache = typeof caches !== 'undefined' ? await caches.open(MODEL_CACHE).catch(() => null) : null;\n  const hit = cache ? await cache.match(url) : null;\n  if (hit) { onProgress?.(1); return await hit.arrayBuffer(); }\n\n  const resp = await fetch(url);\n  if (!resp.ok) throw new Error(`fetch ${url} failed: HTTP ${resp.status}`);\n  const total = Number(resp.headers.get('content-length')) || 0;\n  if (!resp.body || !total) {\n    const buf = await resp.arrayBuffer();\n    onProgress?.(1);\n    if (cache) await cache.put(url, new Response(buf)).catch(() => undefined);\n    return buf;\n  }\n  const reader = resp.body.getReader();\n  const chunks: Uint8Array[] = [];\n  let received = 0;\n  for (;;) {\n    const { done, value } = await reader.read();\n    if (done) break;\n    chunks.push(value);\n    received += value.length;\n    onProgress?.(received / total);\n  }\n  const out = new Uint8Array(received);\n  let off = 0;\n  for (const c of chunks) { out.set(c, off); off += c.length; }\n  if (cache) {\n    await cache.put(url, new Response(out.slice(), { headers: { 'content-length': String(received) } }))\n      .catch(() => undefined);\n  }\n  onProgress?.(1);\n  return out.buffer;\n}\n\n/** Resize (long side → size, bilinear), pad to size×size, SAM-normalize → CHW float32. */\nexport function preprocess(\n  data: Uint8ClampedArray, width: number, height: number, size: number, scale: number,\n): Float32Array {\n  const newW = Math.round(width * scale);\n  const newH = Math.round(height * scale);\n  const chw = new Float32Array(3 * size * size); // zero-padded\n  for (let y = 0; y < newH; y++) {\n    const sy = Math.min(height - 1, y / scale);\n    const y0 = Math.floor(sy);\n    const fy = sy - y0;\n    const y1 = Math.min(height - 1, y0 + 1);\n    for (let x = 0; x < newW; x++) {\n      const sx = Math.min(width - 1, x / scale);\n      const x0 = Math.floor(sx);\n      const fx = sx - x0;\n      const x1 = Math.min(width - 1, x0 + 1);\n      for (let c = 0; c < 3; c++) {\n        const p00 = data[(y0 * width + x0) * 4 + c];\n        const p01 = data[(y0 * width + x1) * 4 + c];\n        const p10 = data[(y1 * width + x0) * 4 + c];\n        const p11 = data[(y1 * width + x1) * 4 + c];\n        const top = p00 + (p01 - p00) * fx;\n        const bot = p10 + (p11 - p10) * fx;\n        const v = top + (bot - top) * fy;\n        chw[c * size * size + y * size + x] = (v - PIXEL_MEAN[c]) / PIXEL_STD[c];\n      }\n    }\n  }\n  return chw;\n}\n\n/** Assemble decoder `point_coords`/`point_labels` from a prompt, in encoder\n *  (resized) space. Box = two points labelled 2/3; points use 1/0; a points-only\n *  prompt pads the absent box slot with `[0,0]` labelled -1. */\nexport function buildDecoderPrompt(\n  prompt: SamPrompt, scale: number,\n): { pointCoords: Float32Array; pointLabels: Float32Array; numPoints: number } {\n  const coords: number[] = [];\n  const labels: number[] = [];\n  for (const p of prompt.points ?? []) { coords.push(p.x * scale, p.y * scale); labels.push(p.label); }\n  if (prompt.box) {\n    const b = prompt.box;\n    coords.push(b.x0 * scale, b.y0 * scale); labels.push(2);\n    coords.push(b.x1 * scale, b.y1 * scale); labels.push(3);\n  } else if (labels.length > 0) {\n    coords.push(0, 0); labels.push(-1);\n  }\n  return {\n    pointCoords: Float32Array.from(coords),\n    pointLabels: Float32Array.from(labels),\n    numPoints: labels.length,\n  };\n}\n\n/** Binarize mask logits (`> threshold`) into a 0/1 mask. */\nexport function binarizeMask(logits: Float32Array, threshold = 0): Uint8Array {\n  const out = new Uint8Array(logits.length);\n  for (let i = 0; i < logits.length; i++) out[i] = logits[i] > threshold ? 1 : 0;\n  return out;\n}\n\n/** Index of the highest-scoring mask in a multimask decoder output. */\nexport function bestMaskIndex(iou: Float32Array | number[]): number {\n  let best = 0;\n  for (let i = 1; i < iou.length; i++) if (iou[i] > iou[best]) best = i;\n  return best;\n}\n\n/** Run the encoder on an RGBA image → a reusable embedding. */\nexport async function runEncoder(\n  encoder: ort.InferenceSession, data: Uint8ClampedArray, width: number, height: number, inputSize: number,\n): Promise<CoreEmbedding> {\n  const scale = inputSize / Math.max(width, height);\n  const input = preprocess(data, width, height, inputSize, scale);\n  const out = await encoder.run({\n    [encoder.inputNames[0]]: new ort.Tensor('float32', input, [1, 3, inputSize, inputSize]),\n  });\n  const emb = out[encoder.outputNames[0]];\n  return {\n    data: emb.data as Float32Array, dims: emb.dims as number[],\n    scale, imageWidth: width, imageHeight: height,\n  };\n}\n\n/** Run the decoder for one prompt against a cached embedding → a binary mask. */\nexport async function runDecoder(\n  decoder: ort.InferenceSession, e: CoreEmbedding, prompt: SamPrompt,\n): Promise<CoreMask> {\n  const { pointCoords, pointLabels, numPoints } = buildDecoderPrompt(prompt, e.scale);\n  const out = await decoder.run({\n    image_embeddings: new ort.Tensor('float32', e.data, e.dims),\n    point_coords: new ort.Tensor('float32', pointCoords, [1, numPoints, 2]),\n    point_labels: new ort.Tensor('float32', pointLabels, [1, numPoints]),\n    mask_input: new ort.Tensor('float32', new Float32Array(256 * 256), [1, 1, 256, 256]),\n    has_mask_input: new ort.Tensor('float32', Float32Array.from([0]), [1]),\n    orig_im_size: new ort.Tensor('float32', Float32Array.from([e.imageHeight, e.imageWidth]), [2]),\n  });\n  const masks = out['masks'] ?? out[decoder.outputNames[0]];\n  const iou = (out['iou_predictions']?.data as Float32Array) ?? Float32Array.from([1]);\n  const [, m, h, w] = masks.dims as number[];\n  const idx = bestMaskIndex(iou.slice(0, m));\n  const logits = (masks.data as Float32Array).subarray(idx * h * w, (idx + 1) * h * w);\n  return { mask: binarizeMask(logits), width: w, height: h, iou: iou[idx] ?? 1 };\n}\n"]}

package/esm2022/lib/toolbar/segmentation/sam-point-tool.service.mjs

@@ -0,0 +1,255 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { WandService } from '../wand/wand.service';
+import { frameToRgba } from './sam-prompt';
+import { getSamModel, isSamModelReady } from './sam-model-registry';
+import { Region, Polygon } from '../../models/region';
+import * as i0 from "@angular/core";
+import * as i1 from "../wand/wand.service";
+/** Interactive SAM point-prompt tool (jit-ui#90, P1).
+ *
+ * Each plain (positive) click segments the clicked object as its OWN new region
+ * — clicking a second fiber doesn't extend the first into it. Shift/Alt-click
+ * adds a negative (exclude) point that refines the CURRENT object, re-running
+ * the decoder against the (cached) image embedding and updating its live region.
+ * `commit()` (Enter) finalises early; `clear()` (Esc) discards the current
+ * prompt + its preview region. Mirrors the wand/brush on-canvas tool pattern and
+ * reuses WandService.maskToPolygons + the shared region store.
+ *
+ * Inference is behind {@link ISamSession} (lazy onnxruntime-web in production,
+ * a fake in tests).
+ */
+export class SamPointToolService {
+    constructor(wandService) {
+        this.wandService = wandService;
+        this.overlay = null;
+        this.session = null;
+        /** In-flight session load — dedupes a warm-up preload against the first click. */
+        this.sessionLoad = null;
+        this.model = getSamModel();
+        this.embedding = null;
+        this.embeddingKey = null;
+        /** Accumulated point prompts, in image (matrix) coords. */
+        this.points = [];
+        /** Id of the in-progress (preview) region being refined, if committed to store. */
+        this.regionId = null;
+        this.status$ = new BehaviorSubject('');
+        this.busy$ = new BehaviorSubject(false);
+        /** Encoder-download progress (0..1) on the first click; -1 when not downloading. */
+        this.progress$ = new BehaviorSubject(-1);
+        this.boundMouseDown = (e) => { void this.onMouseDown(e); };
+    }
+    bindHost(host) { this.host = host; }
+    setModel(id) {
+        const next = getSamModel(id);
+        if (next.id === this.model.id)
+            return;
+        this.model = next;
+        this.embedding = null;
+        this.embeddingKey = null;
+        // Drop the loaded session so the next run reloads the newly-picked model
+        // (ensureSession() returns the cached session as-is otherwise).
+        this.session?.dispose();
+        this.session = null;
+        this.sessionLoad = null;
+    }
+    /** Test seam: inject a fake/alternate session. */
+    useSession(session) { this.session = session; }
+    setMode(active) {
+        if (active) {
+            this.createOverlay();
+            // Warm up the model in the background as soon as the tool is armed, so the
+            // first click doesn't pay the (download +) session-build cost on its path.
+            this.preload();
+        }
+        else {
+            this.destroyOverlay();
+        }
+    }
+    /** Eagerly load the model in the background (fire-and-forget). Safe to call
+     *  repeatedly — it dedupes against an in-flight load and an existing session. */
+    preload() {
+        if (this.session || !isSamModelReady(this.model))
+            return;
+        void this.ensureSession().catch(() => undefined);
+    }
+    /** Finalise the current object: keep its region, start fresh next click. */
+    commit() {
+        this.points = [];
+        this.regionId = null;
+        this.status$.next('');
+    }
+    /** Discard the in-progress prompt + its preview region. */
+    clear() {
+        if (this.regionId != null) {
+            const regions = this.host.getRegions().filter((r) => r.id !== this.regionId);
+            this.host.setRegions(regions);
+        }
+        this.points = [];
+        this.regionId = null;
+        this.status$.next('');
+    }
+    // ── overlay lifecycle (mirrors the wand/brush tools) ────────────────────
+    createOverlay() {
+        const plotEl = this.host?.getOverlayContainer();
+        if (!plotEl || this.overlay)
+            return;
+        const canvas = document.createElement('canvas');
+        Object.assign(canvas.style, {
+            position: 'absolute', top: '0', left: '0', width: '100%', height: '100%',
+            cursor: 'crosshair', zIndex: '100',
+        });
+        canvas.width = plotEl.offsetWidth;
+        canvas.height = plotEl.offsetHeight;
+        plotEl.appendChild(canvas);
+        this.overlay = canvas;
+        canvas.addEventListener('mousedown', this.boundMouseDown);
+    }
+    destroyOverlay() {
+        if (!this.overlay)
+            return;
+        this.overlay.removeEventListener('mousedown', this.boundMouseDown);
+        this.overlay.remove();
+        this.overlay = null;
+        this.points = [];
+        this.regionId = null;
+    }
+    // ── per-click refinement ────────────────────────────────────────────────
+    async onMouseDown(e) {
+        if (e.button !== 0 || !this.overlay)
+            return;
+        // Re-entrancy guard: ignore clicks while a previous prompt is still
+        // downloading the model / encoding / decoding. Without it, clicking again
+        // during the slow first run (e.g. a ~172 MB ViT-B encode on WebGPU) launches
+        // concurrent downloads + GPU encodes that can overwhelm the GPU and freeze
+        // the tab. Each click is fast once the embedding is cached, so this only
+        // drops clicks made while genuinely busy.
+        if (this.busy$.value)
+            return;
+        const cached = this.host.getCachedImageData();
+        if (!cached || cached.frames.length === 0)
+            return;
+        const transform = this.host.getCoordinateTransform();
+        if (!transform.isReady())
+            return;
+        const { x: dataX, y: dataY } = transform.clientToData(e.clientX, e.clientY);
+        if (!Number.isFinite(dataX) || !Number.isFinite(dataY))
+            return;
+        const rx = cached.ratios[0] || 1;
+        const ry = cached.ratios[0] || 1;
+        const ox = cached.originX ?? 0;
+        const oy = cached.originY ?? 0;
+        // Shift or Alt = negative (exclude) point.
+        const label = e.shiftKey || e.altKey ? 0 : 1;
+        // A plain positive click starts a NEW object: clicking another fiber must
+        // segment that fiber on its own, not accumulate with earlier points and
+        // grow the in-progress mask into the adjacent object (which would also
+        // overwrite a previously-segmented region). Only Shift/Alt (exclude) points
+        // refine the current object. This also clears any stale prompt left after a
+        // region was deleted, so the next click segments fresh instead of redrawing
+        // the old merged mask.
+        if (label === 1) {
+            this.points = [];
+            this.regionId = null;
+        }
+        this.points.push({ x: (dataX - ox) / rx, y: (dataY - oy) / ry, label });
+        // Mark busy BEFORE ensureSession: the first click downloads the encoder
+        // (~14–172 MB) and builds the session, which is the longest wait — without
+        // this the UI showed nothing running until that finished.
+        this.busy$.next(true);
+        try {
+            this.status$.next('Loading SAM model…');
+            const session = await this.ensureSession();
+            const key = [
+                this.host.getFileName() ?? '', this.host.getActiveFrameIndex(),
+                `${cached.width}x${cached.height}`, `${ox},${oy},${rx}`, this.model.id,
+            ].join('|');
+            if (!this.embedding || this.embeddingKey !== key) {
+                this.status$.next('Encoding image…');
+                const rgba = frameToRgba(cached, this.host.getActiveFrameIndex());
+                this.embedding = await session.embed({ data: rgba, width: cached.width, height: cached.height });
+                this.embeddingKey = key;
+            }
+            this.status$.next('Segmenting…');
+            const prompt = { points: this.points.slice() };
+            const res = await session.decode(this.embedding, prompt);
+            const polys = this.wandService.maskToPolygons(res.mask, res.width, res.height, cached.width, cached.height, 0, 0);
+            if (polys.length === 0) {
+                this.status$.next('No mask for these points.');
+                return;
+            }
+            const poly = polys[0];
+            this.upsertPreview(poly.xpoints.map((x) => ox + x * rx), poly.ypoints.map((y) => oy + y * ry));
+            this.status$.next('Segmented — click another fiber for a new region, Shift-click to refine, Esc to undo.');
+        }
+        catch (err) {
+            this.status$.next(err instanceof Error ? err.message : 'SAM model unavailable.');
+        }
+        finally {
+            this.busy$.next(false);
+            this.progress$.next(-1);
+        }
+    }
+    /** Replace (or insert) the in-progress preview region in the shared store. */
+    upsertPreview(xData, yData) {
+        if (xData.length < 3)
+            return;
+        const poly = new Polygon();
+        poly.npoints = xData.length;
+        poly.xpoints = xData;
+        poly.ypoints = yData;
+        poly.coordinates = xData.map((x, i) => [x, yData[i]]);
+        poly.closed = true;
+        const regions = this.host.getRegions();
+        const existing = this.regionId != null ? regions.find((r) => r.id === this.regionId) : null;
+        const region = new Region();
+        region.bounds = poly;
+        region.color = this.host.getShapeColor();
+        region.label = 'sam';
+        if (existing) {
+            region.id = existing.id;
+            region.name = existing.name;
+            const idx = regions.findIndex((r) => r.id === this.regionId);
+            if (idx >= 0)
+                regions[idx] = region;
+            else
+                regions.push(region);
+        }
+        else {
+            regions.push(region);
+        }
+        this.host.setRegions(regions);
+        this.regionId = region.id ?? this.regionId;
+    }
+    ensureSession() {
+        if (this.session)
+            return Promise.resolve(this.session);
+        if (this.sessionLoad)
+            return this.sessionLoad;
+        if (!isSamModelReady(this.model)) {
+            return Promise.reject(new Error(`SAM model "${this.model.id}" is not configured yet (no ONNX URLs). ` +
+                'Host it and call setSamModelUrls(), then retry.'));
+        }
+        this.sessionLoad = (async () => {
+            try {
+                const { OnnxSamSession } = await import('./onnx-sam-session');
+                const session = new OnnxSamSession();
+                this.progress$.next(0);
+                await session.loadModel(this.model, (f) => this.progress$.next(f));
+                this.session = session;
+                return session;
+            }
+            finally {
+                this.sessionLoad = null;
+            }
+        })();
+        return this.sessionLoad;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: SamPointToolService, deps: [{ token: i1.WandService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: SamPointToolService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: SamPointToolService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.WandService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sam-point-tool.service.js","sourceRoot":"","sources":["../../../../../src/lib/toolbar/segmentation/sam-point-tool.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { BehaviorSubject } from 'rxjs';\n\nimport { WandService } from '../wand/wand.service';\nimport { WandToolHost } from '../wand/wand-tool.service';\nimport { frameToRgba } from './sam-prompt';\nimport { getSamModel, isSamModelReady } from './sam-model-registry';\nimport { ISamSession, SamEmbedding, SamModelDef, SamPrompt } from '../../contracts/sam.contract';\nimport { Region, Polygon } from '../../models/region';\n\n/** Interactive SAM point-prompt tool (jit-ui#90, P1).\n *\n * Each plain (positive) click segments the clicked object as its OWN new region\n * — clicking a second fiber doesn't extend the first into it. Shift/Alt-click\n * adds a negative (exclude) point that refines the CURRENT object, re-running\n * the decoder against the (cached) image embedding and updating its live region.\n * `commit()` (Enter) finalises early; `clear()` (Esc) discards the current\n * prompt + its preview region. Mirrors the wand/brush on-canvas tool pattern and\n * reuses WandService.maskToPolygons + the shared region store.\n *\n * Inference is behind {@link ISamSession} (lazy onnxruntime-web in production,\n * a fake in tests).\n */\n@Injectable({ providedIn: 'root' })\nexport class SamPointToolService {\n  private host!: WandToolHost;\n  private overlay: HTMLCanvasElement | null = null;\n  private session: ISamSession | null = null;\n  /** In-flight session load — dedupes a warm-up preload against the first click. */\n  private sessionLoad: Promise<ISamSession> | null = null;\n  private model: SamModelDef = getSamModel();\n\n  private embedding: SamEmbedding | null = null;\n  private embeddingKey: string | null = null;\n\n  /** Accumulated point prompts, in image (matrix) coords. */\n  private points: { x: number; y: number; label: 0 | 1 }[] = [];\n  /** Id of the in-progress (preview) region being refined, if committed to store. */\n  private regionId: number | null = null;\n\n  readonly status$ = new BehaviorSubject<string>('');\n  readonly busy$ = new BehaviorSubject<boolean>(false);\n  /** Encoder-download progress (0..1) on the first click; -1 when not downloading. */\n  readonly progress$ = new BehaviorSubject<number>(-1);\n\n  private readonly boundMouseDown: (e: MouseEvent) => void;\n\n  constructor(private wandService: WandService) {\n    this.boundMouseDown = (e) => { void this.onMouseDown(e); };\n  }\n\n  bindHost(host: WandToolHost): void { this.host = host; }\n\n  setModel(id: string): void {\n    const next = getSamModel(id);\n    if (next.id === this.model.id) return;\n    this.model = next;\n    this.embedding = null;\n    this.embeddingKey = null;\n    // Drop the loaded session so the next run reloads the newly-picked model\n    // (ensureSession() returns the cached session as-is otherwise).\n    this.session?.dispose();\n    this.session = null;\n    this.sessionLoad = null;\n  }\n\n  /** Test seam: inject a fake/alternate session. */\n  useSession(session: ISamSession): void { this.session = session; }\n\n  setMode(active: boolean): void {\n    if (active) {\n      this.createOverlay();\n      // Warm up the model in the background as soon as the tool is armed, so the\n      // first click doesn't pay the (download +) session-build cost on its path.\n      this.preload();\n    } else {\n      this.destroyOverlay();\n    }\n  }\n\n  /** Eagerly load the model in the background (fire-and-forget). Safe to call\n   *  repeatedly — it dedupes against an in-flight load and an existing session. */\n  preload(): void {\n    if (this.session || !isSamModelReady(this.model)) return;\n    void this.ensureSession().catch(() => undefined);\n  }\n\n  /** Finalise the current object: keep its region, start fresh next click. */\n  commit(): void {\n    this.points = [];\n    this.regionId = null;\n    this.status$.next('');\n  }\n\n  /** Discard the in-progress prompt + its preview region. */\n  clear(): void {\n    if (this.regionId != null) {\n      const regions = this.host.getRegions().filter((r) => r.id !== this.regionId);\n      this.host.setRegions(regions);\n    }\n    this.points = [];\n    this.regionId = null;\n    this.status$.next('');\n  }\n\n  // ── overlay lifecycle (mirrors the wand/brush tools) ────────────────────\n\n  private createOverlay(): void {\n    const plotEl = this.host?.getOverlayContainer();\n    if (!plotEl || this.overlay) return;\n    const canvas = document.createElement('canvas');\n    Object.assign(canvas.style, {\n      position: 'absolute', top: '0', left: '0', width: '100%', height: '100%',\n      cursor: 'crosshair', zIndex: '100',\n    });\n    canvas.width = plotEl.offsetWidth;\n    canvas.height = plotEl.offsetHeight;\n    plotEl.appendChild(canvas);\n    this.overlay = canvas;\n    canvas.addEventListener('mousedown', this.boundMouseDown);\n  }\n\n  private destroyOverlay(): void {\n    if (!this.overlay) return;\n    this.overlay.removeEventListener('mousedown', this.boundMouseDown);\n    this.overlay.remove();\n    this.overlay = null;\n    this.points = [];\n    this.regionId = null;\n  }\n\n  // ── per-click refinement ────────────────────────────────────────────────\n\n  private async onMouseDown(e: MouseEvent): Promise<void> {\n    if (e.button !== 0 || !this.overlay) return;\n    // Re-entrancy guard: ignore clicks while a previous prompt is still\n    // downloading the model / encoding / decoding. Without it, clicking again\n    // during the slow first run (e.g. a ~172 MB ViT-B encode on WebGPU) launches\n    // concurrent downloads + GPU encodes that can overwhelm the GPU and freeze\n    // the tab. Each click is fast once the embedding is cached, so this only\n    // drops clicks made while genuinely busy.\n    if (this.busy$.value) return;\n    const cached = this.host.getCachedImageData();\n    if (!cached || cached.frames.length === 0) return;\n    const transform = this.host.getCoordinateTransform();\n    if (!transform.isReady()) return;\n    const { x: dataX, y: dataY } = transform.clientToData(e.clientX, e.clientY);\n    if (!Number.isFinite(dataX) || !Number.isFinite(dataY)) return;\n\n    const rx = cached.ratios[0] || 1;\n    const ry = cached.ratios[0] || 1;\n    const ox = cached.originX ?? 0;\n    const oy = cached.originY ?? 0;\n    // Shift or Alt = negative (exclude) point.\n    const label: 0 | 1 = e.shiftKey || e.altKey ? 0 : 1;\n    // A plain positive click starts a NEW object: clicking another fiber must\n    // segment that fiber on its own, not accumulate with earlier points and\n    // grow the in-progress mask into the adjacent object (which would also\n    // overwrite a previously-segmented region). Only Shift/Alt (exclude) points\n    // refine the current object. This also clears any stale prompt left after a\n    // region was deleted, so the next click segments fresh instead of redrawing\n    // the old merged mask.\n    if (label === 1) {\n      this.points = [];\n      this.regionId = null;\n    }\n    this.points.push({ x: (dataX - ox) / rx, y: (dataY - oy) / ry, label });\n\n    // Mark busy BEFORE ensureSession: the first click downloads the encoder\n    // (~14–172 MB) and builds the session, which is the longest wait — without\n    // this the UI showed nothing running until that finished.\n    this.busy$.next(true);\n    try {\n      this.status$.next('Loading SAM model…');\n      const session = await this.ensureSession();\n      const key = [\n        this.host.getFileName() ?? '', this.host.getActiveFrameIndex(),\n        `${cached.width}x${cached.height}`, `${ox},${oy},${rx}`, this.model.id,\n      ].join('|');\n      if (!this.embedding || this.embeddingKey !== key) {\n        this.status$.next('Encoding image…');\n        const rgba = frameToRgba(cached, this.host.getActiveFrameIndex());\n        this.embedding = await session.embed({ data: rgba, width: cached.width, height: cached.height });\n        this.embeddingKey = key;\n      }\n      this.status$.next('Segmenting…');\n      const prompt: SamPrompt = { points: this.points.slice() };\n      const res = await session.decode(this.embedding, prompt);\n      const polys = this.wandService.maskToPolygons(\n        res.mask, res.width, res.height, cached.width, cached.height, 0, 0,\n      );\n      if (polys.length === 0) { this.status$.next('No mask for these points.'); return; }\n      const poly = polys[0];\n      this.upsertPreview(\n        poly.xpoints.map((x) => ox + x * rx),\n        poly.ypoints.map((y) => oy + y * ry),\n      );\n      this.status$.next(\n        'Segmented — click another fiber for a new region, Shift-click to refine, Esc to undo.',\n      );\n    } catch (err) {\n      this.status$.next(err instanceof Error ? err.message : 'SAM model unavailable.');\n    } finally {\n      this.busy$.next(false);\n      this.progress$.next(-1);\n    }\n  }\n\n  /** Replace (or insert) the in-progress preview region in the shared store. */\n  private upsertPreview(xData: number[], yData: number[]): void {\n    if (xData.length < 3) return;\n    const poly = new Polygon();\n    poly.npoints = xData.length;\n    poly.xpoints = xData;\n    poly.ypoints = yData;\n    poly.coordinates = xData.map((x, i) => [x, yData[i]]);\n    poly.closed = true;\n\n    const regions = this.host.getRegions();\n    const existing = this.regionId != null ? regions.find((r) => r.id === this.regionId) : null;\n    const region = new Region();\n    region.bounds = poly;\n    region.color = this.host.getShapeColor();\n    region.label = 'sam';\n    if (existing) {\n      region.id = existing.id;\n      region.name = existing.name;\n      const idx = regions.findIndex((r) => r.id === this.regionId);\n      if (idx >= 0) regions[idx] = region; else regions.push(region);\n    } else {\n      regions.push(region);\n    }\n    this.host.setRegions(regions);\n    this.regionId = region.id ?? this.regionId;\n  }\n\n  private ensureSession(): Promise<ISamSession> {\n    if (this.session) return Promise.resolve(this.session);\n    if (this.sessionLoad) return this.sessionLoad;\n    if (!isSamModelReady(this.model)) {\n      return Promise.reject(new Error(\n        `SAM model \"${this.model.id}\" is not configured yet (no ONNX URLs). ` +\n        'Host it and call setSamModelUrls(), then retry.',\n      ));\n    }\n    this.sessionLoad = (async () => {\n      try {\n        const { OnnxSamSession } = await import('./onnx-sam-session');\n        const session = new OnnxSamSession();\n        this.progress$.next(0);\n        await session.loadModel(this.model, (f) => this.progress$.next(f));\n        this.session = session;\n        return session;\n      } finally {\n        this.sessionLoad = null;\n      }\n    })();\n    return this.sessionLoad;\n  }\n}\n"]}