smithkit 0.4.0 → 0.6.0

package/dist/lib/OptionsValidation.js

@@ -96,9 +96,13 @@ export class OptionsValidation {
             }
         }
         if (options.peripheralScales !== undefined) {
-            OptionsValidation.object(options.peripheralScales, 'Peripheral scales', ['visible']);
-            if (options.peripheralScales.visible !== undefined) {
-                OptionsValidation.boolean(options.peripheralScales.visible, 'Peripheral scale visibility');
+            const keys = ['visible', 'captionsVisible', 'tickLabelsVisible'];
+            OptionsValidation.object(options.peripheralScales, 'Peripheral scales', keys);
+            for (const key of keys) {
+                const value = options.peripheralScales[key];
+                if (value !== undefined) {
+                    OptionsValidation.boolean(value, `Peripheral scales ${key}`);
+                }
             }
         }
         if (options.grid !== undefined) {

package/dist/lib/Smith.d.ts

@@ -1,7 +1,7 @@
 import type { SmithOptions } from './options.js';
 import type { SmithImageExportOptions } from './svg/export.js';
 import type { SmithAppearance } from './appearance/types.js';
-import type { TraceSamples } from './samples.js';
+import type { TraceInput, TraceSamples, TraceTuple } from './samples.js';
 import type { ChartLayers, GridDetail, PeripheralScales } from './layers.js';
 import type { SmithReading } from './rf/RfCalculations.js';
 import type { TraceOptions, TraceUpdateOptions, TraceInfo, MarkerSnapshot, MarkerComparison } from './measurements.js';
@@ -62,6 +62,9 @@ export declare class Smith {
     resetView(): void;
     /** Add a named trace without markers. Use addMarker to create markers explicitly. Returns a chart-local, stable ID. */
     addTrace(values: TraceSamples, options?: TraceOptions): string;
+    addTrace(values: readonly TraceTuple[], options?: TraceOptions): string;
+    addTrace(values: Float64Array, options?: TraceOptions): string;
+    addTrace(values: TraceInput, options?: TraceOptions): string;
     /** Detached metadata snapshots; IDs and marker display numbers survive removals. */
     getTraces(): TraceInfo[];
     private traceIndex;
@@ -71,6 +74,9 @@ export declare class Smith {
     setTraceOptions(id: string, options: TraceOptions): boolean;
     /** Replace samples; by default each marker follows its nearest measured frequency. */
     updateTrace(id: string, values: TraceSamples, options?: TraceUpdateOptions): boolean;
+    updateTrace(id: string, values: readonly TraceTuple[], options?: TraceUpdateOptions): boolean;
+    updateTrace(id: string, values: Float64Array, options?: TraceUpdateOptions): boolean;
+    updateTrace(id: string, values: TraceInput, options?: TraceUpdateOptions): boolean;
     removeTrace(id: string): boolean;
     /** Place a marker on an existing sample; no interpolation is performed. */
     addMarker(traceId: string, sampleIndex?: number): string | undefined;

package/dist/lib/Smith.js

@@ -80,6 +80,12 @@ export class Smith {
         if (options.peripheralScales?.visible !== undefined) {
             this.peripheralScales.setVisible(options.peripheralScales.visible);
         }
+        if (options.peripheralScales?.captionsVisible !== undefined) {
+            this.peripheralScales.setCaptionsVisible(options.peripheralScales.captionsVisible);
+        }
+        if (options.peripheralScales?.tickLabelsVisible !== undefined) {
+            this.peripheralScales.setTickLabelsVisible(options.peripheralScales.tickLabelsVisible);
+        }
         for (const name of ['resistance', 'reactance', 'conductance', 'susceptance']) {
             const layer = this.layers[name];
             for (const settings of [options.grid, options.grid?.layers?.[name]]) {
@@ -143,13 +149,10 @@ export class Smith {
         }
     }
     /** Export the current mounted view as standalone SVG with its configured background. */
-    toSvg(options) {
+    toSvg(options = {}) {
         this.assertAlive();
         this.validateExportOptions(options);
-        const source = this.renderer.toSvg();
-        if (options === undefined) {
-            return source;
-        }
+        const source = this.renderer.toSvg(options.lineDetail ?? 'full');
         const sources = [source];
         if (options.scales) {
             sources.push(options.scales.toSvg({ readout: options.scaleReadout }));
@@ -157,6 +160,9 @@ export class Smith {
         return ImageExporter.svg(sources, options, this.exportLegend(options));
     }
     validateExportOptions(options) {
+        if (options?.lineDetail !== undefined && !['full', 'view'].includes(options.lineDetail)) {
+            throw new TypeError('Export line detail must be full or view.');
+        }
         if (options?.scaleReadout !== undefined && !options.scales) {
             throw new TypeError('Scale readout requires included radial scales.');
         }
@@ -178,7 +184,7 @@ export class Smith {
     async toPng(options = {}) {
         this.assertAlive();
         this.validateExportOptions(options);
-        const sources = [this.toSvg()];
+        const sources = [this.renderer.toSvg(options.lineDetail ?? 'full')];
         if (options.scales) {
             sources.push(options.scales.toSvg({ readout: options.scaleReadout }));
         }
@@ -231,7 +237,6 @@ export class Smith {
         this.assertAlive();
         this.renderer.resetView();
     }
-    /** Add a named trace without markers. Use addMarker to create markers explicitly. Returns a chart-local, stable ID. */
     addTrace(values, options = {}) {
         this.assertAlive();
         this.validateTraceOptions(options);
@@ -285,6 +290,10 @@ export class Smith {
         if (options.mode !== undefined && !['points', 'line', 'both'].includes(options.mode)) {
             throw new TypeError('Trace mode must be points, line, or both.');
         }
+        if (options.lineTolerancePx !== undefined &&
+            (!Number.isFinite(options.lineTolerancePx) || options.lineTolerancePx < 0)) {
+            throw new RangeError('Line tolerance must be finite and non-negative.');
+        }
         for (const key of ['lineWidth', 'pointRadius']) {
             const value = options[key];
             if (value !== undefined && (!Number.isFinite(value) || value <= 0)) {
@@ -323,7 +332,6 @@ export class Smith {
         }
         return true;
     }
-    /** Replace samples; by default each marker follows its nearest measured frequency. */
     updateTrace(id, values, options = {}) {
         this.assertAlive();
         const data = this.data[this.traceIndex(id)];
@@ -419,7 +427,7 @@ export class Smith {
         if (referenceImpedanceOhms === this.referenceOhms) {
             return;
         }
-        const samples = this.data.map((data) => RfCalculations.renormalizeSamples(data.Samples, this.referenceOhms, referenceImpedanceOhms));
+        const samples = this.data.map((data) => data.Samples.renormalize(this.referenceOhms, referenceImpedanceOhms));
         this.data.forEach((data) => data.Markers.forEach((entry) => entry.marker.cancelDrag()));
         this.referenceOhms = referenceImpedanceOhms;
         this.data.forEach((data, index) => data.update(samples[index], 'sample-index'));

package/dist/lib/grid/SmithGridLayer.js

@@ -31,7 +31,9 @@ export class SmithGridLayer extends ConstCircles {
             const label = GridGeometry.label(kind, tick.definition);
             const text = new SmithText(this.scaler.point(label.point), label.text, {
                 rotate: label.rotate,
-                dx: this.scaler.r(label.dx).toString(),
+                // Keep the zero clear of the opposite grid's high-value labels even
+                // when minimum font sizing or browser font metrics enlarge it.
+                dx: real && tick.definition.point.r === 0 ? '0.9em' : this.scaler.r(label.dx).toString(),
                 dy: this.scaler.r(label.dy).toString(),
                 textAnchor: label.textAnchor,
                 dominantBaseline: label.dominantBaseline,

package/dist/lib/index.d.ts

@@ -1,9 +1,9 @@
 export { Smith, SmithEventType } from './Smith.js';
 export type { SmithEvent } from './Smith.js';
 export { Complex } from './math/Complex.js';
-export type { TraceSamples, TraceSample } from './samples.js';
+export type { TraceSamples, TraceSample, TraceTuple, TraceInput } from './samples.js';
 export { Touchstone } from './io/Touchstone.js';
-export type { TouchstoneData } from './io/Touchstone.js';
+export type { TouchstoneData, TouchstoneParseOptions, TouchstoneWriteOptions } from './io/types.js';
 export { SmithScales } from './scales/SmithScales.js';
 export { MarkerMeasurements } from './MarkerMeasurements.js';
 export type { TraceOptions, TraceUpdateOptions, MarkerSelectionStrategy, TraceStyle, TraceRenderMode, TraceInfo, MarkerInfo, MarkerSnapshot, MarkerComparison, } from './measurements.js';

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

@@ -1,10 +1,16 @@
-import type { TraceSamples } from '../samples.js';
-export interface TouchstoneData {
-    samples: TraceSamples;
-    referenceImpedanceOhms: number;
-}
+import type { TraceInput, TraceSamples } from '../samples.js';
+import type { TouchstoneData, TouchstoneParseOptions, TouchstoneWriteOptions } from './types.js';
+/** DOM-independent Touchstone 1.x reflection-trace import and one-port export. */
 export declare class Touchstone {
     private constructor();
-    /** Read one-port Touchstone 1.x data; frequencies in the result are always Hz. */
-    static parse(text: string): TouchstoneData;
+    static parse(text: string, options: TouchstoneParseOptions & {
+        output: 'packed';
+    }): TouchstoneData<Float64Array>;
+    static parse(text: string, options?: TouchstoneParseOptions & {
+        output?: 'objects';
+    }): TouchstoneData;
+    static parse(text: string, options: TouchstoneParseOptions): TouchstoneData<TraceSamples | Float64Array>;
+    /** Serialize a reflection trace as one-port Touchstone, in Hz/RI without rounding or renormalization. */
+    static stringify(samples: TraceInput, options?: TouchstoneWriteOptions): string;
+    private static isNumber;
 }

package/dist/lib/io/Touchstone.js

@@ -1,75 +1,175 @@
+import { TraceBuffer } from '../traces/TraceBuffer.js';
+/** DOM-independent Touchstone 1.x reflection-trace import and one-port export. */
 export class Touchstone {
     constructor() { }
-    /** Read one-port Touchstone 1.x data; frequencies in the result are always Hz. */
-    static parse(text) {
+    /** Frequencies are returned in Hz. Two-port input must be explicitly selected. */
+    static parse(text, options = {}) {
+        const { ports = 1, parameter = 'S11', output = 'objects' } = options;
+        if (![1, 2].includes(ports) ||
+            !['S11', 'S22'].includes(parameter) ||
+            !['objects', 'packed'].includes(output) ||
+            (ports === 1 && parameter !== 'S11')) {
+            throw new TypeError('Expected ports 1 or 2, S11 (or S22 for two ports), and objects or packed output.');
+        }
         const units = { HZ: 1, KHZ: 1e3, MHZ: 1e6, GHZ: 1e9 };
         let frequencyScale = 1e9;
         let format = 'MA';
         let referenceImpedanceOhms = 50;
         let optionsSeen = false;
+        let count = 0;
+        let lineNumber = 0;
+        let recordLine = 0;
+        let fields = 0;
+        let previousFrequency = -1;
+        const width = ports === 1 ? 3 : 9;
+        const record = new Float64Array(width);
         const samples = [];
-        for (const [index, raw] of text
-            .replace(/^\uFEFF/, '')
-            .split(/\r?\n/)
-            .entries()) {
-            const line = raw.split('!')[0].trim();
+        let packed = new Float64Array(output === 'packed' ? 3072 : 0);
+        const fail = (message) => {
+            throw new Error(`Line ${lineNumber}: ${message}`);
+        };
+        // Scan lines lazily: do not retain a line array or allocate sample objects for packed output.
+        for (const match of text.matchAll(/[^\r\n]*(?:\r\n|\r|\n|$)/g)) {
+            lineNumber++;
+            const line = match[0].split('!', 1)[0].trim();
             if (!line) {
                 continue;
             }
-            const fail = (message) => {
-                throw new Error(`Line ${index + 1}: ${message}`);
-            };
             if (line.startsWith('[')) {
-                fail('Only Touchstone 1.x one-port files (.s1p) are supported.');
+                fail('Touchstone 2.x keywords are not supported; use a 1.x .s1p or .s2p file.');
             }
             if (line.startsWith('#')) {
-                if (optionsSeen || samples.length) {
+                if (optionsSeen || count || fields) {
                     fail('The option line must appear once, before the data.');
                 }
                 optionsSeen = true;
-                const options = line.slice(1).trim().toUpperCase().split(/\s+/).filter(Boolean);
-                if (!options.length) {
-                    continue;
+                const tokens = line.slice(1).trim().toUpperCase().split(/\s+/).filter(Boolean);
+                const seen = new Set();
+                for (let i = 0; i < tokens.length; i++) {
+                    const token = tokens[i];
+                    const kind = Object.hasOwn(units, token)
+                        ? 'unit'
+                        : ['RI', 'MA', 'DB'].includes(token)
+                            ? 'format'
+                            : token;
+                    if (!['unit', 'format', 'S', 'R'].includes(kind) || seen.has(kind)) {
+                        fail('Expected Hz|kHz|MHz|GHz, S, RI|MA|DB and one R impedance.');
+                    }
+                    seen.add(kind);
+                    if (kind === 'unit') {
+                        frequencyScale = units[token];
+                    }
+                    else if (kind === 'format') {
+                        format = token;
+                    }
+                    else if (kind === 'R') {
+                        const value = tokens[++i];
+                        if (!value || !Touchstone.isNumber(value)) {
+                            fail('Reference impedance must be a positive finite number.');
+                        }
+                        referenceImpedanceOhms = Number(value);
+                        if (!Number.isFinite(referenceImpedanceOhms) || referenceImpedanceOhms <= 0) {
+                            fail('Reference impedance must be a positive finite number.');
+                        }
+                    }
                 }
-                const [unit = 'GHZ', parameter = 'S', representation = 'MA', r = 'R', impedance = '50'] = options;
-                if (!(unit in units) ||
-                    parameter !== 'S' ||
-                    !['RI', 'MA', 'DB'].includes(representation) ||
-                    r !== 'R' ||
-                    options.length > 5) {
-                    fail('Expected: # Hz|kHz|MHz|GHz S RI|MA|DB R impedance.');
+                continue;
+            }
+            for (const token of line.matchAll(/\S+/g)) {
+                if (fields === width) {
+                    fail('Each frequency record must begin on a new line.');
                 }
-                frequencyScale = units[unit];
-                format = representation;
-                referenceImpedanceOhms = Number(impedance);
-                if (!Number.isFinite(referenceImpedanceOhms) || referenceImpedanceOhms <= 0) {
-                    fail('Reference impedance must be positive.');
+                if (!Touchstone.isNumber(token[0])) {
+                    fail('Expected finite decimal numbers.');
+                }
+                const value = Number(token[0]);
+                if (!Number.isFinite(value)) {
+                    fail('Expected finite decimal numbers.');
+                }
+                if (fields === 0) {
+                    recordLine = lineNumber;
+                    const frequencyHz = value * frequencyScale;
+                    if (frequencyHz < 0 || !Number.isFinite(frequencyHz)) {
+                        fail('Frequency must be finite and non-negative.');
+                    }
+                    // Legacy noise blocks restart the frequency sweep. Never interpret them as S data.
+                    if (ports === 2 && frequencyHz <= previousFrequency) {
+                        fail('Two-port frequencies must increase strictly; noise data is not supported.');
+                    }
+                    record[fields++] = frequencyHz;
+                }
+                else {
+                    record[fields++] = value;
                 }
-                continue;
             }
-            const fields = line.split(/\s+/).map(Number);
-            if (fields.length !== 3 || !fields.every(Number.isFinite)) {
-                fail('Expected frequency and two finite S11 components.');
+            if (fields !== width) {
+                continue;
             }
-            const [frequency, a, b] = fields;
-            const frequencyHz = frequency * frequencyScale;
-            if (frequencyHz < 0 || !Number.isFinite(frequencyHz)) {
-                fail('Frequency must be finite and non-negative.');
+            let real = 0;
+            let imaginary = 0;
+            for (let offset = 1; offset < width; offset += 2) {
+                const a = record[offset];
+                const b = record[offset + 1];
+                if (format === 'MA' && a < 0) {
+                    fail('Magnitude must be non-negative.');
+                }
+                const magnitude = format === 'DB' ? 10 ** (a / 20) : a;
+                const radians = ((b % 360) * Math.PI) / 180;
+                const re = format === 'RI' ? a : magnitude * Math.cos(radians);
+                const im = format === 'RI' ? b : magnitude * Math.sin(radians);
+                if (!Number.isFinite(re) || !Number.isFinite(im)) {
+                    fail('An S-parameter is outside the supported numeric range.');
+                }
+                if (offset === (parameter === 'S11' ? 1 : 7)) {
+                    real = re;
+                    imaginary = im;
+                }
             }
-            if (format === 'MA' && a < 0) {
-                fail('Magnitude must be non-negative.');
+            if (output === 'packed') {
+                if (count * 3 === packed.length) {
+                    const grown = new Float64Array(packed.length * 2);
+                    grown.set(packed);
+                    packed = grown;
+                }
+                packed[count * 3] = record[0];
+                packed[count * 3 + 1] = real;
+                packed[count * 3 + 2] = imaginary;
             }
-            const magnitude = format === 'DB' ? 10 ** (a / 20) : a;
-            const radians = (b * Math.PI) / 180;
-            const reflectionCoefficient = format === 'RI' ? [a, b] : [magnitude * Math.cos(radians), magnitude * Math.sin(radians)];
-            if (!reflectionCoefficient.every(Number.isFinite)) {
-                fail('S11 is outside the supported numeric range.');
+            else {
+                samples.push({ frequencyHz: record[0], reflectionCoefficient: [real, imaginary] });
             }
-            samples.push({ frequencyHz, reflectionCoefficient });
+            previousFrequency = record[0];
+            count++;
+            fields = 0;
         }
-        if (!samples.length) {
-            throw new Error('The file contains no S11 samples.');
+        if (fields) {
+            throw new Error(`Line ${recordLine}: Incomplete ${ports}-port record; expected ${width} values. Noise data is not supported.`);
         }
-        return { samples, referenceImpedanceOhms };
+        if (!count) {
+            throw new Error(`The file contains no ${parameter} samples.`);
+        }
+        return {
+            samples: output === 'packed' ? packed.slice(0, count * 3) : samples,
+            referenceImpedanceOhms,
+        };
+    }
+    /** Serialize a reflection trace as one-port Touchstone, in Hz/RI without rounding or renormalization. */
+    static stringify(samples, options = {}) {
+        const { referenceImpedanceOhms = 50 } = options;
+        if (!Number.isFinite(referenceImpedanceOhms) || referenceImpedanceOhms <= 0) {
+            throw new RangeError('Reference impedance must be positive and finite.');
+        }
+        const data = TraceBuffer.from(samples);
+        const lines = [`# Hz S RI R ${referenceImpedanceOhms}`];
+        for (let i = 0; i < data.length; i++) {
+            if (i > 0 && data.frequency(i) <= data.frequency(i - 1)) {
+                throw new RangeError('Touchstone export requires strictly increasing frequencies.');
+            }
+            lines.push(`${data.frequency(i)} ${data.real(i)} ${data.imaginary(i)}`);
+        }
+        return lines.join('\n') + '\n';
+    }
+    static isNumber(token) {
+        return /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i.test(token);
     }
 }

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/math/Complex.d.ts

@@ -117,7 +117,7 @@ export declare class Complex {
     private static hyperbolicProduct;
     private static hyperbolicReciprocal;
     /**
-     * Elliptic coordinates for principal inverse functions (x,y >= 0).
+     * Elliptic coordinates for principal inverse functions (non-negative x and y).
      * With a = (|z+1| + |z-1|)/2, return acosh(a) and sqrt(a²-x²).
      * Rationalized hypot differences retain tiny components near the branch cuts.
      * Principal branches: https://dlmf.nist.gov/4.37

package/dist/lib/math/Complex.js

@@ -34,7 +34,7 @@ export class Complex {
         }
         if (args.length === 2) {
             const arg0 = args[0];
-            const arg1 = args[1];
+            const arg1 = args[1] === undefined ? 0 : args[1];
             if (typeof arg0 === 'number' && typeof arg1 === 'number') {
                 return new Complex(arg0, arg1);
             }
@@ -598,7 +598,7 @@ export class Complex {
         return Complex.reciprocal(denominator).mul(Math.exp(Math.LN2 - x));
     }
     /**
-     * Elliptic coordinates for principal inverse functions (x,y >= 0).
+     * Elliptic coordinates for principal inverse functions (non-negative x and y).
      * With a = (|z+1| + |z-1|)/2, return acosh(a) and sqrt(a²-x²).
      * Rationalized hypot differences retain tiny components near the branch cuts.
      * Principal branches: https://dlmf.nist.gov/4.37

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() {
@@ -331,7 +356,7 @@ export class SvgChartRenderer {
         this.traces.forEach((d) => d.zoom(transform));
     }
     cursorContainer() {
-        const shape = this.drawReactanceAxis({ fill: 'transparent', stroke: 'none' });
+        const shape = this.drawReactanceAxis({ fill: 'transparent', stroke: 'none', strokeWidth: '0' });
         shape.Element.style('pointer-events', 'all')
             .on('pointermove.smithkit', (event) => {
             this.cursorMove(d3.pointer(event));

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;