@fieldnotes/core 0.57.0 → 0.59.0

package/dist/index.cjs

@@ -37,6 +37,7 @@ __export(index_exports, {
   MEASURE_PRESENCE_KIND: () => MEASURE_PRESENCE_KIND,
   MeasureTool: () => MeasureTool,
   MemoryAdapter: () => MemoryAdapter,
+  MinimapController: () => MinimapController,
   NoteTool: () => NoteTool,
   PING_PRESENCE_KIND: () => PING_PRESENCE_KIND,
   PencilTool: () => PencilTool,
@@ -4796,88 +4797,247 @@ function miniToWorld(t, p) {
   return { x: (p.x - t.offsetX) / t.scale, y: (p.y - t.offsetY) / t.scale };
 }
 
-// src/canvas/minimap.ts
-var WIDTH = 200;
-var HEIGHT = 140;
-var MARGIN = 16;
-var PADDING = 8;
+// src/canvas/minimap-controller.ts
+var DEFAULT_WIDTH = 200;
+var DEFAULT_HEIGHT = 140;
+var DEFAULT_PADDING = 8;
+var DEFAULT_DEBOUNCE_MS2 = 200;
+var DEFAULT_VIEWPORT_STROKE = "#3b82f6";
 var NEUTRAL = "rgba(100,116,139,0.6)";
-var VIEWPORT_STROKE = "#3b82f6";
+var DOM_FALLBACK_TYPES = /* @__PURE__ */ new Set(["note", "text", "html"]);
 function elementColor(el) {
   return "color" in el && typeof el.color === "string" ? el.color : NEUTRAL;
 }
-var Minimap = class {
-  constructor(deps) {
-    this.deps = deps;
-    const canvas = document.createElement("canvas");
-    canvas.width = WIDTH;
-    canvas.height = HEIGHT;
-    Object.assign(canvas.style, {
-      position: "absolute",
-      right: `${MARGIN}px`,
-      bottom: `${MARGIN}px`,
-      width: `${WIDTH}px`,
-      height: `${HEIGHT}px`,
-      background: "rgba(255,255,255,0.85)",
-      border: "1px solid rgba(0,0,0,0.15)",
-      borderRadius: "4px",
-      touchAction: "none",
-      cursor: "pointer",
-      zIndex: "10"
-    });
-    canvas.addEventListener("pointerdown", this.onPointerDown);
-    canvas.addEventListener("pointermove", this.onPointerMove);
-    canvas.addEventListener("pointerup", this.onPointerUp);
-    this.deps.container.appendChild(canvas);
+function sameBounds(a, b) {
+  return a.x === b.x && a.y === b.y && a.w === b.w && a.h === b.h;
+}
+var MinimapController = class {
+  constructor(viewport, canvas, options = {}) {
+    this.viewport = viewport;
     this.canvas = canvas;
+    this.width = options.width ?? DEFAULT_WIDTH;
+    this.height = options.height ?? DEFAULT_HEIGHT;
+    this.padding = options.padding ?? DEFAULT_PADDING;
+    this.background = options.background ?? null;
+    this.viewportStroke = options.viewportStroke ?? DEFAULT_VIEWPORT_STROKE;
+    this.debounceMs = options.debounceMs ?? DEFAULT_DEBOUNCE_MS2;
+    this.interactive = options.interactive !== false;
+    this.requestFrame = options.requestFrame ?? ((cb) => typeof requestAnimationFrame !== "undefined" ? requestAnimationFrame(cb) : 0);
+    this.cancelFrame = options.cancelFrame ?? ((id) => {
+      if (typeof cancelAnimationFrame !== "undefined") cancelAnimationFrame(id);
+    });
+    this.renderer.setStore(viewport.store);
+    this.renderer.setOnImageLoad(() => this.markSceneDirty());
+    this.applyCanvasSize();
+    const onScene = () => this.markSceneDirty();
+    this.unsubs.push(
+      viewport.store.on("add", onScene),
+      viewport.store.on("remove", onScene),
+      viewport.store.on("update", onScene),
+      viewport.store.on("clear", onScene),
+      viewport.layerManager.on("change", onScene),
+      viewport.camera.onChange(() => this.onViewChanged()),
+      viewport.onResize(() => this.onViewChanged())
+    );
+    if (this.interactive) {
+      canvas.style.touchAction = "none";
+      canvas.style.cursor = "pointer";
+      canvas.addEventListener("pointerdown", this.onPointerDown);
+      canvas.addEventListener("pointermove", this.onPointerMove);
+      canvas.addEventListener("pointerup", this.onPointerUp);
+      canvas.addEventListener("pointercancel", this.onPointerEnd);
+      canvas.addEventListener("lostpointercapture", this.onPointerEnd);
+    }
+    this.renderScene();
+    this.requestDraw();
   }
-  canvas;
-  rafId = null;
+  width;
+  height;
+  padding;
+  background;
+  viewportStroke;
+  debounceMs;
+  interactive;
+  requestFrame;
+  cancelFrame;
+  renderer = new ElementRenderer();
+  scene = null;
+  frameId = null;
+  debounceTimer = null;
   dragging = false;
-  scheduleDraw() {
-    if (this.rafId !== null) return;
-    this.rafId = this.deps.requestFrame(this.draw);
+  disposed = false;
+  unsubs = [];
+  setSize(width, height) {
+    if (this.disposed) return;
+    this.width = width;
+    this.height = height;
+    this.applyCanvasSize();
+    this.clearDebounce();
+    this.renderScene();
+    this.requestDraw();
   }
-  destroy() {
-    if (this.rafId !== null) {
-      this.deps.cancelFrame(this.rafId);
-      this.rafId = null;
+  requestDraw() {
+    if (this.disposed || this.frameId !== null) return;
+    this.frameId = this.requestFrame(this.draw);
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.clearDebounce();
+    if (this.frameId !== null) {
+      this.cancelFrame(this.frameId);
+      this.frameId = null;
+    }
+    for (const unsub of this.unsubs.splice(0)) unsub();
+    if (this.interactive) {
+      this.canvas.removeEventListener("pointerdown", this.onPointerDown);
+      this.canvas.removeEventListener("pointermove", this.onPointerMove);
+      this.canvas.removeEventListener("pointerup", this.onPointerUp);
+      this.canvas.removeEventListener("pointercancel", this.onPointerEnd);
+      this.canvas.removeEventListener("lostpointercapture", this.onPointerEnd);
+    }
+  }
+  clearDebounce() {
+    if (this.debounceTimer !== null) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+  }
+  dpr() {
+    return typeof devicePixelRatio !== "undefined" ? devicePixelRatio : 1;
+  }
+  applyCanvasSize() {
+    const dpr = this.dpr();
+    this.canvas.width = Math.max(1, Math.round(this.width * dpr));
+    this.canvas.height = Math.max(1, Math.round(this.height * dpr));
+  }
+  // Single source for both mapping bounds and rendering: layer-visible,
+  // grids excluded. (getElementBounds already returns null for grids, so they
+  // cannot extend the bounding box today — this filter makes the invariant
+  // structural instead of relying on that special case.)
+  sceneElements() {
+    return this.viewport.store.getAll().filter((el) => el.type !== "grid" && this.viewport.layerManager.isLayerVisible(el.layerId));
+  }
+  currentMapping() {
+    const viewportRect = this.viewport.getVisibleRect();
+    const content = getElementsBoundingBox(this.sceneElements());
+    return content ? unionBounds(content, viewportRect) : viewportRect;
+  }
+  onViewChanged() {
+    if (this.disposed) return;
+    const mapping = this.currentMapping();
+    if (!this.scene || !sameBounds(mapping, this.scene.mapping)) {
+      this.markSceneDirty();
     }
-    this.canvas.removeEventListener("pointerdown", this.onPointerDown);
-    this.canvas.removeEventListener("pointermove", this.onPointerMove);
-    this.canvas.removeEventListener("pointerup", this.onPointerUp);
-    this.canvas.remove();
+    this.requestDraw();
   }
-  currentTransform() {
-    const viewport = this.deps.getViewportRect();
-    const content = this.deps.getContentBounds();
-    const mapping = content ? unionBounds(content, viewport) : viewport;
-    return computeMinimapTransform(mapping, WIDTH, HEIGHT, PADDING);
+  markSceneDirty() {
+    if (this.disposed) return;
+    this.clearDebounce();
+    this.debounceTimer = setTimeout(() => {
+      this.debounceTimer = null;
+      this.renderScene();
+      this.requestDraw();
+    }, this.debounceMs);
+  }
+  renderScene() {
+    if (this.disposed) return;
+    const dpr = this.dpr();
+    const mapping = this.currentMapping();
+    const transform = computeMinimapTransform(mapping, this.width, this.height, this.padding);
+    const sceneCanvas = document.createElement("canvas");
+    sceneCanvas.width = Math.max(1, Math.round(this.width * dpr));
+    sceneCanvas.height = Math.max(1, Math.round(this.height * dpr));
+    const ctx = sceneCanvas.getContext("2d");
+    if (!ctx) return;
+    const byLayer = /* @__PURE__ */ new Map();
+    for (const el of this.sceneElements()) {
+      let list = byLayer.get(el.layerId);
+      if (!list) {
+        list = [];
+        byLayer.set(el.layerId, list);
+      }
+      list.push(el);
+    }
+    for (const layer of this.viewport.layerManager.getLayers()) {
+      const els = byLayer.get(layer.id);
+      if (!els || els.length === 0) continue;
+      const opacity = layer.opacity;
+      if (opacity >= 1) {
+        this.renderLayerElements(ctx, els, transform, dpr);
+        continue;
+      }
+      const layerCanvas = document.createElement("canvas");
+      layerCanvas.width = sceneCanvas.width;
+      layerCanvas.height = sceneCanvas.height;
+      const layerCtx = layerCanvas.getContext("2d");
+      if (!layerCtx) continue;
+      this.renderLayerElements(layerCtx, els, transform, dpr);
+      ctx.save();
+      ctx.globalAlpha = opacity;
+      ctx.drawImage(layerCanvas, 0, 0);
+      ctx.restore();
+    }
+    this.scene = { canvas: sceneCanvas, transform, mapping };
+  }
+  renderLayerElements(ctx, elements, t, dpr) {
+    for (const el of elements) {
+      if (DOM_FALLBACK_TYPES.has(el.type)) {
+        const b = getElementBounds(el);
+        if (!b) continue;
+        const tl = worldToMini(t, { x: b.x, y: b.y });
+        ctx.save();
+        ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+        ctx.fillStyle = elementColor(el);
+        ctx.fillRect(tl.x, tl.y, Math.max(1, b.w * t.scale), Math.max(1, b.h * t.scale));
+        ctx.restore();
+        continue;
+      }
+      ctx.save();
+      ctx.setTransform(dpr * t.scale, 0, 0, dpr * t.scale, dpr * t.offsetX, dpr * t.offsetY);
+      this.renderer.renderCanvasElement(ctx, el);
+      ctx.restore();
+    }
   }
   draw = () => {
-    this.rafId = null;
+    this.frameId = null;
+    if (this.disposed) return;
     const ctx = this.canvas.getContext("2d");
     if (!ctx) return;
-    const t = this.currentTransform();
-    const viewport = this.deps.getViewportRect();
-    ctx.clearRect(0, 0, WIDTH, HEIGHT);
-    for (const el of this.deps.getElements()) {
-      const b = getElementBounds(el);
-      if (!b) continue;
-      const tl = worldToMini(t, { x: b.x, y: b.y });
-      ctx.fillStyle = elementColor(el);
-      ctx.fillRect(tl.x, tl.y, Math.max(1, b.w * t.scale), Math.max(1, b.h * t.scale));
-    }
-    const vtl = worldToMini(t, { x: viewport.x, y: viewport.y });
-    ctx.strokeStyle = VIEWPORT_STROKE;
+    const dpr = this.dpr();
+    ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+    ctx.clearRect(0, 0, this.width, this.height);
+    if (this.background) {
+      ctx.fillStyle = this.background;
+      ctx.fillRect(0, 0, this.width, this.height);
+    }
+    const scene = this.scene;
+    if (!scene) return;
+    ctx.drawImage(scene.canvas, 0, 0, this.width, this.height);
+    const viewportRect = this.viewport.getVisibleRect();
+    const tl = worldToMini(scene.transform, { x: viewportRect.x, y: viewportRect.y });
+    ctx.strokeStyle = this.viewportStroke;
     ctx.lineWidth = 1.5;
-    ctx.strokeRect(vtl.x, vtl.y, viewport.w * t.scale, viewport.h * t.scale);
+    ctx.strokeRect(
+      tl.x,
+      tl.y,
+      viewportRect.w * scene.transform.scale,
+      viewportRect.h * scene.transform.scale
+    );
   };
+  navTransform() {
+    return this.scene?.transform ?? computeMinimapTransform(this.currentMapping(), this.width, this.height, this.padding);
+  }
   navigateFromEvent(e) {
     const rect = this.canvas.getBoundingClientRect();
-    const point = { x: e.clientX - rect.left, y: e.clientY - rect.top };
-    const world = miniToWorld(this.currentTransform(), point);
-    this.deps.navigateTo(world);
+    const scaleX = rect.width > 0 ? this.width / rect.width : 1;
+    const scaleY = rect.height > 0 ? this.height / rect.height : 1;
+    const point = {
+      x: (e.clientX - rect.left) * scaleX,
+      y: (e.clientY - rect.top) * scaleY
+    };
+    const world = miniToWorld(this.navTransform(), point);
+    this.viewport.centerCameraAt(world);
   }
   onPointerDown = (e) => {
     e.stopPropagation();
@@ -4898,6 +5058,45 @@ var Minimap = class {
     } catch {
     }
   };
+  // pointercancel / lostpointercapture: a browser gesture or interrupted touch
+  // can end the interaction without a pointerup — the drag must not stick.
+  onPointerEnd = () => {
+    this.dragging = false;
+  };
+};
+
+// src/canvas/minimap.ts
+var WIDTH = 200;
+var HEIGHT = 140;
+var MARGIN = 16;
+var Minimap = class {
+  canvas;
+  controller;
+  constructor(container, viewport) {
+    const canvas = document.createElement("canvas");
+    Object.assign(canvas.style, {
+      position: "absolute",
+      right: `${MARGIN}px`,
+      bottom: `${MARGIN}px`,
+      width: `${WIDTH}px`,
+      height: `${HEIGHT}px`,
+      background: "rgba(255,255,255,0.85)",
+      border: "1px solid rgba(0,0,0,0.15)",
+      borderRadius: "4px",
+      zIndex: "10"
+    });
+    canvas.dataset.fieldnotesMinimap = "true";
+    container.appendChild(canvas);
+    this.canvas = canvas;
+    this.controller = new MinimapController(viewport, canvas, { width: WIDTH, height: HEIGHT });
+  }
+  scheduleDraw() {
+    this.controller.requestDraw();
+  }
+  destroy() {
+    this.controller.dispose();
+    this.canvas.remove();
+  }
 };
 
 // src/canvas/viewport-dom.ts
@@ -5656,6 +5855,19 @@ function computeBounds(elements, padding) {
     h: maxY - minY + padding * 2
   };
 }
+function resolveExportBounds(region, elements, padding) {
+  if (!region) return computeBounds(elements, padding);
+  const finite = Number.isFinite(region.x) && Number.isFinite(region.y) && Number.isFinite(region.w) && Number.isFinite(region.h);
+  if (!finite || region.w <= 0 || region.h <= 0) {
+    throw new RangeError("region must have finite coordinates and positive w/h");
+  }
+  return {
+    x: region.x - padding,
+    y: region.y - padding,
+    w: region.w + padding * 2,
+    h: region.h + padding * 2
+  };
+}
 function renderGridForBounds(ctx, grid, bounds) {
   const visibleBounds = {
     minX: bounds.x,
@@ -5698,6 +5910,29 @@ function nonNegativeOption(value, fallback, name) {
   }
   return resolved;
 }
+function fitExportScale(bounds, requestedScale, options) {
+  const maxDimension = positiveOption(options.maxDimension, DEFAULT_MAX_DIMENSION, "maxDimension");
+  const maxPixels = positiveOption(options.maxPixels, DEFAULT_MAX_PIXELS, "maxPixels");
+  const fits = (scale) => {
+    const w = Math.ceil(bounds.w * scale);
+    const h = Math.ceil(bounds.h * scale);
+    return w <= maxDimension && h <= maxDimension && w * h <= maxPixels;
+  };
+  if (fits(requestedScale)) return requestedScale;
+  const analytical = Math.min(
+    maxDimension / Math.max(bounds.w, bounds.h),
+    Math.sqrt(maxPixels) / Math.sqrt(bounds.w) / Math.sqrt(bounds.h)
+  );
+  let hi = Math.min(requestedScale, analytical);
+  if (fits(hi)) return hi;
+  let lo = 0;
+  for (let i = 0; i < 40; i++) {
+    const mid = (lo + hi) / 2;
+    if (fits(mid)) lo = mid;
+    else hi = mid;
+  }
+  return lo;
+}
 function assertExportSize(width, height, options) {
   const maxDimension = positiveOption(options.maxDimension, DEFAULT_MAX_DIMENSION, "maxDimension");
   const maxPixels = positiveOption(options.maxPixels, DEFAULT_MAX_PIXELS, "maxPixels");
@@ -5772,10 +6007,23 @@ function loadImages(elements, options = {}) {
   });
 }
 async function exportImage(store, options = {}, layerManager) {
-  const scale = positiveOption(options.scale, 2, "scale");
+  const requestedScale = positiveOption(options.scale, 2, "scale");
+  const scaleMode = options.scaleMode ?? "exact";
+  if (scaleMode !== "exact" && scaleMode !== "fit") {
+    throw new RangeError(`scaleMode must be 'exact' or 'fit'`);
+  }
   const padding = nonNegativeOption(options.padding, 0, "padding");
   validateExportResourceOptions(options);
   validateHtmlExportOptions(options);
+  const format = options.format ?? "png";
+  if (format !== "png" && format !== "jpeg") {
+    throw new RangeError(`format must be 'png' or 'jpeg'`);
+  }
+  if (options.quality !== void 0) {
+    if (!Number.isFinite(options.quality) || options.quality <= 0 || options.quality > 1) {
+      throw new RangeError("quality must be a finite number in (0, 1]");
+    }
+  }
   const background = options.background ?? "#ffffff";
   const filter = options.filter;
   const allElements = store.getAll();
@@ -5783,8 +6031,9 @@ async function exportImage(store, options = {}, layerManager) {
   if (filter) {
     visibleElements = visibleElements.filter(filter);
   }
-  const bounds = computeBounds(visibleElements, padding);
+  const bounds = resolveExportBounds(options.region, visibleElements, padding);
   if (!bounds) return null;
+  const scale = scaleMode === "fit" ? fitExportScale(bounds, requestedScale, options) : requestedScale;
   const width = Math.ceil(bounds.w * scale);
   const height = Math.ceil(bounds.h * scale);
   assertExportSize(width, height, options);
@@ -5886,8 +6135,9 @@ async function exportImage(store, options = {}, layerManager) {
     renderGridForBounds(ctx, grid, bounds);
     ctx.restore();
   }
+  const mimeType = format === "jpeg" ? "image/jpeg" : "image/png";
   return new Promise((resolve) => {
-    canvas.toBlob((blob) => resolve(blob), "image/png");
+    canvas.toBlob((blob) => resolve(blob), mimeType, options.quality);
   });
 }
 
@@ -8079,25 +8329,7 @@ var Viewport = class {
     }
     this.unsubToolChange = this.toolManager.onChange(() => this.contextMenu?.close());
     if (options.minimap) {
-      const visibleEls = () => this.store.getAll().filter((el) => this.layerManager.isLayerVisible(el.layerId));
-      this.minimap = new Minimap({
-        container: this.wrapper,
-        getElements: visibleEls,
-        getContentBounds: () => getElementsBoundingBox(visibleEls()),
-        getViewportRect: () => this.camera.getVisibleRect(this.canvasEl.clientWidth, this.canvasEl.clientHeight),
-        navigateTo: (w) => {
-          const z = this.camera.zoom;
-          this.camera.moveTo(
-            this.canvasEl.clientWidth / 2 - w.x * z,
-            this.canvasEl.clientHeight / 2 - w.y * z
-          );
-        },
-        requestFrame: (cb) => typeof requestAnimationFrame !== "undefined" ? requestAnimationFrame(cb) : 0,
-        cancelFrame: (id) => {
-          if (typeof cancelAnimationFrame !== "undefined") cancelAnimationFrame(id);
-        }
-      });
-      this.minimap.scheduleDraw();
+      this.minimap = new Minimap(this.wrapper, this);
     }
     this.domNodeManager = new DomNodeManager({
       domLayer: this.paintStack,
@@ -8133,7 +8365,6 @@ var Viewport = class {
       this.applyCameraTransform();
       this.noteEditor.updateToolbarPosition();
       this.contextMenu?.close();
-      this.minimap?.scheduleDraw();
       this.requestRender();
     });
     this.gridController = new GridController({
@@ -8148,7 +8379,6 @@ var Viewport = class {
       this.store.on("add", (el) => {
         if (el.type === "grid") this.gridController.syncContext();
         this.renderLoop.markLayerDirty(el.layerId);
-        this.minimap?.scheduleDraw();
         this.requestRender();
       }),
       this.store.on("remove", (el) => {
@@ -8156,7 +8386,6 @@ var Viewport = class {
         this.unbindArrowsFrom(el);
         this.domNodeManager.removeDomNode(el.id);
         this.renderLoop.markLayerDirty(el.layerId);
-        this.minimap?.scheduleDraw();
         this.requestRender();
       }),
       this.store.on("update", ({ previous, current }) => {
@@ -8165,21 +8394,18 @@ var Viewport = class {
         if (previous.layerId !== current.layerId) {
           this.renderLoop.markLayerDirty(previous.layerId);
         }
-        this.minimap?.scheduleDraw();
         this.requestRender();
       }),
       this.store.on("clear", () => {
         this.domNodeManager.clearDomNodes();
         this.renderLoop.markAllLayersDirty();
         this.gridController.syncContext();
-        this.minimap?.scheduleDraw();
         this.requestRender();
       })
     ];
     this.layerManager.on("change", () => {
       this.toolContext.activeLayerId = this.layerManager.activeLayerId;
       this.renderLoop.markAllLayersDirty();
-      this.minimap?.scheduleDraw();
       this.requestRender();
     });
     this.interactions = new ViewportInteractions({
@@ -8243,6 +8469,7 @@ var Viewport = class {
   contextMenu = null;
   minimap = null;
   htmlRenderers = /* @__PURE__ */ new Map();
+  resizeListeners = /* @__PURE__ */ new Set();
   get ctx() {
     return this.canvasEl.getContext("2d");
   }
@@ -8267,6 +8494,27 @@ var Viewport = class {
     if (!bbox) return;
     this.camera.fitToContent(bbox, this.wrapper.clientWidth, this.wrapper.clientHeight, padding);
   }
+  /** World-space rectangle currently visible through the canvas. */
+  getVisibleRect() {
+    return this.camera.getVisibleRect(this.canvasEl.clientWidth, this.canvasEl.clientHeight);
+  }
+  /** Centers the camera on a world point without changing zoom. */
+  centerCameraAt(world) {
+    const z = this.camera.zoom;
+    this.camera.moveTo(
+      this.canvasEl.clientWidth / 2 - world.x * z,
+      this.canvasEl.clientHeight / 2 - world.y * z
+    );
+  }
+  /**
+   * Notifies after the host container resizes (ResizeObserver-driven). A resize
+   * changes the visible world rect without a camera event; overlays such as the
+   * minimap subscribe to stay current. Returns an idempotent unsubscribe.
+   */
+  onResize(listener) {
+    this.resizeListeners.add(listener);
+    return () => this.resizeListeners.delete(listener);
+  }
   requestRender() {
     this.renderLoop.requestRender();
   }
@@ -8571,6 +8819,7 @@ var Viewport = class {
     this.unsubStore.forEach((fn) => fn());
     this.resizeObserver?.disconnect();
     this.resizeObserver = null;
+    this.resizeListeners.clear();
     this.wrapper.remove();
   }
   stopInteracting() {
@@ -8620,6 +8869,7 @@ var Viewport = class {
     const dpr = typeof devicePixelRatio !== "undefined" ? devicePixelRatio : 1;
     this.renderLoop.setCanvasSize(rect.width * dpr, rect.height * dpr);
     this.requestRender();
+    this.resizeListeners.forEach((fn) => fn());
   }
   observeResize() {
     if (typeof ResizeObserver === "undefined") return;
@@ -8659,7 +8909,7 @@ function toLaserTrailPresence(emission) {
   };
 }
 var DEFAULT_COLOR = "#ff3b30";
-var DEFAULT_WIDTH = 4;
+var DEFAULT_WIDTH2 = 4;
 var DEFAULT_FADE_MS = 1200;
 var DEFAULT_MAX_POINTS = 512;
 var RemoteLaserOverlay = class {
@@ -8675,7 +8925,7 @@ var RemoteLaserOverlay = class {
   constructor(host, options = {}) {
     this.host = host;
     this.color = options.color ?? DEFAULT_COLOR;
-    this.width = options.width ?? DEFAULT_WIDTH;
+    this.width = options.width ?? DEFAULT_WIDTH2;
     this.fadeMs = options.fadeMs ?? DEFAULT_FADE_MS;
     this.maxPointsPerSender = options.maxPointsPerSender ?? DEFAULT_MAX_POINTS;
     this.unregister = host.registerOverlay((ctx) => this.renderTrails(ctx));
@@ -11904,7 +12154,7 @@ var TemplateTool = class {
 
 // src/tools/laser-tool.ts
 var DEFAULT_COLOR5 = "#ff3b30";
-var DEFAULT_WIDTH2 = 4;
+var DEFAULT_WIDTH3 = 4;
 var DEFAULT_FADE_MS3 = 1200;
 var LaserTool = class {
   name;
@@ -11920,7 +12170,7 @@ var LaserTool = class {
   constructor(options = {}) {
     this.name = options.name ?? "laser";
     this.color = options.color ?? DEFAULT_COLOR5;
-    this.width = options.width ?? DEFAULT_WIDTH2;
+    this.width = options.width ?? DEFAULT_WIDTH3;
     this.fadeMs = options.fadeMs ?? DEFAULT_FADE_MS3;
   }
   now() {
@@ -12167,7 +12417,7 @@ var PingTool = class {
 };
 
 // src/index.ts
-var VERSION = "0.57.0";
+var VERSION = "0.59.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ArrowTool,
@@ -12187,6 +12437,7 @@ var VERSION = "0.57.0";
   MEASURE_PRESENCE_KIND,
   MeasureTool,
   MemoryAdapter,
+  MinimapController,
   NoteTool,
   PING_PRESENCE_KIND,
   PencilTool,