@classytic/labs 0.2.0 → 0.3.0

package/dist/pathways/electronic-devices.mjs

@@ -0,0 +1,152 @@
+//#region src/pathways/electronic-devices.ts
+/**
+* How a piece of sand becomes a switch, and how switches become logic.
+*
+* This chapter is the bridge between the circuits course and the digital logic course. It
+* runs down the abstraction ladder to the carriers themselves, then climbs back up: doped
+* silicon, a junction that conducts one way, a junction whose channel is controlled by a
+* third terminal, and finally four transistors behaving as a NAND gate. By the last step
+* the learner has seen the same NAND from both ends, as silicon and as a symbol.
+*
+* Every device view is driven by the deterministic carrier engine, and every schematic is
+* solved by the nonlinear circuit engine, so the two halves agree.
+*/
+const electronicDevicesPathway = {
+	id: "electronic-devices",
+	title: "Electronic devices: how a piece of sand becomes a switch",
+	description: "Go inside the crystal to see why doping creates carriers, why a junction conducts in only one direction, and how a third terminal takes control of a channel. Finish by watching four transistors become the universal logic gate.",
+	domain: "circuits",
+	grades: ["12", "undergraduate"],
+	estimatedMinutes: 240,
+	modules: [
+		{
+			id: "inside-the-crystal",
+			title: "Inside the crystal",
+			summary: "Pure silicon is a poor conductor. Adding a controlled impurity is what makes electronics possible.",
+			outcomes: [
+				"Explain why a full covalent lattice conducts poorly",
+				"Distinguish n-type and p-type doping by which carrier each one adds",
+				"Use the sign of a Hall voltage to identify the carrier type in a sample"
+			]
+		},
+		{
+			id: "one-way-valve",
+			title: "The one-way valve",
+			summary: "Join p to n and the carriers themselves build a barrier that only forward bias can lower.",
+			outcomes: [
+				"Explain the depletion region as fixed ions left behind by diffusion",
+				"Predict how forward and reverse bias change the barrier width",
+				"Read the knee of a diode curve as the point where the barrier gives way"
+			]
+		},
+		{
+			id: "controlled-valve",
+			title: "The valve someone else controls",
+			summary: "A third terminal that steers a large current is the single idea behind all of modern computing.",
+			outcomes: [
+				"Describe how gate voltage inverts a channel and connects source to drain",
+				"Contrast field control in a MOSFET with current control in a BJT",
+				"Locate threshold voltage on a measured transfer curve"
+			]
+		},
+		{
+			id: "device-to-logic",
+			title: "From device to logic",
+			summary: "Arrange transistors so the output is forced high or low, and a physical device becomes a Boolean one.",
+			outcomes: [
+				"Explain why a resistor pull-up inverter wastes static power and CMOS does not",
+				"Trace which transistors conduct for each input combination of a NAND",
+				"Predict what happens to logic levels when the supply rail sags"
+			]
+		}
+	],
+	steps: [
+		{
+			id: "silicon-lattice",
+			module: "inside-the-crystal",
+			tag: "SiliconLattice",
+			title: "Pure silicon, then a deliberate impurity",
+			purpose: "Break one bond in a covalent lattice, add a donor or an acceptor, and watch a free carrier appear where it physically comes from."
+		},
+		{
+			id: "hall-effect",
+			module: "inside-the-crystal",
+			tag: "HallEffect",
+			title: "Which carrier is actually moving",
+			purpose: "Deflect carriers with a magnetic field and read the sign of the transverse voltage, the measurement that settles electrons against holes."
+		},
+		{
+			id: "pn-junction",
+			module: "one-way-valve",
+			tag: "PnJunction",
+			title: "Inside the diode",
+			purpose: "Sweep the bias and watch the depletion region widen and narrow, with the fixed ions left in place."
+		},
+		{
+			id: "diode",
+			module: "one-way-valve",
+			tag: "Diode",
+			title: "The curve that valve produces",
+			purpose: "Meet the forward knee and the reverse block on a solved current-voltage curve with a live operating point."
+		},
+		{
+			id: "mosfet-inside",
+			module: "controlled-valve",
+			tag: "MosfetInside",
+			title: "Inverting a channel with a field",
+			purpose: "Raise the gate voltage until an inversion layer bridges source and drain, and see conduction begin exactly at threshold."
+		},
+		{
+			id: "transistor",
+			module: "controlled-valve",
+			tag: "Transistor",
+			title: "A small input steering a big current",
+			purpose: "Drive a lamp through a MOSFET and read the transfer curve swept through the circuit engine."
+		},
+		{
+			id: "bjt-inside",
+			module: "controlled-valve",
+			tag: "BjtInside",
+			title: "The other kind of control",
+			purpose: "Watch carriers cross a thin base, with only a sliver recombining, to see why a small base current commands a large collector current."
+		},
+		{
+			id: "rnmos-not",
+			module: "device-to-logic",
+			tag: "RNmosNot",
+			title: "Inversion from one transistor",
+			purpose: "Build a NOT gate with a pull-up resistor, then measure the power it wastes while the output is low. This is the motivation for CMOS."
+		},
+		{
+			id: "cmos-inverter",
+			module: "device-to-logic",
+			tag: "CmosInverter",
+			title: "Two transistors, no wasted power",
+			purpose: "Pair a PMOS pull-up with an NMOS pull-down and watch the solved output snap through the transition."
+		},
+		{
+			id: "cmos-nand",
+			module: "device-to-logic",
+			tag: "CmosNand",
+			title: "Four transistors become a universal gate",
+			purpose: "Series pull-down, parallel pull-up, solved for every input combination. The same NAND the digital logic course is built on."
+		},
+		{
+			id: "cmos-nor",
+			module: "device-to-logic",
+			tag: "CmosNor",
+			title: "The De Morgan twin",
+			purpose: "Swap series for parallel and get the other universal gate, making the duality physical rather than notational."
+		},
+		{
+			id: "brownout",
+			module: "device-to-logic",
+			tag: "Brownout",
+			title: "When the supply is too low to mean anything",
+			purpose: "Drop the rail until the output can no longer swing, showing that a logic level is a physical margin and not a symbol."
+		}
+	]
+};
+
+//#endregion
+export { electronicDevicesPathway };

package/dist/pathways/index.d.mts

@@ -0,0 +1,10 @@
+import { LabPathway, LabPathwayModule, LabPathwayStatus, LabPathwayStep, moduleSteps, pathwayToMdx, plannedSteps, readySteps } from "./types.mjs";
+import { calculusPathway } from "./calculus.mjs";
+import { chemistryFoundationsPathway } from "./chemistry.mjs";
+import { quantumFoundationsPathway } from "./quantum.mjs";
+import { relativityFoundationsPathway } from "./relativity.mjs";
+import { cellSystemsPathway } from "./biology.mjs";
+import { digitalLogicPathway } from "./digital-logic.mjs";
+import { electronicCircuitsPathway } from "./electronic-circuits.mjs";
+import { electronicDevicesPathway } from "./electronic-devices.mjs";
+export { type LabPathway, type LabPathwayModule, type LabPathwayStatus, type LabPathwayStep, calculusPathway, cellSystemsPathway, chemistryFoundationsPathway, digitalLogicPathway, electronicCircuitsPathway, electronicDevicesPathway, moduleSteps, pathwayToMdx, plannedSteps, quantumFoundationsPathway, readySteps, relativityFoundationsPathway };

package/dist/pathways/index.mjs

@@ -0,0 +1,11 @@
+import { calculusPathway } from "./calculus.mjs";
+import { chemistryFoundationsPathway } from "./chemistry.mjs";
+import { quantumFoundationsPathway } from "./quantum.mjs";
+import { relativityFoundationsPathway } from "./relativity.mjs";
+import { cellSystemsPathway } from "./biology.mjs";
+import { digitalLogicPathway } from "./digital-logic.mjs";
+import { electronicCircuitsPathway } from "./electronic-circuits.mjs";
+import { electronicDevicesPathway } from "./electronic-devices.mjs";
+import { moduleSteps, pathwayToMdx, plannedSteps, readySteps } from "./types.mjs";
+
+export { calculusPathway, cellSystemsPathway, chemistryFoundationsPathway, digitalLogicPathway, electronicCircuitsPathway, electronicDevicesPathway, moduleSteps, pathwayToMdx, plannedSteps, quantumFoundationsPathway, readySteps, relativityFoundationsPathway };

package/dist/pathways/quantum.d.mts

@@ -0,0 +1,9 @@
+import { LabPathway } from "./types.mjs";
+
+//#region src/pathways/quantum.d.ts
+/** A phenomenon-first route into quantum information. The pathway contains
+ * metadata only, so CMS and MDX hosts can inspect or generate it without
+ * importing React, Three.js, or any lab runtime. */
+declare const quantumFoundationsPathway: LabPathway;
+//#endregion
+export { quantumFoundationsPathway };

package/dist/pathways/quantum.mjs

@@ -0,0 +1,56 @@
+//#region src/pathways/quantum.ts
+/** A phenomenon-first route into quantum information. The pathway contains
+* metadata only, so CMS and MDX hosts can inspect or generate it without
+* importing React, Three.js, or any lab runtime. */
+const quantumFoundationsPathway = {
+	id: "quantum-from-evidence-to-programs",
+	title: "Quantum physics: from experimental evidence to qubit programs",
+	description: "Begin with observations classical models cannot explain, construct probability and state models, then use those models to program a single qubit.",
+	domain: "physics",
+	grades: ["11", "12"],
+	estimatedMinutes: 76,
+	steps: [
+		{
+			id: "photoelectric-effect",
+			tag: "PhotoelectricEffectLab",
+			title: "Light arrives in energy packets",
+			purpose: "Use threshold wavelength and stopping potential to separate photon energy from photon arrival rate.",
+			defaultAttributes: {
+				metal: "sodium",
+				wavelengthNm: 500,
+				intensity: .35
+			}
+		},
+		{
+			id: "double-slit",
+			tag: "DoubleSlitLab",
+			title: "Single events build a probability pattern",
+			purpose: "Accumulate localized detections and test why distinguishable paths no longer interfere.",
+			defaultAttributes: {
+				detections: 80,
+				wavelengthNm: 550,
+				slitSeparationUm: 120,
+				whichPath: false
+			}
+		},
+		{
+			id: "bloch-sphere",
+			tag: "BlochSphereLab",
+			title: "A pure qubit becomes a direction",
+			purpose: "Connect complex amplitudes and relative phase to measurement probabilities in multiple bases.",
+			defaultAttributes: {
+				preset: "plus",
+				measurementAxis: "z"
+			}
+		},
+		{
+			id: "quantum-gates",
+			tag: "QuantumGateJourneyLab",
+			title: "State transformations become programs",
+			purpose: "Compose reversible gates, predict their effect, and reach a target state while preserving normalization."
+		}
+	]
+};
+
+//#endregion
+export { quantumFoundationsPathway };

package/dist/pathways/relativity.d.mts

@@ -0,0 +1,6 @@
+import { LabPathway } from "./types.mjs";
+
+//#region src/pathways/relativity.d.ts
+declare const relativityFoundationsPathway: LabPathway;
+//#endregion
+export { relativityFoundationsPathway };

package/dist/pathways/relativity.mjs

@@ -0,0 +1,63 @@
+//#region src/pathways/relativity.ts
+const relativityFoundationsPathway = {
+	id: "relativity-from-events-to-evidence",
+	title: "Relativity: from light signals to measured evidence",
+	description: "Build special relativity from invariant light speed, synchronized event coordinates, and atmospheric evidence.",
+	domain: "physics",
+	grades: ["11", "12"],
+	estimatedMinutes: 86,
+	steps: [
+		{
+			id: "relativity-light-clock",
+			tag: "RelativityLightClockLab",
+			title: "Light clocks reveal time dilation",
+			purpose: "Compare proper and coordinate time using the same emission and return events.",
+			defaultAttributes: {
+				beta: .6,
+				properTick: 2,
+				view: "linked"
+			}
+		},
+		{
+			id: "relativity-simultaneity",
+			tag: "RelativitySimultaneityLab",
+			title: "Separated events lose a universal now",
+			purpose: "Transform platform-simultaneous flashes into the moving train frame.",
+			defaultAttributes: {
+				beta: .6,
+				separationM: 300
+			}
+		},
+		{
+			id: "length-contraction",
+			tag: "LengthContractionLab",
+			title: "Length requires a shared now",
+			purpose: "Measure simultaneous endpoints and connect contraction to the preceding event transformation.",
+			defaultAttributes: {
+				beta: .8,
+				properLengthM: 100
+			}
+		},
+		{
+			id: "lorentz-transformation",
+			tag: "LorentzTransformationLab",
+			title: "One transformation unifies the consequences",
+			purpose: "Drag arbitrary events, classify their intervals, and verify what every inertial frame preserves.",
+			defaultAttributes: { beta: .6 }
+		},
+		{
+			id: "muon-survival",
+			tag: "MuonSurvivalLab",
+			title: "Particle counts become experimental evidence",
+			purpose: "Use proper-time decay to explain why atmospheric muons reach Earth.",
+			defaultAttributes: {
+				beta: .995,
+				altitudeKm: 10,
+				population: 1e3
+			}
+		}
+	]
+};
+
+//#endregion
+export { relativityFoundationsPathway };

package/dist/pathways/types.d.mts

@@ -0,0 +1,58 @@
+//#region src/pathways/types.d.ts
+/**
+ * A pathway is a COURSE expressed as metadata: an ordered spine of labs a learner walks
+ * through, with no React, no lab runtime, and no bundler weight. Hosts read it to build a
+ * syllabus page, a lesson plan, or MDX.
+ *
+ * A course-length pathway groups its steps into `modules` (a chapter each). A step may be
+ * `planned`, which lets one file hold BOTH the finished syllabus and the build backlog:
+ * the outline shows the whole course, while generated MDX contains only labs that exist.
+ */
+/** Whether the lab behind a step is built yet. */
+type LabPathwayStatus = 'ready' | 'planned';
+/** One chapter of a course-length pathway. */
+interface LabPathwayModule {
+  id: string;
+  title: string;
+  /** One sentence on what this chapter is for. */
+  summary: string;
+  /** What a learner can DO at the end, written as actions rather than topic labels. */
+  outcomes: readonly string[];
+}
+interface LabPathwayStep {
+  id: string;
+  /** The lab's MDX tag. This is what identifies the runtime, so it must match a manifest. */
+  tag: string;
+  title: string;
+  purpose: string;
+  defaultAttributes?: Readonly<Record<string, string | number | boolean | readonly number[]>>;
+  /** The `LabPathwayModule` id this step belongs to. Omitted on single-arc pathways. */
+  module?: string;
+  /** Defaults to 'ready'. A 'planned' step is designed but unbuilt: it appears in the
+   *  outline and the backlog, and is left out of generated MDX so nothing renders blank. */
+  status?: LabPathwayStatus;
+}
+interface LabPathway {
+  id: string;
+  title: string;
+  description: string;
+  domain: string;
+  grades: readonly string[];
+  estimatedMinutes: number;
+  /** Ordered chapters. Absent on the short single-arc pathways. */
+  modules?: readonly LabPathwayModule[];
+  steps: readonly LabPathwayStep[];
+}
+/** Steps whose lab exists. A step is ready unless it explicitly says otherwise. */
+declare const readySteps: (pathway: LabPathway) => readonly LabPathwayStep[];
+/** Steps still to build, in teaching order: the course's backlog. */
+declare const plannedSteps: (pathway: LabPathway) => readonly LabPathwayStep[];
+/** The steps of one chapter, in order. */
+declare const moduleSteps: (pathway: LabPathway, moduleId: string) => readonly LabPathwayStep[];
+/**
+ * Generate portable MDX for a pathway without importing any lab runtime. Planned steps are
+ * skipped: emitting a tag with no manifest behind it would render an empty lesson.
+ */
+declare function pathwayToMdx(pathway: LabPathway): string;
+//#endregion
+export { LabPathway, LabPathwayModule, LabPathwayStatus, LabPathwayStep, moduleSteps, pathwayToMdx, plannedSteps, readySteps };

package/dist/pathways/types.mjs

@@ -0,0 +1,21 @@
+//#region src/pathways/types.ts
+const encode = (value) => typeof value === "string" ? JSON.stringify(value) : `{${JSON.stringify(value)}}`;
+/** Steps whose lab exists. A step is ready unless it explicitly says otherwise. */
+const readySteps = (pathway) => pathway.steps.filter((step) => (step.status ?? "ready") === "ready");
+/** Steps still to build, in teaching order: the course's backlog. */
+const plannedSteps = (pathway) => pathway.steps.filter((step) => step.status === "planned");
+/** The steps of one chapter, in order. */
+const moduleSteps = (pathway, moduleId) => pathway.steps.filter((step) => step.module === moduleId);
+/**
+* Generate portable MDX for a pathway without importing any lab runtime. Planned steps are
+* skipped: emitting a tag with no manifest behind it would render an empty lesson.
+*/
+function pathwayToMdx(pathway) {
+	return readySteps(pathway).map((step) => {
+		const attributes = Object.entries(step.defaultAttributes ?? {}).map(([key, value]) => ` ${key}=${encode(value)}`).join("");
+		return `<${step.tag}${attributes} />`;
+	}).join("\n\n");
+}
+
+//#endregion
+export { moduleSteps, pathwayToMdx, plannedSteps, readySteps };

package/dist/physics/alternating-current/core.d.mts

@@ -0,0 +1,162 @@
+//#region src/physics/alternating-current/core.d.ts
+/**
+ * Alternating currents (Cambridge International A Level Physics 9702, chapter 21).
+ *
+ * A sinusoidal supply v(t) = V0 sin(2 pi f t) drives a resistor R, so i(t) = v(t) / R. Three
+ * ideas live here, and only the middle one is hard:
+ *
+ *   period and peak   T = 1/f, and v and i share the same shape because R is constant
+ *   r.m.s.            V_rms = V0 / sqrt(2), DEFINED by equal heating, not by averaging v
+ *   rectification     one diode keeps half the wave, a bridge folds the whole wave up, and a
+ *                     capacitor across the load turns the ripple into a nearly steady line
+ *
+ * The r.m.s. part is the reason this file exists. The mean of v over a whole cycle is zero, so
+ * averaging the wave tells a learner nothing. What is NOT zero is the mean of v squared, because
+ * squaring makes every value positive. Power is v squared over R, so the mean of v squared is
+ * what sets the heating. Take the root of that mean and you have the steady d.c. voltage that
+ * would heat the same resistor at the same rate: root, of the mean, of the square.
+ *
+ * `meanSquareFromPeak` returns the exact answer V0^2 / 2. `meanSquareByIntegration` returns the
+ * SAME number by adding up v^2 across one period with Simpson's rule, reading nothing from the
+ * algebra. The lab draws the integrated value, so the horizontal line on the graph is a measured
+ * mean and not a formula redrawn as a line.
+ *
+ * Everything here is pure, deterministic and React-free, so it can be tested directly.
+ */
+interface AcSupply {
+  /** Peak (maximum) voltage V0, in volts. */
+  peakVoltageV: number;
+  /** Frequency f, in hertz. */
+  frequencyHz: number;
+  /** Load resistance R, in ohms. */
+  resistanceOhm: number;
+}
+/** One diode keeps the positive halves; a bridge of four folds the negative halves up. */
+type RectifierMode = 'half' | 'full';
+/** Period of the supply, T = 1 / f, in seconds. */
+declare function acPeriodS(frequencyHz: number): number;
+/** v(t) = V0 sin(2 pi f t), in volts. */
+declare function acVoltageAt(supply: AcSupply, t: number): number;
+/** i(t) = v(t) / R, in amperes. In phase with v, because a resistor has no phase shift. */
+declare function acCurrentAt(supply: AcSupply, t: number): number;
+/** The r.m.s. value of a SINUSOID from its peak: peak / sqrt(2). Works for volts and amps. */
+declare function rmsFromPeak(peak: number): number;
+/** The mean of v^2 over a whole cycle, from the algebra: V0^2 / 2. */
+declare function meanSquareFromPeak(peak: number): number;
+/**
+ * The integral of v^2 over ONE whole period, in V^2 s, by Simpson's rule.
+ *
+ * This is the honest route to the mean square: no identity for sin^2 is used anywhere. The exact
+ * answer is V0^2 T / 2, and Simpson's rule on a smooth periodic function reaches it to far more
+ * figures than the lab ever prints. `intervals` is rounded up to an even number, as Simpson's
+ * rule requires.
+ */
+declare function integrateSquareOverPeriod(peakVoltageV: number, frequencyHz: number, intervals?: number): number;
+/** The mean of v^2 over one period, measured by integration: (integral over T) / T. */
+declare function meanSquareByIntegration(peakVoltageV: number, frequencyHz: number, intervals?: number): number;
+/**
+ * Mean power delivered to R, in watts.
+ *
+ * P_mean = V_rms^2 / R = V0^2 / (2 R), which is exactly HALF the peak power. This single number
+ * is what r.m.s. is for: a steady d.c. supply of V_rms volts across the same R delivers it too.
+ */
+declare function meanAcPowerW(supply: AcSupply): number;
+interface AcState {
+  /** Period T = 1/f, s. */
+  periodS: number;
+  peakVoltageV: number;
+  /** I0 = V0 / R, A. */
+  peakCurrentA: number;
+  /** V_rms = V0 / sqrt(2), V. */
+  rmsVoltageV: number;
+  /** I_rms = I0 / sqrt(2) = V_rms / R, A. */
+  rmsCurrentA: number;
+  /** Mean of v^2 over a cycle, measured by integration, V^2. */
+  meanSquareVoltageV2: number;
+  /** Mean of v^2 from the algebra, V0^2 / 2, V^2. The two agree; the lab shows both. */
+  meanSquareExactV2: number;
+  /** Mean power into R, W. */
+  meanPowerW: number;
+  /** Peak power into R, V0^2 / R, W. Twice the mean. */
+  peakPowerW: number;
+}
+/** Everything the lab reads off one supply driving one resistor. */
+declare function acState(supply: AcSupply): AcState;
+interface WavePoint {
+  /** Time, s. */
+  t: number;
+  /** Supply voltage, V. */
+  v: number;
+  /** Current in R, A. */
+  i: number;
+}
+/** The supply sampled over whole cycles. Deterministic: the same input gives the same points. */
+declare function acWaveTrace(supply: AcSupply, cycles?: number, samplesPerCycle?: number): WavePoint[];
+/** What the diodes let through: half-wave keeps v when positive, full-wave folds it up. */
+declare function rectify(v: number, mode: RectifierMode): number;
+/**
+ * Mean of the rectified output over a whole cycle, with no smoothing capacitor.
+ *
+ * Half-wave gives V0 / pi (0.318 V0), because half the cycle is flat zero. Full-wave gives
+ * 2 V0 / pi (0.637 V0). Neither is V_rms: this is a mean HEIGHT, not a heating value.
+ */
+declare function meanRectifiedVoltage(peakVoltageV: number, mode: RectifierMode): number;
+/** The ripple repeats once per cycle after one diode, twice per cycle after a bridge. */
+declare function rippleFrequencyHz(frequencyHz: number, mode: RectifierMode): number;
+interface RectifiedPoint {
+  /** Time, s. */
+  t: number;
+  /** Supply voltage before the diodes, V. */
+  input: number;
+  /** Diode output with no capacitor, V. */
+  rectified: number;
+  /** Voltage across the load with the smoothing capacitor fitted, V. */
+  output: number;
+}
+interface RectifiedTrace {
+  points: RectifiedPoint[];
+  /** Largest output voltage in the last whole cycle, V. */
+  maxV: number;
+  /** Smallest output voltage in the last whole cycle, V. */
+  minV: number;
+  /** Peak-to-peak ripple in the last whole cycle, V. */
+  rippleV: number;
+  /** Mean output over the last whole cycle, V. */
+  meanV: number;
+  /** How often the output dips, Hz. */
+  rippleFrequencyHz: number;
+  /** Time constant R C, s. Compare it with the period: large R C means small ripple. */
+  timeConstantS: number;
+}
+interface RectifiedInput {
+  supply: AcSupply;
+  /** Smoothing capacitance across the load, farads. Zero means no capacitor. */
+  capacitanceF: number;
+  rectifier: RectifierMode;
+  cycles?: number;
+  samplesPerCycle?: number;
+}
+/**
+ * The load voltage after rectification, with an ideal peak-detector capacitor.
+ *
+ * The model is the one a textbook draws: while the rectified wave is above the capacitor
+ * voltage the diodes conduct and the capacitor follows the wave up; once the wave falls away
+ * the diodes stop conducting and the capacitor discharges through R, decaying by
+ * exp(-dt / RC) each step. So the output is
+ *
+ *   v_out(t) = max( rectified(t), v_out(t - dt) * exp(-dt / RC) )
+ *
+ * With no capacitor RC is zero, the decay factor is zero, and the output is the bare rectified
+ * wave. Charging is instantaneous here (ideal diodes, no series resistance), so the trace is in
+ * its steady state from the first peak onward, which is why the ripple and the mean are measured
+ * over the LAST whole cycle. Nothing random and nothing clock-based: same input, same trace.
+ */
+declare function acRectifiedTrace({
+  supply,
+  capacitanceF,
+  rectifier,
+  cycles,
+  samplesPerCycle
+}: RectifiedInput): RectifiedTrace;
+//#endregion
+export { AcState, AcSupply, RectifiedInput, RectifiedPoint, RectifiedTrace, RectifierMode, WavePoint, acCurrentAt, acPeriodS, acRectifiedTrace, acState, acVoltageAt, acWaveTrace, integrateSquareOverPeriod, meanAcPowerW, meanRectifiedVoltage, meanSquareByIntegration, meanSquareFromPeak, rectify, rippleFrequencyHz, rmsFromPeak };