prographs 0.12.0 → 0.13.0

package/dist/charts/strategycharts/StrategySamples.js

@@ -1,4 +1,5 @@
 import { SampleData } from "../../data/SampleData.js";
+import { BassModel } from "./BassModel.js";
 import { KanoCategory, KanoCurve } from "./KanoCurve.js";
 // src/charts/strategycharts/StrategySamples.ts
 var round = (value, digits = 1) => +value.toFixed(digits);
@@ -468,6 +469,190 @@ var TEAMS = [
 	"Product",
 	"Operations"
 ];
+/** Each round's buyers and the share of the company after the round that each buys. */
+var ROUNDS = [
+	["Founding", []],
+	["Seed", [["Angel investors", .05], ["Halden Seed Fund", .14]]],
+	["Series A", [
+		["Northquill Ventures", .2],
+		["Halden Seed Fund", .03],
+		["Employee pool", .06]
+	]],
+	["Series B", [
+		["Pellmoor Capital", .15],
+		["Northquill Ventures", .03],
+		["Employee pool", .03]
+	]]
+];
+var STAGES = [
+	["Backlog", null],
+	["Ready", 4],
+	["In progress", 3],
+	["Review", 2],
+	["Done", null]
+];
+var CARDS = [
+	[
+		"Gift card balance",
+		0,
+		"Checkout",
+		"Feature"
+	],
+	[
+		"Search by ingredient",
+		0,
+		"Search",
+		"Feature"
+	],
+	[
+		"Archive old orders",
+		0,
+		"Platform",
+		"Chore"
+	],
+	[
+		"Split shipments",
+		0,
+		"Checkout",
+		"Feature"
+	],
+	[
+		"Retry failed payments",
+		1,
+		"Checkout",
+		"Bug"
+	],
+	[
+		"Typo-tolerant search",
+		1,
+		"Search",
+		"Feature"
+	],
+	[
+		"Rotate signing keys",
+		1,
+		"Platform",
+		"Chore"
+	],
+	[
+		"Saved carts sync",
+		2,
+		"Checkout",
+		"Feature"
+	],
+	[
+		"Slow results on mobile",
+		2,
+		"Search",
+		"Bug"
+	],
+	[
+		"Move queues to new cluster",
+		2,
+		"Platform",
+		"Chore"
+	],
+	[
+		"Address lookup",
+		2,
+		"Checkout",
+		"Feature"
+	],
+	[
+		"Tax rounding error",
+		3,
+		"Checkout",
+		"Bug"
+	],
+	[
+		"Filter by dietary need",
+		3,
+		"Search",
+		"Feature"
+	],
+	[
+		"One-page checkout",
+		4,
+		"Checkout",
+		"Feature"
+	],
+	[
+		"Synonym dictionary",
+		4,
+		"Search",
+		"Feature"
+	],
+	[
+		"Upgrade database",
+		4,
+		"Platform",
+		"Chore"
+	],
+	[
+		"Empty results page",
+		4,
+		"Search",
+		"Bug"
+	]
+];
+var OBJECTIVES = [
+	["Make setup quick for new teams", [
+		[
+			"Median setup time under 10 minutes",
+			72,
+			.8
+		],
+		[
+			"Activation rate from 41% to 55%",
+			48,
+			.6
+		],
+		[
+			"Halve setup support tickets",
+			85,
+			.9
+		]
+	]],
+	["Earn the trust of larger customers", [
+		[
+			"Pass the security audit",
+			90,
+			.9
+		],
+		[
+			"Uptime of 99.95% for the quarter",
+			64,
+			.7
+		],
+		[
+			"Sign 6 customers over 500 seats",
+			33,
+			.3
+		],
+		[
+			"Launch single sign-on",
+			55,
+			.5
+		]
+	]],
+	["Grow revenue from existing accounts", [
+		[
+			"Net revenue retention of 112%",
+			40,
+			.5
+		],
+		[
+			"Launch usage-based pricing",
+			20,
+			.3
+		],
+		[
+			"Expansion pipeline of 1.8M",
+			68,
+			.7
+		]
+	]]
+];
 /** SYNTHETIC rows for the strategy diagrams: every company, product, person and number here is invented. */
 var StrategySamples = class {
 	/** `{ technology, position, years }`: place on the cycle from 0 to 100, and years to the plateau or the word Obsolete. */
@@ -593,5 +778,71 @@ var StrategySamples = class {
 			tenure: round(.5 + u() * 9)
 		}));
 	}
+	/** `{ round, holder, shares }`: the fully diluted shares each holder of an invented company has after each funding round. */
+	static capTable(seed = 1) {
+		const { u } = SampleData.rng(seed);
+		const held = /* @__PURE__ */ new Map([["Founders", 8e6], ["Employee pool", 1e6]]);
+		return ROUNDS.flatMap(([round, buyers]) => {
+			const stakes = buyers.map(([holder, stake]) => [holder, stake * (.85 + u() * .3)]);
+			const before = [...held.values()].reduce((sum, shares) => sum + shares, 0), sold = stakes.reduce((sum, [, stake]) => sum + stake, 0);
+			for (const [holder, stake] of stakes) held.set(holder, (held.get(holder) ?? 0) + Math.round(before * stake / (1 - sold) / 1e3) * 1e3);
+			return [...held].map(([holder, shares]) => ({
+				round,
+				holder,
+				shares
+			}));
+		});
+	}
+	/** `{ month, balance, burn }`: an invented company's month-end cash and net burn over a year, with one month of net inflow. */
+	static burn(seed = 1) {
+		const { u, n } = SampleData.rng(seed);
+		let balance = Math.round(4600 + u() * 600) * 1e3;
+		return Array.from({ length: 12 }, (_, i) => {
+			const burn = i === 4 ? -Math.round(40 + u() * 60) * 1e3 : Math.round(175 + 11 * i + n() * 22) * 1e3;
+			balance -= burn;
+			return {
+				month: `${i < 2 ? 2025 : 2026}-${String((i + 10) % 12 + 1).padStart(2, "0")}`,
+				balance,
+				burn
+			};
+		});
+	}
+	/** `{ task, stage, lane, kind, owner, limit }`: an invented shop team's board, each card carrying its stage's work-in-progress limit. A few cards move on a stage by seed. */
+	static kanban(seed = 1) {
+		const { u } = SampleData.rng(seed);
+		return CARDS.map(([task, stage, lane, kind], i) => ({
+			task,
+			at: Math.min(STAGES.length - 1, stage + (u() < .2 ? 1 : 0)),
+			lane,
+			kind,
+			owner: PEOPLE[i % PEOPLE.length]
+		})).sort((a, b) => a.at - b.at).map(({ at, ...card }) => ({
+			...card,
+			stage: STAGES[at][0],
+			limit: STAGES[at][1]
+		}));
+	}
+	/** `{ objective, keyResult, progress, confidence }` for an invented software firm's quarter: progress 0 to 100, confidence 0 to 1. */
+	static okr(seed = 1) {
+		const { u } = SampleData.rng(seed);
+		return OBJECTIVES.flatMap(([objective, results]) => results.map(([keyResult, progress, confidence]) => ({
+			objective,
+			keyResult,
+			progress: clamp(Math.round(progress + (u() - .5) * 16), 0, 100),
+			confidence: round(clamp(confidence + (u() - .5) * .2, 0, 1))
+		})));
+	}
+	/** `{ period, adopters }`: households taking up an invented product in each of its first eight years, drawn from a Bass curve with noise. */
+	static bass(seed = 1) {
+		const { u, n } = SampleData.rng(seed);
+		return BassModel.run({
+			p: .02 + u() * .012,
+			q: .38 + u() * .1,
+			m: Math.round(110 + u() * 40) * 1e3
+		}, 8).map((period) => ({
+			period: 2018 + period.t,
+			adopters: Math.max(0, Math.round(period.adopters * (1 + n() * .035)))
+		}));
+	}
 };
 export { StrategySamples };

package/dist/charts/strategycharts/index.js

@@ -1,17 +1,24 @@
-import { StrategyNotes } from "./StrategyNotes.js";
+import { BassModel } from "./BassModel.js";
+import { StrategyPane } from "./StrategyPane.js";
 import { StrategyRows } from "./StrategyRows.js";
 import { KanoCategory, KanoCurve } from "./KanoCurve.js";
 import { StrategySamples } from "./StrategySamples.js";
 import { StrategyWords } from "./StrategyWords.js";
+import { BassDiffusionChart, BassDiffusionView } from "./BassDiffusionChart.js";
+import { BurnRunwayBalance, BurnRunwayChart, BurnRunwayLayout } from "./BurnRunwayChart.js";
+import { StrategyNotes } from "./StrategyNotes.js";
 import { BusinessModelCanvas, BusinessModelCanvasKind, BusinessModelCanvasNotes } from "./BusinessModelCanvas.js";
+import { CapTableBasis, CapTableChart, CapTableView } from "./CapTableChart.js";
 import { CustomerJourneyEmotionMark, CustomerJourneyEmotionPlace, CustomerJourneyMap, CustomerJourneyStageMark } from "./CustomerJourneyMap.js";
 import { EisenhowerLayout, EisenhowerMatrix, EisenhowerQuadrant, EisenhowerTaskMark } from "./EisenhowerMatrix.js";
 import { FiveForcesArrows, FiveForcesDiagram, FiveForcesForce, FiveForcesRating } from "./FiveForcesDiagram.js";
 import { FootballFieldChart, FootballFieldMark, FootballFieldOrder } from "./FootballFieldChart.js";
 import { StrategyLabels } from "./StrategyLabels.js";
 import { HypeCycleChart, HypeCycleLabels, HypeCycleMarker, HypeCyclePhases } from "./HypeCycleChart.js";
+import { KanbanBoard, KanbanCardDetail } from "./KanbanBoard.js";
 import { KanoAxes, KanoCurveSet, KanoMarker, KanoModelChart, KanoPlacement } from "./KanoModelChart.js";
 import { NineBoxGrid, NineBoxPlacement } from "./NineBoxGrid.js";
+import { OkrTree, OkrTreeLayout, OkrTreeRollup } from "./OkrTree.js";
 import { StrategyCanvasChart, StrategyCanvasOrder } from "./StrategyCanvasChart.js";
 import { TechnologyAdoptionCurve, TechnologyAdoptionSegments } from "./TechnologyAdoptionCurve.js";
 import { WardleyAxis, WardleyMap, WardleyStages } from "./WardleyMap.js";
@@ -27,6 +34,11 @@ var strategychartsCatalog = [
 	CustomerJourneyMap,
 	EisenhowerMatrix,
 	FootballFieldChart,
-	NineBoxGrid
+	NineBoxGrid,
+	CapTableChart,
+	BurnRunwayChart,
+	KanbanBoard,
+	OkrTree,
+	BassDiffusionChart
 ];
-export { BusinessModelCanvas, BusinessModelCanvasKind, BusinessModelCanvasNotes, CustomerJourneyEmotionMark, CustomerJourneyEmotionPlace, CustomerJourneyMap, CustomerJourneyStageMark, EisenhowerLayout, EisenhowerMatrix, EisenhowerQuadrant, EisenhowerTaskMark, FiveForcesArrows, FiveForcesDiagram, FiveForcesForce, FiveForcesRating, FootballFieldChart, FootballFieldMark, FootballFieldOrder, HypeCycleChart, HypeCycleLabels, HypeCycleMarker, HypeCyclePhases, KanoAxes, KanoCategory, KanoCurve, KanoCurveSet, KanoMarker, KanoModelChart, KanoPlacement, NineBoxGrid, NineBoxPlacement, StrategyCanvasChart, StrategyCanvasOrder, StrategyLabels, StrategyNotes, StrategyRows, StrategySamples, StrategyWords, TechnologyAdoptionCurve, TechnologyAdoptionSegments, WardleyAxis, WardleyMap, WardleyStages, strategychartsCatalog };
+export { BassDiffusionChart, BassDiffusionView, BassModel, BurnRunwayBalance, BurnRunwayChart, BurnRunwayLayout, BusinessModelCanvas, BusinessModelCanvasKind, BusinessModelCanvasNotes, CapTableBasis, CapTableChart, CapTableView, CustomerJourneyEmotionMark, CustomerJourneyEmotionPlace, CustomerJourneyMap, CustomerJourneyStageMark, EisenhowerLayout, EisenhowerMatrix, EisenhowerQuadrant, EisenhowerTaskMark, FiveForcesArrows, FiveForcesDiagram, FiveForcesForce, FiveForcesRating, FootballFieldChart, FootballFieldMark, FootballFieldOrder, HypeCycleChart, HypeCycleLabels, HypeCycleMarker, HypeCyclePhases, KanbanBoard, KanbanCardDetail, KanoAxes, KanoCategory, KanoCurve, KanoCurveSet, KanoMarker, KanoModelChart, KanoPlacement, NineBoxGrid, NineBoxPlacement, OkrTree, OkrTreeLayout, OkrTreeRollup, StrategyCanvasChart, StrategyCanvasOrder, StrategyLabels, StrategyNotes, StrategyPane, StrategyRows, StrategySamples, StrategyWords, TechnologyAdoptionCurve, TechnologyAdoptionSegments, WardleyAxis, WardleyMap, WardleyStages, strategychartsCatalog };

package/dist/charts/threefields/BsfcMap3DChart.js

@@ -0,0 +1,231 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { Scales } from "../../core/Scales.js";
+import { BsfcMath } from "../machinecharts/BsfcMath.js";
+import { MachineChart } from "../machinecharts/MachineChart.js";
+import { MachineMesh } from "../machinecharts/MachineMesh.js";
+import { MachineSamples } from "../machinecharts/MachineSamples.js";
+import { ColorRamp } from "../threesurfaces/ColorRamp.js";
+import { SurfaceGeometry } from "../threesurfaces/SurfaceGeometry.js";
+import { CEIL, FLOOR } from "../threesurfaces/SurfaceSpace.js";
+import { TubeBatch } from "../threesurfaces/TubeBatch.js";
+import { MapSheet } from "./MapSheet.js";
+import { ThreeFieldBase } from "./ThreeFieldBase.js";
+import { max, range, scaleLinear, ticks } from "d3";
+// src/charts/threefields/BsfcMap3DChart.ts
+/** Lines of equal consumption laid on the surface, drawn flat on the floor, or left out. */
+var BsfcMap3DContours = /* @__PURE__ */ function(BsfcMap3DContours) {
+	BsfcMap3DContours["Draped"] = "draped-contours";
+	BsfcMap3DContours["Floor"] = "floor-contours";
+	BsfcMap3DContours["None"] = "no-contours";
+	return BsfcMap3DContours;
+}({});
+/** The full-load curve as a wall down to the floor, or as a rail along the edge with its trace on the floor. */
+var BsfcMap3DBoundary = /* @__PURE__ */ function(BsfcMap3DBoundary) {
+	BsfcMap3DBoundary["Wall"] = "full-load-wall";
+	BsfcMap3DBoundary["Rail"] = "full-load-rail";
+	return BsfcMap3DBoundary;
+}({});
+/** `Point` pins the lowest BSFC measured, `Line` joins the most economical point at each power. */
+var BsfcMap3DOptimum = /* @__PURE__ */ function(BsfcMap3DOptimum) {
+	BsfcMap3DOptimum["Point"] = "best-point";
+	BsfcMap3DOptimum["Line"] = "economy-line";
+	BsfcMap3DOptimum["None"] = "no-optimum";
+	return BsfcMap3DOptimum;
+}({});
+var BSFC = "BSFC";
+var ECONOMY = "Best economy line";
+/**
+* An engine's fuel map as a bowl: consumption per unit of work as height over speed and torque, cut off by the full-load
+* curve, with the lowest point pinned. Use it to show how wide and how deep the economical region is; the 2D BSFC map
+* takes the same rows and reads the contours more exactly.
+*/
+var BsfcMap3DChart = class BsfcMap3DChart extends ThreeFieldBase {
+	static meta = {
+		id: "bsfc-map-3d",
+		name: "3D engine BSFC map",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Three,
+		shape: DataShape.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) => 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",
+			boundary: "full-load-wall",
+			power: true,
+			optimum: "best-point",
+			xLabel: "Engine speed (rpm)",
+			yLabel: "Torque (N·m)",
+			zLabel: "BSFC (g/kWh)"
+		};
+	}
+	get sweeps() {
+		const { data, x, y, bsfc } = this.options;
+		return 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, i) => ({
+			y: node.y + (rows[j + 1][i].y - node.y) * t,
+			z: node.z + (rows[j + 1][i].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]
+		];
+		return [...knots.slice(0, -3).flatMap((_, i) => Array.from({ length: pieces }, (_, 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);
+		})), [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 MachineMesh(sweeps, 24, 4), sheet = new MapSheet(mesh, measured, true, [FLOOR + (contours === "floor-contours" ? .55 : .3), CEIL]);
+		const ramp = new ColorRamp(palette.sequential), [low, high] = sheet.z;
+		const paint = (value) => ramp.at(.08 + .85 * (high - value) / (high - low));
+		const tone = palette.color(BSFC);
+		const kwh = (value) => `${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", `${MachineChart.short(node.y)} N·m`],
+				["Power", `${MachineChart.short(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 ? scaleLinear(sheet.z, [0, 1]).ticks(4).map((value) => [sheet.level(value), 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)), .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, .01));
+		this.tubes(new TubeBatch(.011).add(edge), lift, theme.ink);
+		if (boundary === "full-load-wall") this.solid(ctx, SurfaceGeometry.curtain(full.map((node) => sheet.place(node)), FLOOR + .002, (k) => paint(full[k].z), () => paint(high)), lift);
+		else this.tubes(new TubeBatch(.006).add(full.map((node) => sheet.floor(node, .007))), ctx.root, theme.ink);
+		const [mx, my, mz] = edge[Math.floor(edge.length / 2)];
+		this.tag(ctx, "Full load", [
+			mx,
+			(my + FLOOR) / 2,
+			mz + .02
+		], lift);
+		const levels = contours === "no-contours" ? [] : sheet.contours(mesh.levels(10));
+		const draped = contours === "draped-contours", isolines = new TubeBatch(.004);
+		for (const { value, paths } of levels) for (const path of paths) isolines.add(path.map((node) => draped ? sheet.place(node, .004) : sheet.floor(node, .006)), draped ? void 0 : paint(value));
+		if (draped) this.tubes(isolines, lift, theme.ink, .55);
+		else this.tubes(isolines, ctx.root);
+		const peak = max(full, (node) => 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 = range(0, 81).map((i) => first + (last - first) * i / 80);
+		const hyperbolas = new TubeBatch(.004);
+		for (const kw of power && peak > 0 ? ticks(0, peak, 4).filter((value) => value > 0) : []) {
+			const nodes = speeds.map((speed) => on(speed, 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, .006));
+			const [x, y, z] = sheet.place(end);
+			ctx.label(`${kw} kW`, [
+				x + .11,
+				y + .02,
+				z
+			], "muted", 10, lift);
+		}
+		this.tubes(hyperbolas, lift, theme.surface, .85);
+		if (optimum === "economy-line") {
+			const economy = BsfcMap3DChart.eased(BsfcMath.economy(mesh, range(1, 25).map((i) => peak * i / 25))).map(([speed, torque]) => on(speed, torque));
+			const tube = this.tubes(new TubeBatch(.009).add(lay(economy, .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" ? 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
+			}, .004),
+			text: `Lowest ${kwh(best.z)}`,
+			pick: () => ({
+				...told(best, "Lowest BSFC"),
+				color: tone
+			})
+		}], lift);
+	}
+};
+export { BsfcMap3DBoundary, BsfcMap3DChart, BsfcMap3DContours, BsfcMap3DOptimum };