matterviz 0.3.2 → 0.3.4

package/dist/plot/reference-line.js

@@ -48,7 +48,10 @@ export function normalize_value(value) {
     return 0;
 }
 // Normalize a point tuple
-export const normalize_point = (point) => [normalize_value(point[0]), normalize_value(point[1])];
+export const normalize_point = (point) => [
+    normalize_value(point[0]),
+    normalize_value(point[1]),
+];
 // Clip a line segment to a rectangle using Liang-Barsky algorithm
 // Returns clipped [x1, y1, x2, y2] or null if segment is entirely outside
 function clip_segment_to_rect(p1x, p1y, p2x, p2y, x_min, x_max, y_min, y_max) {
@@ -81,7 +84,7 @@ function clip_segment_to_rect(p1x, p1y, p2x, p2y, x_min, x_max, y_min, y_max) {
 }
 // Compute the screen coordinates for a reference line
 // Returns [x1, y1, x2, y2] in pixel coordinates, or null if line is not visible
-export function resolve_line_endpoints(ref_line, { x_min, x_max, y_min, y_max }, { x_scale, x2_scale, y_scale, y2_scale }) {
+export function resolve_line_endpoints(ref_line, { x_min, x_max, y_min, y_max, }, { x_scale, x2_scale, y_scale, y2_scale, }) {
     // Determine which scales to use based on axis assignment
     const active_x_scale = ref_line.x_axis === `x2` && x2_scale ? x2_scale : x_scale;
     const active_y_scale = ref_line.y_axis === `y2` && y2_scale ? y2_scale : y_scale;
@@ -243,7 +246,7 @@ export function calculate_annotation_position(x1, y1, x2, y2, annotation) {
         if (side === `above` || side === `below`) {
             // In SVG, y increases downward. Flip sign if 'above' and perpendicular points down (ny > 0),
             // or if 'below' and perpendicular points up (ny <= 0), to ensure offset is in correct direction
-            const sign = (side === `above`) === (ny > 0) ? -1 : 1;
+            const sign = (side === `above`) === ny > 0 ? -1 : 1;
             perp_x = sign * nx * gap;
             perp_y = sign * ny * gap;
         }
@@ -267,8 +270,7 @@ export function calculate_annotation_position(x1, y1, x2, y2, annotation) {
         text_anchor = `start`; // text starts at gap point, extends right
     }
     else {
-        text_anchor = ({ start: `start`, end: `end`, center: `middle` }[position] ??
-            `middle`);
+        text_anchor = ({ start: `start`, end: `end`, center: `middle` }[position] ?? `middle`);
     }
     const dominant_baseline = ({
         above: `auto`,

package/dist/plot/scales.js

@@ -1,5 +1,5 @@
 import * as math from '../math';
-import { get_arcsinh_threshold, get_scale_type_name, is_time_scale, } from './types';
+import { get_arcsinh_threshold, get_scale_type_name, is_time_scale } from './types';
 import { extent, range } from 'd3-array';
 import { scaleLinear, scaleLog, scaleSequential, scaleSequentialLog, scaleTime, } from 'd3-scale';
 import * as d3_sc from 'd3-scale-chromatic';
@@ -98,8 +98,8 @@ export function generate_arcsinh_ticks(min, max, threshold = 1, count = 10) {
     if (hi <= 0) {
         // Negative range: mirror the positive logic
         return generate_positive_arcsinh_ticks(-hi, -lo, safe_threshold, count)
-            .map((t) => -t)
-            .reverse();
+            .map((tick) => -tick)
+            .toReversed();
     }
     // Mixed range: symmetric ticks around zero (includes_zero is always true here)
     // For very small counts, we prioritize zero as the most meaningful tick
@@ -110,7 +110,7 @@ export function generate_arcsinh_ticks(min, max, threshold = 1, count = 10) {
     ticks.push(...pos_ticks.filter((t) => t > 0));
     // Add negative ticks (mirror of positive)
     const neg_ticks = generate_positive_arcsinh_ticks(0, -lo, safe_threshold, half_count);
-    ticks.push(...neg_ticks.filter((t) => t > 0).map((t) => -t));
+    ticks.push(...neg_ticks.filter((tick) => tick > 0).map((tick) => -tick));
     // For small counts where half_count is 0 or 1, ensure at least some boundary coverage
     if (half_count <= 1 && count >= 2) {
         // Add boundaries if not already present and we have room
@@ -185,7 +185,9 @@ export function create_scale(scale_type, domain, range) {
     const [min_val, max_val] = domain;
     const type_name = get_scale_type_name(scale_type);
     if (type_name === `log`) {
-        return scaleLog().domain([Math.max(min_val, math.LOG_EPS), max_val]).range(range);
+        return scaleLog()
+            .domain([Math.max(min_val, math.LOG_EPS), max_val])
+            .range(range);
     }
     if (type_name === `arcsinh`) {
         const threshold = get_arcsinh_threshold(scale_type);
@@ -221,9 +223,10 @@ options = {}) {
         const time_scale = scaleTime().domain([new Date(min_val), new Date(max_val)]);
         let count = 10; // default
         if (typeof ticks_option === `number`) {
-            count = ticks_option < 0
-                ? Math.ceil((max_val - min_val) / Math.abs(ticks_option) / 86_400_000) // milliseconds per day
-                : ticks_option;
+            count =
+                ticks_option < 0
+                    ? Math.ceil((max_val - min_val) / Math.abs(ticks_option) / 86_400_000) // milliseconds per day
+                    : ticks_option;
         }
         else if (typeof ticks_option === `string`) {
             count = ticks_option === `day` ? 30 : ticks_option === `month` ? 12 : 10;
@@ -248,9 +251,7 @@ options = {}) {
     // Arcsinh scale ticks
     if (type_name === `arcsinh`) {
         const threshold = get_arcsinh_threshold(scale_type);
-        const tick_count = typeof ticks_option === `number` && ticks_option > 0
-            ? ticks_option
-            : default_count;
+        const tick_count = typeof ticks_option === `number` && ticks_option > 0 ? ticks_option : default_count;
         return generate_arcsinh_ticks(min_val, max_val, threshold, tick_count);
     }
     // Linear scale with interval (negative number indicates interval)
@@ -260,9 +261,7 @@ options = {}) {
         return range(start, max_val + interval * interval_padding, interval);
     }
     // Default ticks using scale function
-    const tick_count = typeof ticks_option === `number` && ticks_option > 0
-        ? ticks_option
-        : default_count;
+    const tick_count = typeof ticks_option === `number` && ticks_option > 0 ? ticks_option : default_count;
     const ticks = scale_fn.ticks(tick_count);
     return ticks.map(Number);
 }
@@ -274,9 +273,7 @@ export function calculate_domain(values, scale_type = `linear`) {
     const type_name = get_scale_type_name(scale_type);
     // Only log scale needs domain clamping to positive values
     // Arcsinh and linear can handle any values
-    return type_name === `log`
-        ? [Math.max(min_val, math.LOG_EPS), max_val]
-        : [min_val, max_val];
+    return type_name === `log` ? [Math.max(min_val, math.LOG_EPS), max_val] : [min_val, max_val];
 }
 // Advanced domain calculation with padding and nice boundaries (from ScatterPlot)
 export function get_nice_data_range(points, get_value, range, scale_type, padding_factor, is_time = false) {
@@ -376,15 +373,11 @@ export function generate_log_ticks(min, max, ticks_option) {
     const max_power = Math.ceil(Math.log10(max));
     // For very wide ranges, extend the range to include more ticks
     const range_size = max_power - min_power;
-    const extended_min_power = range_size <= 2
-        ? min_power - 1
-        : min_power - Math.max(1, Math.floor(range_size / 4));
+    const extended_min_power = range_size <= 2 ? min_power - 1 : min_power - Math.max(1, Math.floor(range_size / 4));
     const extended_max_power = range_size <= 2 ? max_power + 1 : max_power;
-    const powers = range(extended_min_power, extended_max_power + 1).map((p) => Math.pow(10, p));
+    const powers = range(extended_min_power, extended_max_power + 1).map((power) => Math.pow(10, power));
     // For narrow ranges, include intermediate values
-    if (max_power - min_power < 3 &&
-        typeof ticks_option === `number` &&
-        ticks_option > 5) {
+    if (max_power - min_power < 3 && typeof ticks_option === `number` && ticks_option > 5) {
         const detailed_ticks = [];
         powers.forEach((power) => {
             detailed_ticks.push(power);
@@ -393,9 +386,9 @@ export function generate_log_ticks(min, max, ticks_option) {
             if (power * 5 <= Math.pow(10, extended_max_power))
                 detailed_ticks.push(power * 5);
         });
-        return detailed_ticks.filter((t) => t >= min && t <= max);
+        return detailed_ticks.filter((tick) => tick >= min && tick <= max);
     }
-    return powers.filter((p) => p >= min && p <= max);
+    return powers.filter((power) => power >= min && power <= max);
 }
 // Get custom label for a tick value if provided, otherwise return null
 export function get_tick_label(tick_value, ticks_option) {
@@ -406,18 +399,13 @@ export function get_tick_label(tick_value, ticks_option) {
 }
 // Create a color scale function from configuration
 export function create_color_scale(color_scale_config, auto_color_range) {
-    const scheme = typeof color_scale_config === `string`
-        ? color_scale_config
-        : color_scale_config.scheme;
+    const scheme = typeof color_scale_config === `string` ? color_scale_config : color_scale_config.scheme;
     const interpolator = (typeof d3_sc[scheme] === `function`
         ? d3_sc[scheme]
         : d3_sc.interpolateViridis);
-    const [min_val, max_val] = (typeof color_scale_config === `string`
-        ? undefined
-        : color_scale_config.value_range) ?? auto_color_range;
-    const scale_type = typeof color_scale_config === `string`
-        ? undefined
-        : color_scale_config.type;
+    const [min_val, max_val] = (typeof color_scale_config === `string` ? undefined : color_scale_config.value_range) ??
+        auto_color_range;
+    const scale_type = typeof color_scale_config === `string` ? undefined : color_scale_config.type;
     const type_name = get_scale_type_name(scale_type);
     if (type_name === `log`) {
         return scaleSequentialLog(interpolator).domain([
@@ -465,7 +453,7 @@ function create_arcsinh_color_scale(interpolator, initial_domain, threshold) {
 export function create_size_scale(config, all_size_values) {
     const [min_radius, max_radius] = config.radius_range ?? [2, 10];
     const auto_range = all_size_values.length > 0
-        ? extent(all_size_values.filter((v) => v !== null))
+        ? extent(all_size_values.filter((val) => val !== null))
         : [0, 1];
     const [min_val, max_val] = config.value_range ?? auto_range;
     const safe_min = min_val ?? 0;

package/dist/plot/types.d.ts

@@ -1,10 +1,8 @@
 import type { D3SymbolName } from '../labels';
 import type { Vec2, Vec3 } from '../math';
 import type DraggablePane from '../overlays/DraggablePane.svelte';
-import type { SimulationNodeDatum } from 'd3-force';
 import type { ComponentProps, Snippet } from 'svelte';
 import type { HTMLAttributes } from 'svelte/elements';
-import type ColorBar from './ColorBar.svelte';
 import type PlotLegend from './PlotLegend.svelte';
 import type { TicksOption } from './scales';
 export interface TweenedOptions<T> {
@@ -200,33 +198,23 @@ export type QuadrantCounts = {
     bottom_left: number;
     bottom_right: number;
 };
-export interface LabelNode<Metadata = Record<string, unknown>> extends SimulationNodeDatum {
-    id: string;
-    anchor_x: number;
-    anchor_y: number;
-    point_node: InternalPoint<Metadata>;
-    label_width: number;
-    label_height: number;
+export interface LabelPlacementWeights {
+    overlap?: number;
+    marker?: number;
+    leader_cross?: number;
+    leader_text?: number;
+    distance?: number;
+    bounds?: number;
 }
 export interface LabelPlacementConfig {
-    collision_strength: number;
-    link_strength: number;
-    link_distance: number;
-    placement_ticks: number;
-    link_distance_range?: [number | null, number | null];
+    sa_iterations?: number;
+    weights?: LabelPlacementWeights;
+    leader_line_threshold?: number;
+    max_labels?: number;
 }
 export type HoverConfig = {
     threshold_px: number;
 };
-export interface AnchorNode extends SimulationNodeDatum {
-    id: string;
-    fx: number;
-    fy: number;
-    point_radius: number;
-    show_color_bar?: boolean;
-    color_bar?: ComponentProps<typeof ColorBar> | null;
-    label_placement_config?: Partial<LabelPlacementConfig>;
-}
 export type LegendConfig = Omit<ComponentProps<typeof PlotLegend>, `series_data` | `on_drag_start` | `on_drag` | `on_drag_end`> & {
     margin?: number | Sides;
     tween?: TweenedOptions<XyObj>;

package/dist/plot/types.js

@@ -1,7 +1,7 @@
 // Type guard for select value narrowing (avoids unsafe casts)
-const SCALE_TYPE_NAMES = [`linear`, `log`, `arcsinh`, `time`];
+const SCALE_TYPE_NAMES = new Set([`linear`, `log`, `arcsinh`, `time`]);
 export function is_scale_type_name(val) {
-    return SCALE_TYPE_NAMES.includes(val);
+    return SCALE_TYPE_NAMES.has(val);
 }
 // Helper to normalize ScaleType to base type name
 export function get_scale_type_name(scale_type) {
@@ -33,9 +33,9 @@ export function is_time_scale(scale_type, format) {
     return format?.startsWith(`%`) ?? false;
 }
 // Type guard for select value narrowing (avoids unsafe casts)
-const Y2_SYNC_MODES = [`none`, `synced`, `align`];
+const Y2_SYNC_MODES = new Set([`none`, `synced`, `align`]);
 export function is_y2_sync_mode(val) {
-    return Y2_SYNC_MODES.includes(val);
+    return Y2_SYNC_MODES.has(val);
 }
 export const LINE_TYPES = [`solid`, `dashed`, `dotted`];
 // Define grid cell identifiers
@@ -50,15 +50,10 @@ export const CELLS_3X3 = [
     `bottom-center`,
     `bottom-right`,
 ];
-export const CORNER_CELLS = [
-    `top-left`,
-    `top-right`,
-    `bottom-left`,
-    `bottom-right`,
-];
+export const CORNER_CELLS = [`top-left`, `top-right`, `bottom-left`, `bottom-right`];
 // Default grid line style (SSOT for all plot components)
 export const DEFAULT_GRID_STYLE = {
-    'stroke': `var(--border-color, gray)`,
+    stroke: `var(--border-color, gray)`,
     'stroke-dasharray': `4`,
     'stroke-width': `1`,
 };

package/dist/plot/utils/label-placement.d.ts

@@ -1,21 +1,38 @@
 import type { AxisConfig, DataSeries, XyObj } from '..';
 import type { PlotScaleFn } from '../scales';
-import type { LabelPlacementConfig } from '../types';
-type ScaleFn = PlotScaleFn;
-export interface AnchorNode {
-    id: string;
-    fx: number;
-    fy: number;
-    point_radius: number;
+import type { LabelPlacementConfig, LabelPlacementWeights } from '../types';
+export interface Rect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
 }
-export declare function compute_label_positions(filtered_series: DataSeries[], config: LabelPlacementConfig & {
-    max_labels?: number;
-    charge_strength?: number;
-    charge_distance_max?: number;
-}, scales: {
-    x_scale_fn: ScaleFn;
-    y_scale_fn: ScaleFn;
-    y2_scale_fn: ScaleFn;
+export interface PlotBounds {
+    min_x: number;
+    min_y: number;
+    max_x: number;
+    max_y: number;
+}
+interface AnchorInfo {
+    x: number;
+    y: number;
+    radius: number;
+}
+interface LabelState extends Rect {
+    anchor_idx: number;
+}
+export declare function parse_font_size(size_str?: string): number;
+export declare function rect_overlap_area(a: Rect, b: Rect): number;
+export declare function rect_circle_overlap(rect: Rect, cx: number, cy: number, radius: number): number;
+export declare function segments_intersect(ax1: number, ay1: number, ax2: number, ay2: number, bx1: number, by1: number, bx2: number, by2: number): boolean;
+export declare function segment_rect_intersects(sx1: number, sy1: number, sx2: number, sy2: number, rect: Rect): boolean;
+export declare function rect_out_of_bounds_area(rect: Rect, bounds: PlotBounds): number;
+export declare function generate_candidates(ax: number, ay: number, point_radius: number, label_w: number, label_h: number, gap: number): XyObj[];
+export declare function compute_delta_energy(labels: LabelState[], anchors: AnchorInfo[], changed_idx: number, old_state: LabelState, new_state: LabelState, weights: Required<LabelPlacementWeights>, bounds: PlotBounds): number;
+export declare function compute_label_positions(filtered_series: DataSeries[], config: LabelPlacementConfig, scales: {
+    x_scale_fn: PlotScaleFn;
+    y_scale_fn: PlotScaleFn;
+    y2_scale_fn: PlotScaleFn;
     x_axis: AxisConfig;
 }, bounds: {
     width: number;

package/dist/plot/utils/label-placement.js

@@ -1,21 +1,148 @@
 import { is_time_scale } from '../types';
-import { forceCollide, forceLink, forceManyBody, forceSimulation } from 'd3-force';
-const is_label_node = (node) => `label_width` in node;
-function parse_font_size(size_str) {
+const DEFAULT_WEIGHTS = {
+    overlap: 30,
+    marker: 100,
+    leader_cross: 10,
+    leader_text: 8,
+    distance: 0.5,
+    bounds: 100,
+};
+export function parse_font_size(size_str) {
     if (!size_str)
         return 12;
-    const match = size_str.match(/^(\d+(?:\.\d+)?)(px|em|rem)?$/);
+    const match = /^(\d+(?:\.\d+)?)(px|em|rem)?$/.exec(size_str);
     if (!match)
         return 12;
     const value = parseFloat(match[1]);
     return match[2] === `em` || match[2] === `rem` ? value * 16 : value;
 }
+// === Geometry helpers ===
+export function rect_overlap_area(a, b) {
+    const ox = Math.max(0, Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x));
+    const oy = Math.max(0, Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y));
+    return ox * oy;
+}
+export function rect_circle_overlap(rect, cx, cy, radius) {
+    // Inflate rect by radius to create an exclusion zone around the marker
+    const left = rect.x - radius;
+    const top = rect.y - radius;
+    const right = rect.x + rect.w + radius;
+    const bottom = rect.y + rect.h + radius;
+    if (cx < left || cx > right || cy < top || cy > bottom)
+        return 0;
+    // Penalty proportional to how deep the marker center is inside the exclusion zone
+    const dx = Math.min(cx - left, right - cx);
+    const dy = Math.min(cy - top, bottom - cy);
+    return Math.min(dx, dy) + radius;
+}
+export function segments_intersect(ax1, ay1, ax2, ay2, bx1, by1, bx2, by2) {
+    const d1x = ax2 - ax1, d1y = ay2 - ay1;
+    const d2x = bx2 - bx1, d2y = by2 - by1;
+    const cross = d1x * d2y - d1y * d2x;
+    if (Math.abs(cross) < 1e-10)
+        return false;
+    const t_val = ((bx1 - ax1) * d2y - (by1 - ay1) * d2x) / cross;
+    const u_val = ((bx1 - ax1) * d1y - (by1 - ay1) * d1x) / cross;
+    return t_val > 0 && t_val < 1 && u_val > 0 && u_val < 1;
+}
+export function segment_rect_intersects(sx1, sy1, sx2, sy2, rect) {
+    const rx = rect.x, ry = rect.y, rx2 = rx + rect.w, ry2 = ry + rect.h;
+    return (segments_intersect(sx1, sy1, sx2, sy2, rx, ry, rx2, ry) ||
+        segments_intersect(sx1, sy1, sx2, sy2, rx2, ry, rx2, ry2) ||
+        segments_intersect(sx1, sy1, sx2, sy2, rx, ry2, rx2, ry2) ||
+        segments_intersect(sx1, sy1, sx2, sy2, rx, ry, rx, ry2));
+}
+export function rect_out_of_bounds_area(rect, bounds) {
+    let penalty = 0;
+    if (rect.x < bounds.min_x)
+        penalty += (bounds.min_x - rect.x) * rect.h;
+    if (rect.y < bounds.min_y)
+        penalty += (bounds.min_y - rect.y) * rect.w;
+    if (rect.x + rect.w > bounds.max_x)
+        penalty += (rect.x + rect.w - bounds.max_x) * rect.h;
+    if (rect.y + rect.h > bounds.max_y)
+        penalty += (rect.y + rect.h - bounds.max_y) * rect.w;
+    return penalty;
+}
+// 8 candidate positions around anchor: R, TR, T, TL, L, BL, B, BR
+// Positions are top-left corner of the label bounding box.
+// All positions keep a full `offset` gap from the marker edge.
+export function generate_candidates(ax, ay, point_radius, label_w, label_h, gap) {
+    const offset = point_radius + gap;
+    return [
+        { x: ax + offset, y: ay - label_h + offset / 2 }, // R  (baseline just below center)
+        { x: ax + offset, y: ay - label_h - offset / 2 }, // TR
+        { x: ax - label_w / 2, y: ay - label_h - offset }, // T
+        { x: ax - label_w - offset, y: ay - label_h - offset / 2 }, // TL
+        { x: ax - label_w - offset, y: ay - label_h + offset / 2 }, // L  (baseline just below center)
+        { x: ax - label_w - offset, y: ay + offset / 2 }, // BL
+        { x: ax - label_w / 2, y: ay + offset }, // B
+        { x: ax + offset, y: ay + offset / 2 }, // BR
+    ];
+}
+// Compute energy delta when only label at `changed_idx` moves
+export function compute_delta_energy(labels, anchors, changed_idx, old_state, new_state, weights, bounds) {
+    let delta = 0;
+    const anchor = anchors[new_state.anchor_idx];
+    const old_cx = old_state.x + old_state.w / 2, old_cy = old_state.y + old_state.h / 2;
+    const new_cx = new_state.x + new_state.w / 2, new_cy = new_state.y + new_state.h / 2;
+    // Distance penalty change
+    delta +=
+        weights.distance *
+            (Math.hypot(new_cx - anchor.x, new_cy - anchor.y) -
+                Math.hypot(old_cx - anchor.x, old_cy - anchor.y));
+    // Bounds penalty change
+    delta +=
+        weights.bounds *
+            (rect_out_of_bounds_area(new_state, bounds) - rect_out_of_bounds_area(old_state, bounds));
+    // Marker overlap change (all markers)
+    for (const marker of anchors) {
+        delta +=
+            weights.marker *
+                (rect_circle_overlap(new_state, marker.x, marker.y, marker.radius) -
+                    rect_circle_overlap(old_state, marker.x, marker.y, marker.radius));
+    }
+    // Pairwise interactions with all other labels
+    for (let jdx = 0; jdx < labels.length; jdx++) {
+        if (jdx === changed_idx)
+            continue;
+        const other = labels[jdx];
+        const anchor_j = anchors[other.anchor_idx];
+        const other_cx = other.x + other.w / 2, other_cy = other.y + other.h / 2;
+        // Label-label overlap delta
+        delta +=
+            weights.overlap *
+                (rect_overlap_area(new_state, other) - rect_overlap_area(old_state, other));
+        // Leader line crossing delta (changed label's leader vs other's leader)
+        const old_cross = segments_intersect(anchor.x, anchor.y, old_cx, old_cy, anchor_j.x, anchor_j.y, other_cx, other_cy);
+        const new_cross = segments_intersect(anchor.x, anchor.y, new_cx, new_cy, anchor_j.x, anchor_j.y, other_cx, other_cy);
+        if (new_cross !== old_cross)
+            delta += (new_cross ? 1 : -1) * weights.leader_cross;
+        // Changed label's leader crossing other label's rect
+        const old_text = segment_rect_intersects(anchor.x, anchor.y, old_cx, old_cy, other);
+        const new_text = segment_rect_intersects(anchor.x, anchor.y, new_cx, new_cy, other);
+        if (new_text !== old_text)
+            delta += (new_text ? 1 : -1) * weights.leader_text;
+        // Other label's leader crossing changed label's rect
+        const old_other = segment_rect_intersects(anchor_j.x, anchor_j.y, other_cx, other_cy, old_state);
+        const new_other = segment_rect_intersects(anchor_j.x, anchor_j.y, other_cx, other_cy, new_state);
+        if (new_other !== old_other)
+            delta += (new_other ? 1 : -1) * weights.leader_text;
+    }
+    return delta;
+}
+// === Main export ===
 export function compute_label_positions(filtered_series, config, scales, bounds) {
-    const { width, height, pad } = bounds;
     const { x_scale_fn, y_scale_fn, y2_scale_fn, x_axis } = scales;
-    const label_nodes = [];
-    const anchor_nodes = [];
-    const links = [];
+    const { width, height, pad } = bounds;
+    const plot_bounds = {
+        min_x: pad.l,
+        min_y: pad.t,
+        max_x: width - pad.r,
+        max_y: height - pad.b,
+    };
+    // Collect all label data in a single pass
+    const label_infos = [];
     for (const series of filtered_series) {
         for (const pt of series.filtered_data ?? []) {
             if (!pt.point_label?.auto_placement || !pt.point_label.text)
@@ -24,72 +151,106 @@ export function compute_label_positions(filtered_series, config, scales, bounds)
                 ? x_scale_fn(new Date(pt.x))
                 : x_scale_fn(pt.x);
             const ay = (series.y_axis === `y2` ? y2_scale_fn : y_scale_fn)(pt.y);
-            const id = `${pt.series_idx}-${pt.point_idx}`;
             const font_size = parse_font_size(pt.point_label.font_size);
-            const w = pt.point_label.text.length * font_size * 0.6 + 10;
-            const h = font_size * 1.2;
-            const r = pt.point_style?.radius ?? 3;
-            label_nodes.push({
-                id,
-                anchor_x: ax,
-                anchor_y: ay,
-                point_node: pt,
-                label_width: w,
-                label_height: h,
-                x: ax + (pt.point_label.offset?.x ?? 5),
-                y: ay + (pt.point_label.offset?.y ?? r + h / 2 + 3),
+            const label_w = pt.point_label.text.length * font_size * 0.6 + 10;
+            const label_h = font_size * 1.2;
+            const radius = pt.point_style?.radius ?? 3;
+            label_infos.push({
+                id: `${pt.series_idx}-${pt.point_idx}`,
+                anchor: { x: ax, y: ay, radius },
+                width: label_w,
+                height: label_h,
+                candidates: generate_candidates(ax, ay, radius, label_w, label_h, 4),
             });
-            anchor_nodes.push({ id: `anchor-${id}`, fx: ax, fy: ay, point_radius: r });
-            links.push({ source: id, target: `anchor-${id}` });
         }
     }
-    if (label_nodes.length === 0)
+    const num_labels = label_infos.length;
+    if (num_labels === 0)
         return {};
-    if (config.max_labels && label_nodes.length > config.max_labels) {
-        return Object.fromEntries(label_nodes.map((n) => [n.id, { x: n.x ?? 0, y: n.y ?? 0 }]));
+    // Fallback: too many labels, just offset to the right with bounds clamping
+    if (config.max_labels && num_labels > config.max_labels) {
+        return Object.fromEntries(label_infos.map((info) => [
+            info.id,
+            {
+                x: Math.min(Math.max(info.anchor.x + 5, plot_bounds.min_x), plot_bounds.max_x - info.width),
+                y: Math.min(Math.max(info.anchor.y, plot_bounds.min_y), plot_bounds.max_y - info.height),
+            },
+        ]));
     }
-    const sim = forceSimulation([...label_nodes, ...anchor_nodes])
-        .force(`link`, forceLink(links)
-        .id((node) => node.id)
-        .distance(config.link_distance)
-        .strength(config.link_strength))
-        .force(`collide`, forceCollide().radius((node) => {
-        if (is_label_node(node)) {
-            return Math.sqrt(node.label_width ** 2 + node.label_height ** 2) / 2 + 2;
-        }
-        return node.point_radius + 2;
-    }).strength(config.collision_strength))
-        .force(`charge`, forceManyBody().strength((node) => {
-        if (is_label_node(node))
-            return 0;
-        return node.point_radius !== undefined && node.fx !== undefined
-            ? -(config.charge_strength ?? 50)
-            : 0;
-    }).distanceMax(config.charge_distance_max ?? 30));
-    sim.stop().tick(config.placement_ticks);
-    const [min_dist, max_dist] = config.link_distance_range ?? [null, null];
-    const result = {};
-    for (const node of label_nodes) {
-        const node_x = node.x ?? 0;
-        const node_y = node.y ?? 0;
-        let x = Math.max(pad.l + node.label_width / 2, Math.min(width - pad.r - node.label_width / 2, node_x));
-        let y = Math.max(pad.t + node.label_height / 2, Math.min(height - pad.b - node.label_height / 2, node_y));
-        if (min_dist || max_dist) {
-            const dx = x - node.anchor_x;
-            const dy = y - node.anchor_y;
-            const dist = Math.hypot(dx, dy);
-            if (max_dist && dist > max_dist) {
-                const s = max_dist / dist;
-                x = node.anchor_x + dx * s;
-                y = node.anchor_y + dy * s;
+    const weights = { ...DEFAULT_WEIGHTS, ...config.weights };
+    const anchors = label_infos.map((info) => info.anchor);
+    // Greedy initialization: pick best candidate per label
+    const labels = [];
+    for (let idx = 0; idx < num_labels; idx++) {
+        const { candidates, width: lw, height: lh, anchor } = label_infos[idx];
+        let best_candidate = candidates[0];
+        let best_score = Infinity;
+        for (const candidate of candidates) {
+            const test_rect = { x: candidate.x, y: candidate.y, w: lw, h: lh };
+            let score = weights.bounds * rect_out_of_bounds_area(test_rect, plot_bounds);
+            for (const placed of labels) {
+                score += weights.overlap * rect_overlap_area(test_rect, placed);
+            }
+            for (const marker of anchors) {
+                score +=
+                    weights.marker * rect_circle_overlap(test_rect, marker.x, marker.y, marker.radius);
             }
-            else if (min_dist && dist > 0 && dist < min_dist) {
-                const s = min_dist / dist;
-                x = node.anchor_x + dx * s;
-                y = node.anchor_y + dy * s;
+            score +=
+                weights.distance *
+                    Math.hypot(candidate.x + lw / 2 - anchor.x, candidate.y + lh / 2 - anchor.y);
+            if (score < best_score) {
+                best_score = score;
+                best_candidate = candidate;
             }
         }
-        result[node.id] = { x, y };
+        labels.push({ x: best_candidate.x, y: best_candidate.y, w: lw, h: lh, anchor_idx: idx });
+    }
+    // Simulated annealing
+    const sa_iterations = config.sa_iterations ?? 2000;
+    const total_steps = sa_iterations * num_labels;
+    const cooling_rate = 1 / total_steps;
+    // Seeded pseudo-random for deterministic results
+    let rng_state = 42;
+    const next_random = () => {
+        rng_state = (rng_state * 1664525 + 1013904223) & 0x7fffffff;
+        return rng_state / 0x7fffffff;
+    };
+    // Reusable scratch objects to avoid allocations in the hot loop
+    const old_scratch = { x: 0, y: 0, w: 0, h: 0, anchor_idx: 0 };
+    const new_scratch = { x: 0, y: 0, w: 0, h: 0, anchor_idx: 0 };
+    const copy_state = (dst, src) => {
+        dst.x = src.x;
+        dst.y = src.y;
+        dst.w = src.w;
+        dst.h = src.h;
+        dst.anchor_idx = src.anchor_idx;
+    };
+    for (let step = 0; step < total_steps; step++) {
+        const temperature = Math.max(0.001, 1.0 - step * cooling_rate);
+        const label_idx = Math.floor(next_random() * num_labels);
+        const current = labels[label_idx];
+        copy_state(old_scratch, current);
+        copy_state(new_scratch, current);
+        // 70% try a candidate position, 30% small perturbation
+        if (next_random() < 0.7) {
+            const candidate = label_infos[label_idx].candidates[Math.floor(next_random() * label_infos[label_idx].candidates.length)];
+            new_scratch.x = candidate.x;
+            new_scratch.y = candidate.y;
+        }
+        else {
+            const max_shift = 30 * temperature + 5;
+            new_scratch.x += (next_random() - 0.5) * 2 * max_shift;
+            new_scratch.y += (next_random() - 0.5) * 2 * max_shift;
+        }
+        const delta = compute_delta_energy(labels, anchors, label_idx, old_scratch, new_scratch, weights, plot_bounds);
+        if (delta < 0 || next_random() < Math.exp(-delta / (temperature * 10 + 0.1))) {
+            current.x = new_scratch.x;
+            current.y = new_scratch.y;
+        }
     }
-    return result;
+    // Return label center positions (matching existing API)
+    return Object.fromEntries(labels.map((label, idx) => [
+        label_infos[idx].id,
+        { x: label.x + label.w / 2, y: label.y + label.h / 2 },
+    ]));
 }