smithkit 0.4.0 → 0.5.0

package/README.md

@@ -5,7 +5,7 @@ interactive SVG Smith charts, RF calculations, and S11 measurement exploration.
 
 [Try the interactive demo](https://rosek86.github.io/smithkit/) or browse the
 [integration examples](https://rosek86.github.io/smithkit/examples/index.html):
-static charts, marker controls, themes, report exports, and lifecycle cleanup.
+static charts, marker controls, a 100,000-sample trace, themes, report exports, and lifecycle cleanup.
 Each example includes its TypeScript source.
 
 Upgrading from 0.3.x? Version 0.4.0 introduces grouped constructor options and
@@ -34,7 +34,7 @@ define the public contract and the compatibility scope intended for 1.0. During
 - Physical impedance/admittance conversions and DOM-independent RF readings.
 - Twelve parameter scales mounted independently of chart zoom.
 - Four peripheral rulers for phase and electrical length.
-- One-port Touchstone 1.x import with RI, MA, and DB representations.
+- Touchstone 1.x `.s1p` / `.s2p` reflection import (RI/MA/DB), packed output, and `.s1p` export.
 - Standalone SVG and configurable PNG export of the chart and radial scales.
 - ESM modules and TypeScript declarations.
 
@@ -121,6 +121,69 @@ events work independently.
 container throws. Call `chart.destroy()` on unmount; it removes the SVG, releases
 event handlers, and cancels queued notifications. Repeated destruction is safe.
 
+## Trace input formats
+
+`addTrace()` and `updateTrace()` accept the same `TraceInput` union:
+
+- `TraceSamples`: an array of objects with `frequencyHz` and `reflectionCoefficient`.
+- `readonly TraceTuple[]`: `[frequencyHz, re, im]` tuples, including `as const` arrays.
+- `Float64Array`: packed triples in the order `f, re, im, f, re, im, …`.
+
+In every format, frequency is in **Hz** and `re`/`im` are the dimensionless
+voltage reflection coefficient **Γ**, relative to the chart's reference impedance.
+A single input must use one format throughout; mixed tuples and objects are rejected.
+Typed-array views are supported; only values inside the supplied view are copied.
+The packed length must be a positive multiple of three. All formats use the same
+finite-value checks and retain input order, duplicate frequencies, and full sample precision.
+
+```ts
+import { Smith, type TraceTuple } from 'smithkit';
+
+const chart = new Smith();
+chart.draw('#smith');
+const samples: readonly TraceTuple[] = [
+  [1e9, 0.4, -0.4],
+  [1.5e9, 0, 0],
+  [2e9, 0.4, 0.4],
+];
+const traceId = chart.addTrace(samples, { name: 'S11', mode: 'line' });
+
+// A later update may use a different format. Each triple is one sample.
+chart.updateTrace(traceId, new Float64Array([1e9, 0.3, -0.3, 1.5e9, 0, 0, 2e9, 0.3, 0.3]));
+```
+
+For large datasets, fill the packed array directly to avoid creating intermediate
+objects or tuples:
+
+```ts
+import { Smith } from 'smithkit';
+
+const count = 100_000;
+const samples = new Float64Array(count * 3);
+for (let i = 0; i < count; i++) {
+  samples[3 * i] = 1e9 + i * 1e4;
+  samples[3 * i + 1] = 0.7 * Math.cos((i / count) * 10);
+  samples[3 * i + 2] = 0.7 * Math.sin((i / count) * 10);
+}
+const chart = new Smith();
+chart.draw('#smith');
+const traceId = chart.addTrace(samples, { mode: 'points' });
+chart.addMarker(traceId, count - 1);
+```
+
+All inputs are copied into owned packed storage (24 bytes per sample for the numeric
+payload). Modifying the input after adding or updating a trace does not change the
+chart. Marker readings and events keep their existing object shape. `Touchstone.parse()` returns object samples by default, or packed triples with
+`output: 'packed'`. `RfCalculations.renormalizeSamples()` preserves object or packed
+representation.
+Invalid replacements leave data, markers, and rendering unchanged.
+
+For more than 5,000 samples, point rendering groups overlapping points into screen
+cells and skips offscreen points; markers still select from the full data. Lines
+retain every sample, so very large SVG paths can remain expensive to render and export.
+Sorted ascending frequencies accelerate frequency selection; unsorted inputs remain
+supported without reordering. There is no automatic interpolation or data reduction.
+
 ## Constructor configuration
 
 `new Smith(options?)` accepts a typed `SmithOptions` object. Every field is optional:
@@ -308,21 +371,41 @@ after destruction throw; trace/marker lookups return empty or missing results.
 
 ## Trace appearance
 
-Pass `mode: 'points' | 'line' | 'both'`, `lineWidth`, and `pointRadius` to
+Pass `mode: 'points' | 'line' | 'both'`, `lineWidth`, `pointRadius`, and `lineTolerancePx` to
 `addTrace` or `setTraceOptions`. Defaults are points, 2 px line width, and 2 px point radius. Both sizes are
 CSS pixels and remain constant under chart zoom and container resize. Widths and radii must be positive and finite.
 `getTraces()` includes the current style.
 
-Lines connect all samples in input order, without smoothing or frequency sorting.
+By default, lines connect all samples in input order, without smoothing or frequency sorting.
 A line-only trace creates one SVG path and no sample circles, suitable for dense
 sweeps. Points/both render every sample for traces up to 5,000 samples. Larger traces
 render one representative per point-radius-sized display cell and skip points
 outside the viewport; representatives are recalculated during zoom/pan.
 This only simplifies the image: all original samples remain available to markers,
-snapping, readouts, and comparisons. Lines still connect every input sample.
+snapping, readouts, and comparisons.
 Styles do not change marker identity or layer ordering. Hidden traces retain their style after sample replacement.
 The demo exposes the same controls per trace.
 
+For dense lines, opt into `lineTolerancePx` (finite, non-negative; default `0` disables
+simplification):
+
+```ts
+chart.setTraceOptions(traceId, { mode: 'line', lineTolerancePx: 0.5 });
+```
+
+The tolerance bounds additional geometric deviation in **CSS pixels**, accounting for
+chart zoom and container size. It does not include SVG coordinate rounding or browser
+antialiasing. Cached, nested geometry levels retain endpoints and input order; zooming
+in selects finer geometry, while panning reuses the current level. The cache is rebuilt
+when samples change, including reference-impedance renormalization. Markers, frequency
+selection, RF calculations, and sample counts always use the full data. The option
+applies to the line in `line` and `both` modes; point rendering is unchanged.
+
+Preparing levels takes extra CPU and memory, and noisy traces may simplify very little.
+This is an opt-in display optimization, not data compression. See the
+[large-trace example](https://rosek86.github.io/smithkit/examples/large-trace/) to compare
+full geometry with pixel tolerances and [local measurements](docs/performance.md).
+
 ## Events and readings
 
 `onEvent(listener)` supports multiple independent subscriptions and returns an
@@ -638,7 +721,30 @@ from S11 alone. At \|Γ\| = 0.1 it reads 10 dB, while return loss reads 20 dB.
 
 Peripheral rulers are hidden by default. Enable them with
 `{ peripheralScales: { visible: true } }` or `chart.peripheralScales.setVisible(true)`.
-`chart.peripheralScales` supports `setVisible(boolean)` and `update(Complex | null)`.
+Axis captions and numeric tick labels can be controlled independently, through the
+constructor, `setOptions()`, or the peripheral scale controls:
+
+```ts
+import { Smith } from 'smithkit';
+
+const chart = new Smith({
+  peripheralScales: { visible: true, captionsVisible: false, tickLabelsVisible: true },
+});
+chart.draw('#smith');
+
+chart.setOptions({ peripheralScales: { captionsVisible: true } });
+chart.peripheralScales.setTickLabelsVisible(false); // Captions and rulers remain visible.
+chart.peripheralScales.setCaptionsVisible(false); // Rulers and indicators remain visible.
+```
+
+Both text options default to `true`; the entire group remains hidden by default.
+When captions are hidden, numeric labels fill the sectors normally reserved for them.
+Hiding/re-showing the rulers preserves both preferences. Text controls do not affect
+ruler lines, ticks, indicators, grid labels, or the independent radial parameter scales.
+SVG/PNG exports preserve the current text visibility. The demo exposes **Axis captions**
+and **Tick values** checkboxes in **Chart settings**.
+
+`chart.peripheralScales.update(Complex | null)` supplies or clears the indicators.
 Its four rulers zoom with the chart: reflection phase, voltage transmission phase,
 wavelengths toward generator, and wavelengths toward load. Wavelength rulers start
 at the negative real axis, with 0.5 λ per revolution (generator clockwise, load
@@ -677,17 +783,29 @@ Import renormalization is enabled by a labeled checkbox. Disable it to reject
 files whose reference differs from the chart. Complex reference impedances and
 multiport renormalization are outside the supported scope.
 
-## Touchstone import
+## Touchstone import and export
 
-`Touchstone.parse(text)` returns `{ samples, referenceImpedanceOhms }`. It accepts
-one-port Touchstone 1.x, converts RI/MA/DB into Cartesian Γ and all frequencies
-into Hz, and throws for unsupported or invalid input.
+`Touchstone.parse(text, options?)` returns `{ samples, referenceImpedanceOhms }`.
+It reads Touchstone 1.x S-parameters, converts RI/MA/DB into Cartesian Γ and
+frequencies into Hz, and throws an `Error` with a line number for invalid content.
+Invalid parser options throw `TypeError`.
+
+| Option      | Default     | Meaning                                                                          |
+| ----------- | ----------- | -------------------------------------------------------------------------------- |
+| `ports`     | `1`         | Source port count: `1` for `.s1p`, `2` for `.s2p`. It is not inferred from text. |
+| `parameter` | `'S11'`     | Reflection parameter: `'S11'` or, with two ports, `'S22'`.                       |
+| `output`    | `'objects'` | Object samples or `'packed'` `Float64Array` containing f/re/im triples.          |
 
 ```ts
 import { Smith, Touchstone } from 'smithkit';
 
 async function showMeasurement(file: File): Promise<Smith> {
-  const { samples, referenceImpedanceOhms } = Touchstone.parse(await file.text());
+  const ports = /\.s2p$/i.test(file.name) ? 2 : 1;
+  const { samples, referenceImpedanceOhms } = Touchstone.parse(await file.text(), {
+    ports,
+    parameter: ports === 2 ? 'S22' : 'S11',
+    output: 'packed',
+  });
   const chart = new Smith({ referenceImpedanceOhms });
   chart.draw('#smith');
   chart.addTrace(samples, { name: file.name });
@@ -695,10 +813,51 @@ async function showMeasurement(file: File): Promise<Smith> {
 }
 ```
 
-Omitted options use Touchstone defaults: GHz, S, MA, 50 Ω. For an existing chart,
-use `RfCalculations.renormalizeSamples` when the file reference differs from
-`chart.referenceImpedanceOhms`. The parser itself does not renormalize data.
-Multiport data and Touchstone 2.x are not supported.
+Packed parsing writes directly into growing typed storage, without creating an
+object or coordinate array per sample. It scans lines incrementally within the
+supplied string; this is not a streaming file API. The returned buffer has exact
+length and is caller-owned. The default object result remains unchanged.
+
+Omitted header options use GHz, S, MA, 50 Ω. The parser accepts comments, BOM,
+LF/CRLF/CR line endings, decimal scientific notation, and continued records. Each
+frequency record starts on a new line. Two-port records use S11, S21, S12, S22
+order; all four parameters are validated even though only one reflection trace is
+returned. Two-port frequencies must increase strictly. Three or more ports,
+per-port/complex reference impedances, noise blocks and Touchstone 2.x keywords
+are rejected. See the [IBIS Touchstone specification](https://www.ibis.org/touchstone_ver2.1/touchstone_ver2_1.pdf)
+for the legacy 1.x data layout.
+
+`Touchstone.stringify(samples, { referenceImpedanceOhms })` returns `.s1p` text
+with a `# Hz S RI R …` header and a final newline. It accepts object samples,
+tuples, or packed triples, writes numeric values without a precision limit, and
+does not modify or renormalize the input. The reference defaults to 50 Ω; supply
+the actual reference of your data. Empty/invalid samples, nonpositive/nonfinite
+reference impedance, and duplicate or descending frequencies throw `RangeError`.
+Samples are never silently sorted or discarded.
+
+```ts
+import { RfCalculations, Touchstone } from 'smithkit';
+
+const sourceText = '# GHz S RI R 50\n1 0 0\n2 0.5 0';
+const parsed = Touchstone.parse(sourceText, { output: 'packed' });
+const samples = RfCalculations.renormalizeSamples(
+  parsed.samples,
+  parsed.referenceImpedanceOhms,
+  75,
+);
+const text = Touchstone.stringify(samples, { referenceImpedanceOhms: 75 });
+// Save text as measurement.s1p in your application.
+```
+
+For an extracted S11/S22 trace, this is **one-port renormalization**: the other
+port remains terminated in the original file reference. It is not renormalization
+of the complete two-port network. Exporting S22 to `.s1p` represents that selected
+port as the single port of the new file; transmission data is not exported.
+
+The [Touchstone example](https://rosek86.github.io/smithkit/examples/touchstone/index.html)
+shows parameter selection, packed import, renormalization and download. In the demo,
+choose **Two-port reflection** before importing `.s2p`; the trace name includes the
+selected parameter. Both `.s1p` and `.s2p` use packed import.
 
 ## PNG and report export
 
@@ -725,6 +884,11 @@ const scalePng = await scales.toPng({ width: 1200, background: 'transparent' });
 - `background`: omit to keep component backgrounds, or pass a concrete CSS color
   (for example `'#fff'`) or `'transparent'` to replace them. Chart colors stay as
   configured; choose a suitable chart theme for your report background.
+- `lineDetail` (chart only): `'full'` (default) includes every sample in each trace line;
+  `'view'` preserves the currently displayed line geometry, including simplification.
+  Both work for SVG and PNG without changing the live chart. Increasing export dimensions
+  scales the current-view error too; use `'full'` for reports requiring all samples.
+  This option does not change point culling, the viewport, markers, or scales.
 - `legend` (chart only): append the names and colors of visible traces. Long names
   wrap; hidden traces are omitted. Default: `false`.
 - `markerLegend` (chart only): independently append marker descriptions below the chart/scales.

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]]) {
@@ -146,7 +152,7 @@ export class Smith {
     toSvg(options) {
         this.assertAlive();
         this.validateExportOptions(options);
-        const source = this.renderer.toSvg();
+        const source = this.renderer.toSvg(options?.lineDetail ?? 'full');
         if (options === undefined) {
             return source;
         }
@@ -157,6 +163,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 +187,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 +240,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 +293,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 +335,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 +430,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/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);
     }
 }