prographs 0.12.0 → 0.13.0

package/dist/charts/biologycharts/PunnettSquare.js

@@ -0,0 +1,342 @@
+import { Chart2D } from "../../core/Chart2D.js";
+import { ChartFamily, DataShape, Dimension, LegendPosition } from "../../core/enums.js";
+import { TextFit } from "../../core/TextFit.js";
+import { PunnettCross, PunnettDominance, PunnettRatios } from "./biologyEnums.js";
+import { BiologyRows } from "./BiologyRows.js";
+import { BiologySamples } from "./BiologySamples.js";
+// src/charts/biologycharts/PunnettSquare.ts
+var GENES = {
+	[PunnettCross.Monohybrid]: 1,
+	[PunnettCross.Dihybrid]: 2,
+	[PunnettCross.Trihybrid]: 3
+};
+var CHAR = 6.2;
+var CAPTION = 15;
+var HEAD = 20;
+var GAP = 16;
+var LINE = 14;
+var BAR = 20;
+var gcd = (a, b) => b ? gcd(b, a % b) : a;
+/**
+* Works a genetic cross: the gametes of one parent down the side, of the other along the top, and the offspring of each pairing in the cells.
+* Use it to show where a 3 to 1 or a 9 to 3 to 3 to 1 ratio comes from, with each gene completely dominant, incompletely dominant or codominant.
+*/
+var PunnettSquare = class PunnettSquare extends Chart2D {
+	static meta = {
+		id: "punnett-square",
+		name: "Punnett square",
+		family: ChartFamily.Matrix,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Crosses two parents from their genotypes: gametes along the top and side, offspring genotypes in the cells coloured by phenotype, and the genotype and phenotype ratios, for one gene or several with dominance set per gene.",
+		tags: [
+			"genetics",
+			"mendel",
+			"monohybrid",
+			"dihybrid",
+			"genotype",
+			"phenotype",
+			"inheritance",
+			"biology"
+		],
+		sample: (seed) => BiologySamples.cross(seed),
+		variants: {
+			cross: [PunnettCross.Dihybrid, PunnettCross.Monohybrid],
+			ratios: Object.values(PunnettRatios)
+		}
+	};
+	/** True when the ratio list is drawn, which names every phenotype beside its colour. */
+	#keyed = false;
+	defaults() {
+		return {
+			gene: "gene",
+			parent1: "parent1",
+			parent2: "parent2",
+			dominance: "dominance",
+			dominantTrait: "dominantTrait",
+			recessiveTrait: "recessiveTrait",
+			mixedTrait: "mixedTrait",
+			parents: ["Parent 1", "Parent 2"],
+			cross: PunnettCross.Dihybrid,
+			ratios: PunnettRatios.List
+		};
+	}
+	plotMargin() {
+		return {
+			top: 8,
+			right: 12,
+			bottom: 8,
+			left: 12
+		};
+	}
+	get legendPosition() {
+		return this.#keyed ? LegendPosition.None : super.legendPosition;
+	}
+	/** The two alleles of a genotype: `Rr` gives R and r, and `IA/i` or `IA i` gives alleles of more than one letter. Anything else gives none. */
+	static alleles(genotype) {
+		const parts = /[\s/|,]/.test(genotype) ? genotype.split(/[\s/|,]+/).filter(Boolean) : [...genotype];
+		return parts.length === 2 ? parts : [];
+	}
+	/** Counts as the lowest whole-number ratio: 12, 4 gives `3 : 1`. */
+	static ratio(counts) {
+		const shared = counts.reduce(gcd, 0) || 1;
+		return counts.map((count) => count / shared).join(" : ");
+	}
+	#genes() {
+		const { data, gene, parent1, parent2, dominance, dominantTrait, recessiveTrait, mixedTrait, cross } = this.options, seen = /* @__PURE__ */ new Set();
+		const upper = (allele) => allele === allele.toUpperCase() && allele !== allele.toLowerCase();
+		return (Array.isArray(data) ? data : []).flatMap((row, i) => {
+			if (row === null || typeof row !== "object") return [];
+			const name = BiologyRows.text(row[gene], `Gene ${i + 1}`);
+			const parents = [PunnettSquare.alleles(BiologyRows.text(row[parent1])), PunnettSquare.alleles(BiologyRows.text(row[parent2]))];
+			if (seen.has(name) || !parents[0].length || !parents[1].length) return [];
+			seen.add(name);
+			const written = [...new Set(parents.flat())], lead = written.find(upper) ?? written[0], rest = written.filter((allele) => allele !== lead);
+			const said = BiologyRows.text(row[dominance]).toLowerCase();
+			const kind = said.startsWith("inc") ? PunnettDominance.Incomplete : said.startsWith("cod") ? PunnettDominance.Codominant : PunnettDominance.Complete;
+			const weak = rest[0] ?? lead, complete = kind === PunnettDominance.Complete;
+			return [{
+				dominance: kind,
+				alleles: [lead, ...rest],
+				parents,
+				traits: [
+					BiologyRows.text(row[dominantTrait], complete ? `${lead}_` : `${lead}${lead}`),
+					BiologyRows.text(row[recessiveTrait], `${weak}${weak}`),
+					BiologyRows.text(row[mixedTrait], `${lead}${weak}`)
+				]
+			}];
+		}).slice(0, GENES[cross] ?? 2);
+	}
+	/** What an offspring carrying `pair` shows at a gene. Only complete dominance hides the second allele of a heterozygote. */
+	static #trait({ alleles, dominance, traits }, pair) {
+		const carried = pair.filter((allele) => allele === alleles[0]).length;
+		if (carried === 2 || carried === 1 && dominance === PunnettDominance.Complete) return traits[0];
+		return carried ? traits[2] : traits[1];
+	}
+	/** The cross worked out: every gamete of each parent, the offspring of each pairing, and the tallies behind the ratios. */
+	get square() {
+		const genes = this.#genes(), single = genes.every((gene) => gene.alleles.every((allele) => allele.length === 1));
+		const gametes = (parent) => genes.length ? genes.reduce((all, gene) => all.flatMap((gamete) => gene.parents[parent].map((allele) => [...gamete, allele])), [[]]) : [];
+		const pair = (gene, a, b) => [a, b].sort((p, q) => gene.alleles.indexOf(p) - gene.alleles.indexOf(q));
+		const written = (pairs) => pairs.map((alleles) => alleles.join(single ? "" : "/")).join(single ? "" : " ");
+		const down = gametes(0), across = gametes(1);
+		const cells = down.flatMap((a, row) => across.map((b, column) => {
+			const pairs = genes.map((gene, g) => pair(gene, a[g], b[g]));
+			return {
+				row,
+				column,
+				genotype: written(pairs),
+				phenotype: genes.map((gene, g) => PunnettSquare.#trait(gene, pairs[g])).join(", ")
+			};
+		}));
+		const tally = (name) => {
+			const classes = /* @__PURE__ */ new Map();
+			for (const cell of cells) (classes.get(name(cell)) ?? classes.set(name(cell), {
+				name: name(cell),
+				count: 0,
+				phenotype: cell.phenotype
+			}).get(name(cell))).count++;
+			return [...classes.values()];
+		};
+		const phenotypes = tally((cell) => cell.phenotype), rank = new Map(phenotypes.map((entry, i) => [entry.name, i]));
+		const text = (gamete) => gamete.join(single ? "" : " ");
+		return {
+			side: down.map(text),
+			top: across.map(text),
+			cells,
+			phenotypes,
+			parents: [written(genes.map((gene) => pair(gene, gene.parents[0][0], gene.parents[0][1]))), written(genes.map((gene) => pair(gene, gene.parents[1][0], gene.parents[1][1])))],
+			genotypes: tally((cell) => cell.genotype).sort((a, b) => rank.get(a.phenotype) - rank.get(b.phenotype))
+		};
+	}
+	draw(ctx) {
+		const { ratios, parents: names } = this.options, { width, height } = ctx.plot, { palette, theme } = ctx;
+		const { side, top, parents, cells, genotypes, phenotypes } = this.square, n = side.length, total = cells.length;
+		for (const entry of phenotypes) palette.color(entry.name);
+		const count = new Map(genotypes.map((entry) => [entry.name, entry.count]));
+		const letters = Math.max(1, ...side.map((gamete) => gamete.length), ...top.map((gamete) => gamete.length));
+		const head = Math.max(18, Math.min(13, 60 / letters) * .62 * letters + 10), sideBand = CAPTION + head, topBand = 35;
+		const panel = ratios !== PunnettRatios.None && n ? Math.max(118, Math.min(230, width * .38)) : 0;
+		const beside = panel > 0 && width - sideBand - panel - GAP >= 80 ? panel + GAP : 0;
+		const size = Math.max(10, Math.min(height - topBand, width - sideBand - beside)), cell = size / (n || 1), pad = cell >= 12 ? 2 : 1;
+		const gx = sideBand + (width - sideBand - size - beside) / 2, gy = topBand + (height - topBand - size) / 2;
+		this.#keyed = beside > 0 && ratios === PunnettRatios.List;
+		const key = (d) => `${d.row}/${d.column}`, cx = (d) => gx + (d.column + .5) * cell, cy = (d) => gy + (d.row + .5) * cell;
+		const rects = ctx.marks("cells", "rect", cells, key).attr("fill", (d) => palette.color(d.phenotype)).attr("rx", Math.min(4, cell / 8));
+		ctx.set(rects, {
+			x: (d) => cx(d) - (cell - pad) / 2,
+			y: (d) => cy(d) - (cell - pad) / 2,
+			width: Math.max(.5, cell - pad),
+			height: Math.max(.5, cell - pad),
+			opacity: 1
+		}, { opacity: 0 }, 240 / (total || 1));
+		ctx.hover(rects, (d) => ({
+			title: d.genotype,
+			color: palette.color(d.phenotype),
+			rows: [
+				["Phenotype", d.phenotype],
+				["Gametes", `${side[d.row]} and ${top[d.column]}`],
+				["Share of offspring", `${count.get(d.genotype)} in ${total}`]
+			]
+		}));
+		const longest = Math.max(1, ...cells.map((d) => d.genotype.length)), font = Math.min(14, (cell - 6) / (longest * .62));
+		const lettered = font >= 6.5 ? cells : [], captioned = cell >= 46 && phenotypes.every((entry) => TextFit.width(entry.name, 5.6) <= cell - 8);
+		const onCell = (name, data, size, shift, words) => {
+			const marks = ctx.text(ctx.marks(name, "text", data, key), size, "ink").attr("text-anchor", "middle").attr("dy", "0.35em").attr("fill", (d) => palette.inkOn(palette.color(d.phenotype))).style("pointer-events", "none").text(words);
+			ctx.set(marks, {
+				x: cx,
+				y: (d) => cy(d) + shift
+			});
+			return marks;
+		};
+		onCell("cell-genotypes", lettered, font, captioned ? -7 : 0, (d) => d.genotype).attr("font-weight", 600);
+		onCell("cell-phenotypes", captioned ? lettered : [], 10, 9, (d) => d.phenotype);
+		const gameteFont = Math.max(7, Math.min(13, (Math.min(cell, head) - 3) / (letters * .62)));
+		const headers = [...top.map((text, i) => ({
+			key: `top-${i}`,
+			text,
+			x: gx + (i + .5) * cell,
+			y: gy - 9,
+			anchor: "middle"
+		})), ...side.map((text, i) => ({
+			key: `side-${i}`,
+			text,
+			x: gx - 7,
+			y: gy + (i + .5) * cell,
+			anchor: "end"
+		}))];
+		const gametes = ctx.text(ctx.marks("axis-gametes", "text", cell >= gameteFont * .9 ? headers : [], (d) => d.key), gameteFont, "ink").attr("font-weight", 600).attr("dy", "0.35em").attr("text-anchor", (d) => d.anchor).text((d) => d.text);
+		ctx.set(gametes, {
+			x: (d) => d.x,
+			y: (d) => d.y
+		});
+		const captions = n ? [{
+			key: "top",
+			text: `${names[1]}: ${parents[1]}`,
+			room: Math.min(width, size + 2 * Math.min(gx, width - gx - size)),
+			transform: `translate(${(gx + size / 2).toFixed(1)},${(gy - HEAD - 5).toFixed(1)})`
+		}, {
+			key: "side",
+			text: `${names[0]}: ${parents[0]}`,
+			room: height,
+			transform: `translate(${(gx - head - 5).toFixed(1)},${(gy + size / 2).toFixed(1)}) rotate(-90)`
+		}] : [];
+		const titled = ctx.text(ctx.marks("axis-parents", "text", captions, (d) => d.key)).attr("text-anchor", "middle").text((d) => TextFit.fit(d.text, d.room, CHAR));
+		ctx.set(titled, { transform: (d) => d.transform });
+		const notes = n ? [] : [{
+			key: "empty",
+			text: "No genotypes to cross",
+			x: 4,
+			y: 12,
+			muted: true
+		}];
+		const chips = [];
+		const px = gx + size + GAP;
+		let y = gy - topBand + 10;
+		const heading = (title, tallies) => {
+			const summary = PunnettSquare.ratio(tallies.map((entry) => entry.count)), lead = TextFit.width(title, 6.9) + 8, inline = lead + TextFit.width(summary, CHAR) <= panel;
+			notes.push({
+				key: title,
+				text: title,
+				x: px,
+				y,
+				bold: true
+			});
+			const lines = inline ? [summary] : summary.split(" : ").reduce((rows, part) => {
+				const last = rows.length - 1, joined = `${rows[last]} : ${part}`;
+				if (rows.length && (TextFit.width(joined, CHAR) + 8 <= panel || rows.length === 3)) rows[last] = joined;
+				else rows.push(part);
+				return rows;
+			}, []);
+			lines.forEach((text, i) => {
+				if (!inline) y += LINE;
+				notes.push({
+					key: `${title}-ratio-${i}`,
+					text: TextFit.fit(i < lines.length - 1 ? `${text} :` : text, inline ? panel - lead : panel, CHAR),
+					x: inline ? px + lead : px,
+					y
+				});
+			});
+		};
+		(beside ? [["Phenotypes", phenotypes], ["Genotypes", genotypes]] : []).forEach(([title, tallies], s) => {
+			heading(title, tallies);
+			if (ratios === PunnettRatios.Bars) {
+				const inner = (entry) => Math.max(.5, panel * entry.count / (total || 1) - 2), fits = (entry, text) => TextFit.width(text, 5.8) + 4 <= inner(entry);
+				const named = s > 0 && tallies.every((entry) => fits(entry, entry.name));
+				let x = px;
+				for (const entry of tallies) {
+					const label = named ? entry.name : fits(entry, `${entry.count}`) ? `${entry.count}` : void 0;
+					chips.push({
+						key: `${title}/${entry.name}`,
+						x,
+						y: y + 7,
+						width: inner(entry),
+						height: BAR,
+						fill: palette.color(entry.phenotype),
+						tally: entry,
+						label
+					});
+					x += inner(entry) + 2;
+				}
+				y += 51;
+				return;
+			}
+			y += 16;
+			const labels = tallies.map((entry) => `${entry.count} ${entry.name}`), widest = Math.max(...labels.map((label) => TextFit.width(label, CHAR)));
+			const columns = Math.max(1, Math.min(tallies.length, Math.floor((panel + 8) / (widest + 22)))), step = panel / columns;
+			const kept = s ? 0 : Math.min(2, Math.ceil(genotypes.length / 2)) + 3;
+			const slots = Math.max(1, Math.floor((height - y) / LINE + 1) - kept) * columns;
+			const shown = tallies.length <= slots ? tallies.length : slots - 1;
+			tallies.slice(0, shown).forEach((entry, i) => {
+				const at = px + i % columns * step, row = y + Math.floor(i / columns) * LINE;
+				chips.push({
+					key: `${title}/${entry.name}`,
+					x: at,
+					y: row - 9,
+					width: 10,
+					height: 10,
+					fill: palette.color(entry.phenotype),
+					tally: entry
+				});
+				notes.push({
+					key: `${title}/${entry.name}`,
+					text: TextFit.fit(labels[i], step - 16, CHAR),
+					x: at + 14,
+					y: row
+				});
+			});
+			if (shown < tallies.length) notes.push({
+				key: `${title}-more`,
+				text: `+${tallies.length - shown} more`,
+				x: px + shown % columns * step,
+				y: y + Math.floor(shown / columns) * LINE,
+				muted: true
+			});
+			y += Math.ceil((shown + (shown < tallies.length ? 1 : 0)) / columns) * LINE + 8;
+		});
+		const swatches = ctx.marks("ratio-marks", "rect", chips, (d) => d.key).attr("fill", (d) => d.fill).attr("rx", 3);
+		ctx.set(swatches, {
+			x: (d) => d.x,
+			y: (d) => d.y,
+			width: (d) => d.width,
+			height: (d) => d.height
+		});
+		ctx.hover(swatches, (d) => ({
+			title: d.tally.name,
+			color: d.fill,
+			rows: [["Offspring", `${d.tally.count} in ${total}`], ...d.tally.name === d.tally.phenotype ? [] : [["Phenotype", d.tally.phenotype]]]
+		}));
+		const inside = ctx.text(ctx.marks("ratio-labels", "text", chips.filter((chip) => chip.label), (d) => d.key), 10, "ink").attr("text-anchor", "middle").attr("dy", "0.35em").attr("fill", (d) => palette.inkOn(d.fill)).style("pointer-events", "none").text((d) => d.label);
+		ctx.set(inside, {
+			x: (d) => d.x + d.width / 2,
+			y: (d) => d.y + d.height / 2
+		});
+		const written = ctx.marks("axis-ratios", "text", notes, (d) => d.key).attr("font-weight", (d) => d.bold ? 600 : 400).text((d) => d.text);
+		ctx.text(written).attr("fill", (d) => d.bold ? theme.ink : d.muted ? theme.inkMuted : theme.inkSecondary);
+		ctx.set(written, {
+			x: (d) => d.x,
+			y: (d) => d.y
+		});
+	}
+};
+export { PunnettSquare };

package/dist/charts/biologycharts/biologyEnums.js

@@ -90,4 +90,25 @@ var SurvivorshipAge = /* @__PURE__ */ function(SurvivorshipAge) {
 	SurvivorshipAge["Relative"] = "relative-age";
 	return SurvivorshipAge;
 }({});
-export { EpidemicCurveBin, EpidemicCurveForm, FoodWebLevel, GseaWeighting, HelicalWheelHelix, HelicalWheelLayout, HydropathyForm, HydropathyScale, PrismaDetail, RankAbundanceMeasure, RankAbundanceModel, RankAbundanceRank, SequenceAlignmentColor, SurvivorshipAge, SurvivorshipScale };
+/** The most genes crossed: one gives a 2 by 2 square, two a 4 by 4, three an 8 by 8. */
+var PunnettCross = /* @__PURE__ */ function(PunnettCross) {
+	PunnettCross["Monohybrid"] = "monohybrid";
+	PunnettCross["Dihybrid"] = "dihybrid";
+	PunnettCross["Trihybrid"] = "trihybrid";
+	return PunnettCross;
+}({});
+/** How a heterozygote looks: like the dominant homozygote, between the two homozygotes, or showing both of them. */
+var PunnettDominance = /* @__PURE__ */ function(PunnettDominance) {
+	PunnettDominance["Complete"] = "complete";
+	PunnettDominance["Incomplete"] = "incomplete";
+	PunnettDominance["Codominant"] = "codominant";
+	return PunnettDominance;
+}({});
+/** Genotype and phenotype ratios as counted lists, as bars split in proportion, or left out. */
+var PunnettRatios = /* @__PURE__ */ function(PunnettRatios) {
+	PunnettRatios["List"] = "ratio-list";
+	PunnettRatios["Bars"] = "ratio-bars";
+	PunnettRatios["None"] = "no-ratios";
+	return PunnettRatios;
+}({});
+export { EpidemicCurveBin, EpidemicCurveForm, FoodWebLevel, GseaWeighting, HelicalWheelHelix, HelicalWheelLayout, HydropathyForm, HydropathyScale, PrismaDetail, PunnettCross, PunnettDominance, PunnettRatios, RankAbundanceMeasure, RankAbundanceModel, RankAbundanceRank, SequenceAlignmentColor, SurvivorshipAge, SurvivorshipScale };

package/dist/charts/biologycharts/index.js

@@ -1,4 +1,4 @@
-import { EpidemicCurveBin, EpidemicCurveForm, FoodWebLevel, GseaWeighting, HelicalWheelHelix, HelicalWheelLayout, HydropathyForm, HydropathyScale, PrismaDetail, RankAbundanceMeasure, RankAbundanceModel, RankAbundanceRank, SequenceAlignmentColor, SurvivorshipAge, SurvivorshipScale } from "./biologyEnums.js";
+import { EpidemicCurveBin, EpidemicCurveForm, FoodWebLevel, GseaWeighting, HelicalWheelHelix, HelicalWheelLayout, HydropathyForm, HydropathyScale, PrismaDetail, PunnettCross, PunnettDominance, PunnettRatios, RankAbundanceMeasure, RankAbundanceModel, RankAbundanceRank, SequenceAlignmentColor, SurvivorshipAge, SurvivorshipScale } from "./biologyEnums.js";
 import { BiologyRows } from "./BiologyRows.js";
 import { BiologySamples } from "./BiologySamples.js";
 import { EpidemicCurve } from "./EpidemicCurve.js";
@@ -9,6 +9,7 @@ import { HelicalWheelPlot } from "./HelicalWheelPlot.js";
 import { HydropathyPlot } from "./HydropathyPlot.js";
 import { PrismaStage, prismaStageOf } from "./PrismaStage.js";
 import { PrismaFlowDiagram } from "./PrismaFlowDiagram.js";
+import { PunnettSquare } from "./PunnettSquare.js";
 import { RankAbundancePlot } from "./RankAbundancePlot.js";
 import { SequenceAlignmentView } from "./SequenceAlignmentView.js";
 import { SurvivorshipCurve } from "./SurvivorshipCurve.js";
@@ -22,6 +23,7 @@ var biologychartsCatalog = [
 	SurvivorshipCurve,
 	FoodWebChart,
 	EpidemicCurve,
-	PrismaFlowDiagram
+	PrismaFlowDiagram,
+	PunnettSquare
 ];
-export { BiologyRows, BiologySamples, EpidemicCurve, EpidemicCurveBin, EpidemicCurveForm, FoodWebChart, FoodWebLevel, GseaEnrichmentPlot, GseaWeighting, HelicalWheelHelix, HelicalWheelLayout, HelicalWheelPlot, HydropathyForm, HydropathyPlot, HydropathyScale, PrismaDetail, PrismaFlowDiagram, PrismaStage, RankAbundanceMeasure, RankAbundanceModel, RankAbundancePlot, RankAbundanceRank, ResidueChemistry, ResidueClass, SequenceAlignmentColor, SequenceAlignmentView, SurvivorshipAge, SurvivorshipCurve, SurvivorshipScale, biologychartsCatalog, prismaStageOf };
+export { BiologyRows, BiologySamples, EpidemicCurve, EpidemicCurveBin, EpidemicCurveForm, FoodWebChart, FoodWebLevel, GseaEnrichmentPlot, GseaWeighting, HelicalWheelHelix, HelicalWheelLayout, HelicalWheelPlot, HydropathyForm, HydropathyPlot, HydropathyScale, PrismaDetail, PrismaFlowDiagram, PrismaStage, PunnettCross, PunnettDominance, PunnettRatios, PunnettSquare, RankAbundanceMeasure, RankAbundanceModel, RankAbundancePlot, RankAbundanceRank, ResidueChemistry, ResidueClass, SequenceAlignmentColor, SequenceAlignmentView, SurvivorshipAge, SurvivorshipCurve, SurvivorshipScale, biologychartsCatalog, prismaStageOf };

package/dist/charts/doecharts/DoeSamples.js

@@ -422,6 +422,40 @@ var WORK = [
 		]
 	]]
 ];
+var SIPOC_SUPPLIERS = [
+	"Fabrication cell",
+	"Powder supplier",
+	"Planning office",
+	"Site services"
+];
+var SIPOC_INPUTS = [
+	["Works order", "Planning office"],
+	["Cut brackets", "Fabrication cell"],
+	["Coating powder", "Powder supplier"],
+	["Racks and hooks", "Fabrication cell"],
+	["Gas and compressed air", "Site services"]
+];
+var SIPOC_STEPS = [
+	"Rack the parts",
+	"Degrease and rinse",
+	"Apply powder",
+	"Cure in oven",
+	"Inspect finish",
+	"Pack and label"
+];
+var SIPOC_OUTPUTS = [
+	["Coated brackets", "Assembly line"],
+	["Coated brackets", "Spares store"],
+	["Inspection record", "Quality office"],
+	["Closed works order", "Planning office"],
+	["Scrap report", "Quality office"]
+];
+var SIPOC_CUSTOMERS = [
+	"Planning office",
+	"Assembly line",
+	"Quality office",
+	"Spares store"
+];
 /** Invented experiments, studies and workshop notes, all drawn from `SampleData.rng`. No plant, product or team is real. */
 var DoeSamples = class {
 	/** A replicated 3 x 2 x 3 factorial on a moulding press: `{ temperature, pressure, resin, strength }`, 36 runs. */
@@ -609,5 +643,49 @@ var DoeSamples = class {
 			}));
 		}).flat();
 	}
+	/**
+	* A SIPOC of a powder coating line: `{ stage, item, partner }`. An input names its supplier and an output its customer;
+	* an output with two customers takes two rows. The seed turns the order of suppliers and customers and adds a step or leaves one out.
+	*/
+	static sipoc(seed) {
+		const { u } = SampleData.rng(seed);
+		const extra = [
+			"Mask the threads",
+			"Pre-heat the parts",
+			""
+		][Math.floor(u() * 3)];
+		const steps = extra ? [
+			...SIPOC_STEPS.slice(0, 2),
+			extra,
+			...SIPOC_STEPS.slice(2)
+		] : SIPOC_STEPS;
+		return [
+			...turn(SIPOC_SUPPLIERS, seed).map((item) => ({
+				stage: "Supplier",
+				item,
+				partner: null
+			})),
+			...SIPOC_INPUTS.map(([item, partner]) => ({
+				stage: "Input",
+				item,
+				partner
+			})),
+			...steps.map((item) => ({
+				stage: "Process",
+				item,
+				partner: null
+			})),
+			...SIPOC_OUTPUTS.map(([item, partner]) => ({
+				stage: "Output",
+				item,
+				partner
+			})),
+			...turn(SIPOC_CUSTOMERS, seed).map((item) => ({
+				stage: "Customer",
+				item,
+				partner: null
+			}))
+		];
+	}
 };
 export { DoeSamples };