prographs 0.12.0 → 0.13.0

package/dist/chunk-INGOG6OV.cjs

@@ -0,0 +1,899 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6;
+
+
+
+
+
+
+
+
+var _chunkSYABFMD7cjs = require('./chunk-SYABFMD7.cjs');
+
+
+var _chunkCM7X3KFUcjs = require('./chunk-CM7X3KFU.cjs');
+
+
+
+var _chunkM4IQ5LIZcjs = require('./chunk-M4IQ5LIZ.cjs');
+
+
+var _chunkL6BGNHFLcjs = require('./chunk-L6BGNHFL.cjs');
+
+
+var _chunkSST7OZN5cjs = require('./chunk-SST7OZN5.cjs');
+
+
+
+
+
+
+var _chunkFDD4UP73cjs = require('./chunk-FDD4UP73.cjs');
+
+
+var _chunkPY4R3IFFcjs = require('./chunk-PY4R3IFF.cjs');
+
+
+var _chunkLNWTC72Ycjs = require('./chunk-LNWTC72Y.cjs');
+
+// src/charts/threefields/BsfcMap3DChart.ts
+var _d3 = require('d3');
+
+// src/charts/threefields/MapSheet.ts
+
+var span = (values) => {
+  const [low, high] = _d3.extent.call(void 0, values.filter(Number.isFinite));
+  return low === void 0 || high === void 0 ? [0, 1] : high > low ? [low, high] : [low - 1, low + 1];
+};
+var mix = (a, b, t) => ({ x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t, z: a.z + (b.z - a.z) * t });
+var MapSheet = (_class = class {
+  /** `points` are the measured nodes the axes must hold. `near` brings the high end of y to the front. */
+  constructor(mesh, points, near = false, range2 = [_chunkSYABFMD7cjs.FLOOR + 0.3, _chunkSYABFMD7cjs.CEIL]) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);
+    this.mesh = mesh;
+    this.near = near;
+    this.range = range2;
+    const all = [...mesh.nodes.flat(), ...points];
+    this.x = span(all.map((node) => node.x));
+    this.y = span(all.map((node) => node.y));
+    this.z = span(all.map((node) => node.z));
+  }
+  
+  
+  
+  
+  
+  
+  __init() {this.across = (x) => (x - this.x[0]) / (this.x[1] - this.x[0]) * 2 - 1}
+  __init2() {this.depth = (y) => (1 - (y - this.y[0]) / (this.y[1] - this.y[0]) * 2) * (this.near ? -1 : 1)}
+  __init3() {this.level = (z) => this.range[0] + (z - this.z[0]) / (this.z[1] - this.z[0]) * (this.range[1] - this.range[0])}
+  /** A node on the sheet. One with no height lies on the floor. */
+  place(node, lift = 0) {
+    return [this.across(node.x), (Number.isFinite(node.z) ? this.level(node.z) : _chunkSYABFMD7cjs.FLOOR) + lift, this.depth(node.y)];
+  }
+  floor(node, lift = 0) {
+    return [this.across(node.x), _chunkSYABFMD7cjs.FLOOR + lift, this.depth(node.y)];
+  }
+  /** The map at fractional mesh coordinates. */
+  node(column, row) {
+    const { nodes, columns, rows } = this.mesh;
+    const i = Math.max(0, Math.min(columns - 2, Math.floor(column))), j = Math.max(0, Math.min(rows - 2, Math.floor(row)));
+    return mix(mix(nodes[j][i], nodes[j][i + 1], column - i), mix(nodes[j + 1][i], nodes[j + 1][i + 1], column - i), row - j);
+  }
+  geometry(paint) {
+    const { nodes, columns, rows } = this.mesh;
+    return _chunkSYABFMD7cjs.SurfaceGeometry.grid(columns, rows, (i, j) => this.place(nodes[j][i]), (i, j) => paint(nodes[j][i].z));
+  }
+  /** Lines of equal height across the sheet, each node carrying the level as its z. */
+  contours(levels) {
+    const { columns, rows, values } = this.mesh;
+    if (!rows || !levels.length) return [];
+    const field = new (0, _chunkSYABFMD7cjs.SurfaceField)(Array.from({ length: columns }, (_, i) => i), Array.from({ length: rows }, (_, j) => j), Float64Array.from(values));
+    return field.lines(levels).map(({ value, paths }) => ({ value, paths: paths.map((path) => path.map(([i, j]) => ({ ...this.node(i, j), z: value }))) }));
+  }
+}, _class);
+
+// src/charts/threefields/ThreeFieldBase.ts
+
+var _three = require('./vendor/three.js');
+var RAD = Math.PI / 180;
+var ThreeFieldBase = class extends _chunkSYABFMD7cjs.SurfaceBase {
+  /** A label on a plate of the surface colour, for text that can lie over any tone of the field. */
+  tag(ctx, text, at, parent) {
+    const plate = _d3.color.call(void 0, ctx.theme.surface);
+    Object.assign(ctx.label(text, at, "ink", 11, parent).element.style, { background: plate ? `${plate.copy({ opacity: 0.82 })}` : "", padding: "1px 5px", borderRadius: "4px" });
+  }
+  /**
+   * A ball on each point, with a post up to its tag. A post grows until its tag clears the ones before it, as seen from
+   * where the camera starts; text is taken as 6.2px a character.
+   */
+  pins(ctx, pins, parent) {
+    const { azimuth = 38, elevation = 26, distance = 5.4 } = this.options;
+    const turn = azimuth * RAD, tilt = elevation * RAD, unit = this.size.height / (2 * distance * Math.tan(19 * RAD));
+    const placed = [];
+    for (const { at, text, pick } of pins) {
+      if (!at.every(Number.isFinite)) continue;
+      const across = (at[0] * Math.cos(turn) - at[2] * Math.sin(turn)) * unit, half = (text.length * 6.2 + 12) / 2;
+      const up = (rise2) => ((at[1] + rise2) * Math.cos(tilt) - (at[0] * Math.sin(turn) + at[2] * Math.cos(turn)) * Math.sin(tilt)) * unit;
+      let rise = 0.17;
+      while (rise < 0.6 && placed.some((tag) => Math.abs(tag.across - across) < tag.half + half && Math.abs(tag.up - up(rise)) < 20)) rise += 0.04;
+      placed.push({ across, up: up(rise), half });
+      const top = [at[0], at[1] + rise, at[2]];
+      this.tubes(new (0, _chunkSYABFMD7cjs.TubeBatch)(3e-3).add([at, top]), parent, ctx.theme.ink);
+      this.dots(ctx, [at], 0.024, () => ctx.color(ctx.theme.ink), parent, pick);
+      this.tag(ctx, text, [top[0], top[1] + 0.055, top[2]], parent);
+    }
+  }
+  /** A second skin around a tube, seen only past its edges: the 3D form of the ring that parts a mark from what lies behind it. */
+  casing(path, radius, color, parent) {
+    const batch = new (0, _chunkSYABFMD7cjs.TubeBatch)(radius * 1.5).add(path);
+    if (!batch.empty) parent.add(new (0, _three.Mesh)(batch.geometry(), this.material({ vertexColors: false, side: _three.BackSide, color, roughness: 1 })));
+  }
+  /** Flat rings on one instanced mesh, for the points where paths begin. */
+  rings(ctx, points, radius, paint, parent, pick) {
+    const shown = points.map((point, k) => ({ point, k })).filter(({ point }) => point.every(Number.isFinite));
+    if (!shown.length) return;
+    const mesh = new (0, _three.InstancedMesh)(new (0, _three.TorusGeometry)(1, 0.3, 8, 28).rotateX(Math.PI / 2), new (0, _three.MeshStandardMaterial)({ roughness: 0.45 }), shown.length);
+    const dummy = new (0, _three.Object3D)();
+    shown.forEach(({ point, k }, at) => {
+      dummy.position.set(...point);
+      dummy.scale.setScalar(radius);
+      dummy.updateMatrix();
+      mesh.setMatrixAt(at, dummy.matrix);
+      mesh.setColorAt(at, paint(k));
+    });
+    mesh.castShadow = true;
+    parent.add(mesh);
+    if (pick) ctx.pick(mesh, (at) => pick(shown[at].k));
+  }
+  /** Colour key: a chip per class stacked beside the far right edge of the box, first entry lowest, each with its label to the right. */
+  key(ctx, entries) {
+    if (!entries.length) return;
+    const chips = new (0, _three.InstancedMesh)(new (0, _three.BoxGeometry)(0.08, 0.08, 0.08), new (0, _three.MeshStandardMaterial)({ roughness: 0.6 }), entries.length);
+    const dummy = new (0, _three.Object3D)();
+    entries.forEach(({ label, color }, k) => {
+      const y = _chunkSYABFMD7cjs.CEIL - (entries.length - 1 - k) * 0.15;
+      dummy.position.set(1.14, y, -1);
+      dummy.updateMatrix();
+      chips.setMatrixAt(k, dummy.matrix);
+      chips.setColorAt(k, ctx.color(color));
+      ctx.label(label, [1.23, y, -1], "muted", 10).center.set(0, 0.5);
+    });
+    ctx.root.add(chips);
+  }
+  /** One row per grid node, for CSV and keyboard access. */
+  gridTable(field) {
+    const rows = Array.from({ length: field.ny }, (_, j) => Array.from({ length: field.nx }, (_2, i) => [field.x[i], field.y[j], field.at(i, j)])).flat();
+    return { columns: ["x", "y", "z"], rows };
+  }
+};
+
+// src/charts/threefields/BsfcMap3DChart.ts
+var BsfcMap3DContours = /* @__PURE__ */ ((BsfcMap3DContours2) => {
+  BsfcMap3DContours2["Draped"] = "draped-contours";
+  BsfcMap3DContours2["Floor"] = "floor-contours";
+  BsfcMap3DContours2["None"] = "no-contours";
+  return BsfcMap3DContours2;
+})(BsfcMap3DContours || {});
+var BsfcMap3DBoundary = /* @__PURE__ */ ((BsfcMap3DBoundary2) => {
+  BsfcMap3DBoundary2["Wall"] = "full-load-wall";
+  BsfcMap3DBoundary2["Rail"] = "full-load-rail";
+  return BsfcMap3DBoundary2;
+})(BsfcMap3DBoundary || {});
+var BsfcMap3DOptimum = /* @__PURE__ */ ((BsfcMap3DOptimum2) => {
+  BsfcMap3DOptimum2["Point"] = "best-point";
+  BsfcMap3DOptimum2["Line"] = "economy-line";
+  BsfcMap3DOptimum2["None"] = "no-optimum";
+  return BsfcMap3DOptimum2;
+})(BsfcMap3DOptimum || {});
+var BSFC = "BSFC";
+var ECONOMY = "Best economy line";
+var BsfcMap3DChart = (_class2 = class _BsfcMap3DChart extends ThreeFieldBase {
+  static __initStatic() {this.meta = {
+    id: "bsfc-map-3d",
+    name: "3D engine BSFC map",
+    family: "scientific" /* Scientific */,
+    dimension: 3 /* Three */,
+    shape: "table" /* Table */,
+    description: "Raises brake specific fuel consumption into a surface over engine speed and torque, bounded by the full-load curve, with the minimum pinned and constant-power lines across it.",
+    tags: ["engine map", "fuel consumption", "fuel island", "torque curve", "automotive", "powertrain", "full load"],
+    sample: (seed) => _chunkFDD4UP73cjs.MachineSamples.bsfcMap(seed),
+    variants: { contours: Object.values(BsfcMap3DContours), boundary: Object.values(BsfcMap3DBoundary), power: [true, false], optimum: Object.values(BsfcMap3DOptimum) }
+  }}
+  defaults() {
+    return {
+      ...super.defaults(),
+      x: "speed",
+      y: "torque",
+      bsfc: "bsfc",
+      contours: "draped-contours" /* Draped */,
+      boundary: "full-load-wall" /* Wall */,
+      power: true,
+      optimum: "best-point" /* Point */,
+      xLabel: "Engine speed (rpm)",
+      yLabel: "Torque (N\xB7m)",
+      zLabel: "BSFC (g/kWh)"
+    };
+  }
+  get sweeps() {
+    const { data, x, y, bsfc } = this.options;
+    return _chunkFDD4UP73cjs.BsfcMath.sweeps((Array.isArray(data) ? data : []).filter((row) => row !== null && typeof row === "object"), x, y, bsfc);
+  }
+  table() {
+    const { x, y, bsfc } = this.options;
+    return { columns: [x, y, bsfc], rows: this.sweeps.flat().map((node) => [node.x, node.y, node.z]) };
+  }
+  /** BSFC at a speed and torque, read off the mesh the surface is drawn from. NaN outside the operating range. */
+  static consumption(mesh, speed, torque) {
+    const rows = mesh.nodes, last = rows.length - 1;
+    if (last < 1 || !(speed >= rows[0][0].x && speed <= rows[last][0].x)) return NaN;
+    let j = 0;
+    while (j < last - 1 && rows[j + 1][0].x < speed) j++;
+    const t = (speed - rows[j][0].x) / (rows[j + 1][0].x - rows[j][0].x || 1);
+    const sweep = rows[j].map((node, i2) => ({ y: node.y + (rows[j + 1][i2].y - node.y) * t, z: node.z + (rows[j + 1][i2].z - node.z) * t }));
+    if (!(torque >= sweep[0].y && torque <= sweep[sweep.length - 1].y)) return NaN;
+    let i = 0;
+    while (i < sweep.length - 2 && sweep[i + 1].y < torque) i++;
+    return sweep[i].z + (sweep[i + 1].z - sweep[i].z) * (torque - sweep[i].y) / (sweep[i + 1].y - sweep[i].y || 1);
+  }
+  /** A uniform cubic B-spline through `points`, held at both ends: the smoothing the 2D map gives its economy line. */
+  static eased(points, pieces = 4) {
+    if (points.length < 3) return points.map(([x, y]) => [x, y]);
+    const knots = [points[0], points[0], ...points, points[points.length - 1], points[points.length - 1]];
+    const out = knots.slice(0, -3).flatMap((_, i) => Array.from({ length: pieces }, (_2, piece) => {
+      const t = piece / pieces, weights = [(1 - t) ** 3, 3 * t ** 3 - 6 * t * t + 4, -3 * t ** 3 + 3 * t * t + 3 * t + 1, t ** 3];
+      return [0, 1].map((axis) => weights.reduce((sum, weight, k) => sum + weight * knots[i + k][axis], 0) / 6);
+    }));
+    return [...out, [points[points.length - 1][0], points[points.length - 1][1]]];
+  }
+  build(ctx) {
+    const { contours, boundary, power, optimum } = this.options, { theme, palette } = ctx;
+    const sweeps = this.sweeps, measured = sweeps.flat();
+    const mesh = new (0, _chunkFDD4UP73cjs.MachineMesh)(sweeps, 24, 4), sheet = new MapSheet(mesh, measured, true, [_chunkSYABFMD7cjs.FLOOR + (contours === "floor-contours" /* Floor */ ? 0.55 : 0.3), _chunkSYABFMD7cjs.CEIL]);
+    const ramp = new (0, _chunkSYABFMD7cjs.ColorRamp)(palette.sequential), [low, high] = sheet.z;
+    const paint = (value) => ramp.at(0.08 + 0.85 * (high - value) / (high - low));
+    const tone = palette.color(BSFC);
+    const kwh = (value) => `${_chunkFDD4UP73cjs.MachineChart.short(value, 4)} g/kWh`;
+    const told = (node, title) => ({
+      title,
+      rows: [["BSFC", kwh(node.z)], ["Speed", `${Math.round(node.x).toLocaleString("en")} rpm`], ["Torque", `${_chunkFDD4UP73cjs.MachineChart.short(node.y)} N\xB7m`], ["Power", `${_chunkFDD4UP73cjs.MachineChart.short(_chunkFDD4UP73cjs.BsfcMath.power(node.x, node.y))} kW`]]
+    });
+    this.box(ctx, {
+      x: this.ticks(sheet.x, sheet.across),
+      y: this.ticks(sheet.y, sheet.depth),
+      z: measured.length ? _d3.scaleLinear.call(void 0, sheet.z, [0, 1]).ticks(4).map((value) => [sheet.level(value), _chunkPY4R3IFFcjs.Scales.format(value, high - low)]) : []
+    });
+    if (!measured.length) return;
+    const lift = this.rise(ctx);
+    if (!mesh.rows) {
+      this.dots(ctx, measured.map((node) => sheet.place(node)), 0.02, (k) => paint(measured[k].z), lift, (k) => told(measured[k]));
+      return;
+    }
+    this.solid(ctx, sheet.geometry(paint), lift, (k) => told(mesh.nodes[Math.floor(k / mesh.columns)][k % mesh.columns]));
+    const full = mesh.nodes.map((row) => row[row.length - 1]), edge = full.map((node) => sheet.place(node, 0.01));
+    this.tubes(new (0, _chunkSYABFMD7cjs.TubeBatch)(0.011).add(edge), lift, theme.ink);
+    if (boundary === "full-load-wall" /* Wall */) this.solid(ctx, _chunkSYABFMD7cjs.SurfaceGeometry.curtain(full.map((node) => sheet.place(node)), _chunkSYABFMD7cjs.FLOOR + 2e-3, (k) => paint(full[k].z), () => paint(high)), lift);
+    else this.tubes(new (0, _chunkSYABFMD7cjs.TubeBatch)(6e-3).add(full.map((node) => sheet.floor(node, 7e-3))), ctx.root, theme.ink);
+    const [mx, my, mz] = edge[Math.floor(edge.length / 2)];
+    this.tag(ctx, "Full load", [mx, (my + _chunkSYABFMD7cjs.FLOOR) / 2, mz + 0.02], lift);
+    const levels = contours === "no-contours" /* None */ ? [] : sheet.contours(mesh.levels(10));
+    const draped = contours === "draped-contours" /* Draped */, isolines = new (0, _chunkSYABFMD7cjs.TubeBatch)(4e-3);
+    for (const { value, paths } of levels) for (const path of paths) isolines.add(path.map((node) => draped ? sheet.place(node, 4e-3) : sheet.floor(node, 6e-3)), draped ? void 0 : paint(value));
+    if (draped) this.tubes(isolines, lift, theme.ink, 0.55);
+    else this.tubes(isolines, ctx.root);
+    const peak = _nullishCoalesce(_d3.max.call(void 0, full, (node) => _chunkFDD4UP73cjs.BsfcMath.power(node.x, node.y)), () => ( 0)), [first, last] = [full[0].x, full[full.length - 1].x];
+    const on = (speed, torque) => ({ x: speed, y: torque, z: _BsfcMap3DChart.consumption(mesh, speed, torque) });
+    const lay = (nodes, lifted) => nodes.map((node) => Number.isFinite(node.z) ? sheet.place(node, lifted) : [NaN, NaN, NaN]);
+    const speeds = _d3.range.call(void 0, 0, 81).map((i) => first + (last - first) * i / 80);
+    const hyperbolas = new (0, _chunkSYABFMD7cjs.TubeBatch)(4e-3);
+    for (const kw of power && peak > 0 ? _d3.ticks.call(void 0, 0, peak, 4).filter((value) => value > 0) : []) {
+      const nodes = speeds.map((speed) => on(speed, _chunkFDD4UP73cjs.BsfcMath.torque(speed, kw))), end = nodes.findLast((node) => Number.isFinite(node.z));
+      if (nodes.filter((node) => Number.isFinite(node.z)).length < 2 || !end) continue;
+      hyperbolas.add(lay(nodes, 6e-3));
+      const [x, y, z] = sheet.place(end);
+      ctx.label(`${kw} kW`, [x + 0.11, y + 0.02, z], "muted", 10, lift);
+    }
+    this.tubes(hyperbolas, lift, theme.surface, 0.85);
+    if (optimum === "economy-line" /* Line */) {
+      const economy = _BsfcMap3DChart.eased(_chunkFDD4UP73cjs.BsfcMath.economy(mesh, _d3.range.call(void 0, 1, 25).map((i) => peak * i / 25))).map(([speed, torque]) => on(speed, torque));
+      const tube = this.tubes(new (0, _chunkSYABFMD7cjs.TubeBatch)(9e-3).add(lay(economy, 0.012)), lift, palette.color(ECONOMY));
+      if (tube) ctx.pick(tube, () => ({ title: ECONOMY, color: palette.color(ECONOMY), rows: [["Joins", "the lowest BSFC at each power"]] }));
+    }
+    const best = optimum === "best-point" /* Point */ ? measured.reduce((lowest, node) => node.z < lowest.z ? node : lowest) : null;
+    if (!best) return;
+    const drawn = _BsfcMap3DChart.consumption(mesh, best.x, best.y);
+    this.pins(ctx, [{ at: sheet.place({ ...best, z: Number.isFinite(drawn) ? drawn : best.z }, 4e-3), text: `Lowest ${kwh(best.z)}`, pick: () => ({ ...told(best, "Lowest BSFC"), color: tone }) }], lift);
+  }
+}, _class2.__initStatic(), _class2);
+
+// src/charts/threefields/CompressorMap3DChart.ts
+
+var CompressorMap3DSurge = /* @__PURE__ */ ((CompressorMap3DSurge2) => {
+  CompressorMap3DSurge2["Wall"] = "surge-wall";
+  CompressorMap3DSurge2["Ribbon"] = "surge-ribbon";
+  CompressorMap3DSurge2["None"] = "no-surge";
+  return CompressorMap3DSurge2;
+})(CompressorMap3DSurge || {});
+var EFFICIENCY = "Efficiency";
+var SPEED = "Speed lines";
+var PEAK = "Peak efficiency";
+var BETWEEN = 5;
+var CompressorMap3DChart = (_class3 = class extends ThreeFieldBase {
+  static __initStatic2() {this.meta = {
+    id: "compressor-map-3d",
+    name: "3D compressor map",
+    family: "scientific" /* Scientific */,
+    dimension: 3 /* Three */,
+    shape: "table" /* Table */,
+    description: "Raises isentropic efficiency into a surface over corrected mass flow and pressure ratio, with the speed lines drawn on it and the surge line as a wall or ribbon.",
+    tags: ["turbomachinery", "turbocharger", "surge line", "efficiency island", "speed line", "gas turbine", "performance map"],
+    sample: (seed) => _chunkFDD4UP73cjs.MachineSamples.compressor(seed),
+    variants: { surge: Object.values(CompressorMap3DSurge), ridge: [false, true], markers: [true, false], floorMap: [true, false] }
+  }}
+  defaults() {
+    return {
+      ...super.defaults(),
+      x: "flow",
+      y: "pressureRatio",
+      series: "speed",
+      efficiency: "efficiency",
+      surge: "surge-wall" /* Wall */,
+      ridge: false,
+      markers: true,
+      floorMap: true,
+      xLabel: "Mass flow (kg/s)",
+      yLabel: "Pressure ratio",
+      zLabel: "Efficiency"
+    };
+  }
+  get rows() {
+    return (Array.isArray(this.options.data) ? this.options.data : []).filter((row) => row !== null && typeof row === "object");
+  }
+  /** Speed lines from surge to choke, slowest first: lower speeds pass less flow. */
+  lines() {
+    const { x, y, series, efficiency } = this.options;
+    const points = this.rows.flatMap((row) => {
+      const flow = _chunkFDD4UP73cjs.MachineChart.number(row[x]), ratio = _chunkFDD4UP73cjs.MachineChart.number(row[y]);
+      return flow === null || ratio === null ? [] : [{ speed: String(_nullishCoalesce(row[series], () => ( "Speed"))), x: flow, y: ratio, z: _nullishCoalesce(_chunkFDD4UP73cjs.MachineChart.number(row[efficiency]), () => ( NaN)) }];
+    });
+    return [..._d3.group.call(void 0, points, (d) => d.speed)].map(([speed, own]) => ({ speed, points: own.sort((a, b) => a.x - b.x) })).sort((a, b) => _d3.mean.call(void 0, a.points, (d) => d.x) - _d3.mean.call(void 0, b.points, (d) => d.x));
+  }
+  table() {
+    const { x, y, series, efficiency } = this.options;
+    return { columns: [series, x, y, efficiency], rows: this.lines().flatMap((line) => line.points.map((d) => [d.speed, d.x, d.y, Number.isFinite(d.z) ? d.z : null])) };
+  }
+  build(ctx) {
+    const { surge, ridge, markers, floorMap } = this.options, { theme, palette } = ctx;
+    const lines = this.lines().map((line) => line.points.every((d) => Number.isFinite(d.z)) ? line : { ...line, points: line.points.map((d) => ({ ...d, z: NaN })) });
+    const all = lines.flatMap((line) => line.points), measured = lines.filter((line) => line.points.length > 1 && Number.isFinite(line.points[0].z));
+    const mesh = new (0, _chunkFDD4UP73cjs.MachineMesh)(measured.map((line) => line.points), 24, BETWEEN), sheet = new MapSheet(mesh, all, false, [_chunkSYABFMD7cjs.FLOOR + (floorMap ? 0.42 : 0.3), _chunkSYABFMD7cjs.CEIL]);
+    const percent2 = (_nullishCoalesce(_d3.max.call(void 0, all, (d) => d.z), () => ( 0))) <= 1.5;
+    const efficiency = (value) => percent2 ? `${_chunkFDD4UP73cjs.MachineChart.short(value * 100)}%` : _chunkFDD4UP73cjs.MachineChart.short(value);
+    const ramp = new (0, _chunkSYABFMD7cjs.ColorRamp)(palette.sequential), [low, high] = sheet.z;
+    const paint = (value) => ramp.at(0.08 + 0.9 * (value - low) / (high - low));
+    palette.color(EFFICIENCY);
+    const ink = palette.color(SPEED), dark = ctx.color(theme.ink);
+    this.box(ctx, {
+      x: this.ticks(sheet.x, sheet.across),
+      y: this.ticks(sheet.y, sheet.depth),
+      z: mesh.rows ? _d3.scaleLinear.call(void 0, sheet.z, [0, 1]).ticks(4).map((value) => [sheet.level(value), efficiency(value)]) : []
+    });
+    if (!all.length) return;
+    const lift = this.rise(ctx);
+    const tip = (d) => ({
+      title: `Speed ${d.speed}`,
+      color: ink,
+      rows: [["Flow", _chunkFDD4UP73cjs.MachineChart.short(d.x, 4)], ["Pressure ratio", _chunkFDD4UP73cjs.MachineChart.short(d.y, 4)], ...Number.isFinite(d.z) ? [["Efficiency", efficiency(d.z)]] : []]
+    });
+    if (mesh.rows) {
+      this.solid(ctx, sheet.geometry(paint), lift, (k) => {
+        const node = mesh.nodes[Math.floor(k / mesh.columns)][k % mesh.columns];
+        return { rows: [["Efficiency", efficiency(node.z)], ["Flow", _chunkFDD4UP73cjs.MachineChart.short(node.x, 4)], ["Pressure ratio", _chunkFDD4UP73cjs.MachineChart.short(node.y, 4)]] };
+      });
+    }
+    const traced = lines.filter((line) => line.points.length > 1).map((line) => {
+      const row = measured.indexOf(line);
+      return { line, nodes: row < 0 || !mesh.rows ? line.points : mesh.nodes[row * BETWEEN] };
+    });
+    for (const { line, nodes } of traced) {
+      const tube = this.tubes(new (0, _chunkSYABFMD7cjs.TubeBatch)(7e-3).add(nodes.map((node) => sheet.place(node, 8e-3))), lift, ink);
+      if (tube) ctx.pick(tube, () => ({ title: `Speed ${line.speed}`, color: ink, rows: [["Flow at surge", _chunkFDD4UP73cjs.MachineChart.short(line.points[0].x)], ["Flow at choke", _chunkFDD4UP73cjs.MachineChart.short(line.points.at(-1).x)]] }));
+      const [x, y, z] = nodes.map((node) => sheet.place(node)).reduce((crest2, point) => point[1] > crest2[1] ? point : crest2);
+      ctx.label(line.speed, [x, y + 0.085, z], "secondary", 10, lift);
+    }
+    const shown = markers ? all : [];
+    this.dots(ctx, shown.map((d) => sheet.place(d, 8e-3)), 0.014, () => ctx.color(ink), lift, (k) => tip(shown[k]));
+    const ends = (pick) => (mesh.rows && measured.length === traced.length ? mesh.nodes : traced.map(({ nodes }) => nodes)).map(pick);
+    const surged = traced.length > 1 ? ends((nodes) => nodes[0]) : [], choked = traced.length > 1 ? ends((nodes) => nodes[nodes.length - 1]) : [];
+    if (surge !== "no-surge" /* None */ && surged.length) {
+      const edge = surged.map((node) => sheet.place(node, 0.01));
+      this.tubes(new (0, _chunkSYABFMD7cjs.TubeBatch)(0.011).add(edge), lift, theme.ink);
+      const wall = surge === "surge-wall" /* Wall */;
+      const band = wall ? _chunkSYABFMD7cjs.SurfaceGeometry.curtain(edge.map(([x2, , z2]) => [x2, _chunkSYABFMD7cjs.CEIL + 0.06, z2]), _chunkSYABFMD7cjs.FLOOR + 2e-3, () => dark, () => dark) : _chunkSYABFMD7cjs.SurfaceGeometry.curtain(edge.map(([x2, y2, z2]) => [x2, y2 + 0.07, z2]), (k) => edge[k][1] - 0.07, () => dark, () => dark);
+      this.solid(ctx, band, lift, void 0, wall ? { transparent: true, opacity: 0.16, depthWrite: false } : {}).castShadow = !wall;
+      const [x, y, z] = edge[Math.floor(edge.length / 2)];
+      this.tag(ctx, "Surge line", [x, wall ? _chunkSYABFMD7cjs.CEIL + 0.14 : y + 0.21, z], lift);
+    }
+    const peaks = ridge ? measured.map((line) => line.points.reduce((best, d) => d.z > best.z ? d : best)) : [];
+    const crest = peaks.length ? palette.color(PEAK) : "";
+    if (peaks.length > 1) this.tubes(new (0, _chunkSYABFMD7cjs.TubeBatch)(6e-3).add(peaks.map((d) => sheet.place(d, 0.012))), lift, crest);
+    this.dots(ctx, peaks.map((d) => sheet.place(d, 0.012)), 0.024, () => ctx.color(crest), lift, (k) => ({ ...tip(peaks[k]), title: `Peak efficiency at ${peaks[k].speed}`, color: crest }));
+    if (!floorMap) return;
+    const flat = new (0, _chunkSYABFMD7cjs.TubeBatch)(4e-3);
+    for (const { nodes } of traced) flat.add(nodes.map((node) => sheet.floor(node, 6e-3)));
+    this.tubes(flat, ctx.root, ink);
+    const islands = new (0, _chunkSYABFMD7cjs.TubeBatch)(4e-3);
+    for (const { value, paths } of sheet.contours(mesh.levels())) for (const path of paths) islands.add(path.map((node) => sheet.floor(node, 6e-3)), paint(value));
+    this.tubes(islands, ctx.root);
+    this.tubes(new (0, _chunkSYABFMD7cjs.TubeBatch)(7e-3).add(surged.map((node) => sheet.floor(node, 7e-3))), ctx.root, theme.ink);
+    this.tubes(new (0, _chunkSYABFMD7cjs.TubeBatch)(4e-3).add(choked.map((node) => sheet.floor(node, 7e-3))), ctx.root, theme.inkMuted);
+  }
+}, _class3.__initStatic2(), _class3);
+
+// src/charts/threefields/LossLandscape3DChart.ts
+
+
+// src/charts/threefields/FieldGrid.ts
+var FieldGrid = class _FieldGrid {
+  constructor(field, space) {
+    this.field = field;
+    this.space = space;
+  }
+  
+  
+  /** Fractional index of `value` along an axis that runs one way, held inside it. */
+  static index(axis, value) {
+    const last = axis.length - 1, falling = axis[0] > axis[last];
+    let i = 0;
+    while (i < last - 1 && (falling ? axis[i + 1] > value : axis[i + 1] < value)) i++;
+    const span2 = axis[i + 1] - axis[i];
+    return i + (span2 ? Math.max(0, Math.min(1, (value - axis[i]) / span2)) : 0);
+  }
+  index(x, y) {
+    return [_FieldGrid.index(this.field.x, x), _FieldGrid.index(this.field.y, y)];
+  }
+  /** The gridded value under a point; a point past the grid reads its nearest edge. */
+  value(x, y) {
+    return this.field.sample(...this.index(x, y));
+  }
+  /** World position on the surface under a point. */
+  at(x, y, lift = 0) {
+    return this.space.at(...this.index(x, y), lift);
+  }
+  /** Lays a track on the surface, cutting each leg so no piece spans more than `cell` grid cells and the line cannot dive under a ridge. */
+  drape(track, lift = 0, cell = 0.5) {
+    const path = [], knots = [];
+    let before = null;
+    for (const [x, y] of track) {
+      const here = this.index(x, y);
+      const pieces = before ? Math.max(1, Math.ceil(Math.max(Math.abs(here[0] - before[0]), Math.abs(here[1] - before[1])) / cell)) : 1;
+      for (let piece = 1; piece < pieces; piece++) {
+        const t = piece / pieces;
+        path.push(this.space.at(before[0] + (here[0] - before[0]) * t, before[1] + (here[1] - before[1]) * t, lift));
+      }
+      knots.push(path.length);
+      path.push(this.space.at(here[0], here[1], lift));
+      before = here;
+    }
+    return { path, knots };
+  }
+};
+
+// src/charts/threefields/LossLandscape3DChart.ts
+var LossLandscape3DTrail = /* @__PURE__ */ ((LossLandscape3DTrail2) => {
+  LossLandscape3DTrail2["Steps"] = "step-markers";
+  LossLandscape3DTrail2["Path"] = "path-only";
+  LossLandscape3DTrail2["None"] = "no-path";
+  return LossLandscape3DTrail2;
+})(LossLandscape3DTrail || {});
+var MOST_DOTS = 90;
+var figure = _d3.format.call(void 0, ".3~g");
+var LossLandscape3DChart = (_class4 = class _LossLandscape3DChart extends ThreeFieldBase {
+  static __initStatic3() {this.meta = {
+    id: "loss-landscape-3d",
+    name: "3D loss landscape",
+    family: "scientific" /* Scientific */,
+    dimension: 3 /* Three */,
+    shape: "grid" /* Grid */,
+    description: "Raises a loss over two parameter directions into a surface on a linear or log height, and lays the path of each optimiser on it as a tube with a marker per step.",
+    tags: ["machine learning", "optimisation", "gradient descent", "loss surface", "training", "optimizer path"],
+    sample: (seed) => _chunkL6BGNHFLcjs.ModelSamples.lossSurface(seed),
+    variants: {
+      scale: ["linear" /* Linear */, "log" /* Log */],
+      trail: Object.values(LossLandscape3DTrail),
+      overlay: ["contour-lines" /* Contours */, "mesh-lines" /* Mesh */, "bare" /* None */],
+      floorMap: [false, true]
+    }
+  }}
+  defaults() {
+    return {
+      ...super.defaults(),
+      scale: "linear" /* Linear */,
+      trail: "step-markers" /* Steps */,
+      overlay: "contour-lines" /* Contours */,
+      floorMap: false,
+      levels: 9,
+      xLabel: "Direction 1",
+      yLabel: "Direction 2",
+      zLabel: "Loss"
+    };
+  }
+  /** The grid, with its depth axis turned when that brings the lower of its two ends to the front, where no wall hides the valley floor. */
+  get losses() {
+    const field = _chunkSYABFMD7cjs.SurfaceField.from(this.options.data).capped(90), { nx, ny } = field;
+    const end = (j) => _nullishCoalesce(_d3.mean.call(void 0, Array.from({ length: nx }, (_, i) => field.at(i, j)).filter(Number.isFinite)), () => ( 0));
+    if (!(end(ny - 1) < end(0))) return field;
+    const turned = new Float64Array(nx * ny);
+    for (let j = 0; j < ny; j++) turned.set(field.z.subarray((ny - 1 - j) * nx, (ny - j) * nx), j * nx);
+    return new (0, _chunkSYABFMD7cjs.SurfaceField)(field.x, [...field.y].reverse(), turned);
+  }
+  table() {
+    return this.gridTable(_chunkSYABFMD7cjs.SurfaceField.from(this.options.data));
+  }
+  /** `Log` is log10 while every loss is positive, and asinh around zero otherwise, so zero and negative losses stay on the chart. */
+  static warp({ zMin, zMax, zDomain }, scale = "linear" /* Linear */) {
+    if (scale !== "log" /* Log */) return { to: (loss) => loss, ticks: _d3.scaleLinear.call(void 0, zDomain, [0, 1]).ticks(4) };
+    if (!(zMin > 0)) {
+      const bend = Math.max(zMax - zMin, 1e-9) / 50;
+      return { to: (loss) => Math.asinh(loss / bend), ticks: _d3.scaleLinear.call(void 0, zDomain, [0, 1]).ticks(4) };
+    }
+    const all = _d3.scaleLog.call(void 0, [zMin, Math.max(zMax, zMin * 1.0001)], [0, 1]).ticks(), tens = all.filter((tick) => Math.abs(Math.log10(tick) % 1) < 1e-9);
+    return { to: Math.log10, ticks: tens.length >= 2 ? tens : all.filter((_, i) => i % Math.ceil(all.length / 4) === 0) };
+  }
+  /** Each run with the loss under every step. A step past the grid sits on its nearest edge, and one over a gap is left out. */
+  runs(ctx, losses, grid) {
+    const paths = _optionalChain([this, 'access', _3 => _3.options, 'access', _4 => _4.data, 'optionalAccess', _5 => _5.paths]);
+    if (this.options.trail === "no-path" /* None */ || !Array.isArray(paths)) return [];
+    return paths.filter((path) => path && Array.isArray(path.points)).map((path, i) => {
+      const name = String(_nullishCoalesce(path.name, () => ( `Path ${i + 1}`)));
+      const read = path.points.map((point, index) => ({ index, x: +_optionalChain([point, 'optionalAccess', _6 => _6[0]]), y: +_optionalChain([point, 'optionalAccess', _7 => _7[1]]) })).filter((step) => Number.isFinite(step.x) && Number.isFinite(step.y)).map((step) => ({ ...step, loss: losses.sample(...grid.index(step.x, step.y)) })).filter((step) => Number.isFinite(step.loss));
+      const { path: laid, knots } = grid.drape(read.map((step) => [step.x, step.y]), 0.012);
+      return { name, color: "", steps: read.map((step, k) => ({ ...step, at: laid[knots[k]] })), path: laid };
+    }).filter((run) => run.steps.length).map((run) => ({ ...run, color: ctx.palette.color(run.name) }));
+  }
+  build(ctx) {
+    const { scale, trail, overlay, floorMap, levels, xLabel, yLabel, zLabel } = this.options;
+    const losses = this.losses, warp = _LossLandscape3DChart.warp(losses, scale);
+    const field = losses.map(warp.to);
+    const space = new (0, _chunkSYABFMD7cjs.SurfaceSpace)(field, "linear" /* Linear */, [_chunkSYABFMD7cjs.FLOOR + (floorMap ? 0.42 : 0.04), _chunkSYABFMD7cjs.CEIL]), grid = new FieldGrid(field, space);
+    const [low, high] = field.zDomain, ramp = new (0, _chunkSYABFMD7cjs.ColorRamp)(ctx.palette.sequential);
+    const paint = (value) => ramp.at(0.05 + 0.95 * (value - low) / (high - low));
+    const [x0, x1] = field.xDomain, [y0, y1] = field.yDomain, reach = losses.zDomain[1] - losses.zDomain[0];
+    this.box(ctx, {
+      x: this.ticks(field.xDomain, (v) => (v - x0) / (x1 - x0 || 1) * 2 - 1),
+      y: this.ticks(field.yDomain, (v) => 1 - (v - y0) / (y1 - y0 || 1) * 2),
+      z: warp.ticks.map((loss) => [space.level(warp.to(loss)), scale === "log" /* Log */ ? figure(loss) : _chunkPY4R3IFFcjs.Scales.format(loss, reach)])
+    });
+    const lift = this.rise(ctx);
+    this.solid(ctx, _chunkSYABFMD7cjs.SurfaceGeometry.grid(field.nx, field.ny, (i, j) => space.at(i, j), (i, j) => paint(field.at(i, j))), lift, (k) => {
+      const i = k % field.nx, j = Math.floor(k / field.nx);
+      return { rows: [[zLabel, figure(losses.at(i, j))], [xLabel, figure(field.x[i])], [yLabel, figure(field.y[j])]] };
+    });
+    if (!field.hasData) return;
+    if (overlay === "mesh-lines" /* Mesh */) this.meshLines(ctx, space, lift);
+    if (overlay === "contour-lines" /* Contours */) this.contourLines(ctx, space, lift, levels);
+    if (floorMap) this.floorContours(ctx, space, paint, levels);
+    const runs = this.runs(ctx, losses, grid);
+    const tip = (run, step, title = `${run.name}, step ${step.index}`) => ({ title, color: run.color, rows: [[zLabel, figure(step.loss)], [xLabel, figure(step.x)], [yLabel, figure(step.y)]] });
+    for (const run of runs) {
+      this.casing(run.path, 8e-3, ctx.theme.surface, lift);
+      const tube = this.tubes(new (0, _chunkSYABFMD7cjs.TubeBatch)(8e-3).add(run.path), lift, run.color);
+      if (tube) ctx.pick(tube, () => ({ title: run.name, color: run.color, rows: [["Steps", run.steps.length - 1], ["Loss at start", figure(run.steps[0].loss)], ["Loss at end", figure(run.steps.at(-1).loss)]] }));
+      if (floorMap) this.tubes(new (0, _chunkSYABFMD7cjs.TubeBatch)(4e-3).add(run.path.map(([x, , z]) => [x, _chunkSYABFMD7cjs.FLOOR + 8e-3, z])), ctx.root, run.color);
+    }
+    const between = trail === "step-markers" /* Steps */ ? runs.flatMap((run) => {
+      const every = Math.max(1, Math.ceil(run.steps.length / MOST_DOTS));
+      return run.steps.slice(1, -1).filter((_, k) => (k + 1) % every === 0).map((step) => ({ run, step }));
+    }) : [];
+    this.dots(ctx, between.map(({ step }) => step.at), 0.014, (k) => ctx.color(between[k].run.color), lift, (k) => tip(between[k].run, between[k].step));
+    this.rings(ctx, runs.map((run) => run.steps[0].at), 0.03, (k) => ctx.color(runs[k].color), lift, (k) => tip(runs[k], runs[k].steps[0], `${runs[k].name}, start`));
+    const ended = runs.filter((run) => run.steps.length > 1);
+    this.dots(ctx, ended.map((run) => run.steps.at(-1).at), 0.03, (k) => ctx.color(ended[k].color), lift, (k) => tip(ended[k], ended[k].steps.at(-1), `${ended[k].name}, end after ${ended[k].steps.at(-1).index} steps`));
+    const lowest = losses.z.indexOf(losses.zMin);
+    if (lowest >= 0) this.pins(ctx, [{ at: space.at(lowest % field.nx, Math.floor(lowest / field.nx)), text: `Lowest loss ${figure(losses.zMin)}` }], lift);
+  }
+}, _class4.__initStatic3(), _class4);
+
+// src/charts/threefields/TerrainRoute3DChart.ts
+
+
+// src/charts/threefields/TerrainRouteMath.ts
+var TerrainRouteMath = class {
+  /**
+   * The route cut into pieces no longer than `cell` grid cells, each with its distance over the ground and the elevation
+   * under it. Points that repeat the one before, or that sit over a gap in the grid, are left out.
+   */
+  static profile(grid, route, cell = 0.5) {
+    const track = (Array.isArray(route) ? route : []).map((point) => [+_optionalChain([point, 'optionalAccess', _8 => _8[0]]), +_optionalChain([point, 'optionalAccess', _9 => _9[1]])]).filter(([x, y]) => Number.isFinite(x) && Number.isFinite(y));
+    const steps = [];
+    const add = (x, y) => {
+      const last = steps[steps.length - 1], elevation = grid.value(x, y), run = last ? Math.hypot(x - last.x, y - last.y) : 0;
+      if (Number.isFinite(elevation) && (!last || run > 0)) steps.push({ x, y, distance: (_nullishCoalesce(_optionalChain([last, 'optionalAccess', _10 => _10.distance]), () => ( 0))) + run, elevation, steep: 0 });
+    };
+    track.forEach(([x, y], k) => {
+      const [px, py] = _nullishCoalesce(track[k - 1], () => ( [x, y])), from = grid.index(px, py), to = grid.index(x, y);
+      const pieces = Math.max(1, Math.ceil(Math.max(Math.abs(to[0] - from[0]), Math.abs(to[1] - from[1])) / cell));
+      for (let piece = 1; piece <= pieces; piece++) add(px + (x - px) * piece / pieces, py + (y - py) * piece / pieces);
+    });
+    return steps;
+  }
+  /** Stretches of `length` with their mean gradient, and each step tagged with the class of the stretch it falls in. */
+  static grade(steps, length, rise = 1e3) {
+    const segments = _chunkFDD4UP73cjs.ElevationMath.segments(steps.map((step) => [step.distance, step.elevation]), length, rise);
+    for (const step of steps) step.steep = _nullishCoalesce(_optionalChain([segments, 'access', _11 => _11[Math.min(segments.length - 1, Math.floor(step.distance / length))], 'optionalAccess', _12 => _12.steep]), () => ( 0));
+    return segments;
+  }
+  /** The step nearest a distance along the route. */
+  static near(steps, distance) {
+    return steps.reduce((best, step) => !best || Math.abs(step.distance - distance) < Math.abs(best.distance - distance) ? step : best, void 0);
+  }
+};
+
+// src/charts/threefields/ThreeFieldsSamples.ts
+var HILLS = [[8, 6, 520, 4.2], [14, 16, 760, 5], [22, 8, 640, 4.6], [25, 19, 880, 5.5], [5, 19, 420, 3.8], [17, 3, 300, 3.5]];
+var WAYPOINTS = [[2, 2], [7, 9], [12.5, 14], [16.5, 11], [20, 13.5], [22.5, 17.5], [25, 19]];
+var spline = (a, b, c, d, t) => 0.5 * (2 * b + (c - a) * t + (2 * a - 5 * b + 4 * c - d) * t * t + (3 * b - a - 3 * c + d) * t ** 3);
+var ThreeFieldsSamples = class {
+  /** A 30 by 24 km block of hill country in metres, on a grid in km, with a road that crosses a shoulder and finishes on the highest summit. */
+  static terrainRoute(seed) {
+    const { u } = _chunkLNWTC72Ycjs.SampleData.rng(seed);
+    const hills = HILLS.map(([east, north, rise, width]) => [east + (u() - 0.5) * 2, north + (u() - 0.5) * 2, rise * (0.8 + u() * 0.4), width * (0.9 + u() * 0.25)]);
+    const phase = u() * 6;
+    const x = Array.from({ length: 61 }, (_, i) => i * 0.5), y = Array.from({ length: 49 }, (_, j) => j * 0.5);
+    const ground = (east, north) => 420 + 4 * east + 6 * north + 24 * Math.sin(0.8 * east + phase) * Math.cos(0.7 * north) + hills.reduce((sum, [cx, cy, rise, width]) => sum + rise * Math.exp(-(((east - cx) ** 2 + (north - cy) ** 2) / width ** 2)), 0);
+    const summit = hills[3];
+    const via = WAYPOINTS.map(([east, north], k) => k === WAYPOINTS.length - 1 ? [summit[0], summit[1]] : [east + (u() - 0.5) * 1.2, north + (u() - 0.5) * 1.2]);
+    const knot = (k) => via[Math.max(0, Math.min(via.length - 1, k))];
+    const route = Array.from({ length: (via.length - 1) * 12 + 1 }, (_, step) => {
+      const k = Math.min(via.length - 2, Math.floor(step / 12)), t = step / 12 - k;
+      return [0, 1].map((axis) => +spline(knot(k - 1)[axis], knot(k)[axis], knot(k + 1)[axis], knot(k + 2)[axis], t).toFixed(2));
+    });
+    return { x, y, z: y.map((north) => x.map((east) => Math.round(ground(east, north)))), route };
+  }
+};
+
+// src/charts/threefields/TerrainRoute3DChart.ts
+var TerrainRoute3DForm = /* @__PURE__ */ ((TerrainRoute3DForm2) => {
+  TerrainRoute3DForm2["Tube"] = "route-tube";
+  TerrainRoute3DForm2["Curtain"] = "route-curtain";
+  return TerrainRoute3DForm2;
+})(TerrainRoute3DForm || {});
+var STEEP = [{ steep: -1, label: "Descent", tone: -0.6 }, { steep: 0, label: "Under 3%", tone: 0 }, { steep: 1, label: "3 to 6%", tone: 0.4 }, { steep: 2, label: "6 to 9%", tone: 0.72 }, { steep: 3, label: "Over 9%", tone: 1 }];
+var SIDES = 6;
+var tenth = (value) => (+value.toFixed(1)).toLocaleString("en");
+var TerrainRoute3DChart = (_class5 = class extends ThreeFieldBase {
+  static __initStatic4() {this.meta = {
+    id: "terrain-route-3d",
+    name: "Terrain route profile",
+    family: "geospatial" /* Geospatial */,
+    dimension: 3 /* Three */,
+    shape: "grid" /* Grid */,
+    description: "Draws an elevation grid as terrain with a route laid over it as a tube coloured by gradient class, the climbs pinned, and optionally a curtain from the route down to the base.",
+    tags: ["route profile", "elevation", "gradient", "climb", "cycling", "hiking", "dem", "track"],
+    sample: (seed) => ThreeFieldsSamples.terrainRoute(seed),
+    variants: { form: Object.values(TerrainRoute3DForm), climbs: [true, false], contours: [false, true], solidBase: [true, false] },
+    valid: ({ form, solidBase }) => form === "route-tube" /* Tube */ || solidBase === false
+  }}
+  defaults() {
+    return { ...super.defaults(), elevation: 32, form: "route-tube" /* Tube */, climbs: true, contours: false, solidBase: true, segment: 1, rise: 1e3, distanceUnit: "km", elevationUnit: "m" };
+  }
+  table() {
+    return this.gridTable(_chunkSYABFMD7cjs.SurfaceField.from(this.options.data));
+  }
+  build(ctx) {
+    const { form, climbs, contours, solidBase, segment, rise, distanceUnit, elevationUnit } = this.options;
+    const curtain = form === "route-curtain" /* Curtain */, { theme, palette } = ctx;
+    const field = _chunkSYABFMD7cjs.SurfaceField.from(this.options.data).capped(110);
+    const bottom = _chunkSYABFMD7cjs.FLOOR + (solidBase && !curtain ? 0.2 : 0.02);
+    const space = new (0, _chunkSYABFMD7cjs.SurfaceSpace)(field, "linear" /* Linear */, [bottom, bottom + 0.85]), grid = new FieldGrid(field, space);
+    const [low, high] = field.zDomain, [x0, x1] = field.xDomain, [y0, y1] = field.yDomain;
+    const ground = new (0, _chunkSYABFMD7cjs.ColorRamp)(_d3.interpolateRgb.call(void 0, theme.grid, theme.axis));
+    const shade = (value) => ground.at((value - low) / (high - low));
+    const whole = (value) => `${Math.round(value).toLocaleString("en")} ${elevationUnit}`, far = (value) => `${tenth(value)} ${distanceUnit}`;
+    this.box(ctx, {
+      x: this.ticks(field.xDomain, (v) => (v - x0) / (x1 - x0 || 1) * 2 - 1),
+      y: this.ticks(field.yDomain, (v) => 1 - (v - y0) / (y1 - y0 || 1) * 2),
+      z: this.ticks(field.zDomain, space.level, 3)
+    }, { bottom: _chunkSYABFMD7cjs.FLOOR });
+    const lift = this.rise(ctx);
+    this.solid(ctx, _chunkSYABFMD7cjs.SurfaceGeometry.grid(field.nx, field.ny, (i, j) => space.at(i, j), (i, j) => shade(field.at(i, j))), lift, (k) => {
+      const i = k % field.nx, j = Math.floor(k / field.nx);
+      return { rows: [["Elevation", whole(field.at(i, j))], ["East", far(field.x[i])], ["North", far(field.y[j])]] };
+    }, curtain ? { roughness: 0.85, transparent: true, opacity: 0.4, depthWrite: false } : { roughness: 0.85 });
+    if (!field.hasData) return;
+    if (solidBase && !curtain) this.skirt(ctx, space, () => ctx.color(theme.grid), lift);
+    if (contours) this.contourLines(ctx, space, lift, 7);
+    const steps = TerrainRouteMath.profile(grid, _optionalChain([this, 'access', _13 => _13.options, 'access', _14 => _14.data, 'optionalAccess', _15 => _15.route])), length = segment > 0 ? segment : 1;
+    const segments = TerrainRouteMath.grade(steps, length, rise);
+    const laid = steps.map((step) => ({ step, at: grid.at(step.x, step.y, 0.014) })).filter(({ at }, k, all) => {
+      const before = _optionalChain([all, 'access', _16 => _16[k - 1], 'optionalAccess', _17 => _17.at]);
+      return !before || (at[0] - before[0]) ** 2 + (at[1] - before[1]) ** 2 + (at[2] - before[2]) ** 2 > 1e-8;
+    });
+    if (laid.length < 2) return;
+    const tones = new Map(STEEP.map(({ steep, tone: tone2 }) => [steep, ctx.color(palette.diverging(tone2))]));
+    const tone = (k) => tones.get(laid[k].step.steep);
+    const told = (k) => {
+      const { step } = laid[Math.min(laid.length - 1, k)], part = segments[Math.min(segments.length - 1, Math.floor(step.distance / length))];
+      return { title: `${far(step.distance)} along the route`, rows: [["Elevation", whole(step.elevation)], ...part ? [["Gradient", `${tenth(part.grade)}%`]] : []] };
+    };
+    const tube = new (0, _chunkCM7X3KFUcjs.SurfaceMesh)(new (0, _chunkSYABFMD7cjs.TubeBatch)(0.011, SIDES).add(laid.map(({ at }) => at), tone).geometry(), this.material({ side: 0, roughness: 0.5 }));
+    tube.castShadow = true;
+    lift.add(tube);
+    this.casing(laid.map(({ at }) => at), 0.011, theme.ink, lift);
+    ctx.pick(tube, (vertex) => told(Math.floor(vertex / SIDES)));
+    if (curtain) this.solid(ctx, _chunkSYABFMD7cjs.SurfaceGeometry.curtain(laid.map(({ at }) => at), _chunkSYABFMD7cjs.FLOOR + 2e-3, tone, tone), lift, (vertex) => told(vertex % laid.length));
+    this.rings(ctx, [laid[0].at], 0.034, () => ctx.color(theme.ink), lift, () => ({ title: "Start", rows: [["Elevation", whole(laid[0].step.elevation)]] }));
+    this.dots(ctx, [laid.at(-1).at], 0.03, () => ctx.color(theme.ink), lift, () => ({ title: "Finish", rows: [["Distance", far(laid.at(-1).step.distance)], ["Elevation", whole(laid.at(-1).step.elevation)]] }));
+    const points = steps.map((step) => [step.distance, step.elevation]);
+    const name = ({ category }) => category === null ? "Climb" : category === 0 ? "HC" : `Cat ${category}`;
+    const found = climbs ? _chunkFDD4UP73cjs.ElevationMath.climbs(points, { rise }).sort((a, b) => b.gain - a.gain).slice(0, 3).sort((a, b) => a.to - b.to) : [];
+    const tip = (climb) => () => ({ title: name(climb), rows: [["Length", far(climb.length)], ["Gain", whole(climb.gain)], ["Mean gradient", `${tenth(climb.grade)}%`], ["Summit", whole(climb.end)]] });
+    const on = (distance) => {
+      const step = TerrainRouteMath.near(steps, distance);
+      return grid.at(step.x, step.y, 0.014);
+    };
+    this.dots(ctx, found.map((climb) => on(climb.from)), 0.02, () => ctx.color(theme.ink), lift, (k) => tip(found[k])());
+    this.pins(ctx, found.map((climb) => ({ at: on(climb.to), text: `${name(climb)} \xB7 ${far(climb.length)} at ${tenth(climb.grade)}%`, pick: tip(climb) })), lift);
+    const used = new Set(laid.map(({ step }) => step.steep));
+    this.key(ctx, STEEP.filter(({ steep }) => used.has(steep)).map(({ label, tone: share }) => ({ label, color: palette.diverging(share) })));
+    ctx.label(`Total ascent ${whole(_chunkFDD4UP73cjs.ElevationMath.ascent(points, 3))} over ${far(steps.at(-1).distance)}`, [0, _chunkSYABFMD7cjs.CEIL + 0.16, -1], "ink", 11);
+  }
+}, _class5.__initStatic4(), _class5);
+
+// src/charts/threefields/WaferMap3DChart.ts
+
+var WaferMap3DEncoding = /* @__PURE__ */ ((WaferMap3DEncoding2) => {
+  WaferMap3DEncoding2["Value"] = "value-height";
+  WaferMap3DEncoding2["Bin"] = "bin-tiles";
+  return WaferMap3DEncoding2;
+})(WaferMap3DEncoding || {});
+var WaferMap3DMark = /* @__PURE__ */ ((WaferMap3DMark2) => {
+  WaferMap3DMark2["Notch"] = "notch";
+  WaferMap3DMark2["Flat"] = "flat";
+  return WaferMap3DMark2;
+})(WaferMap3DMark || {});
+var WaferMap3DBaseline = /* @__PURE__ */ ((WaferMap3DBaseline2) => {
+  WaferMap3DBaseline2["Fitted"] = "fitted-base";
+  WaferMap3DBaseline2["Zero"] = "zero-base";
+  return WaferMap3DBaseline2;
+})(WaferMap3DBaseline || {});
+var RADIUS = 0.98;
+var TOP = -0.32;
+var SLAB = 0.035;
+var TALLEST = 0.62;
+var ZONES = ["Centre", "Middle", "Edge"];
+var percent = (good, total) => total ? `${(100 * good / total).toFixed(1)}%` : "n/a";
+var figure2 = (value) => `${+value.toPrecision(4)}`;
+var WaferMap3DChart = (_class6 = class _WaferMap3DChart extends ThreeFieldBase {
+  static __initStatic5() {this.meta = {
+    id: "wafer-map-3d",
+    name: "3D wafer map",
+    family: "matrix" /* Matrix */,
+    dimension: 3 /* Three */,
+    shape: "table" /* Table */,
+    description: "Stands the dies of a semiconductor wafer on a notched disc as boxes whose height and colour show a measured value, or as flat tiles coloured by test bin, with the yield. The sample wafer is invented.",
+    tags: ["wafer", "semiconductor", "die", "yield", "bin map", "probe", "parametric"],
+    sample: (seed) => _chunkM4IQ5LIZcjs.ReliabilitySamples.wafer(seed),
+    variants: {
+      encoding: Object.values(WaferMap3DEncoding),
+      mark: Object.values(WaferMap3DMark),
+      baseline: Object.values(WaferMap3DBaseline),
+      zones: [false, true]
+    },
+    valid: ({ encoding, baseline }) => encoding === "value-height" /* Value */ || baseline === "fitted-base" /* Fitted */
+  }}
+  defaults() {
+    return {
+      azimuth: 24,
+      elevation: 40,
+      distance: 4.3,
+      x: "x",
+      y: "y",
+      bin: "bin",
+      value: "value",
+      passBin: "Pass",
+      encoding: "value-height" /* Value */,
+      mark: "notch" /* Notch */,
+      baseline: "fitted-base" /* Fitted */,
+      zones: false
+    };
+  }
+  /** Dies, wafer radius in die pitches and yield, exactly as the 2D wafer map counts them. */
+  summary() {
+    const { data, x, y, bin, value, passBin } = this.options;
+    return new (0, _chunkM4IQ5LIZcjs.WaferMap)({ data, x, y, bin, value, passBin }).summary();
+  }
+  table() {
+    const { x, y, bin, value } = this.options;
+    return { columns: [x, y, bin, value], rows: this.summary().dies.map((die) => [die.x, die.y, die.bin, die.value]) };
+  }
+  /**
+   * The wafer's edge as a polygon around the origin, with the orientation mark towards +y: a V notch, or a flat no
+   * nearer the centre than `floor`, the outermost die edge on that side.
+   */
+  static outline(radius, mark, floor = 0, steps = 96) {
+    const flat = mark === "flat" /* Flat */, depth = radius * 0.06;
+    const chord = Math.min(radius * 0.995, Math.max(radius * 0.93, floor + radius * 0.01));
+    const gap = flat ? Math.acos(chord / radius) : Math.asin(depth * 0.8 / radius);
+    const arc = Array.from({ length: steps + 1 }, (_, k) => {
+      const angle = Math.PI / 2 + gap + (2 * Math.PI - 2 * gap) * k / steps;
+      return [radius * Math.cos(angle), radius * Math.sin(angle)];
+    });
+    return flat ? arc : [...arc, [0, radius - depth]];
+  }
+  build(ctx) {
+    const { encoding, mark, baseline, zones, bin, value } = this.options, { theme, palette } = ctx;
+    const { dies, centre, radius, good, zones: rings } = this.summary();
+    if (!dies.length) return;
+    const pitch = RADIUS / radius, side = pitch * 0.9, byValue = encoding === "value-height" /* Value */;
+    const values = dies.map((die) => die.value).filter((v) => v !== null);
+    const low = Math.min(...values), high = Math.max(...values), spread = high - low || 1;
+    const zero = baseline === "zero-base" /* Zero */, from = zero ? Math.min(0, low) : low, to = zero ? Math.max(0, high) : high;
+    const level = (v) => TOP + (zero ? 0 : 0.03) + (v - from) / (to - from || 1) * (TALLEST - (zero ? 0 : 0.03));
+    const counts = /* @__PURE__ */ new Map();
+    for (const die of dies) counts.set(die.bin, (_nullishCoalesce(counts.get(die.bin), () => ( 0))) + 1);
+    if (!byValue) [...counts].sort((a, b) => b[1] - a[1]).forEach(([name]) => palette.color(name || "Unbinned"));
+    const tiles = dies.map((die) => {
+      const measured = byValue && die.value !== null;
+      return {
+        die,
+        x: (die.x - centre[0]) * pitch,
+        z: (die.y - centre[1]) * pitch,
+        from: measured && zero ? level(0) : TOP,
+        to: measured ? level(die.value) : TOP + (byValue ? 0.012 : 0.03),
+        color: byValue ? die.value === null ? theme.grid : palette.sequential((die.value - low) / spread) : palette.color(die.bin || "Unbinned")
+      };
+    });
+    _chunkSST7OZN5cjs.Marks3D.instanced(ctx, new (0, _three.BoxGeometry)(1, 1, 1), tiles, {
+      place: (dummy, tile, progress) => {
+        const tall = Math.max(4e-3, Math.abs(tile.to - tile.from) * progress);
+        dummy.position.set(tile.x, tile.from + (tile.to < tile.from ? -tall : tall) / 2, tile.z);
+        dummy.scale.set(side, tall, side);
+      },
+      color: (tile) => tile.color,
+      tip: ({ die, color }) => ({
+        title: `Die ${die.x}, ${die.y}`,
+        color,
+        rows: [[bin, die.bin || "n/a"], ...die.value === null ? [] : [[value, figure2(die.value)]], ["Ring", ZONES[Math.min(2, Math.floor(die.reach * 3))]]]
+      })
+    });
+    const floor = Math.max(0, ...tiles.map((tile) => tile.z + pitch / 2));
+    const shape = new (0, _three.Shape)(_WaferMap3DChart.outline(RADIUS, mark, floor).map(([x, y]) => new (0, _three.Vector2)(x, y)));
+    const disc = new (0, _three.Mesh)(new (0, _three.ExtrudeGeometry)(shape, { depth: SLAB, bevelEnabled: false }).rotateX(Math.PI / 2).translate(0, TOP, 0), _chunkSST7OZN5cjs.Marks3D.matte({ color: theme.grid }));
+    disc.receiveShadow = true;
+    ctx.root.add(disc);
+    const crest = Math.max(...tiles.map((tile) => Math.max(tile.from, tile.to)));
+    if (zones) {
+      const tall = crest - TOP + 0.035;
+      for (const share of [1 / 3, 2 / 3]) {
+        const fence = new (0, _three.Mesh)(new (0, _three.CylinderGeometry)(share * RADIUS, share * RADIUS, tall, 72, 1, true).translate(0, TOP + tall / 2, 0), _chunkSST7OZN5cjs.Marks3D.matte({ color: theme.ink, transparent: true, opacity: 0.22, depthWrite: false, side: _three.DoubleSide }));
+        ctx.root.add(fence);
+      }
+      ctx.label(rings.map((ring) => `${ring.name} ${percent(ring.good, ring.total)}`).join(" \xB7 "), [0, TOP - 0.1, RADIUS + 0.4], "secondary", 11);
+    }
+    if (byValue && values.length > 1 && high > low) {
+      const peak = tiles.find((tile) => tile.die.value === high), trough = tiles.find((tile) => tile.die.value === low);
+      this.pins(ctx, [{ at: [peak.x, peak.to, peak.z], text: `Highest ${figure2(high)}` }, { at: [trough.x, trough.to, trough.z], text: `Lowest ${figure2(low)}` }], ctx.root);
+    }
+    ctx.label(`Yield ${percent(good, dies.length)} \xB7 ${good} of ${dies.length} dies`, [0, TOP - 0.1, RADIUS + 0.22], "ink", 11);
+  }
+}, _class6.__initStatic5(), _class6);
+
+// src/charts/threefields/index.ts
+var threefieldsCatalog = [LossLandscape3DChart, CompressorMap3DChart, BsfcMap3DChart, TerrainRoute3DChart, WaferMap3DChart];
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.BsfcMap3DContours = BsfcMap3DContours; exports.BsfcMap3DBoundary = BsfcMap3DBoundary; exports.BsfcMap3DOptimum = BsfcMap3DOptimum; exports.BsfcMap3DChart = BsfcMap3DChart; exports.CompressorMap3DSurge = CompressorMap3DSurge; exports.CompressorMap3DChart = CompressorMap3DChart; exports.LossLandscape3DTrail = LossLandscape3DTrail; exports.LossLandscape3DChart = LossLandscape3DChart; exports.TerrainRoute3DForm = TerrainRoute3DForm; exports.TerrainRoute3DChart = TerrainRoute3DChart; exports.WaferMap3DEncoding = WaferMap3DEncoding; exports.WaferMap3DMark = WaferMap3DMark; exports.WaferMap3DBaseline = WaferMap3DBaseline; exports.WaferMap3DChart = WaferMap3DChart; exports.threefieldsCatalog = threefieldsCatalog;