smithkit 0.1.1 → 0.2.0

package/dist/lib/{draw → interaction}/SmithCursor.js

@@ -1,9 +1,9 @@
-import { SmithGroup } from './SmithGroup.js';
-import { SmithCircle } from './SmithCircle.js';
-import { SmithLine } from './SmithLine.js';
-import { SmithArc } from './SmithArc.js';
-import { SmithConstantCircle } from '../SmithConstantCircle.js';
-import { Complex } from '../complex/Complex.js';
+import { SmithGroup } from '../svg/SmithGroup.js';
+import { SmithCircle } from '../svg/SmithCircle.js';
+import { SmithLine } from '../svg/SmithLine.js';
+import { SmithArc } from '../svg/SmithArc.js';
+import { SmithConstantCircle } from '../rf/SmithConstantCircle.js';
+import { Complex } from '../math/Complex.js';
 export class SmithCursor {
     scaler;
     epsilon = 1.5e-4;

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

@@ -0,0 +1,10 @@
+import type { TraceSamples } from '../samples.js';
+export interface TouchstoneData {
+    samples: TraceSamples;
+    referenceImpedanceOhms: number;
+}
+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;
+}

package/dist/lib/io/Touchstone.js

@@ -0,0 +1,75 @@
+export class Touchstone {
+    constructor() { }
+    /** Read one-port Touchstone 1.x data; frequencies in the result are always Hz. */
+    static parse(text) {
+        const units = { HZ: 1, KHZ: 1e3, MHZ: 1e6, GHZ: 1e9 };
+        let frequencyScale = 1e9;
+        let format = 'MA';
+        let referenceImpedanceOhms = 50;
+        let optionsSeen = false;
+        const samples = [];
+        for (const [index, raw] of text
+            .replace(/^\uFEFF/, '')
+            .split(/\r?\n/)
+            .entries()) {
+            const line = raw.split('!')[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.');
+            }
+            if (line.startsWith('#')) {
+                if (optionsSeen || samples.length) {
+                    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 [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.');
+                }
+                frequencyScale = units[unit];
+                format = representation;
+                referenceImpedanceOhms = Number(impedance);
+                if (!Number.isFinite(referenceImpedanceOhms) || referenceImpedanceOhms <= 0) {
+                    fail('Reference impedance must be positive.');
+                }
+                continue;
+            }
+            const fields = line.split(/\s+/).map(Number);
+            if (fields.length !== 3 || !fields.every(Number.isFinite)) {
+                fail('Expected frequency and two finite S11 components.');
+            }
+            const [frequency, a, b] = fields;
+            const frequencyHz = frequency * frequencyScale;
+            if (frequencyHz < 0 || !Number.isFinite(frequencyHz)) {
+                fail('Frequency must be finite and non-negative.');
+            }
+            if (format === 'MA' && a < 0) {
+                fail('Magnitude must be non-negative.');
+            }
+            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.');
+            }
+            samples.push({ frequencyHz, reflectionCoefficient });
+        }
+        if (!samples.length) {
+            throw new Error('The file contains no S11 samples.');
+        }
+        return { samples, referenceImpedanceOhms };
+    }
+}

package/dist/lib/layers.d.ts

@@ -1,7 +1,4 @@
-import type { ConstCircles } from './draw/ConstCircles.js';
-import type { ConstQCircles } from './draw/ConstQCircles.js';
-import type { ConstSwrCircles } from './draw/ConstSwrCircles.js';
-import type { Complex } from './complex/Complex.js';
+import type { Complex } from './math/Complex.js';
 export interface GridStyle {
     stroke: string;
     /** Non-scaling stroke width in CSS pixels. */
@@ -10,7 +7,7 @@ export interface GridStyle {
     minorWidth: number;
     textColor: string;
     textFontFamily: string;
-    /** Font size in SVG chart units; labels scale with chart geometry. */
+    /** Base font size in chart units; adaptive layout enforces a 9 CSS px minimum in the default view. */
     textFontSize: number;
 }
 export interface CircleStyle {
@@ -43,6 +40,3 @@ export interface PeripheralScales {
     /** Pass null to clear the indicators. */
     update(reflectionCoefficient: Complex | null): void;
 }
-/** Keep renderer instances out of the public chart API. */
-export declare function gridLayer(layer: ConstCircles, assertAlive: () => void): GridLayer;
-export declare function circleLayer(layer: ConstQCircles | ConstSwrCircles, minimum: number, assertAlive: () => void): CircleLayer;

package/dist/lib/layers.js

@@ -1,73 +1 @@
-/** Keep renderer instances out of the public chart API. */
-export function gridLayer(layer, assertAlive) {
-    return {
-        setVisible(visible) {
-            assertAlive();
-            layer.visibility(visible);
-        },
-        setMinorVisible(visible) {
-            assertAlive();
-            layer.displayMinor(visible);
-        },
-        setStyle(style) {
-            assertAlive();
-            validateLengths(style, ['majorWidth', 'minorWidth', 'textFontSize']);
-            const properties = {
-                stroke: 'Stroke',
-                majorWidth: 'MajorWidth',
-                minorWidth: 'MinorWidth',
-                textColor: 'TextColor',
-                textFontFamily: 'TextFontFamily',
-                textFontSize: 'TextFontSize',
-            };
-            for (const key of Object.keys(properties)) {
-                const value = style[key];
-                if (value !== undefined) {
-                    layer[properties[key]] = String(value);
-                }
-            }
-        },
-    };
-}
-export function circleLayer(layer, minimum, assertAlive) {
-    const validate = (value) => {
-        if (!Number.isFinite(value) || value < minimum || value <= 0) {
-            throw new RangeError(`Circle value must be finite, positive, and at least ${minimum}.`);
-        }
-    };
-    return {
-        setVisible(visible) {
-            assertAlive();
-            layer.visibility(visible);
-        },
-        setStyle(style) {
-            assertAlive();
-            validateLengths(style, ['strokeWidth']);
-            if (style.stroke !== undefined) {
-                layer.Stroke = style.stroke;
-            }
-            if (style.strokeWidth !== undefined) {
-                layer.StrokeWidth = String(style.strokeWidth);
-            }
-        },
-        addValue(value) {
-            assertAlive();
-            validate(value);
-            layer.append(value);
-        },
-        removeValue(value) {
-            assertAlive();
-            validate(value);
-            layer.remove(value);
-        },
-    };
-}
-function validateLengths(style, keys) {
-    for (const key of keys) {
-        const value = style[key];
-        if (value !== undefined &&
-            (typeof value !== 'number' || !Number.isFinite(value) || value <= 0)) {
-            throw new RangeError(`${String(key)} must be a positive finite number.`);
-        }
-    }
-}
+export {};

package/dist/lib/{complex → math}/Complex.d.ts

@@ -126,5 +126,6 @@ export declare class Complex {
     static equals(z1: Complex, z2: Complex, epsilon?: number): boolean;
     static toPolar(z: Complex): [number, number];
     static toVector(z: Complex): [number, number];
+    /** Format Cartesian components with Number.toFixed(dp), defaulting to three decimal places. */
     static toString(z: Complex, dp?: number): string;
 }

package/dist/lib/{complex → math}/Complex.js

@@ -626,7 +626,7 @@ export class Complex {
     static toVector(z) {
         return [z.re, z.im];
     }
-    // TODO: format
+    /** Format Cartesian components with Number.toFixed(dp), defaulting to three decimal places. */
     static toString(z, dp = 3) {
         const re = z.re.toFixed(dp);
         const im = Math.abs(z.im).toFixed(dp);

package/dist/lib/math/geometry.d.ts

@@ -0,0 +1,14 @@
+export type Point = [number, number];
+export interface Line {
+    p1: Point;
+    p2: Point;
+}
+export interface Circle {
+    p: Point;
+    r: number;
+}
+export interface Arc {
+    p1: Point;
+    p2: Point;
+    r: number;
+}

package/dist/lib/measurements.d.ts

@@ -1,5 +1,5 @@
-import { Complex } from './complex/Complex.js';
-import type { SmithReading } from './rf.js';
+import { Complex } from './math/Complex.js';
+import type { SmithReading } from './rf/RfCalculations.js';
 export type TraceRenderMode = 'points' | 'line' | 'both';
 export interface TraceStyle {
     mode: TraceRenderMode;
@@ -49,5 +49,3 @@ export interface MarkerComparison {
     /** Shortest signed B − A phase difference in [−180, 180); undefined at Γ = 0. */
     readonly phaseDeltaDegrees: number | undefined;
 }
-/** Compare B against A without a chart or browser. Frequencies must be finite and non-negative. */
-export declare function compareMarkerReadings(a: Pick<MarkerSnapshot, 'frequencyHz' | 'impedanceOhms' | 'reflectionCoefficient'>, b: Pick<MarkerSnapshot, 'frequencyHz' | 'impedanceOhms' | 'reflectionCoefficient'>): MarkerComparison;

package/dist/lib/measurements.js

@@ -1,19 +1 @@
-/** Compare B against A without a chart or browser. Frequencies must be finite and non-negative. */
-export function compareMarkerReadings(a, b) {
-    if (![a.frequencyHz, b.frequencyHz].every((frequencyHz) => Number.isFinite(frequencyHz) && frequencyHz >= 0)) {
-        throw new RangeError('Marker frequencies must be finite and non-negative.');
-    }
-    const isFinite = (value) => Number.isFinite(value.re) && Number.isFinite(value.im);
-    const hasPhase = (gamma) => isFinite(gamma) && (gamma.re !== 0 || gamma.im !== 0);
-    const phaseDelta = hasPhase(a.reflectionCoefficient) && hasPhase(b.reflectionCoefficient)
-        ? ((b.reflectionCoefficient.arg() - a.reflectionCoefficient.arg()) * 180) / Math.PI
-        : undefined;
-    const impedanceDelta = a.impedanceOhms && b.impedanceOhms && isFinite(a.impedanceOhms) && isFinite(b.impedanceOhms)
-        ? b.impedanceOhms.sub(a.impedanceOhms)
-        : undefined;
-    return {
-        frequencyDeltaHz: b.frequencyHz - a.frequencyHz,
-        impedanceDeltaOhms: impedanceDelta && isFinite(impedanceDelta) ? impedanceDelta : undefined,
-        phaseDeltaDegrees: phaseDelta === undefined ? undefined : ((phaseDelta + 540) % 360) - 180,
-    };
-}
+export {};

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

@@ -0,0 +1,65 @@
+import type { TraceSamples } from '../samples.js';
+import { Complex } from '../math/Complex.js';
+/** Physical quantities derived from a voltage reflection coefficient Γ. */
+export interface SmithReading {
+    readonly reflectionCoefficient: Complex;
+    readonly impedanceOhms: Complex | undefined;
+    readonly admittanceSiemens: Complex | undefined;
+    readonly phaseDegrees: number | undefined;
+    readonly vswr: number | undefined;
+    readonly standingWaveRatioDb: number | undefined;
+    readonly returnLossDb: number;
+    readonly reflectionLossDb: number | undefined;
+    readonly attenuationDb: number | undefined;
+    readonly q: number | undefined;
+    readonly powerReflectionCoefficient: number;
+    readonly voltageReflectionCoefficientMagnitude: number;
+    readonly powerTransmissionCoefficient: number | undefined;
+    readonly voltageTransmissionCoefficientMagnitude: number;
+    readonly currentTransmissionCoefficientMagnitude: number;
+    readonly standingWavePeak: number | undefined;
+    readonly standingWaveLossCoefficient: number | undefined;
+}
+/** An ideal series component equivalent to a reactance at one frequency. */
+export type ReactiveComponent = {
+    readonly kind: 'inductor';
+    readonly inductanceHenries: number;
+} | {
+    readonly kind: 'capacitor';
+    readonly capacitanceFarads: number;
+};
+export declare class RfCalculations {
+    private constructor();
+    private static readonly calcs;
+    private static validateReference;
+    private static validateComplex;
+    private static finite;
+    /** Convert Γ to physical impedance in ohms; undefined at the open circuit Γ = 1. */
+    static reflectionToImpedance(gamma: Complex, referenceImpedanceOhms?: number): Complex | undefined;
+    /** Convert physical impedance in ohms to Γ. Undefined for a singular result. */
+    static impedanceToReflection(impedanceOhms: Complex, referenceImpedanceOhms?: number): Complex | undefined;
+    /** Convert Γ to physical admittance in siemens; undefined at the short circuit Γ = −1. */
+    static reflectionToAdmittance(gamma: Complex, referenceImpedanceOhms?: number): Complex | undefined;
+    /** Convert physical admittance in siemens to Γ. Undefined for a singular result. */
+    static admittanceToReflection(admittanceSiemens: Complex, referenceImpedanceOhms?: number): Complex | undefined;
+    /**
+     * Read Γ without a chart or DOM. Undefined means a singular or inapplicable quantity.
+     * Passive-load quantities are undefined outside |Γ| ≤ 1; exact infinite limits are retained.
+     * Attenuation assumes a fully reflecting termination and is half the return loss.
+     */
+    static readReflection(gamma: Complex, referenceImpedanceOhms?: number): SmithReading;
+    /**
+     * Change the positive real reference impedance of a voltage reflection coefficient.
+     * Preserves physical impedance, including exact open/short limits. A singular or
+     * 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. */
+    static renormalizeSamples(samples: TraceSamples, fromOhms: number, toOhms: number): TraceSamples;
+    /**
+     * 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.
+     * Non-finite reactance and negative/non-finite frequency throw RangeError.
+     */
+    static reactanceToComponent(reactanceOhms: number, frequencyHz: number): ReactiveComponent | undefined;
+}

package/dist/lib/rf/RfCalculations.js

@@ -0,0 +1,161 @@
+import { Complex } from '../math/Complex.js';
+import { SmithConstantCircle } from './SmithConstantCircle.js';
+export class RfCalculations {
+    constructor() { }
+    static calcs = new SmithConstantCircle();
+    static validateReference(referenceImpedanceOhms) {
+        if (!Number.isFinite(referenceImpedanceOhms) || referenceImpedanceOhms <= 0) {
+            throw new RangeError('Reference impedance must be positive and finite.');
+        }
+    }
+    static validateComplex(value) {
+        if (!Number.isFinite(value.re) || !Number.isFinite(value.im)) {
+            throw new RangeError('Complex components must be finite.');
+        }
+    }
+    static finite(value) {
+        return value && Number.isFinite(value.re) && Number.isFinite(value.im) ? value : undefined;
+    }
+    /** Convert Γ to physical impedance in ohms; undefined at the open circuit Γ = 1. */
+    static reflectionToImpedance(gamma, referenceImpedanceOhms = 50) {
+        RfCalculations.validateReference(referenceImpedanceOhms);
+        RfCalculations.validateComplex(gamma);
+        return RfCalculations.finite(RfCalculations.calcs.rflCoeffToImpedance(gamma)?.mul(referenceImpedanceOhms));
+    }
+    /** Convert physical impedance in ohms to Γ. Undefined for a singular result. */
+    static impedanceToReflection(impedanceOhms, referenceImpedanceOhms = 50) {
+        RfCalculations.validateReference(referenceImpedanceOhms);
+        RfCalculations.validateComplex(impedanceOhms);
+        return RfCalculations.finite(RfCalculations.calcs.impedanceToRflCoeff(impedanceOhms.div(referenceImpedanceOhms)));
+    }
+    /** Convert Γ to physical admittance in siemens; undefined at the short circuit Γ = −1. */
+    static reflectionToAdmittance(gamma, referenceImpedanceOhms = 50) {
+        RfCalculations.validateReference(referenceImpedanceOhms);
+        RfCalculations.validateComplex(gamma);
+        return RfCalculations.finite(RfCalculations.calcs.rflCoeffToAdmittance(gamma)?.div(referenceImpedanceOhms));
+    }
+    /** Convert physical admittance in siemens to Γ. Undefined for a singular result. */
+    static admittanceToReflection(admittanceSiemens, referenceImpedanceOhms = 50) {
+        RfCalculations.validateReference(referenceImpedanceOhms);
+        RfCalculations.validateComplex(admittanceSiemens);
+        return RfCalculations.finite(RfCalculations.calcs.admittanceToRflCoeff(admittanceSiemens.mul(referenceImpedanceOhms)));
+    }
+    /**
+     * Read Γ without a chart or DOM. Undefined means a singular or inapplicable quantity.
+     * Passive-load quantities are undefined outside |Γ| ≤ 1; exact infinite limits are retained.
+     * Attenuation assumes a fully reflecting termination and is half the return loss.
+     */
+    static readReflection(gamma, referenceImpedanceOhms = 50) {
+        const impedanceOhms = RfCalculations.reflectionToImpedance(gamma, referenceImpedanceOhms);
+        const admittanceSiemens = RfCalculations.reflectionToAdmittance(gamma, referenceImpedanceOhms);
+        const magnitude = gamma.abs();
+        const passive = magnitude <= 1;
+        const returnLossDb = -20 * Math.log10(magnitude);
+        const vswr = passive ? (1 + magnitude) / (1 - magnitude) : undefined;
+        return {
+            reflectionCoefficient: gamma,
+            impedanceOhms,
+            admittanceSiemens,
+            phaseDegrees: magnitude === 0 ? undefined : (gamma.arg() * 180) / Math.PI,
+            vswr,
+            standingWaveRatioDb: vswr === undefined ? undefined : 20 * Math.log10(vswr),
+            returnLossDb,
+            reflectionLossDb: passive ? (-10 / Math.LN10) * Math.log1p(-(magnitude ** 2)) : undefined,
+            attenuationDb: passive ? returnLossDb / 2 : undefined,
+            q: impedanceOhms && (impedanceOhms.re !== 0 || impedanceOhms.im !== 0)
+                ? Math.abs(impedanceOhms.im / impedanceOhms.re)
+                : undefined,
+            powerReflectionCoefficient: magnitude ** 2,
+            voltageReflectionCoefficientMagnitude: magnitude,
+            powerTransmissionCoefficient: passive ? 1 - magnitude ** 2 : undefined,
+            voltageTransmissionCoefficientMagnitude: gamma.add(1).abs(),
+            currentTransmissionCoefficientMagnitude: Complex.one().sub(gamma).abs(),
+            standingWavePeak: vswr === undefined ? undefined : Math.sqrt(vswr),
+            standingWaveLossCoefficient: passive
+                ? (1 + magnitude ** 2) / (1 - magnitude ** 2)
+                : undefined,
+        };
+    }
+    /**
+     * Change the positive real reference impedance of a voltage reflection coefficient.
+     * Preserves physical impedance, including exact open/short limits. A singular or
+     * unrepresentable result is undefined; non-finite inputs throw RangeError.
+     */
+    static renormalizeReflection(gamma, fromOhms, toOhms) {
+        RfCalculations.validateReference(fromOhms);
+        RfCalculations.validateReference(toOhms);
+        if (!Number.isFinite(gamma.re) || !Number.isFinite(gamma.im)) {
+            throw new RangeError('Reflection coefficient components must be finite.');
+        }
+        if (fromOhms === toOhms || (gamma.im === 0 && Math.abs(gamma.re) === 1)) {
+            return gamma;
+        }
+        // Γnew = (Γold + k) / (1 + k Γold). Scale references before summing.
+        const referenceScale = Math.max(fromOhms, toOhms);
+        const from = fromOhms / referenceScale;
+        const to = toOhms / referenceScale;
+        const k = (fromOhms - toOhms) / referenceScale / (from + to);
+        const scale = Math.max(1, Math.abs(gamma.re), Math.abs(gamma.im));
+        const x = gamma.re / scale;
+        const y = gamma.im / scale;
+        const inverseScale = 1 / scale;
+        const nr = x + k * inverseScale;
+        const dr = inverseScale + k * x;
+        const di = k * y;
+        const denominatorScale = Math.max(Math.abs(dr), Math.abs(di));
+        if (denominatorScale === 0) {
+            return;
+        }
+        const real = dr / denominatorScale;
+        const imaginary = di / denominatorScale;
+        const denominator = real ** 2 + imaginary ** 2;
+        const re = ((nr / denominatorScale) * real + (y / denominatorScale) * imaginary) / denominator;
+        // Analytic imaginary numerator avoids cancellation for very large finite Γ.
+        const im = (((1 - k) * (1 + k) * (y / denominatorScale)) / denominator) *
+            (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) {
+                throw new RangeError(`Invalid sample at index ${index}.`);
+            }
+            const gamma = RfCalculations.renormalizeReflection(Complex.from(...sample.reflectionCoefficient), fromOhms, toOhms);
+            if (!gamma) {
+                throw new RangeError(`Renormalization is singular or outside the numeric range at sample ${index}.`);
+            }
+            return { frequencyHz: sample.frequencyHz, reflectionCoefficient: gamma.toVector() };
+        });
+    }
+    /**
+     * 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.
+     * Non-finite reactance and negative/non-finite frequency throw RangeError.
+     */
+    static reactanceToComponent(reactanceOhms, frequencyHz) {
+        if (!Number.isFinite(reactanceOhms)) {
+            throw new RangeError('Reactance must be finite.');
+        }
+        if (!Number.isFinite(frequencyHz) || frequencyHz < 0) {
+            throw new RangeError('Frequency must be finite and non-negative.');
+        }
+        if (frequencyHz === 0 || reactanceOhms === 0) {
+            return;
+        }
+        // Compute in log space so intermediate products/quotients cannot overflow.
+        const logReactance = Math.log(Math.abs(reactanceOhms));
+        const logAngularFrequency = Math.log(2 * Math.PI) + Math.log(frequencyHz);
+        const value = Math.exp((reactanceOhms > 0 ? logReactance : -logReactance) - logAngularFrequency);
+        if (!Number.isFinite(value) || value === 0) {
+            return;
+        }
+        return reactanceOhms > 0
+            ? { kind: 'inductor', inductanceHenries: value }
+            : { kind: 'capacitor', capacitanceFarads: value };
+    }
+}

package/dist/lib/{SmithConstantCircle.d.ts → rf/SmithConstantCircle.d.ts}

@@ -1,6 +1,5 @@
-import { Circle } from './shapes/Circle.js';
-import { Point } from './shapes/Point.js';
-import { Complex } from './complex/Complex.js';
+import type { Circle, Point } from '../math/geometry.js';
+import { Complex } from '../math/Complex.js';
 export declare class SmithConstantCircle {
     Z0: number;
     constructor(Z0?: number);

package/dist/lib/{SmithConstantCircle.js → rf/SmithConstantCircle.js}

@@ -1,5 +1,4 @@
-import { complexRatio } from './math/complexRatio.js';
-import { Complex } from './complex/Complex.js';
+import { Complex } from '../math/Complex.js';
 export class SmithConstantCircle {
     Z0;
     constructor(Z0 = 50) {
@@ -18,8 +17,8 @@ export class SmithConstantCircle {
         return this.transform(c, 1 - c.re, -c.im, 1 + c.re, c.im, -2);
     }
     transform(value, nr, ni, dr, di, determinant) {
-        const quotient = complexRatio(nr, ni, dr, di);
-        if (!quotient) {
+        const quotient = Complex.div(Complex.from(nr, ni), Complex.from(dr, di));
+        if (!Number.isFinite(quotient.re) || !Number.isFinite(quotient.im)) {
             return;
         }
         // The analytic imaginary numerator avoids cancellation of nearly equal products.

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

@@ -0,0 +1,16 @@
+import type { Complex } from '../math/Complex.js';
+export interface PeripheralScale {
+    id: string;
+    title: string;
+    unit: '°' | 'λ';
+    ticks: number[];
+    major: (value: number) => boolean;
+    angle: (value: number) => number;
+    read: (gamma: Complex) => number | null;
+}
+export declare class PeripheralScaleDefinitions {
+    private constructor();
+    private static phase;
+    /** A full reflection-coefficient rotation represents half a wavelength along the line. */
+    static create(): PeripheralScale[];
+}

package/dist/lib/scales/PeripheralScaleDefinitions.js

@@ -0,0 +1,54 @@
+export class PeripheralScaleDefinitions {
+    constructor() { }
+    static phase(gamma) {
+        return gamma.re === 0 && gamma.im === 0
+            ? null
+            : (Math.atan2(gamma.im, gamma.re) * 180) / Math.PI;
+    }
+    /** A full reflection-coefficient rotation represents half a wavelength along the line. */
+    static create() {
+        const wavelengths = (gamma, direction) => {
+            const degrees = PeripheralScaleDefinitions.phase(gamma);
+            return degrees === null ? null : (0.25 + (direction * degrees) / 720 + 0.5) % 0.5;
+        };
+        return [
+            {
+                id: 'transmission-phase',
+                title: 'Transmission phase · °',
+                unit: '°',
+                ticks: Array.from({ length: 179 }, (_, i) => -89 + i),
+                major: (v) => v % 5 === 0,
+                // Project from Γ = −1 to the perimeter, not from the chart center.
+                angle: (v) => 2 * v,
+                read: (gamma) => PeripheralScaleDefinitions.phase({ re: 1 + gamma.re, im: gamma.im }),
+            },
+            {
+                id: 'reflection-phase',
+                title: 'Reflection phase · °',
+                unit: '°',
+                ticks: Array.from({ length: 180 }, (_, i) => -178 + i * 2),
+                major: (v) => v % 10 === 0,
+                angle: (v) => v,
+                read: PeripheralScaleDefinitions.phase,
+            },
+            {
+                id: 'wavelengths-load',
+                title: 'Wavelengths → load',
+                unit: 'λ',
+                ticks: Array.from({ length: 250 }, (_, i) => i / 500),
+                major: (v) => Math.round(v * 500) % 5 === 0,
+                angle: (v) => 720 * v - 180,
+                read: (gamma) => wavelengths(gamma, 1),
+            },
+            {
+                id: 'wavelengths-generator',
+                title: 'Wavelengths → generator',
+                unit: 'λ',
+                ticks: Array.from({ length: 250 }, (_, i) => i / 500),
+                major: (v) => Math.round(v * 500) % 5 === 0,
+                angle: (v) => 180 - 720 * v,
+                read: (gamma) => wavelengths(gamma, -1),
+            },
+        ];
+    }
+}

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

@@ -0,0 +1,15 @@
+import type { Complex } from '../math/Complex.js';
+export interface RadialScale {
+    id: string;
+    title: string;
+    description?: string;
+    unit: 'dB' | 'ratio';
+    read: (gamma: Complex) => number;
+    values: number[];
+    position: (value: number) => number;
+}
+export declare class RadialScaleDefinitions {
+    private constructor();
+    /** Normalized positions along each scale, from zero to one. */
+    static create(): RadialScale[];
+}