smithkit 0.3.0 → 0.5.0

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

@@ -21,13 +21,15 @@ export interface GridLayer {
     setVisible(visible: boolean): void;
     /** Show or hide labels independently of grid lines. Default: true. */
     setLabelsVisible(visible: boolean): void;
-    /** Default: detailed. Basic shows only the principal normalized values. */
+    /** Default: standard. Basic shows only the principal normalized values. */
     setDetail(detail: GridDetail): void;
     setStyle(style: Partial<GridStyle>): void;
 }
 export interface CircleLayer {
     setVisible(visible: boolean): void;
     setStyle(style: Partial<CircleStyle>): void;
+    /** Replace the complete set after validation; duplicates are ignored and empty clears it. */
+    setValues(values: readonly number[]): void;
     addValue(value: number): void;
     removeValue(value: number): void;
 }
@@ -41,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

@@ -0,0 +1,58 @@
+import type { SmithAppearance } from './appearance/types.js';
+import type { CircleStyle, GridDetail, GridStyle } from './layers.js';
+/** Settings for an individual impedance/admittance grid layer. */
+export interface GridLayerOptions {
+    visible?: boolean;
+    detail?: GridDetail;
+    labelsVisible?: boolean;
+    style?: Partial<GridStyle>;
+}
+/** Shared settings for all four grids, followed by per-layer overrides. */
+export interface GridOptions {
+    /** Default: standard. */
+    detail?: GridDetail;
+    /** Default: true. */
+    labelsVisible?: boolean;
+    style?: Partial<GridStyle>;
+    layers?: {
+        resistance?: GridLayerOptions;
+        reactance?: GridLayerOptions;
+        conductance?: GridLayerOptions;
+        susceptance?: GridLayerOptions;
+    };
+}
+export interface CircleLayerOptions {
+    /** Default: false. */
+    visible?: boolean;
+    style?: Partial<CircleStyle>;
+    /** Replace the default values. Empty hides all circles; duplicate values are ignored. */
+    values?: readonly number[];
+}
+export interface CircleOptions {
+    q?: CircleLayerOptions;
+    vswr?: CircleLayerOptions;
+}
+export interface InteractionOptions {
+    /** Enable wheel/pan/pinch gestures. Default: false. */
+    zoom?: boolean;
+    /** Enable cursor overlay and pointer readings. Default: false. */
+    cursor?: boolean;
+}
+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. */
+    referenceImpedanceOhms?: number;
+    /** Default: the light preset. Use overrides for fonts, colors, and marker/cursor styling. */
+    appearance?: SmithAppearance;
+    interaction?: InteractionOptions;
+    grid?: GridOptions;
+    circles?: CircleOptions;
+    peripheralScales?: PeripheralScalesOptions;
+}

package/dist/lib/options.js

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

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';
@@ -13,6 +13,7 @@ export declare class SvgChartRenderer {
     private readonly defaultTransform;
     private transform;
     private zoomEnabled;
+    private cursorEnabled;
     private applyingView;
     private zoomBehavior;
     private svg;
@@ -41,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;
@@ -50,6 +51,8 @@ export declare class SvgChartRenderer {
     private cursorMove;
     setMarkerDragging(dragging: boolean): void;
     hideCursor(): void;
+    /** Disable tracking and cancel queued readings; enabling waits for the next pointer move. */
+    setCursorEnabled(enabled: boolean): void;
     private initCursor;
     get cursorPosition(): Complex;
     private initializeZoom;
@@ -61,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';
@@ -28,7 +29,8 @@ export class SvgChartRenderer {
     scalers;
     defaultTransform = d3.zoomIdentity.translate(62.5, 62.5).scale(0.75);
     transform = d3.zoomIdentity;
-    zoomEnabled = true;
+    zoomEnabled = false;
+    cursorEnabled = false;
     applyingView = false;
     zoomBehavior = d3.zoom();
     svg;
@@ -63,25 +65,25 @@ export class SvgChartRenderer {
         this.constResistance = new ConstResistance({
             data: gridData,
             scaler: this.scalers.default,
-            detail: 'detailed',
+            detail: 'standard',
         });
         this.constResistance.show();
         this.constReactance = new ConstReactance({
             data: gridData,
             scaler: this.scalers.default,
-            detail: 'detailed',
+            detail: 'standard',
         });
         this.constReactance.show();
         this.constConductance = new ConstConductance({
             data: gridData,
             scaler: this.scalers.default,
-            detail: 'detailed',
+            detail: 'standard',
         });
         this.constConductance.hide();
         this.constSusceptance = new ConstSusceptance({
             data: gridData,
             scaler: this.scalers.default,
-            detail: 'detailed',
+            detail: 'standard',
         });
         this.constSusceptance.hide();
         this.constQCircles = new ConstQCircles(this.scalers.default);
@@ -135,6 +137,9 @@ export class SvgChartRenderer {
         this.peripheralScales = {
             setVisible: (visible) => {
                 assertAlive();
+                if (typeof visible !== 'boolean') {
+                    throw new TypeError('Peripheral scale visibility must be a boolean.');
+                }
                 if (visible) {
                     this.peripheralScaleRenderer.show();
                 }
@@ -143,11 +148,22 @@ 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);
             },
         };
+        this.peripheralScaleRenderer.hide();
         this.initializeZoom();
         this.resizeObserver = new ResizeObserver(() => this.updateViewportScale());
         this.resizeObserver.observe(this.svg.Node);
@@ -167,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() {
@@ -216,7 +246,7 @@ export class SvgChartRenderer {
         return { default: impedance, impedance, admittance };
     }
     cursorMove(p) {
-        if (this.markerDragging) {
+        if (!this.cursorEnabled || this.markerDragging) {
             return;
         }
         this.cursor.Position = Complex.from(this.scalers.default.pointInvert(p));
@@ -226,7 +256,7 @@ export class SvgChartRenderer {
         if (dragging) {
             this.cursorBeforeMarkerDrag = this.svg.Node.style.getPropertyValue('cursor') || null;
             this.svg.Element.style('cursor', 'grabbing').style('--smithkit-marker-cursor', 'grabbing');
-            this.cursor.hide();
+            this.hideCursor();
         }
         else {
             this.svg.Element.style('cursor', () => this.cursorBeforeMarkerDrag).style('--smithkit-marker-cursor', null);
@@ -235,6 +265,24 @@ export class SvgChartRenderer {
     }
     hideCursor() {
         this.cursor.hide();
+        if (this.cursorEnabled) {
+            this.onCursorChange?.(undefined);
+        }
+    }
+    /** Disable tracking and cancel queued readings; enabling waits for the next pointer move. */
+    setCursorEnabled(enabled) {
+        this.assertAlive();
+        if (typeof enabled !== 'boolean') {
+            throw new TypeError('Cursor enabled must be a boolean.');
+        }
+        if (this.cursorEnabled === enabled) {
+            return;
+        }
+        this.cursorEnabled = enabled;
+        if (!enabled) {
+            this.cursor.hide();
+            this.onCursorChange?.(undefined);
+        }
     }
     initCursor() {
         const cursor = new SmithCursor(this.scalers.default);
@@ -314,8 +362,7 @@ export class SvgChartRenderer {
             this.cursorMove(d3.pointer(event));
         })
             .on('pointerleave.smithkit', () => {
-            this.cursor.hide();
-            this.onCursorChange?.(undefined);
+            this.hideCursor();
         });
         return shape;
     }

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. */