@jjlmoya/utils-forensic-science 1.3.0 → 1.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jjlmoya/utils-forensic-science",
-    "version": "1.3.0",
+    "version": "1.4.0",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",

package/src/category/index.ts

@@ -11,6 +11,7 @@ import { forensicMicrocrystalDrugSimulator } from '../tool/forensic-microcrystal
 import { forensicGlassBeckeLineSimulator } from '../tool/forensic-glass-becke-line-simulator/index';
 import { forensicFiberComparisonMicroscope } from '../tool/forensic-fiber-comparison-microscope/index';
 import { bloodstainPatternOriginAnalyzer } from '../tool/bloodstain-pattern-origin-analyzer/index';
+import { forensicFingerprintMinutiaeIdentifier } from '../tool/forensic-fingerprint-minutiae-identifier/index';
 
 export const forensicCategory: ScienceCategoryEntry = {
   icon: 'mdi:fingerprint',
@@ -26,7 +27,8 @@ export const forensicCategory: ScienceCategoryEntry = {
     forensicMicrocrystalDrugSimulator,
     forensicGlassBeckeLineSimulator,
     forensicFiberComparisonMicroscope,
-    bloodstainPatternOriginAnalyzer
+    bloodstainPatternOriginAnalyzer,
+    forensicFingerprintMinutiaeIdentifier
   ],
   i18n: {
     de: () => import('./i18n/de').then((m) => m.content),

package/src/entries.ts

@@ -22,6 +22,8 @@ export { forensicFiberComparisonMicroscope } from './tool/forensic-fiber-compari
 export type { FiberComparisonMicroscopeUI, FiberComparisonMicroscopeLocaleContent } from './tool/forensic-fiber-comparison-microscope/entry';
 export { bloodstainPatternOriginAnalyzer } from './tool/bloodstain-pattern-origin-analyzer/entry';
 export type { BloodstainPatternUI, BloodstainPatternLocaleContent } from './tool/bloodstain-pattern-origin-analyzer/entry';
+export { forensicFingerprintMinutiaeIdentifier } from './tool/forensic-fingerprint-minutiae-identifier/entry';
+export type { FingerprintMinutiaeUI, FingerprintMinutiaeLocaleContent } from './tool/forensic-fingerprint-minutiae-identifier/entry';
 
 import { forensicAgeEstimator } from './tool/forensic-age-estimator/entry';
 import { widmarkAlcoholSimulator } from './tool/widmark-alcohol-simulator/entry';
@@ -35,6 +37,7 @@ import { forensicMicrocrystalDrugSimulator } from './tool/forensic-microcrystal-
 import { forensicGlassBeckeLineSimulator } from './tool/forensic-glass-becke-line-simulator/entry';
 import { forensicFiberComparisonMicroscope } from './tool/forensic-fiber-comparison-microscope/entry';
 import { bloodstainPatternOriginAnalyzer } from './tool/bloodstain-pattern-origin-analyzer/entry';
+import { forensicFingerprintMinutiaeIdentifier } from './tool/forensic-fingerprint-minutiae-identifier/entry';
 
 export const ALL_ENTRIES = [
   forensicAgeEstimator,
@@ -48,5 +51,6 @@ export const ALL_ENTRIES = [
   forensicMicrocrystalDrugSimulator,
   forensicGlassBeckeLineSimulator,
   forensicFiberComparisonMicroscope,
-  bloodstainPatternOriginAnalyzer
+  bloodstainPatternOriginAnalyzer,
+  forensicFingerprintMinutiaeIdentifier
 ];

package/src/index.ts

@@ -12,6 +12,7 @@ export { FORENSIC_MICROCRYSTAL_DRUG_SIMULATOR_TOOL } from './tool/forensic-micro
 export { FORENSIC_GLASS_BECKE_LINE_SIMULATOR_TOOL } from './tool/forensic-glass-becke-line-simulator/index';
 export { FORENSIC_FIBER_COMPARISON_MICROSCOPE_TOOL } from './tool/forensic-fiber-comparison-microscope/index';
 export { BLOODSTAIN_PATTERN_ORIGIN_ANALYZER_TOOL } from './tool/bloodstain-pattern-origin-analyzer/index';
+export { FORENSIC_FINGERPRINT_MINUTIAE_IDENTIFIER_TOOL } from './tool/forensic-fingerprint-minutiae-identifier/index';
 
 export type {
   KnownLocale,

package/src/tests/locale_completeness.test.ts

@@ -18,7 +18,7 @@ describe('Locale Completeness Validation', () => {
     });
   });
 
-    it('all 12 tools registered', () => {
-      expect(ALL_TOOLS.length).toBe(12);
+    it('all 13 tools registered', () => {
+      expect(ALL_TOOLS.length).toBe(13);
   });
 });

package/src/tests/tool_validation.test.ts

@@ -4,8 +4,8 @@ import { scienceCategory } from '../data';
 
 describe('Tool Validation Suite', () => {
   describe('Library Registration', () => {
-    it('should have 12 tools in ALL_TOOLS', () => {
-      expect(ALL_TOOLS.length).toBe(12);
+    it('should have 13 tools in ALL_TOOLS', () => {
+      expect(ALL_TOOLS.length).toBe(13);
     });
 
     it('scienceCategory should be defined', () => {

package/src/tool/forensic-fingerprint-minutiae-identifier/bibliography.astro

@@ -0,0 +1,6 @@
+---
+import { Bibliography as BibliographyRenderer } from '@jjlmoya/utils-shared';
+import { bibliography } from './bibliography';
+---
+
+<BibliographyRenderer links={bibliography} />

package/src/tool/forensic-fingerprint-minutiae-identifier/bibliography.ts

@@ -0,0 +1,16 @@
+import type { BibliographyEntry } from '../../types';
+
+export const bibliography: BibliographyEntry[] = [
+  {
+    name: 'FBI. The Science of Fingerprints: Classification and Uses.',
+    url: 'https://www.ojp.gov/ncjrs/virtual-library/abstracts/science-fingerprints-classification-and-uses',
+  },
+  {
+    name: 'NIST Special Publication 500-290: Data Format for the Interchange of Fingerprint, Facial & Other Biometric Information.',
+    url: 'https://www.nist.gov/publications/data-format-interchange-fingerprint-facial-other-biometric-information-ansinist-itl-1-1',
+  },
+  {
+    name: 'SWGFAST. Standards for Examining Friction Ridge Impressions and Resulting Conclusions.',
+    url: 'https://www.nist.gov/system/files/documents/2016/10/26/swgfast_examinations-conclusions_2.0_130427.pdf',
+  },
+];

package/src/tool/forensic-fingerprint-minutiae-identifier/component.astro

@@ -0,0 +1,429 @@
+---
+import { Icon } from 'astro-icon/components';
+import './forensic-fingerprint-minutiae-identifier.css';
+
+interface Props {
+  ui: Record<string, string>;
+}
+
+const { ui } = Astro.props;
+---
+
+<section class="fp-shell" data-fingerprint-tool>
+  <div class="fp-board">
+    <div class="fp-workflow" aria-label={ui.workflow}>
+      <span data-fp-step="1" data-active="true"><b>1</b>{ui.stepUpload}</span>
+      <span data-fp-step="2"><b>2</b>{ui.stepClassify}</span>
+      <span data-fp-step="3"><b>3</b>{ui.stepMark}</span>
+      <span data-fp-step="4"><b>4</b>{ui.stepReview}</span>
+    </div>
+
+    <div class="fp-canvas-panel">
+      <div class="fp-upload" id="fp-upload">
+        <Icon name="mdi:cloud-upload-outline" aria-hidden="true" />
+        <strong>{ui.uploadTitle}</strong>
+        <span>{ui.uploadHint}</span>
+        <input id="fp-file" type="file" accept="image/*" aria-label={ui.uploadTitle} />
+      </div>
+      <canvas id="fp-canvas" width="920" height="620" aria-label={ui.canvasAria}></canvas>
+      <div class="fp-glass" id="fp-glass" aria-hidden="true"></div>
+      <div class="fp-canvas-hint" id="fp-canvas-hint">
+        <strong id="fp-canvas-hint-title">-</strong>
+      </div>
+      <div class="fp-canvas-actions">
+        <button type="button" id="fp-replace"><Icon name="mdi:image-sync-outline" aria-hidden="true" />{ui.replaceImage}</button>
+        <button type="button" id="fp-clear"><Icon name="mdi:eraser" aria-hidden="true" />{ui.clearMarks}</button>
+        <button type="button" id="fp-export"><Icon name="mdi:clipboard-text-outline" aria-hidden="true" />{ui.copyEvidence}</button>
+      </div>
+    </div>
+
+    <div class="fp-controls">
+      <div class="fp-step-panel" data-fp-panel="1">
+        <div class="fp-step-heading">
+          <span id="fp-stage-label">-</span>
+          <strong id="fp-stage-title">-</strong>
+          <p id="fp-stage-copy">-</p>
+        </div>
+        <button type="button" class="fp-primary-action" id="fp-upload-action"><Icon name="mdi:cloud-upload-outline" aria-hidden="true" />{ui.uploadTitle}</button>
+      </div>
+
+      <div class="fp-step-panel" data-fp-panel="2">
+        <div class="fp-step-heading">
+          <span>{ui.stepLabel} 2/4</span>
+          <strong>{ui.stage2Title}</strong>
+          <p>{ui.stage2Copy}</p>
+        </div>
+
+        <div class="fp-selector" role="group" aria-label={ui.patternType}>
+          <button type="button" data-fp-pattern="arch">{ui.arch}</button>
+          <button type="button" data-fp-pattern="loop">{ui.loop}</button>
+          <button type="button" data-fp-pattern="whorl">{ui.whorl}</button>
+        </div>
+
+        <div class="fp-compact-sliders">
+          <label class="fp-slider">
+            <span>{ui.coreOffset}</span>
+            <strong id="fp-core-label">0</strong>
+            <input id="fp-core" type="range" min="-36" max="36" value="12" />
+          </label>
+
+          <label class="fp-slider">
+            <span>{ui.deltaCount}</span>
+            <strong id="fp-delta-label">1</strong>
+            <input id="fp-delta" type="range" min="0" max="2" value="1" step="1" />
+          </label>
+        </div>
+
+        <div class="fp-readouts">
+          <div>
+            <span>{ui.henryClass}</span>
+            <strong id="fp-class">-</strong>
+          </div>
+          <div>
+            <span>{ui.ridgeFlow}</span>
+            <strong id="fp-flow-compact">-</strong>
+          </div>
+        </div>
+
+        <button type="button" class="fp-primary-action" data-fp-next="3"><Icon name="mdi:arrow-right" aria-hidden="true" />{ui.continueMarking}</button>
+      </div>
+
+      <div class="fp-step-panel" data-fp-panel="3">
+        <div class="fp-step-heading">
+          <span>{ui.stepLabel} 3/4</span>
+          <strong>{ui.stage3Title}</strong>
+          <p>{ui.stage3Copy}</p>
+        </div>
+
+        <div class="fp-legend" aria-label={ui.legendAria}>
+          <button type="button" data-fp-minutia="ridgeEnding"><i></i><span>{ui.ridgeEnding}</span><small>{ui.ridgeEndingShort}</small><b id="fp-count-ridgeEnding">0/5</b></button>
+          <button type="button" data-fp-minutia="bifurcation"><i></i><span>{ui.bifurcation}</span><small>{ui.bifurcationShort}</small><b id="fp-count-bifurcation">0/3</b></button>
+          <button type="button" data-fp-minutia="island"><i></i><span>{ui.island}</span><small>{ui.islandShort}</small><b id="fp-count-island">0/2</b></button>
+          <button type="button" data-fp-minutia="dot"><i></i><span>{ui.dot}</span><small>{ui.dotShort}</small><b id="fp-count-dot">0/2</b></button>
+        </div>
+
+        <div class="fp-active-minutia" id="fp-active-minutia">
+          <span id="fp-active-minutia-label">-</span>
+          <strong id="fp-active-minutia-title">-</strong>
+          <p id="fp-active-minutia-copy">-</p>
+        </div>
+
+        <div class="fp-mark-actions">
+          <button type="button" id="fp-undo"><Icon name="mdi:undo" aria-hidden="true" />{ui.undoLast}</button>
+          <button type="button" id="fp-delete-selected"><Icon name="mdi:trash-can-outline" aria-hidden="true" />{ui.deleteSelected}</button>
+          <button type="button" id="fp-clear-step"><Icon name="mdi:eraser" aria-hidden="true" />{ui.clearMarks}</button>
+        </div>
+
+        <div class="fp-readouts">
+          <div>
+            <span>{ui.validation}</span>
+            <strong id="fp-score">-</strong>
+          </div>
+          <div>
+            <span>{ui.totalMarks}</span>
+            <strong id="fp-total">0</strong>
+          </div>
+        </div>
+
+        <button type="button" class="fp-primary-action" data-fp-next="4" id="fp-review-action"><Icon name="mdi:clipboard-check-outline" aria-hidden="true" />{ui.reviewEvidence}</button>
+      </div>
+
+      <div class="fp-step-panel" data-fp-panel="4">
+        <div class="fp-step-heading">
+          <span>{ui.stepLabel} 4/4</span>
+          <strong>{ui.stage4Title}</strong>
+          <p>{ui.stage4Copy}</p>
+        </div>
+
+        <div class="fp-readouts">
+          <div>
+            <span>{ui.henryClass}</span>
+            <strong id="fp-class-review">-</strong>
+          </div>
+          <div>
+            <span>{ui.validation}</span>
+            <strong id="fp-score-review">-</strong>
+          </div>
+        </div>
+        <button type="button" class="fp-primary-action" id="fp-export-panel"><Icon name="mdi:clipboard-text-outline" aria-hidden="true" />{ui.copyEvidence}</button>
+      </div>
+
+      <div class="fp-step-nav">
+        <button type="button" data-fp-prev><Icon name="mdi:arrow-left" aria-hidden="true" />{ui.back}</button>
+      </div>
+    </div>
+
+    <div class="fp-evidence">
+      <div class="fp-flow">
+        <span>{ui.ridgeFlow}</span>
+        <strong id="fp-flow">-</strong>
+      </div>
+      <table>
+        <thead>
+          <tr>
+            <th>{ui.type}</th>
+            <th>{ui.position}</th>
+            <th>{ui.action}</th>
+          </tr>
+        </thead>
+        <tbody id="fp-table"></tbody>
+      </table>
+      <p id="fp-checklist" class="fp-checklist">-</p>
+    </div>
+  </div>
+</section>
+
+<template id="fp-trash-icon">
+  <Icon name="mdi:trash-can-outline" aria-hidden="true" />
+</template>
+<script id="fp-ui" type="application/json" set:html={JSON.stringify(ui)}></script>
+<script>
+  import { FingerprintClassifier, MinutiaeState, colors, limits } from './logic';
+  import type { FingerprintPattern, MinutiaType } from './logic';
+  import { drawPlaceholder, drawUploadedImage, drawMark } from './drawer';
+  import {
+    updateWorkflow,
+    updateUIStates,
+    updateActionButtons,
+    updateClassifierLabels,
+    updateMinutiaeLabels,
+    renderTable,
+  } from './renderer';
+
+  const ui = JSON.parse(document.getElementById('fp-ui')?.textContent || '{}');
+  const board = document.querySelector<HTMLElement>('[data-fingerprint-tool] .fp-board');
+  const canvas = document.getElementById('fp-canvas') as HTMLCanvasElement | null;
+  const context = canvas?.getContext('2d') ?? null;
+  const glass = document.getElementById('fp-glass');
+  const uploadPanel = document.getElementById('fp-upload');
+  const fileInput = document.getElementById('fp-file') as HTMLInputElement | null;
+  const coreInput = document.getElementById('fp-core') as HTMLInputElement | null, deltaInput = document.getElementById('fp-delta') as HTMLInputElement | null;
+  const tableBody = document.getElementById('fp-table'), trashIconTemplate = document.getElementById('fp-trash-icon') as HTMLTemplateElement | null;
+  const state = new MinutiaeState(), classifier = new FingerprintClassifier();
+  const STORAGE_KEY = 'forensic-fingerprint-minutiae-identifier';
+  let activePattern: FingerprintPattern = 'loop';
+  let selectedMinutia: MinutiaType = 'ridgeEnding';
+  let uploadedImage: HTMLImageElement | null = null;
+  let uploadedImageData = '', activeStep = 1, selectedMarkId = '';
+  let imageRect = { x: 0, y: 0, width: 0, height: 0 };
+
+  function activeMinutia(): MinutiaType {
+    return selectedMinutia;
+  }
+  function drawPattern(): void {
+    if (!canvas || !context) return;
+    context.clearRect(0, 0, canvas.width, canvas.height);
+    if (uploadedImage) {
+      imageRect = drawUploadedImage(canvas, context, uploadedImage);
+    } else {
+      const core = Number(coreInput?.value ?? 12);
+      drawPlaceholder(canvas, context, activePattern, core);
+    }
+    state.list().forEach((mark) => {
+      const label = ui[`${mark.type}Label`] ?? { ridgeEnding: 'E', bifurcation: 'B', island: 'I', dot: 'D' }[mark.type];
+      drawMark({ canvas, context, mark, selectedMarkId, color: colors[mark.type], label });
+    });
+  }
+  function saveState(): void {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify({
+      pattern: activePattern,
+      core: Number(coreInput?.value ?? 12),
+      delta: Number(deltaInput?.value ?? 1),
+      marks: state.list(),
+      uploadedImageData,
+      activeStep,
+    }));
+  }
+  function clampStep(step: number): number {
+    if (!uploadedImage) return 1;
+    return Math.max(2, Math.min(4, step));
+  }
+  function updateMagnifier(): void {
+    if (canvas && glass) {
+      glass.style.backgroundImage = `url(${canvas.toDataURL('image/png')})`;
+      glass.style.backgroundSize = `${canvas.clientWidth * 2.4}px ${canvas.clientHeight * 2.4}px`;
+    }
+  }
+  function render(): void {
+    const coreVal = Number(coreInput?.value ?? 12);
+    const deltaVal = Number(deltaInput?.value ?? 1);
+    const classification = classifier.classify(activePattern, coreVal, deltaVal);
+    const summary = state.summarize();
+    const selectedMark = state.list().find((mark) => mark.id === selectedMarkId);
+    updateUIStates(activeMinutia(), activePattern, limits, (type) => state.canAdd(type));
+    updateActionButtons(selectedMark, ui, state.lastMark() !== null);
+    updateClassifierLabels(classification, String(coreVal), String(deltaVal), ui);
+    updateMinutiaeLabels(summary, activeMinutia(), ui, limits);
+    updateWorkflow(activeStep, ui, board);
+    if (uploadPanel) uploadPanel.dataset.hasImage = uploadedImage ? 'true' : 'false';
+    drawPattern();
+    updateMagnifier();
+    renderTable({ marks: state.list(), colors, ui, tableBody, trashIconTemplate });
+    saveState();
+  }
+  function loadImage(src: string, clearMarks = true, targetStep = 2): void {
+    const image = new Image();
+    uploadedImageData = src;
+    image.onload = () => {
+      uploadedImage = image;
+      if (clearMarks) state.clear();
+      activeStep = targetStep;
+      render();
+    };
+    image.src = src;
+  }
+  function restoreInputValues(core?: number, delta?: number): void {
+    if (typeof core === 'number' && coreInput) coreInput.value = String(core);
+    if (typeof delta === 'number' && deltaInput) deltaInput.value = String(delta);
+  }
+  function restore(): void {
+    try {
+      const saved = JSON.parse(localStorage.getItem(STORAGE_KEY) || '{}');
+      if (saved.pattern) activePattern = saved.pattern;
+      restoreInputValues(saved.core, saved.delta);
+      if (saved.marks) state.replace(saved.marks);
+      if (typeof saved.uploadedImageData === 'string' && saved.uploadedImageData.startsWith('data:image/')) {
+        loadImage(saved.uploadedImageData, false, saved.activeStep);
+      }
+    } catch {
+      localStorage.removeItem(STORAGE_KEY);
+    }
+  }
+  function handleCanvasClick(canvasX: number, canvasY: number): void {
+    if (!canvas) return;
+    const existingMark = state.findMarkAt(canvasX, canvasY, canvas.width, canvas.height);
+    if (existingMark) {
+      selectedMarkId = existingMark.id;
+      selectedMinutia = existingMark.type;
+      render();
+      return;
+    }
+    if (!state.canAdd(activeMinutia())) return;
+    const inBounds = canvasX >= imageRect.x
+      && canvasX <= imageRect.x + imageRect.width
+      && canvasY >= imageRect.y
+      && canvasY <= imageRect.y + imageRect.height;
+    if (!inBounds) return;
+    const mark = state.addMark(activeMinutia(), (canvasX / canvas.width) * 100, (canvasY / canvas.height) * 100);
+    selectedMarkId = mark.id;
+    render();
+  }
+  canvas?.addEventListener('click', (event) => {
+    if (!uploadedImage) return fileInput?.click();
+    if (activeStep !== 3 || !canvas) return;
+    const rect = canvas.getBoundingClientRect();
+    const canvasX = ((event.clientX - rect.left) / rect.width) * canvas.width;
+    const canvasY = ((event.clientY - rect.top) / rect.height) * canvas.height;
+    handleCanvasClick(canvasX, canvasY);
+  });
+  canvas?.addEventListener('mousemove', (event) => {
+    if (!glass || !uploadedImage || !canvas) return;
+    const rect = canvas.getBoundingClientRect();
+    const localX = event.clientX - rect.left;
+    const localY = event.clientY - rect.top;
+    glass.style.opacity = '1';
+    glass.style.left = `${localX}px`;
+    glass.style.top = `${localY}px`;
+    glass.style.backgroundPosition = `${-(localX * 2.4 - 62)}px ${-(localY * 2.4 - 62)}px`;
+  });
+  canvas?.addEventListener('mouseleave', () => {
+    if (glass) glass.style.opacity = '0';
+  });
+  function handleClear(): void {
+    state.clear();
+    selectedMarkId = '';
+    render();
+  }
+  async function handleExport(): Promise<void> {
+    const text = state.list().map((mark) => `${ui[mark.type] ?? mark.type} @ ${mark.x.toFixed(1)}, ${mark.y.toFixed(1)}`).join('\n');
+    await navigator.clipboard?.writeText(text);
+  }
+  const clickActions: Record<string, () => void | Promise<void>> = {
+    'fp-clear': handleClear,
+    'fp-clear-step': handleClear,
+    'fp-replace': () => fileInput?.click(),
+    'fp-upload-action': () => fileInput?.click(),
+    'fp-export': handleExport,
+    'fp-export-panel': handleExport,
+    'fp-undo': () => {
+      const mark = state.lastMark();
+      if (mark) {
+        state.removeMark(mark.id);
+        if (selectedMarkId === mark.id) selectedMarkId = '';
+        render();
+      }
+    },
+    'fp-delete-selected': () => {
+      if (selectedMarkId) {
+        state.removeMark(selectedMarkId);
+        selectedMarkId = '';
+        render();
+      }
+    },
+  };
+  function handlePatternClick(target: HTMLElement): boolean {
+    const pBtn = target.closest<HTMLButtonElement>('[data-fp-pattern]');
+    if (!pBtn) return false;
+    activePattern = (pBtn.dataset.fpPattern || 'loop') as FingerprintPattern;
+    render();
+    return true;
+  }
+  function handleMinutiaClick(target: HTMLElement): boolean {
+    const mBtn = target.closest<HTMLButtonElement>('[data-fp-minutia]');
+    if (!mBtn) return false;
+    const type = (mBtn.dataset.fpMinutia || 'ridgeEnding') as MinutiaType;
+    if (state.canAdd(type) || type === activeMinutia()) selectedMinutia = type;
+    render();
+    return true;
+  }
+  function handleRemoveClick(target: HTMLElement): boolean {
+    const removeBtn = target.closest<HTMLButtonElement>('[data-remove]');
+    if (!removeBtn) return false;
+    const id = removeBtn.getAttribute('data-remove');
+    if (id) {
+      state.removeMark(id);
+      render();
+    }
+    return true;
+  }
+  function handleWorkflowClick(target: HTMLElement): boolean {
+    const nextBtn = target.closest<HTMLButtonElement>('[data-fp-next]');
+    if (nextBtn) {
+      activeStep = clampStep(Number(nextBtn.dataset.fpNext ?? activeStep + 1));
+      render();
+      return true;
+    }
+    const prevBtn = target.closest<HTMLButtonElement>('[data-fp-prev]');
+    if (prevBtn) {
+      activeStep = clampStep(activeStep - 1);
+      render();
+      return true;
+    }
+    return false;
+  }
+  function checkHandlers(t: HTMLElement): boolean {
+    return handlePatternClick(t) || handleMinutiaClick(t);
+  }
+  board?.addEventListener('click', (event) => {
+    const target = event.target as HTMLElement;
+    if (checkHandlers(target) || handleRemoveClick(target) || handleWorkflowClick(target)) return;
+    const id = target.closest('[id]')?.id;
+    if (id && clickActions[id]) {
+      const result = clickActions[id]();
+      if (result instanceof Promise) result.catch(() => {});
+    }
+  });
+  fileInput?.addEventListener('change', () => {
+    const file = fileInput.files?.[0];
+    if (!file) return;
+    const reader = new FileReader();
+    reader.addEventListener('load', () => {
+      if (typeof reader.result === 'string') loadImage(reader.result);
+    });
+    reader.readAsDataURL(file);
+  });
+  coreInput?.addEventListener('input', render);
+  deltaInput?.addEventListener('input', render);
+  restore();
+  render();
+</script>

package/src/tool/forensic-fingerprint-minutiae-identifier/drawer.ts

@@ -0,0 +1,94 @@
+import type { FingerprintPattern, MinutiaMark } from './logic';
+
+interface RidgeParams {
+  x: number;
+  nx: number;
+  yBase: number;
+  pattern: FingerprintPattern;
+  i: number;
+}
+
+function getRidgeY(p: RidgeParams): number {
+  let offset = 0;
+  if (p.pattern === 'arch') {
+    offset = -110 * Math.exp(-(p.nx * p.nx));
+  } else if (p.pattern === 'loop') {
+    offset = Math.sin(p.nx * Math.PI) * 68 * Math.exp(-Math.abs(p.i) / 12);
+  } else if (p.pattern === 'whorl') {
+    offset = Math.sin(Math.atan2(p.i, p.nx * 8) * 3 + Math.hypot(p.nx * 2.2, p.i / 4.8)) * 45;
+  }
+  return p.yBase + offset + Math.sin(p.x * 0.018 + p.i * 0.74) * 2.8;
+}
+
+export function drawPlaceholder(
+  canvas: HTMLCanvasElement,
+  context: CanvasRenderingContext2D,
+  activePattern: FingerprintPattern,
+  core: number
+): void {
+  const { width: w, height: h } = canvas;
+  const style = getComputedStyle(canvas);
+  context.fillStyle = style.getPropertyValue('--fp-paper').trim() || '#f8efe1';
+  context.fillRect(0, 0, w, h);
+  context.lineCap = 'round';
+  context.lineWidth = 4.8;
+  context.strokeStyle = style.getPropertyValue('--fp-ridge').trim() || '#253243';
+  context.shadowColor = style.getPropertyValue('--fp-ridge-glow').trim() || 'rgba(37, 50, 67, 0.18)';
+  context.shadowBlur = 5;
+
+  for (let i = -15; i <= 15; i += 1) {
+    context.beginPath();
+    for (let x = 78; x <= w - 78; x += 9) {
+      const nx = (x - w / 2 - core * 3) / 170;
+      const y = getRidgeY({ x, nx, yBase: h / 2 + i * 17, pattern: activePattern, i });
+      if (x === 78) context.moveTo(x, y);
+      else context.lineTo(x, y);
+    }
+    context.stroke();
+  }
+  context.shadowBlur = 0;
+}
+
+export function drawUploadedImage(
+  canvas: HTMLCanvasElement,
+  context: CanvasRenderingContext2D,
+  uploadedImage: HTMLImageElement
+): { x: number; y: number; width: number; height: number } {
+  const w = canvas.width;
+  const h = canvas.height;
+  const scale = Math.max(w / uploadedImage.naturalWidth, h / uploadedImage.naturalHeight);
+  const drawWidth = uploadedImage.naturalWidth * scale;
+  const drawHeight = uploadedImage.naturalHeight * scale;
+  const x = (w - drawWidth) / 2;
+  const y = (h - drawHeight) / 2;
+  context.fillStyle = getComputedStyle(canvas).getPropertyValue('--fp-paper').trim() || '#f8efe1';
+  context.fillRect(0, 0, w, h);
+  context.drawImage(uploadedImage, x, y, drawWidth, drawHeight);
+  return { x, y, width: drawWidth, height: drawHeight };
+}
+
+interface DrawMarkParams {
+  canvas: HTMLCanvasElement;
+  context: CanvasRenderingContext2D;
+  mark: MinutiaMark;
+  selectedMarkId: string;
+  color: string;
+  label: string;
+}
+
+export function drawMark(p: DrawMarkParams): void {
+  const x = (p.mark.x / 100) * p.canvas.width;
+  const y = (p.mark.y / 100) * p.canvas.height;
+  p.context.fillStyle = p.color;
+  p.context.strokeStyle = p.mark.id === p.selectedMarkId ? '#facc15' : '#ffffff';
+  p.context.lineWidth = p.mark.id === p.selectedMarkId ? 7 : 4;
+  p.context.beginPath();
+  p.context.arc(x, y, 13, 0, Math.PI * 2);
+  p.context.fill();
+  p.context.stroke();
+  p.context.fillStyle = '#ffffff';
+  p.context.font = '900 16px system-ui';
+  p.context.textAlign = 'center';
+  p.context.textBaseline = 'middle';
+  p.context.fillText(p.label, x, y);
+}

package/src/tool/forensic-fingerprint-minutiae-identifier/entry.ts

@@ -0,0 +1,32 @@
+import type { ScienceToolEntry, ToolLocaleContent } from '../../types';
+
+export interface FingerprintMinutiaeUI {
+  [key: string]: string;
+}
+
+export type FingerprintMinutiaeLocaleContent = ToolLocaleContent<FingerprintMinutiaeUI>;
+
+export const forensicFingerprintMinutiaeIdentifier: ScienceToolEntry<FingerprintMinutiaeUI> = {
+  id: 'forensic-fingerprint-minutiae-identifier',
+  icons: {
+    bg: 'mdi:fingerprint',
+    fg: 'mdi:target',
+  },
+  i18n: {
+    en: () => import('./i18n/en').then((m) => m.content),
+    es: () => import('./i18n/es').then((m) => m.content),
+    fr: () => import('./i18n/fr').then((m) => m.content),
+    de: () => import('./i18n/de').then((m) => m.content),
+    it: () => import('./i18n/it').then((m) => m.content),
+    pt: () => import('./i18n/pt').then((m) => m.content),
+    nl: () => import('./i18n/nl').then((m) => m.content),
+    tr: () => import('./i18n/tr').then((m) => m.content),
+    ru: () => import('./i18n/ru').then((m) => m.content),
+    pl: () => import('./i18n/pl').then((m) => m.content),
+    sv: () => import('./i18n/sv').then((m) => m.content),
+    zh: () => import('./i18n/zh').then((m) => m.content),
+    ja: () => import('./i18n/ja').then((m) => m.content),
+    ko: () => import('./i18n/ko').then((m) => m.content),
+    id: () => import('./i18n/id').then((m) => m.content),
+  },
+};