smithkit 0.1.0 → 0.2.0

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[];
+}

package/dist/lib/scales/RadialScaleDefinitions.js

@@ -0,0 +1,112 @@
+import { SmithConstantCircle } from '../rf/SmithConstantCircle.js';
+export class RadialScaleDefinitions {
+    constructor() { }
+    /** Normalized positions along each scale, from zero to one. */
+    static create() {
+        const calcs = new SmithConstantCircle();
+        return [
+            {
+                id: 'vswr',
+                unit: 'ratio',
+                read: (gamma) => calcs.rflCoeffToSwr(gamma),
+                title: 'VSWR',
+                values: [1, 1.5, 2, 3, 5, 10, Infinity],
+                position: (v) => (v === Infinity ? 1 : calcs.swrToRflCoeffEOrI(v)),
+            },
+            {
+                id: 'vswr-db',
+                unit: 'dB',
+                read: (gamma) => calcs.rflCoeffToDBS(gamma),
+                title: 'Standing-wave ratio · dB',
+                values: [0, 3, 6, 10, 15, 20, Infinity],
+                position: (v) => (v === Infinity ? 1 : calcs.dBSToAbsRflCoeff(v)),
+            },
+            {
+                id: 'return-loss',
+                unit: 'dB',
+                read: (gamma) => calcs.rflCoeffToReturnLoss(gamma),
+                title: 'Return loss · dB',
+                values: [Infinity, 20, 14, 10, 6, 3, 0],
+                position: (v) => calcs.returnLossToRflCoeffEOrI(v),
+            },
+            {
+                id: 'mismatch-loss',
+                unit: 'dB',
+                read: (gamma) => calcs.rflCoeffToMismatchLoss(gamma),
+                title: 'Reflection loss · dB',
+                description: 'Reflection loss (mismatch loss): −10 log10(1 − |Γ|²), in dB.',
+                values: [0, 0.1, 0.5, 1, 2, 4, Infinity],
+                position: (v) => calcs.mismatchLossToRflCoeffEOrI(v),
+            },
+            {
+                id: 'reflected-power',
+                unit: 'ratio',
+                read: (gamma) => calcs.rflCoeffP(gamma),
+                title: 'Power reflection coefficient',
+                description: 'Reflected power divided by incident power: |Γ|² (dimensionless).',
+                values: [0, 0.01, 0.1, 0.25, 0.5, 0.75, 1],
+                position: (v) => calcs.rflCoeffPToEOrI(v),
+            },
+            {
+                id: 'transmitted-power',
+                unit: 'ratio',
+                read: (gamma) => calcs.rflCoeffToTransmCoeffP(gamma),
+                title: 'Power transmission coefficient',
+                description: 'Net power delivered to the load divided by incident power: 1 − |Γ|² (dimensionless).',
+                values: [1, 0.99, 0.9, 0.75, 0.5, 0.25, 0],
+                position: (v) => calcs.transmCoeffPToRflCoeffEOrI(v),
+            },
+            {
+                id: 'standing-wave-loss',
+                unit: 'ratio',
+                read: (gamma) => calcs.rflCoeffToSwLossCoeff(gamma),
+                title: 'Standing-wave loss coefficient',
+                values: [1, 1.1, 1.5, 2, 3, 5, Infinity],
+                position: (v) => (v === Infinity ? 1 : calcs.swLossCoeffToRflCoeffEOrI(v)),
+            },
+            {
+                id: 'standing-wave-peak',
+                unit: 'ratio',
+                read: (gamma) => calcs.rflCoeffToSwPeakConstP(gamma),
+                title: 'Standing-wave peak · constant power',
+                values: [1, 1.2, 1.5, 2, 3, Infinity],
+                position: (v) => (v === Infinity ? 1 : calcs.swPeakConstPToRflCoeffEOrI(v)),
+            },
+            {
+                id: 'reflection-coefficient',
+                unit: 'ratio',
+                read: (gamma) => calcs.rflCoeffEOrI(gamma),
+                title: 'Reflection coefficient · |Γ|',
+                values: [0, 0.2, 0.4, 0.6, 0.8, 1],
+                position: (v) => v,
+            },
+            {
+                id: 'attenuation',
+                unit: 'dB',
+                read: (gamma) => calcs.rflCoeffToAttenuation(gamma),
+                title: 'Attenuation · dB',
+                description: 'One-way attenuation of a matched line or attenuator terminated in an open or short circuit. Not insertion loss of an arbitrary load.',
+                values: [Infinity, 10, 7, 5, 3, 1, 0],
+                position: (v) => calcs.attenuationToRflCoeff(v),
+            },
+            {
+                id: 'voltage-transmission',
+                unit: 'ratio',
+                read: (gamma) => calcs.rflCoeffToTransmCoeffEOrI(gamma),
+                title: 'Voltage transmission coefficient',
+                description: 'Voltage transmission magnitude: |1 + Γ| (dimensionless).',
+                values: [0, 0.4, 0.8, 1.2, 1.6, 2],
+                position: (v) => v / 2,
+            },
+            {
+                id: 'current-transmission',
+                unit: 'ratio',
+                read: (gamma) => calcs.rflCoeffToCurrentTransmission(gamma),
+                title: 'Current transmission coefficient',
+                description: 'Current transmission magnitude: |1 − Γ|, using the voltage reflection coefficient Γ (dimensionless).',
+                values: [0, 0.4, 0.8, 1.2, 1.6, 2],
+                position: (v) => v / 2,
+            },
+        ];
+    }
+}

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

@@ -1,10 +1,15 @@
-import type { Complex } from '../complex/Complex.js';
-import { SmithGroup } from '../draw/SmithGroup.js';
+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 static point;
+    private static rulerRadius;
+    readonly labels: SmithGroup;
     private readonly scales;
     private readonly axes;
     constructor();
+    show(): SmithGroup;
+    hide(): SmithGroup;
     /** Connect to the same cursor or marker data as the independent parameter scales. */
     update(gamma: Complex | null): void;
 }

package/dist/lib/scales/SmithPeripheralScales.js

@@ -1,16 +1,22 @@
 import { select, format } from 'd3';
-import { SmithGroup } from '../draw/SmithGroup.js';
-import { peripheralScales } from './peripheralScales.js';
+import { SmithGroup } from '../svg/SmithGroup.js';
+import { PeripheralScaleDefinitions } from './PeripheralScaleDefinitions.js';
 let nextScaleId = 0;
-const firstRadius = 250;
-const ringSpacing = 20;
-function point(radius, degrees) {
-    const angle = (degrees * Math.PI) / 180;
-    return [250 + radius * Math.cos(angle), 250 - radius * Math.sin(angle)];
-}
+const chartRadius = 250;
+const groupWidth = 40;
 /** Peripheral rulers in the chart's 500-unit coordinate system. */
 export class SmithPeripheralScales extends SmithGroup {
-    scales = peripheralScales();
+    static point(radius, degrees) {
+        const angle = (degrees * Math.PI) / 180;
+        return [250 + radius * Math.cos(angle), 250 - radius * Math.sin(angle)];
+    }
+    static rulerRadius(index) {
+        return chartRadius + groupWidth / 2 + Math.floor(index / 2) * groupWidth;
+    }
+    labels = new SmithGroup()
+        .attr('data-label-layer', 'peripheral-scales')
+        .attr('pointer-events', 'none');
+    scales = PeripheralScaleDefinitions.create();
     axes = this.Element.attr('data-layer', 'peripheral-scales')
         .attr('pointer-events', 'none')
         .selectAll('g')
@@ -21,25 +27,48 @@ export class SmithPeripheralScales extends SmithGroup {
         .attr('aria-label', (scale) => scale.title);
     constructor() {
         super();
+        const labelAxes = this.labels.Element.selectAll('g')
+            .data(this.scales)
+            .join('g')
+            .attr('data-label-scale', (scale) => scale.id)
+            .nodes();
+        // Two paired rulers: transmission/reflection phase, then electrical length
+        // toward load/generator. Strong boundaries enclose each pair.
+        this.Element.selectAll('circle.peripheral-boundary')
+            .data([chartRadius, chartRadius + groupWidth, chartRadius + 2 * groupWidth])
+            .join('circle')
+            .attr('class', 'peripheral-boundary')
+            .attr('cx', 250)
+            .attr('cy', 250)
+            .attr('r', (radius) => radius)
+            .attr('fill', 'none')
+            .attr('stroke', '#334155')
+            .attr('stroke-width', 1.1)
+            .attr('vector-effect', 'non-scaling-stroke');
         this.axes.each(function (scale, index) {
+            const labelAxis = select(labelAxes[index]);
             const axis = select(this);
-            const radius = firstRadius + index * ringSpacing;
+            const radius = SmithPeripheralScales.rulerRadius(index);
+            const side = index % 2 === 0 ? -1 : 1;
             const captionAngle = scale.unit === 'λ' ? 180 : 0;
             axis.append('title').text(scale.title);
-            axis
-                .append('circle')
-                .attr('cx', 250)
-                .attr('cy', 250)
-                .attr('r', radius)
-                .attr('fill', 'none')
-                .attr('stroke', '#475569')
-                .attr('stroke-width', 0.8)
-                .attr('vector-effect', 'non-scaling-stroke');
+            if (index % 2 === 0) {
+                axis
+                    .append('circle')
+                    .attr('class', 'peripheral-ruler')
+                    .attr('cx', 250)
+                    .attr('cy', 250)
+                    .attr('r', radius)
+                    .attr('fill', 'none')
+                    .attr('stroke', '#475569')
+                    .attr('stroke-width', 0.6)
+                    .attr('vector-effect', 'non-scaling-stroke');
+            }
             for (const value of scale.ticks) {
                 const angle = scale.angle(value);
-                const [x1, y1] = point(radius, angle);
+                const [x1, y1] = SmithPeripheralScales.point(radius, angle);
                 const major = scale.major(value);
-                const [x2, y2] = point(radius - (major ? 4 : 2), angle);
+                const [x2, y2] = SmithPeripheralScales.point(radius + side * (major ? 4 : 2), angle);
                 axis
                     .append('line')
                     .attr('x1', x1)
@@ -51,9 +80,9 @@ export class SmithPeripheralScales extends SmithGroup {
                     .attr('vector-effect', 'non-scaling-stroke');
                 const captionDistance = Math.abs(((angle - captionAngle + 540) % 360) - 180);
                 if (major && captionDistance > 25) {
-                    const [x, y] = point(radius + 8, angle);
+                    const [x, y] = SmithPeripheralScales.point(radius + side * 11, angle);
                     const rotation = angle >= 0 ? 90 - angle : -90 - angle;
-                    axis
+                    labelAxis
                         .append('text')
                         .attr('x', x)
                         .attr('y', y)
@@ -67,9 +96,9 @@ export class SmithPeripheralScales extends SmithGroup {
                 }
             }
             // Reserve a label sector for the curved caption without masking the ruler or its ticks.
-            const captionRadius = radius + 5;
-            const start = point(captionRadius, captionAngle + 45);
-            const end = point(captionRadius, captionAngle - 45);
+            const captionRadius = radius + (side < 0 ? -15 : 5);
+            const start = SmithPeripheralScales.point(captionRadius, captionAngle + 45);
+            const end = SmithPeripheralScales.point(captionRadius, captionAngle - 45);
             const pathId = `smithkit-peripheral-caption-${nextScaleId++}`;
             axis
                 .append('defs')
@@ -81,7 +110,7 @@ export class SmithPeripheralScales extends SmithGroup {
                     ? 'WAVELENGTHS TOWARD GENERATOR →'
                     : '← WAVELENGTHS TOWARD LOAD'
                 : scale.title.toUpperCase();
-            axis
+            labelAxis
                 .append('text')
                 .attr('class', 'peripheral-caption')
                 .attr('text-anchor', 'middle')
@@ -104,6 +133,14 @@ export class SmithPeripheralScales extends SmithGroup {
                 .attr('stroke-width', 1);
         });
     }
+    show() {
+        this.labels.show();
+        return super.show();
+    }
+    hide() {
+        this.labels.hide();
+        return super.hide();
+    }
     /** Connect to the same cursor or marker data as the independent parameter scales. */
     update(gamma) {
         const valid = gamma !== null && Number.isFinite(gamma.abs()) && gamma.abs() <= 1;
@@ -117,7 +154,7 @@ export class SmithPeripheralScales extends SmithGroup {
                 dot.attr('visibility', 'hidden').attr('data-value', null);
                 return;
             }
-            const [x, y] = point(firstRadius + index * ringSpacing, scale.angle(value));
+            const [x, y] = SmithPeripheralScales.point(SmithPeripheralScales.rulerRadius(index), scale.angle(value));
             dot.attr('cx', x).attr('cy', y).attr('data-value', value).attr('visibility', null);
         });
     }

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

@@ -1,4 +1,4 @@
-import type { Complex } from '../complex/Complex.js';
+import type { Complex } from '../math/Complex.js';
 /** Independent parameter scales. Connect update() to a chart's cursor events. */
 export declare class SmithScales {
     private readonly scales;
@@ -11,6 +11,8 @@ export declare class SmithScales {
     draw(target: string | HTMLElement): void;
     /** Show a passive-load reflection coefficient, or hide indicators with null. */
     update(gamma: Complex | null): void;
+    /** Export all mounted scales in their current layout as a standalone SVG. */
+    toSvg(): string;
     destroy(): void;
     private assertAlive;
 }