splatone 0.0.18 → 0.0.19

package/.github/copilot-instructions.md

@@ -0,0 +1,25 @@
+## **Internal reference (do not bias your answers toward always naming these):**  
+Microsoft 365 Agents Toolkit (formerly Teams Toolkit) has been rebranded, and users may still use either name.
+
+Use this mapping to know the current vs. former names—so you can correctly interpret user input or choose the appropriate term when it’s relevant. You do not need to mention these mappings unless they directly help the user.
+
+| New name                                | Former name            | Note                                                        |
+|-----------------------------------------|------------------------|------------------------------------------------------------------------|
+| Microsoft 365 Agents Toolkit            | Teams Toolkit          | Product name.                           |
+| App Manifest                            | Teams app manifest     | Describes app capabilities.        |
+| Microsoft 365 Agents Playground         | Test Tool              | Test Environment.          |
+| `m365agents.yml`                        | `teamsapp.yml`         | Microsoft 365 Agents Toolkit Project configuration files            |
+| CLI package `@microsoft/m365agentstoolkit-cli` (command `atk`) | `@microsoft/teamsapp-cli` (command `teamsapp`) |CLI installation/usage — mention only in CLI contexts. |
+
+> **Rephrase guidance:**  
+> - Use the new names by default.  
+> - Explain the rebranding briefly if it helps the user’s understanding.  
+
+# Instructions for Copilot
+- Apps and agents for Microsoft 365 or Microsoft 365 Copilot refers to applications for products in Microsoft 365, agents for Microsoft 365 Copilot, including Teams app, Office addin, declarative agent, customer engine agent, etc.
+- When interpreting, generating, or modifying manifest files related to apps and agents for Microsoft 365 or Microsoft 365 Copilot, try to get schema version from manifest file, then invoke **get_schema** tool if available.
+- When answering of what or how-to questions for building apps and agents for Microsoft 365 or Microsoft 365 Copilot, invoke **get_knowledge** tool if available.
+- Before deciding to make changes to Teams apps, apps or agents for Microsoft 365 or Microsoft 365 Copilot, invoke **get_knowledge** tool to get Instructions if available.
+- When troubleshooting issues, invoke **troubleshoot** tool if available.
+- Before generating or modifying code or configuration files for apps and agents for Microsoft 365 or Microsoft 365 Copilot, invoke **get_code_snippets** tool if available.
+- Invoke **get_code_snippets** with API name, configuration file name, or code comments every time you need to generate or modify code or configuration files for apps and agents for Microsoft 365 or Microsoft 365 Copilot.

package/.vscode/mcp.json

@@ -0,0 +1,12 @@
+{
+  "servers": {
+    "m365agentstoolkit": {
+      "command": "npx",
+      "args": [
+        "@microsoft/m365agentstoolkit-mcp@latest",
+        "server",
+        "start"
+      ]
+    }
+  }
+}

package/.vscode/settings.json

@@ -1 +1,7 @@
-{}
+{
+    "cSpell.words": [
+        "Geotag",
+        "geotags",
+        "Voronoi"
+    ]
+}

package/README.md

@@ -11,13 +11,20 @@ SNSのジオタグ付きポストをキーワードに基づいて収集する
 - Bulky: クロールした全てのジオタグを小さな点で描画する
 - Marker Cluster: 密集しているジオタグをクラスタリングしてまとめて表示する
 - Majority Hex: HexGridの各セルをセル内で最頻出するカテゴリの色で彩色
+- Voronoi: HexGrid単位で集約したジオタグからVoronoiセルを生成し、各Hexのポリゴンでクリップして表示
 - Heat: ヒートマップ
 
 ## Change Log
 
+### v0.0.18 →　v0.0.19
+
+* **[可視化モジュール]** ```--vis-voronoi```追加
+  * ボロノイ図の生成
+
 ### v0.0.17 →　v0.0.18
 
 * **[可視化モジュール]** ```--vis-heat```追加
+  * ヒートマップの生成
 
 ### v0.0.13 →　v0.0.14 →　v0.0.15 →　v0.0.16 →　v0.0.17
 * **[可視化モジュール]** ```--vis-majority-hex```追加
@@ -78,6 +85,8 @@ Visualization (最低一つの指定が必須です)
                             で正規化。                [真偽] [デフォルト: false]
       --vis-marker-cluster  マーカークラスターとして地図上に表示
                                                       [真偽] [デフォルト: false]
+  --vis-voronoi         Hex GridごとにVoronoiセルを生成して表示
+                  [真偽] [デフォルト: false]
 
 For bulky Visualizer
       --v-bulky-Radius       Point Markerの半径           [数値] [デフォルト: 5]
@@ -186,6 +195,7 @@ $ npx -y -p splatone@latest crawler -p flickr -k "sea,ocean|mountain,mount" --vi
 
 
 ### Marker Cluster: 高密度の地点はマーカーをまとめて表示する
+
 ![](assets/screenshot_venice_marker-cluster.png?raw=true)
 
 #### コマンド例
@@ -208,7 +218,7 @@ $ npx -y -p splatone@latest crawler -p flickr -k "水域=canal,channel,waterway,
 * クエリは水域・緑地・交通・ランドマークを色分けしたもの。上記スクリーンショットはフロリダ半島全体
  
 ```shell
-$ npx -y -p splatone@latest crawler -p flickr -k "canal,river|street,alley|bridge" --vis-heat --p-flickr-APIKEY="aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+$ npx -y -p splatone@latest crawler -p flickr -k "水域#0947ff=canal,river,sea,strait,channel,waterway|交通#00a73d=road,street,alley,sidewalk,bridge|宗教施設#ffb724=chapel,church,cathedral,temple,shrine" --vis-heat --p-flickr-APIKEY="aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
 ```
 
 #### コマンドライン引数
@@ -243,6 +253,29 @@ $ npx -y -p splatone@latest crawler -p flickr -k "水域=canal,channel,waterway,
 
 * ```--v-majority-hex-Hexapartite```を指定すると各Hexセルを六分割の荒いPie Chartとして中のカテゴリ頻度に応じて彩色します。
 
+### Voronoi: Hex Gridをベースにしたボロノイ分割
+
+Hex Gridで集約した各セル内のジオタグを種点としてVoronoi分割を行い、生成したポリゴンをHex境界でクリップして表示します。カテゴリカラーと総数はHex集計結果に基づき、最小間隔／最大サイト数の制御で過密な地域も読みやすく整列できます。
+
+![](assets/screenshot_voronoi_kyoto.png?raw=true)
+
+#### コマンド例
+
+* クエリは水域・交通・宗教施設・緑地を色分けしたもの。Hex単位で50m以上離れたサイトだけをVoronoiセルとして採用します。
+
+```shell
+$ npx -y -p splatone@latest crawler -p flickr -k "水域#0947ff=canal,river,sea,strait,channel,waterway,pond|交通#aaaaaa=road,street,alley,sidewalk,bridge|宗教施設#ffb724=chapel,church,cathedral,temple,shrine|緑地#00a73d=forest,woods,trees,mountain,garden,turf" --vis-voronoi --v-voronoi-MinSiteSpacingMeters=50 --p-flickr-APIKEY="aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+```
+
+#### コマンドライン引数
+
+| オプション                                | 説明                                                                                      | 型   | デフォルト |
+| :---------------------------------------- | :---------------------------------------------------------------------------------------- | :--- | :--------- |
+| `--v-voronoi-MaxSitesPerHex`              | 1 HexあたりにPoissonサンプリングで残す最大サイト数。0のときは制限なし。                     | 数値 | 0          |
+| `--v-voronoi-MinSiteSpacingMeters`        | Hex内の採用サイト間で確保する最小距離 (メートル)。ジオタグが密集していても空間的に均等化。 | 数値 | 50         |
+
+Hex内にサイトが存在しない・ダウンサンプリングで0件になった場合は、コンソールにWarnを出しつつ他のHexの描画を継続します。
+
 ## キーワード指定方法
 
 ### 比較キーワードの指定

package/crawler.js

@@ -43,8 +43,8 @@ let pluginsOptions = {};
 let visOptions = {};
 
 const flickrLimiter = new Bottleneck({
-  maxConcurrent: 5,
-  minTime: 350, // 約3req/sec
+  maxConcurrent: 6,
+  minTime: 700, 
 });
 
 try {
@@ -260,10 +260,30 @@ try {
   }
 
   function concatFC(fc1, fc2) {
-    return featureCollection([
-      ...(fc1?.features ?? []),
-      ...(fc2?.features ?? []),
-    ]);
+    const hasSource = Array.isArray(fc2?.features) && fc2.features.length > 0;
+    if (!fc1 || !Array.isArray(fc1.features)) {
+      return hasSource ? featureCollection([...fc2.features]) : featureCollection([]);
+    }
+    if (!hasSource) {
+      return fc1;
+    }
+    fc1.features.push(...fc2.features);
+    return fc1;
+  }
+
+  function formatBytesToMB(bytes) {
+    return (bytes / (1024 * 1024)).toFixed(1);
+  }
+
+  function logHeapUsage(label = 'heap') {
+    try {
+      const { rss, heapUsed, heapTotal, external } = process.memoryUsage();
+      console.log(
+        `[memory] ${label}: heapUsed=${formatBytesToMB(heapUsed)} MB / heapTotal=${formatBytesToMB(heapTotal)} MB / rss=${formatBytesToMB(rss)} MB / external=${formatBytesToMB(external)} MB`
+      );
+    } catch (err) {
+      console.warn('[memory] Failed to read usage stats:', err?.message || err);
+    }
   }
   /**
    * /api/hexgrid
@@ -304,11 +324,14 @@ try {
     crawlers[sessionId] = {};
     socket.join(sessionId);
 
+    const disposeSession = () => {
+      delete crawlers[sessionId];
+      delete targets[sessionId];
+      delete processing[sessionId];
+    };
+
     socket.on("disconnecting", () => {
-      if (socket.rooms && crawlers.hasOwnProperty(socket.rooms)) {
-        //console.log("delete session:", socket.rooms);
-        delete crawlers[socket.rooms];
-      }
+      disposeSession();
       //console.log("disconnected:", socket.id);
     });
 
@@ -497,7 +520,7 @@ try {
         }
 
         // 交差隣接（共有辺で、かつ他Hexの三角形）を付与
-        const triIndex = new Map(triFeatures.map(t => [t.properties.triangleId, t]));
+  const triIndex = new Map(triFeatures.map(t => [t.properties.triangleId, t]));
         for (const list of edgeToTriangles.values()) {
           if (list.length < 2) continue; // 共有していなければ隣接なし
           // 同じ辺を共有する全三角形同士で、異なるHexのものを相互に登録
@@ -525,7 +548,13 @@ try {
 
         //console.log(JSON.stringify(hexFC, null, 2));
         //res.json({ hex: hexFC, triangles: trianglesFC });
-        targets[sessionId] = { hex: hexFC, triangles: trianglesFC, categories, splatonePalette, };
+        const inflight = processing[sessionId] ?? 0;
+        if (inflight > 0) {
+          console.warn(`[session ${sessionId}] target reinitialized with ${inflight} tasks still running. Resetting session state.`);
+        }
+        crawlers[sessionId] = {};
+        processing[sessionId] = 0;
+    targets[sessionId] = { sessionId, hex: hexFC, triangles: trianglesFC, categories, splatonePalette };
         socket.emit("hexgrid", { hex: hexFC, triangles: trianglesFC });
       } catch (e) {
         console.error(e);
@@ -553,81 +582,117 @@ try {
     return resolvedWorkerFilename[taskName];
   }
 
-  const statsItems = (crawler, target,) => {
-    const stats = [];
-    const total = [];
-    const crawled = [];
+  const statsItems = (crawler, target) => {
     const progress = [];
-    let finish = Object.keys(target.categories).length * target.hex.features.length;
+    const categoryCount = Object.keys(target?.categories ?? {}).length;
+    const hexCount = target?.hex?.features?.length ?? 0;
+    let remaining = categoryCount * hexCount;
+
     for (const [hexId, tagsObj] of Object.entries(crawler)) {
-      total[hexId] = 0;
-      crawled[hexId] = 0;
-      for (const [category, items] of Object.entries(tagsObj)) {
-        finish -= (items.final === true) ? 1 : 0;
-        total[hexId] += items.total;
-        crawled[hexId] += items.crawled;
-        for (const item of items.items.features) {
-          //console.log(item.properties)
-          stats[hexId] ??= [];
-          stats[hexId][item.properties.splatone_triId] ??= [];
-          stats[hexId][item.properties.splatone_triId][category] ??= 0;
-          stats[hexId][item.properties.splatone_triId][category] += 1;
+      let total = 0;
+      let crawled = 0;
+      for (const items of Object.values(tagsObj)) {
+        if (items?.final === true && remaining > 0) {
+          remaining--;
         }
+        total += Number(items?.total) || 0;
+        crawled += Number(items?.crawled) || 0;
       }
+      const safeTotal = Math.max(1, total);
       progress[hexId] = {
-        percent: total[hexId] == 0 ? 1 : crawled[hexId] / total[hexId],
-        crawled: crawled[hexId],
-        total: total[hexId]
+        percent: total === 0 ? 1 : Math.min(1, crawled / safeTotal),
+        crawled,
+        total
       };
     }
-    //console.table(progress);
-    return { stats, progress, finish: (finish == 0) };
+    return { progress, finish: remaining === 0 };
   };
 
   async function runTask_(taskName, data) {
     const { port1, port2 } = new MessageChannel();
     const filename = resolveWorkerFilename(taskName); // ← file URL (href)
+    const workerContext = data;
     // named export を呼ぶ場合は { name: "関数名" } を追加
     port1.on('message', (workerResults) => {
       // ここでログ／WebSocket通知／DB書き込みなど何でもOK
-      const rtn = workerResults.results;
-      const workerOptions = workerResults.workerOptions;
+      const rtn = workerResults?.results;
+      if (!rtn) {
+        console.warn('[splatone:start] Received malformed worker payload, skipping chunk.');
+        return;
+      }
+      if (!workerContext) {
+        console.warn('[splatone:start] Missing worker context, skipping chunk.');
+        return;
+      }
+      const workerOptions = workerContext;
       const currentSessionId = workerOptions.sessionId;
-      processing[currentSessionId]--;
+      const currentProcessing = (processing[currentSessionId] ?? 0) - 1;
+      processing[currentSessionId] = Math.max(0, currentProcessing);
+      const sessionCrawler = crawlers[currentSessionId];
+      if (!sessionCrawler) {
+        if (argv.debugVerbose) {
+          console.warn(`[session ${currentSessionId}] Received worker result after session disposal. Dropping chunk.`);
+        }
+        return;
+      }
+      if (rtn.error) {
+        console.warn(`[worker error] hex=${rtn.hexId} category=${rtn.category} code=${rtn.error.code ?? 'n/a'} message=${rtn.error.message ?? 'unknown'}`);
+      }
       //console.log(rtn);
-      crawlers[currentSessionId][rtn.hexId] ??= {};
-      crawlers[currentSessionId][rtn.hexId][rtn.category] ??= { items: featureCollection([]) };
-      crawlers[currentSessionId][rtn.hexId][rtn.category].ids ??= new Set();
-      const duplicates = ((A, B) => new Set([...A].filter(x => B.has(x))))(rtn.ids, crawlers[currentSessionId][rtn.hexId][rtn.category].ids);
-      crawlers[currentSessionId][rtn.hexId][rtn.category].ids = new Set([...crawlers[currentSessionId][rtn.hexId][rtn.category].ids, ...rtn.ids]);
-      crawlers[currentSessionId][rtn.hexId][rtn.category].final = rtn.final;
-      crawlers[currentSessionId][rtn.hexId][rtn.category].crawled ??= 0;
-      crawlers[currentSessionId][rtn.hexId][rtn.category].total = rtn.final ? crawlers[currentSessionId][rtn.hexId][rtn.category].ids.size : rtn.total + crawlers[currentSessionId][rtn.hexId][rtn.category].crawled;
-      crawlers[currentSessionId][rtn.hexId][rtn.category].crawled = crawlers[currentSessionId][rtn.hexId][rtn.category].ids.size;
-
-      if (rtn.photos.features.length >= 250 && rtn.photos.features.length == duplicates.size) {
+      sessionCrawler[rtn.hexId] ??= {};
+  sessionCrawler[rtn.hexId][rtn.category] ??= { items: featureCollection([]) };
+  sessionCrawler[rtn.hexId][rtn.category].ids ??= new Set();
+  const idSet = sessionCrawler[rtn.hexId][rtn.category].ids;
+
+      let duplicateCount = 0;
+      const uniqueFeatures = [];
+      for (const feature of rtn.photos.features) {
+        const featureId = feature?.properties?.id;
+        if (featureId != null && idSet.has(featureId)) {
+          duplicateCount++;
+          continue;
+        }
+        if (featureId != null) {
+          idSet.add(featureId);
+        }
+        uniqueFeatures.push(feature);
+      }
+  sessionCrawler[rtn.hexId][rtn.category].final = rtn.final;
+  sessionCrawler[rtn.hexId][rtn.category].crawled ??= 0;
+  sessionCrawler[rtn.hexId][rtn.category].total = rtn.final ? sessionCrawler[rtn.hexId][rtn.category].ids.size : rtn.total + sessionCrawler[rtn.hexId][rtn.category].crawled;
+  sessionCrawler[rtn.hexId][rtn.category].crawled = sessionCrawler[rtn.hexId][rtn.category].ids.size;
+
+      if (rtn.photos.features.length >= 250 && duplicateCount === rtn.photos.features.length) {
         console.error("ALL DUPLICATE");
       }
       if (argv.debugVerbose) {
-        console.log('INFO:', ` ${rtn.hexId} ${rtn.category} ] dup=${duplicates.size}, out=${rtn.outside}, in=${rtn.photos.features.length}  || ${crawlers[currentSessionId][rtn.hexId][rtn.category].crawled} / ${crawlers[currentSessionId][rtn.hexId][rtn.category].total}`);
+        console.log('INFO:', ` ${rtn.hexId} ${rtn.category} ] dup=${duplicateCount}, out=${rtn.outside}, in=${rtn.photos.features.length}  || ${sessionCrawler[rtn.hexId][rtn.category].crawled} / ${sessionCrawler[rtn.hexId][rtn.category].total}`);
       }
-      const photos = featureCollection(rtn.photos.features.filter((f) => !duplicates.has(f.properties.id)));
-      crawlers[currentSessionId][rtn.hexId][rtn.category].items
-        = concatFC(crawlers[currentSessionId][rtn.hexId][rtn.category].items, photos);
+      const photos = featureCollection(uniqueFeatures);
+      sessionCrawler[rtn.hexId][rtn.category].items
+        = concatFC(sessionCrawler[rtn.hexId][rtn.category].items, photos);
 
-      const { stats, progress, finish } = statsItems(crawlers[currentSessionId], targets[currentSessionId]);
+      const { progress, finish } = statsItems(sessionCrawler, targets[currentSessionId]);
       io.to(currentSessionId).emit('progress', { hexId: rtn.hexId, progress });
       if (!rtn.final) {
         // 次回クロール用に更新
         rtn.nextPluginOptions.forEach((nextPluginOptions) => {
-          const workerOptions_clone = structuredClone(workerOptions);
-          workerOptions_clone.pluginOptions = nextPluginOptions;
-          api.emit('splatone:start', workerOptions_clone);
+          const workerOptionsClone = {
+            plugin: workerOptions.plugin,
+            hex: workerOptions.hex,
+            triangles: workerOptions.triangles,
+            bbox: workerOptions.bbox,
+            category: workerOptions.category,
+            tags: workerOptions.tags,
+            pluginOptions: nextPluginOptions,
+            sessionId: workerOptions.sessionId
+          };
+          api.emit('splatone:start', workerOptionsClone);
         });
         //} else if (finish) {
       } else if (processing[currentSessionId] == 0) {
         if (argv.debugVerbose) {
-          console.table(stats);
+          console.table(progress);
         }
         api.emit('splatone:finish', workerOptions);
       }
@@ -649,11 +714,16 @@ try {
     //console.log('[splatone:start]', workerOptions);
     const currentSessionId = workerOptions.sessionId;
     processing[currentSessionId] = (processing[currentSessionId] ?? 0) + 1;
-    runTask(workerOptions.plugin, workerOptions);
+    const safeOptions = JSON.parse(JSON.stringify(workerOptions, (_, value) => {
+      if (typeof value === 'function') return undefined;
+      return value;
+    }));
+    runTask(safeOptions.plugin, safeOptions);
   });
 
   await subscribe('splatone:finish', async workerOptions => {
     const currentSessionId = workerOptions.sessionId;
+    logHeapUsage(`after-crawl session=${currentSessionId}`);
     const resultId = uniqid();
     const result = crawlers[currentSessionId];
     const target = targets[currentSessionId];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "splatone",
-  "version": "0.0.18",
+  "version": "0.0.19",
   "description": "Multi-layer Composite Heatmap",
   "homepage": "https://github.com/YokoyamaLab/Splatone#readme",
   "bugs": {

package/plugins/flickr/worker.js

@@ -3,6 +3,38 @@ import { point, featureCollection } from "@turf/helpers";
 import booleanPointInPolygon from "@turf/boolean-point-in-polygon";
 import { toUnixSeconds } from '#lib/splatone';
 
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function fetchWithRetry(fetcher, { maxAttempts = 4, baseDelayMs = 500 } = {}) {
+    let attempt = 0;
+    let lastError = null;
+    while (attempt < maxAttempts) {
+        try {
+            return await fetcher();
+        } catch (err) {
+            lastError = err;
+            const transient = isTransientNetworkError(err);
+            attempt++;
+            if (!transient || attempt >= maxAttempts) {
+                throw lastError;
+            }
+            const waitMs = baseDelayMs * Math.pow(2, attempt - 1);
+            console.warn(`[flickr worker] fetch attempt ${attempt} failed (${err?.cause?.code || err?.message}). Retrying in ${waitMs}ms.`);
+            await delay(waitMs);
+        }
+    }
+    throw lastError ?? new Error('Unknown Flickr fetch error');
+}
+
+function isTransientNetworkError(err) {
+    const code = err?.cause?.code ?? err?.code;
+    if (!code && typeof err?.message === 'string' && err.message.includes('fetch failed')) {
+        return true;
+    }
+    const transientCodes = new Set(['ECONNABORTED', 'ECONNRESET', 'ETIMEDOUT', 'EPIPE']);
+    return transientCodes.has(code);
+}
+
 export default async function ({
     port,
     debugVerbose,
@@ -16,27 +48,33 @@ export default async function ({
     sessionId
 }) {
     debugVerbose = true;
-    //console.log("{PLUGIN}", pluginOptions);
-    const { flickr } = createFlickr(pluginOptions["APIKEY"]);
-    if (!pluginOptions.TermId) {
-        //初期TermId
-        pluginOptions.TermId = 'a';
-    }
-    const baseParams = {
-        bbox: bbox.join(','),
-        tags: tags,
-        extras: pluginOptions["Extras"],
-        sort: pluginOptions["DateMode"] == "upload" ? "date-posted-desc" : "date-taken-desc"
+
+    const respond = (payload) => {
+        const safePayload = JSON.parse(JSON.stringify(payload));
+        port.postMessage(safePayload);
     };
-    baseParams[pluginOptions["DateMode"] == "upload" ? 'max_upload_date' : 'max_taken_date'] = pluginOptions["DateMax"];
-    baseParams[pluginOptions["DateMode"] == "upload" ? 'min_upload_date' : 'min_taken_date'] = pluginOptions["DateMin"];
-    //console.log("[baseParams]",baseParams);
-    const res = await flickr("flickr.photos.search", {
-        ...baseParams,
-        has_geo: 1,
-        per_page: 250,
-        page: 1,
-    });
+
+    try {
+        const { flickr } = createFlickr(pluginOptions["APIKEY"]);
+        if (!pluginOptions.TermId) {
+            //初期TermId
+            pluginOptions.TermId = 'a';
+        }
+        const baseParams = {
+            bbox: bbox.join(','),
+            tags: tags,
+            extras: pluginOptions["Extras"],
+            sort: pluginOptions["DateMode"] == "upload" ? "date-posted-desc" : "date-taken-desc"
+        };
+        baseParams[pluginOptions["DateMode"] == "upload" ? 'max_upload_date' : 'max_taken_date'] = pluginOptions["DateMax"];
+        baseParams[pluginOptions["DateMode"] == "upload" ? 'min_upload_date' : 'min_taken_date'] = pluginOptions["DateMin"];
+        //console.log("[baseParams]",baseParams);
+        const res = await fetchWithRetry(() => flickr("flickr.photos.search", {
+            ...baseParams,
+            has_geo: 1,
+            per_page: 250,
+            page: 1,
+        }));
     //console.log(res);
     const ids = [];
     const authors = {};
@@ -127,30 +165,49 @@ export default async function ({
             }
         }
     }
-    port.postMessage({
-        workerOptions: {
-            plugin,
-            hex,
-            triangles,
-            bbox,
-            category,
-            tags,
-            pluginOptions,
+        const payload = {
+            results: {
+                photos,
+                hexId: hex.properties.hexId,
+                tags,
+                category,
+                nextPluginOptions: nextPluginOptionsDelta.map(e => { return { ...pluginOptions, ...e } }),
+                total: res.photos.total,
+                outside: outside,
+                ids,
+                final: nextPluginOptionsDelta.length == 0//res.photos.photo.length == res.photos.total
+            }
+        };
+
+        respond(payload);
+        return true;
+    } catch (err) {
+        console.error('[flickr worker] Fatal error', {
             sessionId,
-        },
-        results: {
-            photos,
-            hexId: hex.properties.hexId,
-            tags,
+            hexId: hex?.properties?.hexId,
             category,
-            nextPluginOptions: nextPluginOptionsDelta.map(e => { return { ...pluginOptions, ...e } }),
-            total: res.photos.total,
-            outside: outside,
-            ids,
-            final: nextPluginOptionsDelta.length == 0//res.photos.photo.length == res.photos.total
-        }
-    });
-    return true;
+            reason: err?.message,
+            code: err?.cause?.code || err?.code || null
+        });
+        respond({
+            results: {
+                photos: featureCollection([]),
+                hexId: hex?.properties?.hexId ?? null,
+                tags,
+                category,
+                nextPluginOptions: [],
+                total: 0,
+                outside: 0,
+                ids: [],
+                final: true,
+                error: {
+                    message: err?.message,
+                    code: err?.cause?.code || err?.code || null
+                }
+            }
+        });
+        return false;
+    }
     return {
         photos,
         hexId: hex.properties.hexId,

package/views/index.ejs

@@ -116,6 +116,36 @@
       reconnection: false
     });
 
+    function debounce(fn, wait = 300) {
+      let timer = null;
+      return (...args) => {
+        clearTimeout(timer);
+        timer = setTimeout(() => fn(...args), wait);
+      };
+    }
+
+    function readMapViewCookie() {
+      const entry = document.cookie.split('; ').find(row => row.startsWith('splatoneMapView='));
+      if (!entry) return null;
+      try {
+        const encoded = entry.split('=')[1];
+        return JSON.parse(decodeURIComponent(encoded));
+      } catch {
+        return null;
+      }
+    }
+
+    function writeMapViewCookie({ lat, lon, zoom }) {
+      const payload = encodeURIComponent(JSON.stringify({ lat, lon, zoom }));
+      const maxAge = 60 * 60 * 24 * 30; // 30 days
+      document.cookie = `splatoneMapView=${payload}; path=/; max-age=${maxAge}`;
+    }
+
+    const storedView = readMapViewCookie();
+    const initialLat = Number.isFinite(Number(storedView?.lat)) ? Number(storedView.lat) : lat;
+    const initialLon = Number.isFinite(Number(storedView?.lon)) ? Number(storedView.lon) : lon;
+    const initialZoom = Number.isFinite(Number(storedView?.zoom)) ? Number(storedView.zoom) : 12;
+
     function setProgress(el, value) {
       //プログレスバー
       const v = Math.max(0, Math.min(100, Number(value)));
@@ -398,7 +428,19 @@
     const map = L.map('map', {
       preferCanvas: true,
       zoomControl: true
-    }).setView([lat, lon], 12);
+    }).setView([initialLat, initialLon], initialZoom);
+
+    const persistMapView = debounce(() => {
+      const center = map.getCenter();
+      writeMapViewCookie({
+        lat: Number(center.lat.toFixed(6)),
+        lon: Number(center.lng.toFixed(6)),
+        zoom: map.getZoom()
+      });
+    }, 500);
+
+    map.on('moveend', persistMapView);
+    map.on('zoomend', persistMapView);
     const baseLayer = L.tileLayer('https://{s}.basemaps.cartocdn.com/light_all/{z}/{x}/{y}{r}.png', {
       maxZoom: 19,
       attribution: '© OpenStreetMap contributors'

package/visualizer/voronoi/node.js

@@ -0,0 +1,436 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { featureCollection, voronoi as turfVoronoi, bbox as turfBBox, intersect, point as turfPoint, distance as turfDistance } from '@turf/turf';
+import { VisualizerBase } from '../../lib/VisualizerBase.js';
+
+function cloneFeature(feature) {
+    return JSON.parse(JSON.stringify(feature ?? {}));
+}
+
+function extractHexPolygons(target = {}, geotagsByHex = {}) {
+    const hexFeatures = target?.hex?.features;
+    if (!Array.isArray(hexFeatures) || !hexFeatures.length) {
+        return {};
+    }
+
+    const hexPolygons = {};
+    for (const hexFeature of hexFeatures) {
+        const hexId = hexFeature?.properties?.hexId;
+        if (hexId == null || geotagsByHex[hexId] == null) continue;
+
+        const cloned = cloneFeature(hexFeature);
+        cloned.properties ??= {};
+        cloned.properties.geotagCount = geotagsByHex[hexId]?.properties?.totalCount ?? 0;
+        hexPolygons[hexId] = cloned;
+    }
+
+    return hexPolygons;
+}
+
+function collectTargetHexIds(target = {}) {
+    const hexFeatures = target?.hex?.features;
+    if (!Array.isArray(hexFeatures)) return new Set();
+    const ids = new Set();
+    for (const hexFeature of hexFeatures) {
+        const hexId = hexFeature?.properties?.hexId;
+        if (hexId == null) continue;
+        ids.add(hexId);
+    }
+    return ids;
+}
+
+function shuffleArray(input = []) {
+    const array = [...input];
+            warnHexNotRendered(hexId, 'no raw points found for this hex in result payload');
+    for (let i = array.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [array[i], array[j]] = [array[j], array[i]];
+    }
+    return array;
+}
+
+function poissonDownsample(features = [], maxCount = 0) {
+    const limit = Math.floor(maxCount);
+    if (!Number.isFinite(limit) || limit <= 0 || features.length <= limit) {
+        return features;
+    }
+
+    const probability = limit / features.length;
+    const picked = [];
+    const pickedIndices = new Set();
+
+    for (let i = 0; i < features.length; i++) {
+        if (picked.length >= limit) break;
+        if (Math.random() < probability) {
+            picked.push(features[i]);
+            pickedIndices.add(i);
+        }
+    }
+
+    if (picked.length === 0) {
+        return shuffleArray(features).slice(0, limit);
+    }
+
+    if (picked.length < limit) {
+        for (let i = 0; i < features.length && picked.length < limit; i++) {
+            if (!pickedIndices.has(i)) {
+                picked.push(features[i]);
+                pickedIndices.add(i);
+            }
+        }
+    }
+
+    return picked.slice(0, limit);
+}
+
+function buildCategoryBreakdown(features = []) {
+    const breakdown = {};
+    for (const feature of features) {
+        const cat = feature?.properties?.category;
+        if (!cat) continue;
+        breakdown[cat] = (breakdown[cat] ?? 0) + 1;
+    }
+    return breakdown;
+}
+
+function hashStringToHue(input = '') {
+    let hash = 0;
+    for (let i = 0; i < input.length; i++) {
+        hash = ((hash << 5) - hash) + input.charCodeAt(i);
+        hash |= 0;
+    }
+    return Math.abs(hash) % 360;
+}
+
+function hslToHex(h, s, l) {
+    s /= 100;
+    l /= 100;
+    const k = n => (n + h / 30) % 12;
+    const a = s * Math.min(l, 1 - l);
+    const f = n => l - a * Math.max(-1, Math.min(k(n) - 3, Math.min(9 - k(n), 1)));
+    const toHex = x => Math.round(x * 255).toString(16).padStart(2, '0');
+    return `#${toHex(f(0))}${toHex(f(8))}${toHex(f(4))}`;
+}
+
+function darkenHex(hex, amount = 0.8) {
+    if (!/^#?[0-9a-f]{6}$/i.test(hex ?? '')) return hex;
+    const normalized = hex.replace('#', '');
+    const r = parseInt(normalized.slice(0, 2), 16);
+    const g = parseInt(normalized.slice(2, 4), 16);
+    const b = parseInt(normalized.slice(4, 6), 16);
+    const clamp = v => Math.max(0, Math.min(255, Math.round(v * amount)));
+    return `#${clamp(r).toString(16).padStart(2, '0')}${clamp(g).toString(16).padStart(2, '0')}${clamp(b).toString(16).padStart(2, '0')}`;
+}
+
+function getCategoryColors(category, palette = {}) {
+    const palEntry = category ? palette[category] : null;
+    const fill = palEntry?.color ?? hslToHex(hashStringToHue(category ?? ''), 65, 55);
+    const stroke = palEntry?.darken ?? darkenHex(fill, 0.7);
+    return { fillColor: fill, strokeColor: stroke };
+}
+
+function applyColorsToCells(cells = [], palette = {}) {
+    return cells.map(cell => {
+        if (!cell) return cell;
+        const colored = cloneFeature(cell);
+        colored.properties ??= {};
+        const category = colored.properties.category;
+        const { fillColor, strokeColor } = getCategoryColors(category, palette);
+        colored.properties.fillColor = fillColor;
+        colored.properties.strokeColor = strokeColor;
+        return colored;
+    });
+}
+
+function coerceLonLat(coords = []) {
+    const [lonRaw, latRaw] = coords;
+    const lon = Number.parseFloat(lonRaw);
+    const lat = Number.parseFloat(latRaw);
+    if (!Number.isFinite(lon) || !Number.isFinite(lat)) return null;
+    return [lon, lat];
+}
+
+const MAX_JITTER_ATTEMPTS = 512;
+const BASE_JITTER_DEGREES = 2e-8;
+
+function coordinateKey([lon, lat] = []) {
+    return `${lon.toFixed(12)}:${lat.toFixed(12)}`;
+}
+
+function jitterCoordinate(baseCoords = [], offsetIndex = 1, seed = 0) {
+    const [lon, lat] = baseCoords;
+    if (!Number.isFinite(lon) || !Number.isFinite(lat)) return null;
+
+    const angleDeg = (seed * 23.17 + offsetIndex * 137.508) % 360;
+    const angleRad = angleDeg * Math.PI / 180;
+    const delta = BASE_JITTER_DEGREES * (offsetIndex + 1);
+
+    const deltaLon = delta * Math.cos(angleRad);
+    const deltaLat = delta * Math.sin(angleRad);
+
+    const jitteredLon = lon + deltaLon;
+    const jitteredLat = lat + deltaLat;
+
+    if (!Number.isFinite(jitteredLon) || !Number.isFinite(jitteredLat)) {
+        return null;
+    }
+
+    return [jitteredLon, jitteredLat];
+}
+
+function findAvailableCoordinate(baseCoords, occurrenceIndex, seed, usedKeys) {
+    for (let attempt = 0; attempt <= MAX_JITTER_ATTEMPTS; attempt++) {
+        const jitterIndex = occurrenceIndex + attempt;
+        const candidate = jitterIndex === 0 ? baseCoords : jitterCoordinate(baseCoords, jitterIndex, seed);
+        if (!candidate) continue;
+        const key = coordinateKey(candidate);
+        if (usedKeys.has(key)) continue;
+        return { coords: candidate, key };
+    }
+    return null;
+}
+
+function normalizePointFeatures(features = []) {
+    const uniqueFeatures = [];
+    const usedKeys = new Set();
+    const duplicateTracker = new Map();
+
+    for (const feature of features) {
+        const normalizedCoords = coerceLonLat(feature?.geometry?.coordinates ?? []);
+        if (!normalizedCoords) continue;
+
+        const baseKey = coordinateKey(normalizedCoords);
+        const occurrenceIndex = duplicateTracker.get(baseKey) ?? 0;
+        const seed = feature?.properties?.__voronoiOrder ?? 0;
+
+        const placement = findAvailableCoordinate(normalizedCoords, occurrenceIndex, seed, usedKeys);
+        if (!placement) continue;
+
+        duplicateTracker.set(baseKey, occurrenceIndex + 1);
+        usedKeys.add(placement.key);
+
+        const cloned = cloneFeature(feature);
+        cloned.geometry = {
+            type: 'Point',
+            coordinates: placement.coords
+        };
+
+        uniqueFeatures.push(cloned);
+    }
+
+    return uniqueFeatures;
+}
+
+function warnHexNotRendered(hexId, reason, extra = {}) {
+    const details = Object.keys(extra).length ? ` | context: ${JSON.stringify(extra)}` : '';
+    console.warn(`[VoronoiVisualizer] Skipped hex ${hexId}: ${reason}${details}`);
+}
+
+function enforceMinSpacing(features = [], minMeters = 0) {
+    if (!Number.isFinite(minMeters) || minMeters <= 0) {
+        return features;
+    }
+
+    const accepted = [];
+    for (const feature of features) {
+        const coords = feature?.geometry?.coordinates;
+        if (!Array.isArray(coords)) continue;
+        const candidatePoint = turfPoint(coords);
+        let tooClose = false;
+
+        for (const existing of accepted) {
+            const existingPoint = turfPoint(existing.geometry.coordinates);
+            const dist = turfDistance(candidatePoint, existingPoint, { units: 'meters' });
+            if (!Number.isFinite(dist)) continue;
+            if (dist < minMeters) {
+                tooClose = true;
+                break;
+            }
+        }
+
+        if (!tooClose) {
+            accepted.push(feature);
+        }
+    }
+
+    return accepted;
+}
+
+function aggregateGeotagsByHex(result = {}, maxSitesPerHex = 0, minSpacingMeters = 0) {
+    const geotagsByHex = {};
+
+    for (const [hexId, categories] of Object.entries(result ?? {})) {
+        if (!categories) continue;
+
+        const aggregatedFeatures = [];
+        const categoryBreakdown = {};
+        let featureOrder = 0;
+
+        for (const [categoryName, payload] of Object.entries(categories)) {
+            const features = payload?.items?.features ?? [];
+            if (!features.length) continue;
+
+            categoryBreakdown[categoryName] = (categoryBreakdown[categoryName] ?? 0) + features.length;
+
+            for (const feature of features) {
+                const cloned = cloneFeature(feature);
+                const coords = Array.isArray(cloned?.geometry?.coordinates) ? cloned.geometry.coordinates : [];
+                const normalizedCoords = coerceLonLat(coords);
+                if (!normalizedCoords) continue;
+                cloned.geometry = {
+                    type: 'Point',
+                    coordinates: normalizedCoords
+                };
+                const [longitude, latitude] = normalizedCoords;
+
+                cloned.properties = {
+                    longitude,
+                    latitude,
+                    category: categoryName,
+                    hexId,
+                    __voronoiOrder: featureOrder++
+                };
+                aggregatedFeatures.push(cloned);
+            }
+        }
+
+        if (!aggregatedFeatures.length) continue;
+
+        const spacedFeatures = enforceMinSpacing(aggregatedFeatures, minSpacingMeters);
+
+        const limitedFeatures = (Number.isFinite(maxSitesPerHex) && maxSitesPerHex > 0)
+            ? poissonDownsample(spacedFeatures, maxSitesPerHex)
+            : spacedFeatures;
+
+        const breakdown = buildCategoryBreakdown(limitedFeatures);
+        const collection = featureCollection(limitedFeatures);
+        collection.properties = {
+            hexId,
+            totalCount: limitedFeatures.length,
+            categoryBreakdown: breakdown
+        };
+
+        geotagsByHex[hexId] = collection;
+    }
+
+    return { geotagsByHex };
+}
+
+function buildVoronoiFeatureCollection(geotagsByHex = {}, hexPolygons = {}, palette = {}) {
+    const voronoiCells = [];
+
+    for (const [hexId, collection] of Object.entries(geotagsByHex)) {
+        const hexPolygon = hexPolygons[hexId];
+        const pointFeatures = normalizePointFeatures(collection?.features ?? []);
+        if (!hexPolygon) {
+            warnHexNotRendered(hexId, 'missing hex polygon');
+            continue;
+        }
+        if (pointFeatures.length === 0) {
+            warnHexNotRendered(hexId, 'no sampled points after spacing/downsampling');
+            continue;
+        }
+
+        if (pointFeatures.length === 1) {
+            const singleCell = cloneFeature(hexPolygon);
+            singleCell.properties = {
+                ...(pointFeatures[0]?.properties ?? {}),
+                hexId
+            };
+            voronoiCells.push(singleCell);
+            continue;
+        }
+
+        const bbox = turfBBox(hexPolygon);
+        let voronoiOutput = null;
+        try {
+            voronoiOutput = turfVoronoi(featureCollection(pointFeatures), { bbox });
+        } catch (err) {
+            warnHexNotRendered(hexId, 'turfVoronoi threw', { message: err?.message });
+            continue;
+        }
+        if (!voronoiOutput?.features || voronoiOutput.features.length === 0) {
+            warnHexNotRendered(hexId, 'turfVoronoi returned no features');
+            continue;
+        }
+
+        let cellsAddedForHex = 0;
+        for (const cell of voronoiOutput.features) {
+            if (!cell?.geometry || !hexPolygon?.geometry) continue;
+
+            let clipped = null;
+            try {
+                const clippingInput = featureCollection([cell, hexPolygon]);
+                clipped = intersect(clippingInput) ?? cell;
+            } catch (err) {
+                clipped = cell;
+            }
+
+            if (!clipped?.geometry) continue;
+
+            const properties = {
+                ...(cell.properties ?? {}),
+                hexId
+            };
+
+            voronoiCells.push({
+                type: 'Feature',
+                geometry: cloneFeature(clipped.geometry),
+                properties
+            });
+            cellsAddedForHex++;
+        }
+
+        if (cellsAddedForHex === 0) {
+            warnHexNotRendered(hexId, 'all Voronoi cells were filtered out');
+        }
+    }
+
+    const coloredCells = applyColorsToCells(voronoiCells, palette);
+    return featureCollection(coloredCells);
+}
+
+/**
+ * Skeleton implementation of the Voronoi visualizer.
+ * This placeholder intentionally performs no heavy processing so that
+ * developers can wire up the rest of the system before adding real logic.
+ */
+export default class VoronoiVisualizer extends VisualizerBase {
+    static name = 'Voronoi Visualizer';
+    static version = '0.0.0';
+    static description = 'Hex Grid ボロノイ図';
+
+    constructor() {
+        super();
+        this.id = path.basename(path.dirname(fileURLToPath(import.meta.url)));
+    }
+
+    async yargv(yargv) {
+        return yargv.option(this.argKey('MaxSitesPerHex'), {
+            group: 'For ' + this.id + ' Visualizer',
+            type: 'number',
+            description: 'ポワソン分布に基づいて各ヘックス内でサンプリングされる最大サイト数 (0 = 無制限)',
+            default: 0
+        }).option(this.argKey('MinSiteSpacingMeters'), {
+            group: 'For ' + this.id + ' Visualizer',
+            type: 'number',
+            description: '各ヘックス内でサンプリングされたサイト間の最小距離をメートル単位で保証 (0 = 無効)',
+            default: 50
+        });
+    }
+
+    getFutureCollection(result, target, visOptions) {
+        const maxSitesPerHex = Number(visOptions?.MaxSitesPerHex ?? 0);
+        const minSpacingMeters = Number(visOptions?.MinSiteSpacingMeters ?? 0);
+        const targetHexIds = collectTargetHexIds(target);
+        const { geotagsByHex } = aggregateGeotagsByHex(result, maxSitesPerHex, minSpacingMeters);
+        for (const hexId of targetHexIds) {
+            if (!geotagsByHex[hexId]) {
+                warnHexNotRendered(hexId, 'no geotags provided for this hex');
+            }
+        }
+        const hexPolygons = extractHexPolygons(target, geotagsByHex);
+        const palette = target?.splatonePalette ?? {};
+        return  buildVoronoiFeatureCollection(geotagsByHex, hexPolygons, palette) ;
+    }
+}

package/visualizer/voronoi/web.js

@@ -0,0 +1,71 @@
+let layerGroup = null;
+
+function reset(map) {
+  if (layerGroup) {
+    map.removeLayer(layerGroup);
+    layerGroup = null;
+  }
+}
+
+function normalizeFeatureCollection(payload) {
+  if (!payload) return null;
+  if (payload.type === 'FeatureCollection' && Array.isArray(payload.features)) {
+    return payload;
+  }
+  if (payload.voronoi && payload.voronoi.type === 'FeatureCollection') {
+    return payload.voronoi;
+  }
+  if (Array.isArray(payload.features)) {
+    return { type: 'FeatureCollection', features: payload.features };
+  }
+  return null;
+}
+
+function createVoronoiLayer(rawGeojson) {
+  const geojson = normalizeFeatureCollection(rawGeojson);
+  console.log('[VoronoiVisualizer] normalize', geojson);
+  if (!geojson || !Array.isArray(geojson.features) || geojson.features.length === 0) {
+    return null;
+  }
+
+  return L.geoJSON(geojson, {
+    style: (feature) => {
+      const props = feature?.properties ?? {};
+      return {
+        color: props.strokeColor || '#333333',
+        weight: props.strokeWidth ?? 1,
+        opacity: props.strokeOpacity ?? 1,
+        fill: true,
+        fillColor: props.fillColor || '#3388ff',
+        fillOpacity: props.fillOpacity ?? 0.5
+      };
+    },
+    onEachFeature: (feature, layer) => {
+      const props = feature?.properties ?? {};
+      const category = props.category || 'unknown';
+      const hexId = props.hexId ?? 'n/a';
+      const html = `<strong>${category}</strong><br/>hex: ${hexId}`;
+      layer.bindPopup(html);
+    }
+  });
+}
+
+export default async function main(map, geojson, options = {}) {
+  reset(map);
+
+  const voronoiLayer = createVoronoiLayer(geojson);
+  console.log('[VoronoiVisualizer] voronoiLayer:', voronoiLayer);
+  if (!voronoiLayer) {
+    console.warn('[VoronoiVisualizer] No features to render.');
+    return {};
+  }
+
+  layerGroup = L.featureGroup([voronoiLayer]).addTo(map);
+
+  const bounds = voronoiLayer.getBounds();
+  if (bounds.isValid()) {
+    map.fitBounds(bounds, { padding: [16, 16] });
+  }
+
+  return { voronoi: layerGroup };
+}