smithkit 0.4.0 → 0.5.0

package/dist/lib/io/types.d.ts

@@ -0,0 +1,17 @@
+import type { TraceSamples } from '../samples.js';
+export interface TouchstoneData<T extends TraceSamples | Float64Array = TraceSamples> {
+    samples: T;
+    referenceImpedanceOhms: number;
+}
+export interface TouchstoneParseOptions {
+    /** Source port count, normally taken from the filename extension. Default: 1. */
+    ports?: 1 | 2;
+    /** Reflection parameter to extract. S22 requires ports: 2. Default: S11. */
+    parameter?: 'S11' | 'S22';
+    /** Packed output contains f/re/im triples in Hz, without intermediate sample objects. */
+    output?: 'objects' | 'packed';
+}
+export interface TouchstoneWriteOptions {
+    /** Reference of the supplied data, in ohms. Does not renormalize it. Default: 50. */
+    referenceImpedanceOhms?: number;
+}

package/dist/lib/io/types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/layers.d.ts

@@ -43,6 +43,10 @@ export interface ChartLayers {
 }
 export interface PeripheralScales {
     setVisible(visible: boolean): void;
+    /** Show or hide axis captions independently of numeric tick labels. Default: true. */
+    setCaptionsVisible(visible: boolean): void;
+    /** Show or hide numeric tick labels independently of captions. Default: true. */
+    setTickLabelsVisible(visible: boolean): void;
     /** Pass null to clear the indicators. */
     update(reflectionCoefficient: Complex | null): void;
 }

package/dist/lib/measurements.d.ts

@@ -7,6 +7,8 @@ export interface TraceStyle {
     lineWidth: number;
     /** Point radius in CSS pixels; remains constant under chart zoom and container resize. Default: 2. */
     pointRadius: number;
+    /** Maximum additional line simplification error in CSS pixels. Zero disables it (default). */
+    lineTolerancePx: number;
 }
 export interface TraceOptions extends Partial<TraceStyle> {
     name?: string;

package/dist/lib/options.d.ts

@@ -41,6 +41,10 @@ export interface InteractionOptions {
 export interface PeripheralScalesOptions {
     /** Show the peripheral rulers as one group. Default: false. */
     visible?: boolean;
+    /** Show curved axis captions. Default: true. */
+    captionsVisible?: boolean;
+    /** Show numeric tick labels. Default: true. */
+    tickLabelsVisible?: boolean;
 }
 export interface SmithOptions {
     /** Positive real reference impedance in ohms. Default: 50. */

package/dist/lib/rendering/SvgChartRenderer.d.ts

@@ -1,7 +1,7 @@
 import type { SmithTheme } from '../appearance/types.js';
 import { SmithData } from '../traces/SmithData.js';
 import type { SmithMarker } from '../traces/SmithMarker.js';
-import { TraceSamples } from '../samples.js';
+import { TraceInput } from '../samples.js';
 import { Complex } from '../math/Complex.js';
 import type { ChartLayers, PeripheralScales } from '../layers.js';
 import type { TraceStyle } from '../measurements.js';
@@ -42,7 +42,7 @@ export declare class SvgChartRenderer {
     setTheme(theme: SmithTheme): void;
     draw(target: string | HTMLElement): void;
     /** Export the current mounted view as standalone SVG with its configured background. */
-    toSvg(): string;
+    toSvg(lineDetail?: 'full' | 'view'): string;
     /** Remove this chart and release its event handlers. Safe to call more than once. */
     destroy(): void;
     private updateViewportScale;
@@ -64,6 +64,6 @@ export declare class SvgChartRenderer {
     private cursorContainer;
     private drawReactanceAxis;
     /** Construct trace rendering without exposing chart containers or scalers to Smith. */
-    createTrace(values: TraceSamples, color: string, style: Partial<TraceStyle>, onMarkerDrag: (marker: SmithMarker, dragging: boolean) => void): SmithData;
+    createTrace(values: TraceInput, color: string, style: Partial<TraceStyle>, onMarkerDrag: (marker: SmithMarker, dragging: boolean) => void): SmithData;
     removeTrace(trace: SmithData): void;
 }

package/dist/lib/rendering/SvgChartRenderer.js

@@ -1,3 +1,4 @@
+import { OptionsValidation } from '../OptionsValidation.js';
 import { SvgTheme } from '../appearance/SvgTheme.js';
 import * as d3 from 'd3';
 import { MouseGesture } from '../interaction/MouseGesture.js';
@@ -147,6 +148,16 @@ export class SvgChartRenderer {
                 }
                 this.labelLayout.update(true);
             },
+            setCaptionsVisible: (visible) => {
+                assertAlive();
+                OptionsValidation.boolean(visible, 'Peripheral scale caption visibility');
+                this.peripheralScaleRenderer.setCaptionsVisible(visible);
+            },
+            setTickLabelsVisible: (visible) => {
+                assertAlive();
+                OptionsValidation.boolean(visible, 'Peripheral scale tick label visibility');
+                this.peripheralScaleRenderer.setTickLabelsVisible(visible);
+            },
             update: (gamma) => {
                 assertAlive();
                 this.peripheralScaleRenderer.update(gamma);
@@ -172,9 +183,23 @@ export class SvgChartRenderer {
         this.updateViewportScale();
     }
     /** Export the current mounted view as standalone SVG with its configured background. */
-    toSvg() {
+    toSvg(lineDetail = 'full') {
         this.assertAlive();
-        return SvgExporter.chart(this.svg.Node);
+        const replacements = new Map();
+        if (lineDetail === 'full') {
+            for (const trace of this.traces) {
+                const replacement = trace.fullExportLine();
+                if (replacement) {
+                    replacements.set(replacement.node, replacement.path);
+                }
+            }
+        }
+        return SvgExporter.chart(this.svg.Node, (original, copy) => {
+            const replacement = replacements.get(original);
+            if (replacement !== undefined) {
+                copy.setAttribute('d', replacement);
+            }
+        });
     }
     /** Remove this chart and release its event handlers. Safe to call more than once. */
     destroy() {

package/dist/lib/rf/RfCalculations.d.ts

@@ -54,8 +54,10 @@ export declare class RfCalculations {
      * unrepresentable result is undefined; non-finite inputs throw RangeError.
      */
     static renormalizeReflection(gamma: Complex, fromOhms: number, toOhms: number): Complex | undefined;
-    /** Copy and renormalize every sample; reject invalid/singular data without modifying the input. */
+    /** Copy and renormalize samples, preserving object or packed representation. */
+    static renormalizeSamples(samples: Float64Array, fromOhms: number, toOhms: number): Float64Array;
     static renormalizeSamples(samples: TraceSamples, fromOhms: number, toOhms: number): TraceSamples;
+    static renormalizeSamples(samples: TraceSamples | Float64Array, fromOhms: number, toOhms: number): TraceSamples | Float64Array;
     /**
      * Convert reactance in ohms at a frequency in Hz to an ideal series L or C.
      * Zero frequency, zero reactance, or an unrepresentable component returns undefined.

package/dist/lib/rf/RfCalculations.js

@@ -115,20 +115,37 @@ export class RfCalculations {
             (inverseScale / denominatorScale);
         return Number.isFinite(re) && Number.isFinite(im) ? Complex.from(re, im) : undefined;
     }
-    /** Copy and renormalize every sample; reject invalid/singular data without modifying the input. */
     static renormalizeSamples(samples, fromOhms, toOhms) {
         RfCalculations.validateReference(fromOhms);
         RfCalculations.validateReference(toOhms);
-        return samples.map((sample, index) => {
-            if (!Number.isFinite(sample.frequencyHz) ||
-                sample.frequencyHz < 0 ||
-                sample.reflectionCoefficient.length !== 2) {
+        const convert = (frequencyHz, re, im, index) => {
+            if (!Number.isFinite(frequencyHz) || frequencyHz < 0) {
                 throw new RangeError(`Invalid sample at index ${index}.`);
             }
-            const gamma = RfCalculations.renormalizeReflection(Complex.from(...sample.reflectionCoefficient), fromOhms, toOhms);
+            const gamma = RfCalculations.renormalizeReflection(Complex.from(re, im), fromOhms, toOhms);
             if (!gamma) {
                 throw new RangeError(`Renormalization is singular or outside the numeric range at sample ${index}.`);
             }
+            return gamma;
+        };
+        if (samples instanceof Float64Array) {
+            if (samples.length % 3 !== 0) {
+                throw new RangeError('Packed samples must contain complete f/re/im triples.');
+            }
+            const result = new Float64Array(samples.length);
+            for (let offset = 0; offset < samples.length; offset += 3) {
+                const gamma = convert(samples[offset], samples[offset + 1], samples[offset + 2], offset / 3);
+                result[offset] = samples[offset];
+                result[offset + 1] = gamma.re;
+                result[offset + 2] = gamma.im;
+            }
+            return result;
+        }
+        return samples.map((sample, index) => {
+            if (sample.reflectionCoefficient.length !== 2) {
+                throw new RangeError(`Invalid sample at index ${index}.`);
+            }
+            const gamma = convert(sample.frequencyHz, ...sample.reflectionCoefficient, index);
             return { frequencyHz: sample.frequencyHz, reflectionCoefficient: gamma.toVector() };
         });
     }

package/dist/lib/samples.d.ts

@@ -1,6 +1,10 @@
-/** One S11 sample. The reflection coefficient is [real, imaginary]. */
+/** One reflection sample. The reflection coefficient is [real, imaginary]. */
 export interface TraceSample {
     readonly frequencyHz: number;
     readonly reflectionCoefficient: readonly [number, number];
 }
 export type TraceSamples = readonly TraceSample[];
+/** One reflection sample: frequency in Hz, followed by the real and imaginary parts of Γ. */
+export type TraceTuple = readonly [frequencyHz: number, re: number, im: number];
+/** Homogeneous object samples, tuples, or packed f/re/im triples. Inputs are copied. */
+export type TraceInput = TraceSamples | readonly TraceTuple[] | Float64Array;

package/dist/lib/scales/SmithPeripheralScales.d.ts

@@ -2,12 +2,17 @@ import type { Complex } from '../math/Complex.js';
 import { SmithGroup } from '../svg/SmithGroup.js';
 /** Peripheral rulers in the chart's 500-unit coordinate system. */
 export declare class SmithPeripheralScales extends SmithGroup {
+    private captionsVisible;
+    private tickLabelsVisible;
     private static point;
     private static rulerRadius;
     readonly labels: SmithGroup;
     private readonly scales;
     private readonly axes;
     constructor();
+    setCaptionsVisible(visible: boolean): void;
+    setTickLabelsVisible(visible: boolean): void;
+    private updateLabelVisibility;
     show(): SmithGroup;
     hide(): SmithGroup;
     /** Connect to the same cursor or marker data as the independent parameter scales. */

package/dist/lib/scales/SmithPeripheralScales.js

@@ -6,6 +6,8 @@ const chartRadius = 250;
 const groupWidth = 40;
 /** Peripheral rulers in the chart's 500-unit coordinate system. */
 export class SmithPeripheralScales extends SmithGroup {
+    captionsVisible = true;
+    tickLabelsVisible = true;
     static point(radius, degrees) {
         const angle = (degrees * Math.PI) / 180;
         return [250 + radius * Math.cos(angle), 250 - radius * Math.sin(angle)];
@@ -79,11 +81,13 @@ export class SmithPeripheralScales extends SmithGroup {
                     .attr('stroke-width', major ? 0.8 : 0.5)
                     .attr('vector-effect', 'non-scaling-stroke');
                 const captionDistance = Math.abs(((angle - captionAngle + 540) % 360) - 180);
-                if (major && captionDistance > 25) {
+                if (major) {
                     const [x, y] = SmithPeripheralScales.point(radius + side * 11, angle);
                     const rotation = angle >= 0 ? 90 - angle : -90 - angle;
                     labelAxis
                         .append('text')
+                        .attr('class', 'peripheral-tick-label')
+                        .classed('peripheral-caption-sector', captionDistance <= 25)
                         .attr('x', x)
                         .attr('y', y)
                         .attr('transform', `rotate(${rotation},${x},${y})`)
@@ -132,6 +136,21 @@ export class SmithPeripheralScales extends SmithGroup {
                 .attr('stroke', 'var(--smithkit-scales-indicatorOutline)')
                 .attr('stroke-width', 1);
         });
+        this.updateLabelVisibility();
+    }
+    setCaptionsVisible(visible) {
+        this.captionsVisible = visible;
+        this.updateLabelVisibility();
+    }
+    setTickLabelsVisible(visible) {
+        this.tickLabelsVisible = visible;
+        this.updateLabelVisibility();
+    }
+    updateLabelVisibility() {
+        this.labels.Element.selectAll('.peripheral-caption').attr('display', this.captionsVisible ? null : 'none');
+        this.labels.Element.selectAll('.peripheral-tick-label').attr('display', this.tickLabelsVisible ? null : 'none');
+        // Fill the reserved caption sectors with numeric labels when captions are hidden.
+        this.labels.Element.selectAll('.peripheral-caption-sector').attr('display', this.tickLabelsVisible && !this.captionsVisible ? null : 'none');
     }
     show() {
         this.labels.show();

package/dist/lib/svg/SvgExporter.d.ts

@@ -4,7 +4,7 @@ export declare class SvgExporter {
     private static readonly namespace;
     private static readonly properties;
     private static readonly nonInherited;
-    static chart(source: SVGElement): string;
+    static chart(source: SVGElement, customize?: (original: SVGElement, copy: SVGElement) => void): string;
     /** Preserve the current CSS layout of separate scale SVGs in one SVG document. */
     static scales(container: HTMLElement, axes: readonly SVGSVGElement[], customize?: (copy: SVGElement, index: number) => void, caption?: {
         text: string;

package/dist/lib/svg/SvgExporter.js

@@ -46,9 +46,9 @@ export class SvgExporter {
         'baseline-shift',
         'text-decoration',
     ]);
-    static chart(source) {
+    static chart(source, customize) {
         const bounds = SvgExporter.bounds(source);
-        const copy = SvgExporter.copy(source);
+        const copy = SvgExporter.copy(source, customize);
         SvgExporter.background(copy, source);
         SvgExporter.size(copy, bounds.width, bounds.height);
         return SvgExporter.serialize(copy);
@@ -120,7 +120,7 @@ export class SvgExporter {
         }
         return bounds;
     }
-    static copy(source) {
+    static copy(source, customize) {
         const copy = source.cloneNode(true);
         const originals = [source, ...source.querySelectorAll('*')];
         const copies = [copy, ...copy.querySelectorAll('*')];
@@ -167,6 +167,7 @@ export class SvgExporter {
                     element.removeAttribute(attribute.name);
                 }
             }
+            customize?.(original, element);
         });
         return copy;
     }

package/dist/lib/svg/export.d.ts

@@ -25,6 +25,8 @@ export interface MarkerLegendOptions {
     fields?: readonly MarkerLegendField[];
 }
 export interface SmithImageExportOptions extends ImageExportOptions {
+    /** Full samples (default) or current displayed line geometry. View detail scales with export dimensions. */
+    lineDetail?: 'full' | 'view';
     /** Include a footer with the names and colors of visible traces. Default: false. */
     legend?: boolean;
     /** Include a marker legend below the chart/scales, independently of the trace legend. Default: false. */

package/dist/lib/traces/SmithData.d.ts

@@ -2,7 +2,8 @@ import { SmithGroup } from '../svg/SmithGroup.js';
 import type { TraceStyle, MarkerSelectionStrategy } from '../measurements.js';
 import { SmithMarker } from './SmithMarker.js';
 import { SmithScaler } from '../svg/SmithScaler.js';
-import type { TraceSamples, TraceSample } from '../samples.js';
+import type { TraceInput, TraceSample } from '../samples.js';
+import { TraceBuffer } from './TraceBuffer.js';
 import { type TraceTransform } from './TraceRenderer.js';
 /** Coordinates trace rendering, draggable markers, and deferred marker events. */
 export declare class SmithData {
@@ -21,19 +22,23 @@ export declare class SmithData {
     private selectHandler;
     private visible;
     private handler;
-    constructor(data: TraceSamples, color: string, transform: TraceTransform, container: SmithGroup, scaler: SmithScaler, markerDragHandler?: ((marker: SmithMarker, dragging: boolean) => void) | undefined, markerContainer?: SmithGroup, style?: Partial<TraceStyle>);
+    constructor(data: TraceInput, color: string, transform: TraceTransform, container: SmithGroup, scaler: SmithScaler, markerDragHandler?: ((marker: SmithMarker, dragging: boolean) => void) | undefined, markerContainer?: SmithGroup, style?: Partial<TraceStyle>);
     setViewportScale(scale: number): void;
     zoom(transform: TraceTransform): void;
     addMarker(sampleIndex?: number): number;
     removeMarker(index: number): boolean;
     setMarkerSample(index: number, sampleIndex: number): boolean;
     setMarkerFrequency(index: number, frequencyHz: number): boolean;
-    get Samples(): TraceSamples;
+    get Samples(): TraceBuffer;
     get SampleCount(): number;
     get Color(): string;
     get Visible(): boolean;
     markerSampleIndex(index: number): number;
     setColor(color: string): void;
+    fullExportLine(): {
+        node: SVGElement;
+        path: string;
+    } | undefined;
     get Style(): TraceStyle;
     setStyle(options: Partial<TraceStyle>): void;
     setVisible(visible: boolean): void;
@@ -43,10 +48,11 @@ export declare class SmithData {
     setMarkerSelectHandler(handler: (marker: SmithMarker) => void): void;
     private notifyMarker;
     private cancelEvents;
-    update(values: TraceSamples, strategy?: MarkerSelectionStrategy): void;
+    update(values: TraceInput | TraceBuffer, strategy?: MarkerSelectionStrategy): void;
     destroy(): void;
     get Markers(): {
         number: number;
+        sampleIndex: number;
         selectedPoint: TraceSample;
         marker: SmithMarker;
     }[];

package/dist/lib/traces/SmithData.js

@@ -110,6 +110,9 @@ export class SmithData {
         this.renderer.setColor(color);
         this.markers.forEach((marker) => marker.setColor(color));
     }
+    fullExportLine() {
+        return this.renderer.fullExportLine();
+    }
     get Style() {
         return this.renderer.Style;
     }
@@ -129,12 +132,15 @@ export class SmithData {
     }
     moveMarker(entry) {
         const marker = this.markers.get(entry);
-        marker.move(this.scaler.point(entry.selectedPoint.reflectionCoefficient));
+        marker.move(this.scaler.point([
+            this.model.Samples.real(entry.sampleIndex),
+            this.model.Samples.imaginary(entry.sampleIndex),
+        ]));
         this.updateReading(entry, marker);
         this.notifyMarker(entry);
     }
     updateReading(entry, marker) {
-        marker.setReading(`${this.name}, marker ${entry.number}`, this.model.markerSampleIndex(this.model.markerIndex(entry)), this.SampleCount, entry.selectedPoint.frequencyHz);
+        marker.setReading(`${this.name}, marker ${entry.number}`, this.model.markerSampleIndex(this.model.markerIndex(entry)), this.SampleCount, this.model.Samples.frequency(entry.sampleIndex));
     }
     setName(name) {
         this.name = name;
@@ -151,7 +157,7 @@ export class SmithData {
             this.pendingEvents.delete(entry);
             const index = this.model.markerIndex(entry);
             if (!this.destroyed && index >= 0) {
-                this.handler?.(index, entry.selectedPoint);
+                this.handler?.(index, this.model.Samples.sample(entry.sampleIndex));
             }
         }, 0);
         this.pendingEvents.set(entry, timer);
@@ -182,7 +188,11 @@ export class SmithData {
         this.renderer.destroy();
     }
     get Markers() {
-        return this.model.Markers.map((entry) => ({ ...entry, marker: this.markers.get(entry) }));
+        return this.model.Markers.map((entry) => ({
+            ...entry,
+            selectedPoint: this.model.Samples.sample(entry.sampleIndex),
+            marker: this.markers.get(entry),
+        }));
     }
     setMarkerMoveHandler(handler) {
         this.handler = handler;

package/dist/lib/traces/TraceBuffer.d.ts

@@ -0,0 +1,19 @@
+import type { TraceInput, TraceSample } from '../samples.js';
+import type { Point } from '../math/geometry.js';
+/** Owned, packed f/re/im storage. Never exposes the mutable backing buffer. */
+export declare class TraceBuffer {
+    private readonly values;
+    private readonly sorted;
+    private constructor();
+    static from(input: TraceInput): TraceBuffer;
+    static empty(): TraceBuffer;
+    get length(): number;
+    frequency(index: number): number;
+    real(index: number): number;
+    imaginary(index: number): number;
+    sample(index: number): TraceSample;
+    nearestFrequency(frequencyHz: number): number;
+    private lowerBound;
+    nearestPoint(point: Readonly<Point>): number;
+    renormalize(fromOhms: number, toOhms: number): TraceBuffer;
+}

package/dist/lib/traces/TraceBuffer.js

@@ -0,0 +1,176 @@
+import { Complex } from '../math/Complex.js';
+import { RfCalculations } from '../rf/RfCalculations.js';
+/** Owned, packed f/re/im storage. Never exposes the mutable backing buffer. */
+export class TraceBuffer {
+    values;
+    sorted;
+    constructor(values, sorted) {
+        this.values = values;
+        this.sorted = sorted;
+    }
+    static from(input) {
+        const packed = input instanceof Float64Array;
+        if ((!packed && !Array.isArray(input)) || !input.length || (packed && input.length % 3 !== 0)) {
+            throw new RangeError('A trace requires complete samples with frequency, real, and imaginary values.');
+        }
+        const count = packed ? input.length / 3 : input.length;
+        const values = new Float64Array(count * 3);
+        const tuples = !packed && Array.isArray(input[0]);
+        let sorted = true;
+        for (let i = 0; i < count; i++) {
+            let f;
+            let re;
+            let im;
+            if (packed) {
+                f = input[i * 3];
+                re = input[i * 3 + 1];
+                im = input[i * 3 + 2];
+            }
+            else {
+                const sample = input[i];
+                if (tuples) {
+                    if (!Array.isArray(sample) || sample.length !== 3) {
+                        throw new RangeError(`Invalid tuple at sample ${i}; expected [frequencyHz, re, im].`);
+                    }
+                    [f, re, im] = sample;
+                }
+                else {
+                    if (!sample ||
+                        typeof sample !== 'object' ||
+                        Array.isArray(sample) ||
+                        !('reflectionCoefficient' in sample) ||
+                        !Array.isArray(sample.reflectionCoefficient) ||
+                        sample.reflectionCoefficient.length !== 2) {
+                        throw new RangeError(`Invalid object at sample ${i}; expected frequencyHz and reflectionCoefficient.`);
+                    }
+                    f = sample.frequencyHz;
+                    [re, im] = sample.reflectionCoefficient;
+                }
+            }
+            if (!Number.isFinite(f) || f < 0 || !Number.isFinite(re) || !Number.isFinite(im)) {
+                throw new RangeError(`Invalid sample at index ${i}; frequency must be non-negative and all values finite.`);
+            }
+            values[i * 3] = f;
+            values[i * 3 + 1] = re;
+            values[i * 3 + 2] = im;
+            if (i > 0 && f < values[(i - 1) * 3]) {
+                sorted = false;
+            }
+        }
+        return new TraceBuffer(values, sorted);
+    }
+    static empty() {
+        return new TraceBuffer(new Float64Array(), true);
+    }
+    get length() {
+        return this.values.length / 3;
+    }
+    frequency(index) {
+        return this.values[index * 3];
+    }
+    real(index) {
+        return this.values[index * 3 + 1];
+    }
+    imaginary(index) {
+        return this.values[index * 3 + 2];
+    }
+    sample(index) {
+        return {
+            frequencyHz: this.frequency(index),
+            reflectionCoefficient: [this.real(index), this.imaginary(index)],
+        };
+    }
+    nearestFrequency(frequencyHz) {
+        if (this.sorted) {
+            const right = this.lowerBound(frequencyHz);
+            if (right === 0) {
+                return 0;
+            }
+            const distance = frequencyHz - this.frequency(right - 1);
+            if (right < this.length && this.frequency(right) - frequencyHz < distance) {
+                return right;
+            }
+            // Find the earliest equally close sample, including floating-point rounding
+            // ties between distinct frequencies far below the requested frequency.
+            let low = 0;
+            let high = right - 1;
+            while (low < high) {
+                const mid = Math.floor((low + high) / 2);
+                if (frequencyHz - this.frequency(mid) > distance) {
+                    low = mid + 1;
+                }
+                else {
+                    high = mid;
+                }
+            }
+            return low;
+        }
+        let closest = 0;
+        let distance = Math.abs(this.frequency(0) - frequencyHz);
+        for (let i = 1; i < this.length; i++) {
+            const next = Math.abs(this.frequency(i) - frequencyHz);
+            if (next < distance) {
+                closest = i;
+                distance = next;
+            }
+        }
+        return closest;
+    }
+    lowerBound(frequencyHz) {
+        let low = 0;
+        let high = this.length;
+        while (low < high) {
+            const mid = Math.floor((low + high) / 2);
+            if (this.frequency(mid) < frequencyHz) {
+                low = mid + 1;
+            }
+            else {
+                high = mid;
+            }
+        }
+        return low;
+    }
+    nearestPoint(point) {
+        let closest = 0;
+        let distance = Infinity;
+        const [real, imaginary] = point;
+        // A coordinate difference is a lower bound on Euclidean distance. Reject
+        // points outside the current bounding square before evaluating the norm.
+        // Keep the boundary inclusive and compare surviving norms with Math.hypot
+        // to preserve first-input ties, including ties caused by floating-point rounding.
+        for (let offset = 1; offset < this.values.length; offset += 3) {
+            const dx = real - this.values[offset];
+            if (Math.abs(dx) > distance) {
+                continue;
+            }
+            const dy = imaginary - this.values[offset + 1];
+            if (Math.abs(dy) > distance) {
+                continue;
+            }
+            const next = Math.hypot(dx, dy);
+            if (next < distance) {
+                closest = (offset - 1) / 3;
+                distance = next;
+                if (distance === 0) {
+                    return closest;
+                }
+            }
+        }
+        return closest;
+    }
+    renormalize(fromOhms, toOhms) {
+        RfCalculations.renormalizeSamples([], fromOhms, toOhms);
+        const values = new Float64Array(this.values.length);
+        for (let i = 0; i < this.length; i++) {
+            const gamma = RfCalculations.renormalizeReflection(Complex.from(this.real(i), this.imaginary(i)), fromOhms, toOhms);
+            if (!gamma) {
+                throw new RangeError(`Renormalization is singular or outside the numeric range at sample ${i}.`);
+            }
+            values[i * 3] = this.frequency(i);
+            const [re, im] = gamma.toVector();
+            values[i * 3 + 1] = re;
+            values[i * 3 + 2] = im;
+        }
+        return new TraceBuffer(values, this.sorted);
+    }
+}

package/dist/lib/traces/TraceLineDetail.d.ts

@@ -0,0 +1,8 @@
+import { TraceBuffer } from './TraceBuffer.js';
+/** Nested radial-distance levels with a conservative accumulated error in Γ units. */
+export declare class TraceLineDetail {
+    private readonly levels;
+    constructor(data: TraceBuffer);
+    /** Undefined means use every sample. No data scan or allocation during view selection. */
+    select(tolerance: number): Uint32Array | undefined;
+}