@pirireis/webglobeplugins 1.0.3 → 1.0.4

package/webglobeplugins/programs/totems/attachments/adaptive-opacity.js

@@ -0,0 +1,131 @@
+import { noRegisterGlobeProgramCache } from "../../programcache";
+import { CameraUniformBlockTotemCache } from "../camerauniformblock";
+const epsilon = 0.1;
+export function createSmoothstepOpacityPolicy(minZoom = 4, maxZoom = 12) {
+    const denom = maxZoom - minZoom;
+    if (!Number.isFinite(denom) || denom === 0) {
+        throw new Error("createSmoothstepOpacityPolicy: invalid zoom range");
+    }
+    const smoothstep = (x) => x * x * (3 - 2 * x);
+    return (zoomLevel) => {
+        const t = (zoomLevel - minZoom) / denom;
+        const c = Math.min(1, Math.max(0, t));
+        return 1 - smoothstep(c);
+    };
+}
+/**
+ * Hysteresis policy: reduces flicker by using separate enter/exit zooms.
+ * Example: fade-in begins at enterStart, but won’t fade-out until exitEnd.
+ */
+export function createHysteresisOpacityPolicy(params) {
+    const { enterStart, enterEnd, exitStart, exitEnd } = params;
+    if (!(exitEnd <= exitStart && exitStart <= enterStart && enterStart <= enterEnd)) {
+        throw new Error("createHysteresisOpacityPolicy: expected exitEnd <= exitStart <= enterStart <= enterEnd");
+    }
+    const lerp01 = (x, a, b) => {
+        if (a === b)
+            return x >= b ? 1 : 0;
+        const t = (x - a) / (b - a);
+        return Math.min(1, Math.max(0, t));
+    };
+    return (zoomLevel, prevOpacity) => {
+        // If we were mostly “off”, only allow rising once we hit the enter band.
+        if (prevOpacity <= 0.5) {
+            if (zoomLevel <= exitStart)
+                return lerp01(zoomLevel, exitEnd, exitStart) * 0; // clamp to 0 band
+            if (zoomLevel < enterStart)
+                return 0;
+            return lerp01(zoomLevel, enterStart, enterEnd);
+        }
+        // If we were mostly “on”, only allow falling once we hit the exit band.
+        if (zoomLevel >= enterStart)
+            return lerp01(zoomLevel, enterStart, enterEnd);
+        if (zoomLevel > exitStart)
+            return 1;
+        // decreasing band
+        return 1 - lerp01(zoomLevel, exitEnd, exitStart);
+    };
+}
+/**
+ * Curve policy: caller supplies any curve f(t) where t is normalized [0..1].
+ * This is the most flexible option (e.g., gamma, custom spline, etc.).
+ */
+export function createCurveOpacityPolicy(params) {
+    const { minZoom, maxZoom, curve } = params;
+    const denom = maxZoom - minZoom;
+    if (!Number.isFinite(denom) || denom === 0) {
+        throw new Error("createCurveOpacityPolicy: invalid zoom range");
+    }
+    return (zoomLevel) => {
+        const t = (zoomLevel - minZoom) / denom;
+        const c = Math.min(1, Math.max(0, t));
+        const y = curve(c);
+        return Math.min(1, Math.max(0, y));
+    };
+}
+class AdaptiveOpacityAttachment {
+    globe;
+    cameraUniformBlock;
+    lastZoomLevel = -1;
+    isChangedFlag = false;
+    registry = new Map();
+    defaultAdaptiveOpacityPolicy = createSmoothstepOpacityPolicy(5.5, 7);
+    constructor(globe) {
+        this.globe = globe;
+        this.cameraUniformBlock = CameraUniformBlockTotemCache.get(this.globe);
+        this.cameraUniformBlock.registerAttachment(this);
+    }
+    update() {
+        const zoomLevel = this.globe.api_GetCurrentLODWithDecimal();
+        if (epsilon > Math.abs(this.lastZoomLevel - zoomLevel)) {
+            this._setIsChanged(false);
+            return;
+        }
+        ;
+        this._setIsChanged(true);
+        this.lastZoomLevel = zoomLevel;
+        this.registry.forEach((plugin) => {
+            plugin.__adaptiveOpacity_set((plugin.__adaptivePolicy || this.defaultAdaptiveOpacityPolicy)(zoomLevel, plugin.__adaptiveOpacity));
+        });
+    }
+    registerPlugin(plugin) {
+        if (this.registry.has(plugin.id)) {
+            return false;
+        }
+        this.registry.set(plugin.id, plugin);
+        plugin.__adaptiveOpacity_set((plugin.__adaptivePolicy ||
+            this.defaultAdaptiveOpacityPolicy)(this.lastZoomLevel));
+        return true;
+    }
+    unregisterPlugin(plugin) {
+        if (!this.registry.has(plugin.id)) {
+            return false;
+        }
+        this.registry.delete(plugin.id);
+        return true;
+    }
+    _setIsChanged(value) {
+        this.isChangedFlag = value;
+    }
+    get isChanged() {
+        return this.isChangedFlag;
+    }
+    free() {
+        this.cameraUniformBlock.unregisterAttachment(this);
+    }
+}
+export const AdaptiveOpacityAttachmentObserver = Object.freeze({
+    subscribe: (subscriber) => {
+        const attachment = noRegisterGlobeProgramCache.getProgram(subscriber.globe, AdaptiveOpacityAttachment);
+        if (!attachment.registerPlugin(subscriber)) {
+            noRegisterGlobeProgramCache.releaseProgram(subscriber.globe, AdaptiveOpacityAttachment);
+        }
+    },
+    unsubscribe: (subscriber) => {
+        const attachment = noRegisterGlobeProgramCache.getProgram(subscriber.globe, AdaptiveOpacityAttachment);
+        if (attachment.unregisterPlugin(subscriber)) {
+            subscriber.__adaptiveOpacity_set(1);
+            noRegisterGlobeProgramCache.releaseProgram(subscriber.globe, AdaptiveOpacityAttachment);
+        }
+    }
+});

package/{programs/totems → webglobeplugins/programs/totems/attachments}/dem-textures-manager.js

@@ -1,7 +1,7 @@
-import { mergeMeshes } from "../../Math/tessellation/tile-merger";
-import { globeBBoxToXYBBOX } from "../../Math/methods";
-import { noRegisterGlobeProgramCache } from "../programcache";
-import { CameraUniformBlockTotemCache } from "./camerauniformblock";
+import { mergeMeshes } from "../../../Math/tessellation/tile-merger";
+import { globeBBoxToXYBBOX } from "../../../Math/methods";
+import { noRegisterGlobeProgramCache } from "../../programcache";
+import { CameraUniformBlockTotemCache } from "../camerauniformblock";
 export const DEM_TEXTURE_BLOCK_STRING = `
 layout(std140) uniform DemTextureUniformBlock {
     vec4 u_demTextureBBOX[6]; // 96 bytes
@@ -256,10 +256,16 @@ export class DemTextureManager {
 export const DemTextureManagerCache = Object.freeze({
     get: (globe) => {
         const result = noRegisterGlobeProgramCache.getProgram(globe, DemTextureManager);
-        window.demManager = result;
+        // window.demManager = result;
         return result;
     },
     release: (globe) => {
         noRegisterGlobeProgramCache.releaseProgram(globe, DemTextureManager);
     }
 });
+// // declare demManager window global
+// declare global {
+//     interface Window {
+//         demManager: DemTextureManager;
+//     }
+// }

package/{programs → webglobeplugins/programs}/vectorfields/logics/drawrectangleparticles.js

@@ -1,3 +1,6 @@
+/**
+ * Author: Toprak Nihat Deniz Ozturk
+ */
 import { createProgram } from "../../../util/webglobjectbuilders";
 import { glProgramCache } from "../../programcache";
 import { ParticleUBO } from "./particle-ubo";
@@ -9,7 +12,7 @@ precision highp float;
 ` + ParticleUBO.glslCode() + `
 uniform sampler2D u_vector_field;
 uniform sampler2D u_color_field;
-uniform sampler2D u_speed_field;
+uniform sampler2D u_magnitude_field;
 in vec2 in_position;
 out vec4 base_color;
 
@@ -24,35 +27,38 @@ vec2 read_value(const vec2 uv) {
     
 
 vec2 lookup_wind(const vec2 uv) { // gerek kalmayabilir. sampler linear methodu ayni isi yapiyor 
-    // return texture(u_vector_field, uv).rg; // lower-res hardware filtering
-    vec2 res = vec2(textureSize(u_vector_field, 0));
-    vec2 px = 1.0 / res;
-    vec2 vc = (floor(uv * res)) * px;
-    vec2 f = fract(uv * res);
-    vec2 tl = read_value(vc).rg;
-    vec2 tr = read_value(vc + vec2(px.x, 0)).rg;
-    vec2 bl = read_value(vc + vec2(0, px.y)).rg;
-    vec2 br = read_value(vc + px).rg;
+    vec2 value =texture(u_vector_field, uv).rg; // lower-res hardware filtering
+    // normalize value
+    float length = length(value);
+    if ( length == 0.0 || value.x == escape_value || value.y == escape_value) {
+        return vec2(0.0);
+    }
+    return value/length;
 
-    return mix(mix(tl, tr, f.x), mix(bl, br, f.x), f.y);
+    // vec2 res = vec2(textureSize(u_vector_field, 0));
+    // vec2 px = 1.0 / res;
+    // vec2 vc = (floor(uv * res)) * px;
+    // vec2 f = fract(uv * res);
+    // vec2 tl = read_value(vc).rg;
+    // vec2 tr = read_value(vc + vec2(px.x, 0)).rg;
+    // vec2 bl = read_value(vc + vec2(0, px.y)).rg;
+    // vec2 br = read_value(vc + px).rg;
+
+    // return mix(mix(tl, tr, f.x), mix(bl, br, f.x), f.y);
 }
 
 
 void main(){
-    if ( use_speed_field != 0.0 ) {
-        base_color = vec4(0.0);
-        return;
-        float speed = texture(u_speed_field, in_position).r;
-        if ( speed < min_speed_threshold || speed > max_speed_threshold ) {
+    if ( use_magnitude_field > 0.5) {
+        float magnitude = texture(u_magnitude_field, in_position).r;
+    
+        if ( magnitude < min_magnitude_threshold || magnitude > max_magnitude_threshold ) {
             base_color = vec4(0.0);
             return;
         }
     }
 
     vec2 direction_vector = lookup_wind(in_position);    
-    if (direction_vector.r == 0.0 && direction_vector.g == 0.0) return;
-    
-
     vec2 limp;
     if ( 0 == gl_VertexID) { limp = -tail_wing_base_limp; }
     else if ( 1 == gl_VertexID) { limp = vec2( tail_wing_base_limp.x, -tail_wing_base_limp.y); }
@@ -65,7 +71,7 @@ void main(){
     vec2 pos = in_position * 2.0 - 1.0;
     gl_Position = vec4(pos + limp, 0.0, 1.0);
     
-    base_color = use_color_field != 0.0 ? texture(u_color_field, in_position).rgba : vec4(color, 1.0);
+    base_color = use_color_field != 0.0 ? texture(u_color_field, in_position).rgba : color;
 }`;
 const fragmentShaderSource = `#version 300 es
 precision highp float;
@@ -79,15 +85,15 @@ export class DrawRectangleParticleProgram {
     program;
     _vector_field_location;
     _color_texture_location;
-    _speed_field_location;
+    _magnitude_field_location;
     constructor(gl) {
         this.gl = gl;
         // this.decoyBuffer = new DecoyBufferManager(gl);
-        const { program, _vector_field_location, _color_texture_location, _speed_field_location } = this._createProgram();
+        const { program, _vector_field_location, _color_texture_location, _magnitude_field_location } = this._createProgram();
         this.program = program;
         this._vector_field_location = _vector_field_location;
         this._color_texture_location = _color_texture_location;
-        this._speed_field_location = _speed_field_location;
+        this._magnitude_field_location = _magnitude_field_location;
     }
     _createProgram() {
         const gl = this.gl;
@@ -100,7 +106,7 @@ export class DrawRectangleParticleProgram {
             program,
             _vector_field_location: gl.getUniformLocation(program, 'u_vector_field'),
             _color_texture_location: gl.getUniformLocation(program, 'u_color_field'),
-            _speed_field_location: gl.getUniformLocation(program, 'u_speed_field')
+            _magnitude_field_location: gl.getUniformLocation(program, 'u_magnitude_field')
         };
     }
     /**
@@ -108,7 +114,7 @@ export class DrawRectangleParticleProgram {
      * @param vectorFieldTexture | RG32F texture R: x, G: y
      * @param uboManager | WaveParticalUboManager under ubo.js
      */
-    draw(bufferManager, vectorFieldTexture, uboManager, colorFieldTexture, speedFieldTexture) {
+    draw(bufferManager, vectorFieldTexture, uboManager, colorFieldTexture, magnitudeFieldTexture) {
         const { gl, program } = this;
         gl.useProgram(program);
         gl.bindVertexArray(bufferManager.getSourceVao());
@@ -119,10 +125,10 @@ export class DrawRectangleParticleProgram {
             gl.uniform1i(this._color_texture_location, 1);
             gl.bindTexture(gl.TEXTURE_2D, colorFieldTexture);
         }
-        if (speedFieldTexture) {
+        if (magnitudeFieldTexture) {
             gl.activeTexture(gl.TEXTURE2);
-            gl.uniform1i(this._speed_field_location, 2);
-            gl.bindTexture(gl.TEXTURE_2D, speedFieldTexture);
+            gl.uniform1i(this._magnitude_field_location, 2);
+            gl.bindTexture(gl.TEXTURE_2D, magnitudeFieldTexture);
         }
         gl.activeTexture(gl.TEXTURE0);
         gl.uniform1i(this._vector_field_location, 0);

package/{programs → webglobeplugins/programs}/vectorfields/logics/particle-ubo.js

@@ -1,16 +1,19 @@
+/**
+ * Author: Toprak Nihat Deniz Ozturk
+ */
 import { UBO_BINDING_POINTS } from "./constants";
 import { UniformBlockManager } from "../../../util/gl-util/uniform-block/manager";
 const INITIAL_UBO_DATA = /*@__PURE__*/ new Float32Array([93.17, 0.2, 1.0, 7.0, 1.0, 1.0, 1.0, 0.05, 2000, 2000, 0]);
 export const ParticleUBO = /*@__PURE__*/ new UniformBlockManager("Seawave_UBO", [
+    { name: "color", type: "vec4", value: new Float32Array([1.0, 1.0, 1.0, 1.0]) },
     { name: "tail_wing_base_limp", type: "vec2", value: INITIAL_UBO_DATA.slice(2, 4) },
     { name: "draw_texture_size", type: "vec2", value: INITIAL_UBO_DATA.slice(8, 10) },
     { name: "random_seed", type: "float", value: INITIAL_UBO_DATA.slice(0, 1) },
     { name: "range", type: "float", value: INITIAL_UBO_DATA.slice(1, 2) },
     { name: "escape_value", type: "float", value: INITIAL_UBO_DATA.slice(10, 11) },
     { name: "drop_rate", type: "float", value: INITIAL_UBO_DATA.slice(7, 8) },
-    { name: "color", type: "vec3", value: INITIAL_UBO_DATA.slice(4, 7) },
     { name: "use_color_field", type: "float", value: new Float32Array([0]) },
-    { name: "use_speed_field", type: "float", value: new Float32Array([0]) },
-    { name: "min_speed_threshold", type: "float", value: new Float32Array([0]) },
-    { name: "max_speed_threshold", type: "float", value: new Float32Array([10000]) },
+    { name: "use_magnitude_field", type: "float", value: new Float32Array([0]) },
+    { name: "min_magnitude_threshold", type: "float", value: new Float32Array([0]) },
+    { name: "max_magnitude_threshold", type: "float", value: new Float32Array([10000]) },
 ], UBO_BINDING_POINTS.SEAWAVE);

package/{programs → webglobeplugins/programs}/vectorfields/logics/pixelbased.js

@@ -45,17 +45,13 @@ vec2 random_position(vec2 st){
 
 void main(){
     vec2 vec = lookup_wind(in_position).xy;
-    if (vec.x == 0.0 && vec.y == 0.0){
-        out_position = random_position(in_position);
-        return;
-    }
     float random_value = random(in_position + random_seed);
-    if (random_value < drop_rate){ 
+    if (vec.x == 0.0 && vec.y == 0.0 || random_value < drop_rate) {
         out_position = random_position(in_position);
         return;
     }
-    float speed_multiplier = use_speed_field != 0.0 ? texture(speed_field, in_position).r : 1.0;
-    out_position = in_position + (vec / draw_texture_size)  * range * speed_multiplier * tail_wing_base_limp.y;
+    
+    out_position = in_position + (vec / draw_texture_size)  * range * tail_wing_base_limp.x;
 }
 `;
 const fragmentShaderSource = `#version 300 es

package/{semiplugins → webglobeplugins/semiplugins}/shape-on-terrain/terrain-polygon/data/cache.js

@@ -1,20 +1,24 @@
 import { createTriangleTessellationMeta } from "../../../../Math/tessellation/triangle-tessellation";
-import { triangulation } from "./polygon-to-triangles";
+import { triangulation, calculateRealEdges } from "./polygon-to-triangles";
 import RBush from "rbush";
 import { RADIAN } from "../../../../Math/methods";
 // TODO: use type instead of any
-function _entry(polygon, kmThreshold) {
+function _entry(polygon) {
     __polygonInputWGS84ToRadian(polygon);
-    const trianglesData = triangulation(polygon, kmThreshold);
+    const trianglesData = triangulation(polygon);
     const cacheTriangles = [];
+    const realEdges = calculateRealEdges(polygon.geometry, trianglesData.indices);
     for (let i = 0; i < trianglesData.indices.length; i += 3) {
         const idx0 = trianglesData.indices[i] * 2;
         const idx1 = trianglesData.indices[i + 1] * 2;
         const idx2 = trianglesData.indices[i + 2] * 2;
+        const idx0RealEdge = realEdges[i];
+        const idx1RealEdge = realEdges[i + 1];
+        const idx2RealEdge = realEdges[i + 2];
         const v0 = [trianglesData.vertices[idx0], trianglesData.vertices[idx0 + 1]];
         const v1 = [trianglesData.vertices[idx1], trianglesData.vertices[idx1 + 1]];
         const v2 = [trianglesData.vertices[idx2], trianglesData.vertices[idx2 + 1]];
-        const tessellationMeta = createTriangleTessellationMeta(v0, v1, v2);
+        const tessellationMeta = createTriangleTessellationMeta(v0, v1, v2, idx0RealEdge, idx1RealEdge, idx2RealEdge);
         cacheTriangles.push({
             polygon: polygon,
             offset: i / 3,
@@ -38,11 +42,9 @@ function __polygonInputWGS84ToRadian(polygon) {
 }
 export class Cache {
     cache = new Map();
-    kmThreshold;
     rbush = new RBush();
     bboxes = [];
-    constructor(kmThreshold) {
-        this.kmThreshold = kmThreshold;
+    constructor() {
     }
     clear() {
         this.cache.clear();
@@ -52,7 +54,7 @@ export class Cache {
         if (this.cache.has(key)) {
             this.remove(key);
         }
-        const triangles = _entry(polygon, this.kmThreshold);
+        const triangles = _entry(polygon);
         this.rbush.load(triangles);
         this.cache.set(key, { polygon: polygon, triangles });
     }

package/{semiplugins → webglobeplugins/semiplugins}/shape-on-terrain/terrain-polygon/data/master-worker.js

@@ -1,50 +1,74 @@
 /// <reference lib="webworker" />
+/* eslint-disable no-restricted-globals */
+import { uint32Escape } from "../../../../Math/tessellation/triangle-tessellation";
 const _workers = [];
 const _workerMap = new Map();
-let _maxWorkers = 4; // Default, updated in init
+let _maxWorkers = 4;
 let _nextWorkerIndex = 0;
-// Configuration state to pass to new workers or re-broadcast
 let _pickableState;
+let _arcState;
 let _variativeColorsOn;
-// Initialize workers
+// NEW: barrier state for "wait for all outputs of the last dispatched batch"
+let _batchInFlight = false;
+let _batchPending = 0;
 function initWorkers() {
-    _maxWorkers = Math.max(1, (navigator.hardwareConcurrency || 4) - 1);
-    for (let i = 0; i < _maxWorkers; i++) {
+    _maxWorkers = Math.max(1, ((navigator.hardwareConcurrency - 2) || 4) - 1);
+    console.log(`TerrainPolygon: initializing ${_maxWorkers} workers.`);
+    for (let i = 0; i < _maxWorkers; i++)
         addWorker();
-    }
 }
 function addWorker() {
+    // IMPORTANT: use the TS entry so the bundler can build the worker module.
     // @ts-ignore
-    const worker = new Worker(new URL("./worker.js", import.meta.url), { type: 'module' });
+    const worker = new Worker(new URL("./worker.ts", import.meta.url), { type: "module" });
     const wrapper = {
         worker,
         inProgress: false,
         insertDeleteQueue: [],
         lastBBOXData: null,
         itemCount: 0,
-        lastOutput: null
+        lastOutput: null,
     };
     worker.onmessage = (event) => {
         wrapper.inProgress = false;
         wrapper.lastOutput = event.data;
-        mergeAndSendResults();
+        // Barrier: only merge/send after all workers dispatched for this batch have finished.
+        if (_batchInFlight) {
+            _batchPending = Math.max(0, _batchPending - 1);
+            if (_batchPending === 0) {
+                _batchInFlight = false;
+                mergeAndSendResults();
+                // Start next batch (if anything queued while we were waiting)
+                triggerAllWorkers();
+            }
+            return;
+        }
+        // Fallback (should rarely happen): if not in a batch, allow immediate draining.
         sendToSubWorker(wrapper);
     };
-    // Initialize sub-worker with current global state
     worker.postMessage({
         pickableState: _pickableState,
         variativeColorsOn: _variativeColorsOn,
+        arcState: _arcState,
         insertDeleteQueue: [],
         bboxes: null,
     });
     _workers.push(wrapper);
 }
 function mergeAndSendResults() {
-    let totalVec3s = 0;
-    let totalIndices = 0;
-    let totalLongLats = 0;
-    let totalPickIndices = 0;
-    let totalVariativeColors = 0;
+    // Match the working master-worker.js sentinel/header layout
+    const BASE_VEC3S = 9; // 3 vertices * 3
+    const BASE_INDICES = 3;
+    const BASE_LONGLATS = 6; // 3 vertices * 2
+    const BASE_PICKINDICES = 3;
+    const BASE_VARIATIVE = _variativeColorsOn ? 12 : 0; // 3 vertices * 4
+    const BASE_REAL_EDGE_ARC_INDICES = _arcState ? 1 : 0; // reserve header only when arc mode is enabled
+    let totalVec3s = BASE_VEC3S;
+    let totalIndices = BASE_INDICES;
+    let totalLongLats = BASE_LONGLATS;
+    let totalPickIndices = BASE_PICKINDICES;
+    let totalVariativeColors = BASE_VARIATIVE;
+    let totalRealEdgeArcIndices = BASE_REAL_EDGE_ARC_INDICES;
     const validOutputs = [];
     for (const w of _workers) {
         if (w.lastOutput) {
@@ -52,6 +76,9 @@ function mergeAndSendResults() {
             totalVec3s += w.lastOutput.vec3s.length;
             totalIndices += w.lastOutput.indices.length;
             totalLongLats += w.lastOutput.longLats.length;
+            if (_arcState && w.lastOutput.realEdgeArcIndices) {
+                totalRealEdgeArcIndices += w.lastOutput.realEdgeArcIndices.length;
+            }
             if (w.lastOutput.pickIndices)
                 totalPickIndices += w.lastOutput.pickIndices.length;
             if (w.lastOutput.variativeColors)
@@ -64,21 +91,50 @@ function mergeAndSendResults() {
         vec3s: new Float32Array(totalVec3s),
         indices: new Uint32Array(totalIndices),
         longLats: new Float32Array(totalLongLats),
+        realEdgeArcIndices: _arcState && totalRealEdgeArcIndices > 0 ? new Uint32Array(totalRealEdgeArcIndices) : null,
         pickIndices: totalPickIndices > 0 ? new Float32Array(totalPickIndices) : null,
-        variativeColors: totalVariativeColors > 0 ? new Float32Array(totalVariativeColors) : null
+        variativeColors: totalVariativeColors > 0 ? new Uint8Array(totalVariativeColors) : null,
     };
-    let offsetVec3s = 0;
-    let offsetIndices = 0;
-    let offsetLongLats = 0;
-    let offsetPickIndices = 0;
-    let offsetVariativeColors = 0;
-    let vertexOffset = 0;
+    // Sentinel/header (as in master-worker.js)
+    merged.vec3s[0] = NaN;
+    merged.vec3s[1] = NaN;
+    merged.vec3s[2] = NaN;
+    // Uint32Array cannot hold NaN; writing NaN becomes 0. Keep the header reserved anyway.
+    merged.indices[0] = 0;
+    merged.indices[1] = 0;
+    merged.indices[2] = 0;
+    merged.longLats[0] = NaN;
+    merged.longLats[1] = NaN;
+    if (_arcState && merged.realEdgeArcIndices) {
+        merged.realEdgeArcIndices[0] = 0; // header/sentinel
+    }
+    if (merged.variativeColors) {
+        // Sentinel/header (no-color marker)
+        merged.variativeColors[0] = 0;
+        merged.variativeColors[1] = 0;
+        merged.variativeColors[2] = 0;
+        merged.variativeColors[3] = 255;
+    }
+    let offsetVec3s = BASE_VEC3S;
+    let offsetIndices = BASE_INDICES;
+    let offsetLongLats = BASE_LONGLATS;
+    let offsetPickIndices = BASE_PICKINDICES;
+    let offsetVariativeColors = BASE_VARIATIVE;
+    let vertexOffset = 3; // reserve 3 vertices
+    let arcCounter = BASE_REAL_EDGE_ARC_INDICES;
     for (const out of validOutputs) {
         merged.vec3s.set(out.vec3s, offsetVec3s);
         offsetVec3s += out.vec3s.length;
         for (let i = 0; i < out.indices.length; i++) {
             merged.indices[offsetIndices + i] = out.indices[i] + vertexOffset;
         }
+        if (_arcState && merged.realEdgeArcIndices && out.realEdgeArcIndices) {
+            for (let i = 0; i < out.realEdgeArcIndices.length; i++) {
+                const realEdgeIndice = out.realEdgeArcIndices[i];
+                merged.realEdgeArcIndices[arcCounter++] =
+                    realEdgeIndice === uint32Escape ? uint32Escape : realEdgeIndice + vertexOffset;
+            }
+        }
         offsetIndices += out.indices.length;
         vertexOffset += out.vec3s.length / 3;
         merged.longLats.set(out.longLats, offsetLongLats);
@@ -92,51 +148,59 @@ function mergeAndSendResults() {
             offsetVariativeColors += out.variativeColors.length;
         }
     }
-    // Send merged result to Main Thread
     self.postMessage(merged, [
         merged.vec3s.buffer,
         merged.indices.buffer,
         merged.longLats.buffer,
         ...(merged.pickIndices ? [merged.pickIndices.buffer] : []),
-        ...(merged.variativeColors ? [merged.variativeColors.buffer] : [])
+        ...(merged.variativeColors ? [merged.variativeColors.buffer] : []),
+        ...(merged.realEdgeArcIndices ? [merged.realEdgeArcIndices.buffer] : []),
     ]);
 }
 function sendToSubWorker(wrapper) {
     if (wrapper.inProgress)
-        return;
+        return false;
     if (wrapper.insertDeleteQueue.length === 0 && wrapper.lastBBOXData === null)
-        return;
+        return false;
     wrapper.inProgress = true;
     wrapper.worker.postMessage({
-        pickableState: undefined, // State is set on init, only send updates if needed
+        pickableState: undefined,
         variativeColorsOn: undefined,
+        arcState: undefined,
         bboxes: wrapper.lastBBOXData,
         insertDeleteQueue: wrapper.insertDeleteQueue,
     });
     wrapper.lastBBOXData = null;
     wrapper.insertDeleteQueue = [];
+    return true;
 }
 function triggerAllWorkers() {
+    // If a batch is already running, do not start another one.
+    if (_batchInFlight)
+        return;
+    let dispatched = 0;
     for (const w of _workers) {
-        sendToSubWorker(w);
+        if (sendToSubWorker(w))
+            dispatched++;
+    }
+    // Start barrier only if we actually dispatched work.
+    if (dispatched > 0) {
+        _batchInFlight = true;
+        _batchPending = dispatched;
     }
 }
-// Handle messages from Main Thread
 self.onmessage = (event) => {
-    const { bboxes, insertDeleteQueue, pickableState, variativeColorsOn } = event.data;
-    // Initialize if not already done
+    const { bboxes, insertDeleteQueue, pickableState, variativeColorsOn, arcState } = event.data;
     if (_workers.length === 0) {
         _pickableState = pickableState;
         _variativeColorsOn = variativeColorsOn;
+        _arcState = arcState;
         initWorkers();
     }
-    // Handle BBOX updates
     if (bboxes) {
-        for (const w of _workers) {
+        for (const w of _workers)
             w.lastBBOXData = bboxes;
-        }
     }
-    // Handle Insert/Delete
     if (insertDeleteQueue && insertDeleteQueue.length > 0) {
         if (insertDeleteQueue[0] === "__CLEAR_ALL_ITEMS__") {
             _workerMap.clear();
@@ -148,7 +212,7 @@ self.onmessage = (event) => {
         }
         else {
             for (const item of insertDeleteQueue) {
-                if (typeof item === 'string') {
+                if (typeof item === "string") {
                     // Delete
                     const workerIdx = _workerMap.get(item);
                     if (workerIdx !== undefined) {
@@ -158,7 +222,7 @@ self.onmessage = (event) => {
                     }
                 }
                 else {
-                    // Insert
+                    // Insert/Update: MUST enqueue the full polygon payload, not just the key
                     let workerIdx = _workerMap.get(item.key);
                     if (workerIdx === undefined) {
                         workerIdx = _nextWorkerIndex;
@@ -166,12 +230,12 @@ self.onmessage = (event) => {
                         _workers[workerIdx].itemCount++;
                         _nextWorkerIndex = (_nextWorkerIndex + 1) % _workers.length;
                     }
-                    _workers[workerIdx].insertDeleteQueue.push(item.key);
+                    _workers[workerIdx].insertDeleteQueue.push(item);
                 }
             }
         }
     }
-    // Trigger all workers to process the new data
+    // This now starts a "batch" and waits for all dispatched workers to respond
+    // before mergeAndSendResults() is called.
     triggerAllWorkers();
 };
-export {};