prographs 0.12.0 → 0.13.0

package/dist/chunk-M4IQ5LIZ.cjs

@@ -0,0 +1,422 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } var _class;
+
+var _chunkAL4XQZH6cjs = require('./chunk-AL4XQZH6.cjs');
+
+
+var _chunkEEF5WRRZcjs = require('./chunk-EEF5WRRZ.cjs');
+
+
+var _chunkLNWTC72Ycjs = require('./chunk-LNWTC72Y.cjs');
+
+// src/charts/reliabilitycharts/ReliabilitySamples.ts
+var sig = (value, digits = 2) => +value.toPrecision(digits);
+var ReliabilitySamples = class {
+  /** A cooling-water fault tree: `{ id, parent, label, gate, probability }`, with a probability on each basic event. */
+  static faultTree(seed) {
+    const { u } = _chunkLNWTC72Ycjs.SampleData.rng(seed);
+    const p = (base) => sig(base * (0.6 + 0.8 * u()));
+    const event = (id, parent, label, base) => ({ id, parent, label, gate: null, probability: p(base) });
+    const gate = (id, parent, label, kind) => ({ id, parent, label, gate: kind, probability: null });
+    return [
+      gate("TOP", null, "No cooling water flow", "or"),
+      gate("G1", "TOP", "Both pumps fail", "and"),
+      event("E1", "G1", "Pump A fails", 0.04),
+      event("E2", "G1", "Pump B fails", 0.05),
+      event("E3", "TOP", "Suction valve shut", 2e-3),
+      gate("G2", "TOP", "No power", "and"),
+      event("E4", "G2", "Mains supply lost", 0.02),
+      event("E5", "G2", "Generator fails to start", 0.06),
+      ...seed % 2 ? [] : [event("E6", "TOP", "Strainer blocked", 4e-3)]
+    ];
+  }
+  /** A gas-leak event tree: `{ id, parent, system, branch, probability, outcome }`. The first row is the leak and its frequency per year. */
+  static eventTree(seed) {
+    const { u } = _chunkLNWTC72Ycjs.SampleData.rng(seed);
+    const works = (base) => sig(Math.min(0.995, base + 0.04 * (u() - 0.5)), 3);
+    const pair = (id, parent, system, success, outcomes) => [
+      { id: `${id}1`, parent, system, branch: "success", probability: success, outcome: outcomes[0] },
+      { id: `${id}0`, parent, system, branch: "failure", probability: sig(1 - success, 3), outcome: outcomes[1] }
+    ];
+    return [
+      { id: "IE", parent: null, system: "Gas leak", branch: null, probability: sig(0.05 + 0.1 * u()), outcome: null },
+      ...pair("D", "IE", "Detection", works(0.95), [null, null]),
+      ...pair("S", "D1", "Isolation", works(0.9), ["Safe shutdown", null]),
+      ...pair("N", "S0", "No ignition", works(0.8), ["Gas cloud", "Jet fire"]),
+      ...pair("M", "D0", "No ignition", works(0.7), ["Gas cloud", "Explosion"])
+    ];
+  }
+  /** A loss-of-containment bow-tie: `{ side, path, barrier }`, one row per barrier, plus the event and hazard rows. */
+  static bowTie(seed) {
+    const { u } = _chunkLNWTC72Ycjs.SampleData.rng(seed);
+    const lanes = (side, list) => list.flatMap(([path, barriers]) => barriers.slice(0, 1 + Math.floor(u() * barriers.length)).map((barrier) => ({ side, path, barrier })));
+    return [
+      { side: "hazard", path: "LPG storage", barrier: null },
+      { side: "event", path: "Loss of containment", barrier: null },
+      ...lanes("threat", [["Corrosion", ["Coating", "Inspection"]], ["Overpressure", ["Relief valve", "Pressure trip"]], ["Vehicle impact", ["Crash barrier"]], ["Operator error", ["Procedure", "Interlock"]]]),
+      ...lanes("consequence", [["Fire", ["Gas detection", "Deluge"]], ["Explosion", ["Ignition control", "Blast wall"]], ["Injury", ["Evacuation"]], ["Spill to ground", ["Bund"]]])
+    ];
+  }
+  /** A pumping system as stages in series: `{ block, stage, branch, reliability }`. Blocks sharing a stage are redundant unless they share a branch. */
+  static blocks(seed) {
+    const { u } = _chunkLNWTC72Ycjs.SampleData.rng(seed);
+    const r = (base) => sig(1 - (1 - base) * (0.5 + u()), 3);
+    return [
+      { block: "Supply", stage: "Power", branch: null, reliability: r(0.995) },
+      { block: "Pump A", stage: "Pumping", branch: "A", reliability: r(0.93) },
+      { block: "Pump B", stage: "Pumping", branch: "B", reliability: r(0.93) },
+      ...seed % 2 ? [] : [{ block: "Pump C", stage: "Pumping", branch: "C", reliability: r(0.9) }],
+      { block: "PLC", stage: "Control", branch: null, reliability: r(0.99) },
+      { block: "Valve 1", stage: "Delivery", branch: "Line 1", reliability: r(0.97) },
+      { block: "Filter", stage: "Delivery", branch: "Line 1", reliability: r(0.98) },
+      { block: "Valve 2", stage: "Delivery", branch: "Line 2", reliability: r(0.95) }
+    ];
+  }
+  /** 4,096 samples of a rate gyro at rest, 100 Hz: `{ time, rate }` in seconds and °/s, made of white noise, a flicker floor and a slow random walk. */
+  static gyro(seed) {
+    const { n: n2 } = _chunkLNWTC72Ycjs.SampleData.rng(seed);
+    const white = 0.02, flicker = 35e-4, walk = 5e-4;
+    const poles = [4, 16, 64, 256, 1024].map((samples) => Math.exp(-1 / samples)), states = poles.map(() => 0);
+    let wander = 0;
+    return Array.from({ length: 4096 }, (_, i) => {
+      poles.forEach((pole, k) => {
+        states[k] = pole * states[k] + Math.sqrt(1 - pole * pole) * n2();
+      });
+      wander += walk * n2();
+      return { time: +(i * 0.01).toFixed(2), rate: +(white * n2() + flicker * states.reduce((sum, value) => sum + value, 0) + wander).toFixed(5) };
+    });
+  }
+  /** A supply voltage against clock frequency sweep of one device: `{ voltage, frequency, pass }` in volts and GHz, with one stray failure inside the passing region. */
+  static shmoo(seed) {
+    const { u } = _chunkLNWTC72Ycjs.SampleData.rng(seed);
+    const knee = 0.6 + 0.06 * u(), gain = 3.3 + 0.5 * u(), hole = [3 + Math.floor(u() * 5), 1 + Math.floor(u() * 3)];
+    return Array.from({ length: 11 }, (_, i) => Array.from({ length: 10 }, (_2, j) => {
+      const voltage = +(0.8 + i * 0.04).toFixed(2), frequency = +(1 + j * 0.2).toFixed(1);
+      const limit = gain * Math.max(0, voltage - knee) ** 0.75 * (1 + 0.04 * (u() - 0.5));
+      return { voltage, frequency, pass: frequency <= limit && !(i === hole[0] + 3 && j === hole[1]) ? 1 : 0 };
+    })).flat();
+  }
+  /** Probe results for one wafer: `{ x, y, bin, value }` with die indices from 1, a test bin, and threshold voltage in volts. Yield falls toward the edge and around one defect cluster. */
+  static wafer(seed) {
+    const { u, n: n2 } = _chunkLNWTC72Ycjs.SampleData.rng(seed);
+    const across = 19, centre = (across + 1) / 2, radius = across / 2;
+    const angle = u() * 2 * Math.PI, spot = [centre + Math.cos(angle) * radius * 0.5, centre + Math.sin(angle) * radius * 0.5], tilt = (u() - 0.5) * 4e-3;
+    const rows = [];
+    for (let y = 1; y <= across; y++) for (let x = 1; x <= across; x++) {
+      const reach = Math.hypot(Math.abs(x - centre) + 0.5, Math.abs(y - centre) + 0.5) / radius;
+      if (reach > 1) continue;
+      const near = Math.hypot(x - spot[0], y - spot[1]), draw = u();
+      const bin = near < 1.8 && draw < 0.8 ? "Short" : draw < 0.03 + 0.4 * reach ** 5 ? u() < 0.6 ? "Leakage" : "Open" : draw > 0.975 ? "Slow" : "Pass";
+      rows.push({ x, y, bin, value: +(0.45 + 0.035 * reach * reach + tilt * (x - centre) + 6e-3 * n2()).toFixed(4) });
+    }
+    return rows;
+  }
+  /** A bathtub scan of a serial receiver: `{ position, ber }` across one unit interval, from a dual-Dirac jitter model, measured down to 1e-10. */
+  static jitterScan(seed) {
+    const { u, n: n2 } = _chunkLNWTC72Ycjs.SampleData.rng(seed);
+    const sigma = 0.018 + 8e-3 * u(), spread = 0.1 + 0.06 * u();
+    const wall = (x) => 0.25 * (_chunkAL4XQZH6cjs.StatMath.normalCdf(-(x - spread / 2) / sigma) + _chunkAL4XQZH6cjs.StatMath.normalCdf(-(x + spread / 2) / sigma));
+    return Array.from({ length: 41 }, (_, i) => i / 40).flatMap((position) => {
+      const ber = (wall(position) + wall(1 - position)) * Math.exp(0.2 * n2());
+      return ber < 1e-10 ? [] : [{ position: +position.toFixed(3), ber: +Math.min(0.5, ber).toExponential(3) }];
+    });
+  }
+  /** A feed and reaction unit: equipment and instruments as `nodes` (`{ id, kind, label }`), process and signal lines as `links` (`{ source, target, line }`). */
+  static processUnit(seed) {
+    const unit = 100 * (1 + seed % 4), tag = (letters, offset = 1) => `${letters}-${unit + offset}`;
+    const spare = seed % 2 === 1;
+    const nodes = [
+      { id: "tank", kind: "tank", label: tag("T") },
+      { id: "pumpA", kind: "pump", label: `${tag("P")}A` },
+      ...spare ? [{ id: "pumpB", kind: "pump", label: `${tag("P")}B` }] : [],
+      { id: "fv", kind: "control-valve", label: tag("FV") },
+      { id: "heater", kind: "exchanger", label: tag("E") },
+      { id: "reactor", kind: "vessel", label: tag("R") },
+      { id: "outlet", kind: "valve", label: tag("HV", 2) },
+      { id: "ft", kind: "instrument", label: tag("FT") },
+      { id: "fic", kind: "instrument", label: tag("FIC") },
+      { id: "tt", kind: "instrument", label: tag("TT", 2) },
+      { id: "tic", kind: "instrument", label: tag("TIC", 2) }
+    ];
+    const pipe = (source, target) => ({ source, target, line: "process" }), wire = (source, target) => ({ source, target, line: "signal" });
+    const links = [
+      pipe("tank", "pumpA"),
+      pipe("pumpA", "fv"),
+      ...spare ? [pipe("tank", "pumpB"), pipe("pumpB", "fv")] : [],
+      pipe("fv", "heater"),
+      pipe("heater", "reactor"),
+      pipe("reactor", "outlet"),
+      pipe("reactor", "tank"),
+      wire("pumpA", "ft"),
+      wire("ft", "fic"),
+      wire("fic", "fv"),
+      wire("reactor", "tt"),
+      wire("tt", "tic"),
+      wire("tic", "heater")
+    ];
+    return { nodes, links };
+  }
+  /** A small plant network: `{ id, kind, from, label, rating, voltage }`, fed from a grid infeed through one transformer to a bus with four feeders. */
+  static powerNetwork(seed) {
+    const { u } = _chunkLNWTC72Ycjs.SampleData.rng(seed);
+    const pick = (list) => list[Math.floor(u() * list.length)];
+    const high = "33 kV", medium = "11 kV";
+    return [
+      { id: "GRID", kind: "source", from: null, label: "Grid", rating: `${pick([500, 750, 1e3])} MVA`, voltage: high },
+      { id: "CB1", kind: "breaker", from: "GRID", label: "CB1", rating: "1250 A", voltage: high },
+      { id: "T1", kind: "transformer", from: "CB1", label: "T1", rating: `${pick([10, 16, 20])} MVA`, voltage: medium },
+      { id: "BUS", kind: "bus", from: "T1", label: "Main bus", rating: null, voltage: medium },
+      { id: "CB2", kind: "breaker", from: "BUS", label: "CB2", rating: "630 A", voltage: medium },
+      { id: "M1", kind: "motor", from: "CB2", label: "Pump M1", rating: `${pick([0.8, 1.2, 1.6])} MW`, voltage: medium },
+      { id: "CB3", kind: "breaker", from: "BUS", label: "CB3", rating: "630 A", voltage: medium },
+      { id: "G1", kind: "generator", from: "CB3", label: "Standby", rating: `${pick([2, 2.5, 3])} MVA`, voltage: medium },
+      { id: "Q1", kind: "switch", from: "BUS", label: "Q1", rating: "400 A", voltage: medium },
+      { id: "L1", kind: "load", from: "Q1", label: "Process", rating: `${pick([1.5, 2, 2.4])} MW`, voltage: medium },
+      { id: "F1", kind: "fuse", from: "BUS", label: "F1", rating: "63 A", voltage: medium },
+      { id: "L2", kind: "load", from: "F1", label: "Lighting", rating: `${pick([120, 160, 200])} kW`, voltage: medium }
+    ];
+  }
+  /** A motor starter in ladder logic: `{ rung, step, kind, tag, state, preset, comment }`. The seed sets which inputs are on. */
+  static ladder(seed) {
+    const running = seed % 3 !== 0 ? 1 : 0, timed = seed % 2 === 0 && running ? 1 : 0;
+    const contact = (rung, step, kind, tag, state, comment = null) => ({ rung, step, kind, tag, state, preset: null, comment });
+    return [
+      contact(1, 1, "nc", "Stop", 0, "Motor start and stop with seal-in"),
+      contact(1, 2, "no", "Start", 0),
+      contact(1, 2, "no", "M1", running),
+      contact(1, 3, "nc", "OL1", 0),
+      { rung: 1, step: 4, kind: "coil", tag: "M1", state: null, preset: null, comment: null },
+      contact(2, 1, "no", "M1", running, "Run-up delay"),
+      { rung: 2, step: 2, kind: "timer", tag: "T1", state: null, preset: `${3 + seed % 4} s`, comment: null },
+      contact(3, 1, "no", "T1", timed, "Open discharge valve"),
+      contact(3, 2, "nc", "LSH", 0),
+      { rung: 3, step: 3, kind: "coil", tag: "V1", state: null, preset: null, comment: null }
+    ];
+  }
+  /** A single feedback loop with a disturbance: `nodes` (`{ id, kind, label }`) and `links` (`{ source, target, sign }`). */
+  static controlLoop(seed) {
+    const { u } = _chunkLNWTC72Ycjs.SampleData.rng(seed);
+    const whole = (low, high) => low + Math.floor(u() * (high - low + 1));
+    const nodes = [
+      { id: "r", kind: "input", label: "R(s)" },
+      { id: "e", kind: "sum", label: "" },
+      { id: "c", kind: "block", label: `${whole(2, 9)}(s+${whole(1, 4)})/s` },
+      { id: "u", kind: "sum", label: "" },
+      { id: "g", kind: "block", label: `${whole(1, 6)}/(s+${whole(2, 9)})` },
+      { id: "y", kind: "output", label: "Y(s)" },
+      { id: "h", kind: "block", label: `1/(0.${whole(1, 5)}s+1)` },
+      { id: "d", kind: "input", label: "D(s)" }
+    ];
+    const link = (source, target, sign = null) => ({ source, target, sign });
+    return { nodes, links: [link("r", "e", "+"), link("e", "c"), link("c", "u", "+"), link("d", "u", "+"), link("u", "g"), link("g", "y"), link("g", "h"), link("h", "e", "-")] };
+  }
+};
+
+// src/charts/reliabilitycharts/SchematicChart.ts
+var SchematicChart = class extends _chunkEEF5WRRZcjs.Chart2D {
+  plotMargin() {
+    return { top: 8, right: 12, bottom: 8, left: 12 };
+  }
+  rows() {
+    const { data } = this.options;
+    return (Array.isArray(data) ? data : []).filter((row) => row !== null && typeof row === "object");
+  }
+  static word(cell) {
+    return cell === null || cell === void 0 ? "" : String(cell).trim();
+  }
+  static number(cell) {
+    if (cell === null || cell === void 0 || cell === "" || typeof cell === "boolean") return null;
+    const value = +cell;
+    return Number.isFinite(value) ? value : null;
+  }
+  /** A filled triangle with its tip at `x, y`, pointing along `angle` in degrees (0 is right, 90 is down). */
+  static arrow(x, y, angle, size = 7) {
+    const turn = angle * Math.PI / 180, cos = Math.cos(turn), sin = Math.sin(turn), half = size * 0.45;
+    const at = (along, across) => `${+(x + along * cos - across * sin).toFixed(2)},${+(y + along * sin + across * cos).toFixed(2)}`;
+    return `M${at(0, 0)} L${at(-size, -half)} L${at(-size, half)} Z`;
+  }
+  wires(ctx, name, wires) {
+    const paths = ctx.marks(name, "path", wires, (wire) => wire.key).attr("fill", "none").attr("stroke", (wire) => _nullishCoalesce(wire.color, () => ( ctx.theme.inkSecondary))).attr("stroke-width", (wire) => _nullishCoalesce(wire.width, () => ( 1.5))).attr("stroke-dasharray", (wire) => _nullishCoalesce(wire.dash, () => ( null))).attr("stroke-linejoin", "round").attr("stroke-linecap", "round");
+    ctx.set(paths, { d: (wire) => wire.d });
+    paths.style("pointer-events", (wire) => wire.tip ? null : "none");
+    ctx.hover(paths.filter((wire) => !!wire.tip), (wire) => wire.tip);
+    return paths;
+  }
+  notes(ctx, name, notes) {
+    const fills = { ink: ctx.theme.ink, secondary: ctx.theme.inkSecondary, muted: ctx.theme.inkMuted };
+    const marks = ctx.marks(name, "text", notes, (note) => note.key).attr("text-anchor", (note) => _nullishCoalesce(note.anchor, () => ( "middle"))).attr("dominant-baseline", "central").attr("font-size", (note) => _nullishCoalesce(note.size, () => ( 10))).attr("font-weight", (note) => _nullishCoalesce(note.weight, () => ( null))).attr("font-family", ctx.theme.fontFamily).attr("fill", (note) => _nullishCoalesce(note.fill, () => ( fills[_nullishCoalesce(note.tone, () => ( "ink"))]))).attr("stroke", (note) => note.halo ? ctx.theme.surface : null).attr("stroke-width", (note) => note.halo ? 3 : null).attr("paint-order", (note) => note.halo ? "stroke" : null).style("pointer-events", "none").text((note) => note.text);
+    ctx.set(marks, { x: (note) => note.x, y: (note) => note.y });
+  }
+};
+
+// src/charts/reliabilitycharts/SchematicLabel.ts
+var EM = 0.565;
+var SchematicLabel = class _SchematicLabel {
+  static width(text, size = 10) {
+    return text.length * size * EM;
+  }
+  /** `text` cut to `room` px with an ellipsis, or nothing when under two characters would show. */
+  static fit(text, room, size = 10) {
+    if (_SchematicLabel.width(text, size) <= room) return text;
+    const keep = Math.floor(room / (size * EM)) - 1;
+    return keep >= 2 ? `${text.slice(0, keep).trimEnd()}\u2026` : "";
+  }
+  /** Up to `lines` lines broken at spaces, the last one cut to fit. */
+  static wrap(text, room, lines, size = 10) {
+    const out = [];
+    let rest = text.trim();
+    while (rest && out.length < lines) {
+      const cut = rest.lastIndexOf(" ", Math.floor(room / (size * EM)));
+      if (out.length === lines - 1 || _SchematicLabel.width(rest, size) <= room || cut <= 0) {
+        out.push(_SchematicLabel.fit(rest, room, size));
+        break;
+      }
+      out.push(rest.slice(0, cut));
+      rest = rest.slice(cut + 1);
+    }
+    return out.filter(Boolean);
+  }
+  /** A probability, rate or reliability in few characters: 0.95, 0.0125, 2.5e-5, and 0.99962 with every nine kept. */
+  static probability(value) {
+    if (value === null || !Number.isFinite(value)) return "?";
+    if (value === 0) return "0";
+    if (value > 0.99 && value < 1) return value.toFixed(Math.min(8, Math.ceil(-Math.log10(1 - value)) + 1));
+    return Math.abs(value) < 1e-3 ? value.toExponential(1) : `${+value.toPrecision(3)}`;
+  }
+};
+
+// src/charts/reliabilitycharts/WaferMap.ts
+var WaferMapEncoding = /* @__PURE__ */ ((WaferMapEncoding2) => {
+  WaferMapEncoding2["Bin"] = "bin";
+  WaferMapEncoding2["Value"] = "value";
+  return WaferMapEncoding2;
+})(WaferMapEncoding || {});
+var WaferMapMark = /* @__PURE__ */ ((WaferMapMark2) => {
+  WaferMapMark2["Notch"] = "notch";
+  WaferMapMark2["Flat"] = "flat";
+  return WaferMapMark2;
+})(WaferMapMark || {});
+var ZONES = ["Centre", "Middle", "Edge"];
+var n = (value) => +value.toFixed(2);
+var percent = (good, total) => total ? `${(100 * good / total).toFixed(1)}%` : "n/a";
+var WaferMap = (_class = class _WaferMap extends SchematicChart {
+  static __initStatic() {this.meta = {
+    id: "wafer-map",
+    name: "Wafer map",
+    family: "matrix" /* Matrix */,
+    dimension: 2 /* Two */,
+    shape: "table" /* Table */,
+    description: "Draws the dies of a semiconductor wafer in place, coloured by test bin or a measured value, with the notch or flat and the yield overall and by ring. The sample wafer is invented.",
+    tags: ["wafer", "semiconductor", "die", "yield", "bin map", "probe", "defect"],
+    sample: (seed) => ReliabilitySamples.wafer(seed),
+    variants: {
+      encoding: Object.values(WaferMapEncoding),
+      mark: Object.values(WaferMapMark),
+      zones: [false, true]
+    }
+  }}
+  defaults() {
+    return { x: "x", y: "y", bin: "bin", value: "value", passBin: "Pass", encoding: "bin" /* Bin */, mark: "notch" /* Notch */, zones: false };
+  }
+  /** The value ramp has its own key beside the wafer. */
+  legendItems() {
+    return this.options.encoding === "value" /* Value */ ? [] : super.legendItems();
+  }
+  /** Dies, wafer radius and yield. A position given twice keeps its first row. */
+  summary() {
+    const { x, y, bin, value, passBin } = this.options;
+    const seen = /* @__PURE__ */ new Map();
+    for (const row of this.rows()) {
+      const column = SchematicChart.number(row[x]), line = SchematicChart.number(row[y]);
+      if (column === null || line === null || seen.has(`${column}/${line}`)) continue;
+      seen.set(`${column}/${line}`, { x: column, y: line, bin: SchematicChart.word(row[bin]), value: SchematicChart.number(row[value]), reach: 0 });
+    }
+    const dies = [...seen.values()], xs = dies.map((die) => die.x), ys = dies.map((die) => die.y);
+    const centre = dies.length ? [(Math.min(...xs) + Math.max(...xs)) / 2, (Math.min(...ys) + Math.max(...ys)) / 2] : [0, 0];
+    const radius = Math.max(0.5, ...dies.map((die) => Math.hypot(Math.abs(die.x - centre[0]) + 0.5, Math.abs(die.y - centre[1]) + 0.5)));
+    const zones = ZONES.map((name) => ({ name, good: 0, total: 0 }));
+    let good = 0;
+    for (const die of dies) {
+      die.reach = Math.hypot(die.x - centre[0], die.y - centre[1]) / radius;
+      const zone = zones[Math.min(2, Math.floor(die.reach * 3))], pass = die.bin === passBin;
+      zone.total++;
+      if (pass) {
+        zone.good++;
+        good++;
+      }
+    }
+    return { dies, centre, radius, good, zones };
+  }
+  /** The wafer's edge around the origin: a V notch, or a flat no higher than `floor`, the lowest die edge. */
+  static outline(radius, mark, floor = 0) {
+    if (mark === "flat" /* Flat */) {
+      const chord = Math.min(radius * 0.995, Math.max(radius * 0.93, floor + 1)), half2 = Math.sqrt(radius * radius - chord * chord);
+      return `M${n(half2)},${n(chord)} A${n(radius)},${n(radius)} 0 1 0 ${n(-half2)},${n(chord)} Z`;
+    }
+    const depth = Math.max(4, radius * 0.05), half = depth * 0.8, drop = Math.sqrt(radius * radius - half * half);
+    return `M${n(half)},${n(drop)} A${n(radius)},${n(radius)} 0 1 0 ${n(-half)},${n(drop)} L0,${n(radius - depth)} Z`;
+  }
+  draw(ctx) {
+    const { width, height } = ctx.plot, { encoding, mark, zones, value, bin } = this.options, { theme, palette } = ctx;
+    const { dies, centre, radius, good, zones: rings } = this.summary();
+    const panel = Math.max(84, Math.min(150, width * 0.3)), side = Math.max(20, Math.min(height, width - panel - 10));
+    const reach = side / 2 - 2, pitch = reach / radius, wx = side / 2, wy = height / 2;
+    const byValue = encoding === "value" /* Value */;
+    const values = dies.map((die) => die.value).filter((v) => v !== null);
+    const low = Math.min(...values), span = Math.max(...values) - low || 1;
+    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 color = (die) => byValue ? die.value === null ? theme.grid : palette.sequential((die.value - low) / span) : palette.color(die.bin || "Unbinned");
+    const gap = pitch >= 9 ? 1 : pitch >= 5 ? 0.5 : 0;
+    const cells = ctx.marks("cells", "rect", dies, (die) => `${die.x}/${die.y}`).attr("fill", color).attr("rx", pitch >= 9 ? 1.5 : 0);
+    ctx.set(cells, { x: (die) => wx + (die.x - centre[0] - 0.5) * pitch + gap, y: (die) => wy + (die.y - centre[1] - 0.5) * pitch + gap, width: Math.max(0.5, pitch - 2 * gap), height: Math.max(0.5, pitch - 2 * gap) });
+    ctx.hover(cells, (die) => ({
+      title: `Die ${die.x}, ${die.y}`,
+      color: color(die),
+      rows: [[bin, die.bin || "n/a"], ...die.value === null ? [] : [[value, +die.value.toPrecision(4)]], ["Ring", ZONES[Math.min(2, Math.floor(die.reach * 3))]]]
+    }));
+    const floor = Math.max(0, ...dies.map((die) => (die.y - centre[1] + 0.5) * pitch));
+    const edge = ctx.marks("axis-wafer", "path", dies.length ? [_WaferMap.outline(reach, mark, floor)] : []).attr("fill", "none").attr("stroke", theme.axis).attr("stroke-width", 1.5).attr("transform", `translate(${n(wx)},${n(wy)})`);
+    ctx.set(edge, { d: (d) => d });
+    const circles = ctx.marks("rings", "circle", zones && dies.length ? [1 / 3, 2 / 3] : []).attr("fill", "none").attr("stroke", theme.ink).attr("stroke-width", 1.5).attr("stroke-dasharray", "4 3");
+    ctx.set(circles, { cx: wx, cy: wy, r: (share) => share * reach });
+    circles.style("pointer-events", "none");
+    const left = side + 12, room = width - left, notes = [];
+    let y = Math.max(8, height / 2 - (60 + (zones ? 62 : 0) + (byValue ? 44 : 0)) / 2);
+    if (dies.length) {
+      notes.push(
+        { key: "yield/title", text: "Yield", x: left, y: y + 6, anchor: "start", tone: "secondary" },
+        { key: "yield/value", text: percent(good, dies.length), x: left, y: y + 26, anchor: "start", size: Math.min(22, room / 3.6), weight: 600 },
+        { key: "yield/count", text: SchematicLabel.fit(`${good} of ${dies.length} dies`, room), x: left, y: y + 46, anchor: "start", tone: "secondary" }
+      );
+      y += 66;
+      if (zones) {
+        rings.forEach((ring, i) => notes.push(
+          { key: `zone/${ring.name}`, text: ring.name, x: left, y: y + 6 + i * 16, anchor: "start", tone: "secondary" },
+          { key: `zone/${ring.name}/value`, text: percent(ring.good, ring.total), x: left + Math.min(room, 96), y: y + 6 + i * 16, anchor: "end", weight: 600 }
+        ));
+        y += 62;
+      }
+    }
+    const steps = byValue && values.length ? Array.from({ length: 24 }, (_, i) => i) : [], keyWidth = Math.min(room, 110);
+    const ramp = ctx.marks("size-key", "rect", steps, (i) => i).attr("fill", (i) => palette.sequential(i / 23));
+    ctx.set(ramp, { x: (i) => left + i * keyWidth / 24, y: y + 14, width: keyWidth / 24 + 0.5, height: 8 });
+    if (steps.length) {
+      notes.push(
+        { key: "key/title", text: SchematicLabel.fit(value, room), x: left, y: y + 5, anchor: "start", tone: "secondary" },
+        { key: "key/low", text: `${+low.toPrecision(3)}`, x: left, y: y + 31, anchor: "start", size: 9, tone: "secondary" },
+        { key: "key/high", text: `${+(low + span).toPrecision(3)}`, x: left + keyWidth, y: y + 31, anchor: "end", size: 9, tone: "secondary" }
+      );
+    }
+    this.notes(ctx, "labels", notes);
+  }
+}, _class.__initStatic(), _class);
+
+
+
+
+
+
+
+
+exports.ReliabilitySamples = ReliabilitySamples; exports.SchematicChart = SchematicChart; exports.SchematicLabel = SchematicLabel; exports.WaferMapEncoding = WaferMapEncoding; exports.WaferMapMark = WaferMapMark; exports.WaferMap = WaferMap;

package/dist/{chunk-Y2KIUKJF.cjs → chunk-MPDHDKYZ.cjs}

@@ -4,7 +4,7 @@ var _chunk6KYVL5HYcjs = require('./chunk-6KYVL5HY.cjs');
 
 
 
-var _chunkUMEKIIHJcjs = require('./chunk-UMEKIIHJ.cjs');
+var _chunkLNWTC72Ycjs = require('./chunk-LNWTC72Y.cjs');
 
 // src/charts/threeglobe/GlobeEnums.ts
 var GlobeSurface = /* @__PURE__ */ ((GlobeSurface2) => {
@@ -234,7 +234,7 @@ var finite = (value, fallback = 0) => {
 var GlobeSamples = class {
   /** `{ name, lon, lat, value, group }`: points clustered around cities. */
   static scatter(seed, count = 320) {
-    const cities = _chunkUMEKIIHJcjs.SampleData.cities(seed), points = _chunkUMEKIIHJcjs.SampleData.points(seed, count, 3);
+    const cities = _chunkLNWTC72Ycjs.SampleData.cities(seed), points = _chunkLNWTC72Ycjs.SampleData.points(seed, count, 3);
     return points.map((point, i) => {
       const city = cities[(i * 7 + Math.floor(+point.size)) % cities.length], spread = 3 + +city.value / 100 * 9;
       return {
@@ -248,7 +248,7 @@ var GlobeSamples = class {
   }
   /** `{ from, to, fromLon, fromLat, toLon, toLat, value }`: routes out of the three biggest hubs. */
   static routes(seed) {
-    const cities = _chunkUMEKIIHJcjs.SampleData.cities(seed), hubs = [...cities].sort((a, b) => +b.value - +a.value).slice(0, 3);
+    const cities = _chunkLNWTC72Ycjs.SampleData.cities(seed), hubs = [...cities].sort((a, b) => +b.value - +a.value).slice(0, 3);
     return cities.flatMap((city, i) => hubs.filter((hub, h) => hub !== city && (i + h) % 2 === 0).map((hub) => ({
       from: hub.name,
       to: city.name,
@@ -261,7 +261,7 @@ var GlobeSamples = class {
   }
   /** `{ track, lon, lat, time, value }`: wandering paths between cities. */
   static tracks(seed, tracks = 5, steps = 30) {
-    const cities = _chunkUMEKIIHJcjs.SampleData.cities(seed), walk = _chunkUMEKIIHJcjs.SampleData.timeSeries(seed, steps, 1);
+    const cities = _chunkLNWTC72Ycjs.SampleData.cities(seed), walk = _chunkLNWTC72Ycjs.SampleData.timeSeries(seed, steps, 1);
     return Array.from({ length: tracks }, (_, t) => {
       const [a, b] = [cities[t * 3 % cities.length], cities[(t * 3 + 7) % cities.length]];
       const span = (+b.lon - +a.lon + 540) % 360 - 180;
@@ -273,12 +273,12 @@ var GlobeSamples = class {
   }
   /** World regions with a second variable, `properties.share`. */
   static regions(seed) {
-    const world2 = _chunkUMEKIIHJcjs.WorldSample.countries(seed), other = _chunkUMEKIIHJcjs.WorldSample.countries(seed + 1);
+    const world2 = _chunkLNWTC72Ycjs.WorldSample.countries(seed), other = _chunkLNWTC72Ycjs.WorldSample.countries(seed + 1);
     return { ...world2, features: world2.features.map((feature, i) => ({ ...feature, properties: { ...feature.properties, share: other.features[i].properties.value } })) };
   }
   /** A global potential: `x` is longitude, `y` latitude. */
   static field(seed) {
-    const { z } = _chunkUMEKIIHJcjs.SampleData.surface(seed, 37);
+    const { z } = _chunkLNWTC72Ycjs.SampleData.surface(seed, 37);
     const lons = Array.from({ length: 37 }, (_, i) => -180 + i * 10), lats = Array.from({ length: 37 }, (_, i) => -90 + i * 5);
     return { x: lons, y: lats, z: z.map((row) => row.map((value, i) => value + 0.35 * Math.sin(i / 36 * Math.PI * 6))) };
   }
@@ -822,7 +822,7 @@ var GlobeChart = class extends _chunk6KYVL5HYcjs.Chart3D {
     this.draw(ctx);
   }
   get basemap() {
-    return (_nullishCoalesce(this.options.basemap, () => ( (world ??= _chunkUMEKIIHJcjs.WorldSample.countries(1))))).features;
+    return (_nullishCoalesce(this.options.basemap, () => ( (world ??= _chunkLNWTC72Ycjs.WorldSample.countries(1))))).features;
   }
   get oceanColor() {
     return this.theme.grid;
@@ -1127,7 +1127,7 @@ var Bubble3DMap = (_class8 = class extends SiteGlobeChart {
     shape: "geo" /* Geo */,
     description: "Stands spheres, domes, discs or columns on a projected map, with size honestly scaled to the value.",
     tags: ["proportional symbol", "graduated symbol"],
-    sample: (seed) => _chunkUMEKIIHJcjs.SampleData.cities(seed),
+    sample: (seed) => _chunkLNWTC72Ycjs.SampleData.cities(seed),
     variants: {
       bubble: Object.values(GlobeBubble),
       volumetric: [false, true],
@@ -1501,7 +1501,7 @@ var FlatProjectionPlane = (_class13 = class extends SiteGlobeChart {
     shape: "geo" /* Geo */,
     description: "Lays the world flat through a chosen projection, with optional Tissot circles exposing its distortion.",
     tags: ["map projection", "tissot", "mollweide", "robinson", "interrupted"],
-    sample: (seed) => _chunkUMEKIIHJcjs.SampleData.cities(seed),
+    sample: (seed) => _chunkLNWTC72Ycjs.SampleData.cities(seed),
     variants: {
       projection: Object.values(GlobeProjection),
       land: ["solid" /* Solid */, "dotted" /* Dotted */, "outline" /* Outline */],
@@ -1607,7 +1607,7 @@ var Globe3DChart = (_class15 = class extends SiteGlobeChart {
     shape: "geo" /* Geo */,
     description: "Shows named places on a lit, rotatable earth built from real country geometry.",
     tags: ["earth", "world", "locator", "orthographic"],
-    sample: (seed) => _chunkUMEKIIHJcjs.SampleData.cities(seed),
+    sample: (seed) => _chunkLNWTC72Ycjs.SampleData.cities(seed),
     variants: { land: Object.values(GlobeLand), graticule: [false, true], marker: Object.values(GlobeMarker), surface: Object.values(GlobeSurface) }
   }}
   defaults() {
@@ -2090,7 +2090,7 @@ var RingGlobe = (_class22 = class extends SiteGlobeChart {
     shape: "geo" /* Geo */,
     description: "Marks places with geodesic rings whose radius shows reach, or plots longitude profiles on an orbit.",
     tags: ["ripple", "pulse", "range rings", "orbit", "buffer"],
-    sample: (seed) => _chunkUMEKIIHJcjs.SampleData.cities(seed),
+    sample: (seed) => _chunkLNWTC72Ycjs.SampleData.cities(seed),
     variants: {
       form: Object.values(GlobeRingForm),
       rings: [3, 1, 5],

package/dist/{chunk-4EMPKRZU.cjs → chunk-MRQ42ZJE.cjs}

@@ -35,7 +35,7 @@ var _chunkSL46XHUKcjs = require('./chunk-SL46XHUK.cjs');
 var _chunkEEF5WRRZcjs = require('./chunk-EEF5WRRZ.cjs');
 
 
-var _chunkUMEKIIHJcjs = require('./chunk-UMEKIIHJ.cjs');
+var _chunkLNWTC72Ycjs = require('./chunk-LNWTC72Y.cjs');
 
 // src/charts/hierarchy/PartitionChart.ts
 var _d3 = require('d3');
@@ -324,10 +324,10 @@ var TreeSamples = class _TreeSamples {
   /** First tree from `seed` on with at least three top-level branches, since two branches make weak examples. */
   static broad(seed, depth = 3, breadth = 4) {
     for (let next = seed; next < seed + 40; next++) {
-      const tree4 = _chunkUMEKIIHJcjs.SampleData.tree(next, depth, breadth);
+      const tree4 = _chunkLNWTC72Ycjs.SampleData.tree(next, depth, breadth);
       if ((_nullishCoalesce(_optionalChain([tree4, 'access', _11 => _11.children, 'optionalAccess', _12 => _12.length]), () => ( 0))) >= 3) return tree4;
     }
-    return _chunkUMEKIIHJcjs.SampleData.tree(seed, depth, breadth);
+    return _chunkLNWTC72Ycjs.SampleData.tree(seed, depth, breadth);
   }
   /** Uneven depth: every third internal child collapses into one leaf holding its subtree's total. */
   static uneven(seed, depth = 3, breadth = 4) {

package/dist/{chunk-EU5D2MF4.cjs → chunk-MYV4KZWP.cjs}

@@ -18,13 +18,13 @@ var _chunkNEVHPFWRcjs = require('./chunk-NEVHPFWR.cjs');
 var _chunkSRQSXNSPcjs = require('./chunk-SRQSXNSP.cjs');
 
 
-var _chunkAL4XQZH6cjs = require('./chunk-AL4XQZH6.cjs');
 
 
 
+var _chunkFJJFDFDHcjs = require('./chunk-FJJFDFDH.cjs');
 
 
-var _chunkFJJFDFDHcjs = require('./chunk-FJJFDFDH.cjs');
+var _chunkAL4XQZH6cjs = require('./chunk-AL4XQZH6.cjs');
 
 
 var _chunkXX2YTCORcjs = require('./chunk-XX2YTCOR.cjs');
@@ -36,7 +36,7 @@ var _chunkPY4R3IFFcjs = require('./chunk-PY4R3IFF.cjs');
 var _chunk35CT4Q2Ecjs = require('./chunk-35CT4Q2E.cjs');
 
 
-var _chunkUMEKIIHJcjs = require('./chunk-UMEKIIHJ.cjs');
+var _chunkLNWTC72Ycjs = require('./chunk-LNWTC72Y.cjs');
 
 // src/charts/mlcharts/AttentionHeatmap.ts
 var _d3 = require('d3');
@@ -214,7 +214,7 @@ var AttentionSamples = class _AttentionSamples {
   /** Softmax over noisy logits, so each row is a true probability distribution. */
   static crossAttention(seed = 1) {
     const heads = HEADS.map(({ name, focus, spread }, h) => {
-      const { values } = _chunkUMEKIIHJcjs.SampleData.matrix(seed + h, TARGET.length, SOURCE.length);
+      const { values } = _chunkLNWTC72Ycjs.SampleData.matrix(seed + h, TARGET.length, SOURCE.length);
       return {
         name,
         weights: TARGET.map((_, t) => _AttentionSamples.softmax(SOURCE.map((_2, s) => -((s - focus(ALIGNED[t])) ** 2) / (2 * spread ** 2) + NOISE * values[t][s])))
@@ -485,7 +485,7 @@ var squared = (a, b) => (a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2;
 var CurveDiagnosticSamples = class {
   /** Standard normal draws from `SampleData`, since its generators are the only seeded source. */
   static #normals(seed, count) {
-    const values = _chunkUMEKIIHJcjs.SampleData.distribution(seed, count, 1).map((row) => (row.value - 40) / 8);
+    const values = _chunkLNWTC72Ycjs.SampleData.distribution(seed, count, 1).map((row) => (row.value - 40) / 8);
     let i = 0;
     return () => values[i++ % values.length];
   }
@@ -511,7 +511,7 @@ var CurveDiagnosticSamples = class {
   }
   /** `{ k, inertia, silhouette }` from running k-means and the silhouette on `SampleData.points`, which is itself synthetic. */
   static clusterSweep(seed, most = 10) {
-    const points = _chunkUMEKIIHJcjs.SampleData.points(seed, 160, 4).map((row, i) => [row.x, row.y - 0.8 * row.x + i % 2 * 42]);
+    const points = _chunkLNWTC72Ycjs.SampleData.points(seed, 160, 4).map((row, i) => [row.x, row.y - 0.8 * row.x + i % 2 * 42]);
     return Array.from({ length: most }, (_, i) => {
       const k = i + 1, { labels, inertia } = this.#kMeans(points, k);
       return { k, inertia: +inertia.toFixed(1), silhouette: k > 1 ? +this.#silhouette(points, labels, k).toFixed(4) : null };
@@ -1164,7 +1164,7 @@ var DecisionSamples = class {
   }
   /** Three overlapping clusters with that classifier's probabilities evaluated onto a grid. */
   static clusters(seed) {
-    const points = _chunkUMEKIIHJcjs.SampleData.points(seed, 150, 3);
+    const points = _chunkLNWTC72Ycjs.SampleData.points(seed, 150, 3);
     const predict = this.naiveBayes(points, "x", "y", "group");
     const sweep = (column) => {
       const [low = 0, high = 1] = _d3.extent.call(void 0, points, (row) => Number(row[column])), pad = (high - low) * 0.05;
@@ -1573,7 +1573,7 @@ var RESPONSE_MIDPOINT = 50;
 var RESPONSE_WIDTH = 14;
 var ExplainabilitySamples = class {
   static #normals(seed, count) {
-    const values = _chunkUMEKIIHJcjs.SampleData.distribution(seed, count, 1).map((row) => (row.value - 40) / 8);
+    const values = _chunkLNWTC72Ycjs.SampleData.distribution(seed, count, 1).map((row) => (row.value - 40) / 8);
     let i = 0;
     return () => values[i++ % values.length];
   }
@@ -1588,7 +1588,7 @@ var ExplainabilitySamples = class {
   /** Synthetic ICE sweeps: `{ instance, x, prediction, observed }`, one saturating response per instance, whose slope flips for some. */
   static iceCurves(seed) {
     const z = this.#normals(seed, CURVES * 2);
-    const observed = _chunkUMEKIIHJcjs.SampleData.points(seed, CURVES).map((row) => row.x);
+    const observed = _chunkLNWTC72Ycjs.SampleData.points(seed, CURVES).map((row) => row.x);
     const low = Math.min(...observed), high = Math.max(...observed);
     const grid = Array.from({ length: GRID2 }, (_, i) => +(low + (high - low) * i / (GRID2 - 1)).toFixed(2));
     return observed.flatMap((at, i) => {