fix(data): import Factorio product probabilities

ApocDev · ApocDev · commit 1964dfdc9f60 · 2026-07-15T18:43:05.000-04:00
Use Factorio 2.1 independent and shared product probabilities when computing expected yields, and surface chances compactly in block rows and hover details.\n\nCloses #161
diff --git a/app/e2e/mut/product-probability.e2e.ts b/app/e2e/mut/product-probability.e2e.ts
@@ -0,0 +1,49 @@
+import { DatabaseSync } from "node:sqlite";
+import { expect, test } from "@playwright/test";
+import { activeProjectDbFile, goto, uniqueName } from "./helpers";
+
+test("probabilistic recipe products show their chance and solve from expected yield", async ({
+  page,
+}) => {
+  const data = {
+    recipes: ["kicalk-mk04-breeder"],
+    goals: [{ name: "kicalk-mk04", rate: 1 }],
+    machines: { "kicalk-mk04-breeder": "kicalk-plantation-mk01" },
+  };
+  const db = new DatabaseSync(activeProjectDbFile());
+  let id: number;
+  try {
+    const inserted = db
+      .prepare("INSERT INTO blocks (name, data) VALUES (?, ?)")
+      .run(uniqueName("Probabilistic kicalk"), JSON.stringify(data));
+    id = Number(inserted.lastInsertRowid);
+  } finally {
+    db.close();
+  }
+
+  await goto(page, `/block/${id}`);
+  const row = page.locator('[data-recipe-row="kicalk-mk04-breeder"]');
+  await expect(row).toContainText("0.16/s");
+
+  const optionalMk04 = row.getByRole("button", {
+    name: /^Kicalk MK 04 0\.19\/s · 40% chance/,
+  });
+  await expect(optionalMk04).toBeVisible();
+  await expect(optionalMk04.locator("[data-product-probability]")).toHaveText("40%");
+
+  await optionalMk04.hover();
+  await expect(page.getByText("40% chance per craft", { exact: true })).toBeVisible();
+  await expect(page.getByText("3 on success · 1.2 expected per craft", { exact: true })).toBeVisible();
+
+  await row.getByLabel("Variable recipe results").hover();
+  const variableResult = page.getByText(
+    /Kicalk MK 04: 3 on success · 40% chance · 1.2 expected\/craft/,
+  );
+  await expect(variableResult).toBeVisible();
+
+  await page.keyboard.press("Escape");
+  await expect(variableResult).toBeHidden();
+  await row.getByText("Grow kicalk gen 4", { exact: true }).hover();
+  const recipeCard = page.getByText("kicalk-mk04-breeder", { exact: true }).locator("..");
+  await expect(recipeCard.getByText("40% chance", { exact: false }).first()).toBeVisible();
+});
diff --git a/app/src/components/block/item-chip.test.tsx b/app/src/components/block/item-chip.test.tsx
@@ -1,5 +1,6 @@
 // @vitest-environment jsdom
 import { cleanup, fireEvent, render } from "@testing-library/react";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
 import { afterEach, describe, expect, it, vi } from "vite-plus/test";
 import { ItemChip } from "./item-chip.tsx";
 import { IncidentalSpoilageChip } from "./incidental-spoilage-chip.tsx";
@@ -10,7 +11,40 @@ vi.mock("#/server/factorio", () => ({
   itemDetailFn: () => Promise.resolve(null),
 }));
 
+window.ResizeObserver ??= class {
+  observe() {}
+  unobserve() {}
+  disconnect() {}
+} as unknown as typeof ResizeObserver;
+
 describe("ItemChip spoil time", () => {
+  it("shows a probabilistic product chance compactly and in its hover context", () => {
+    const client = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+    const { getByRole, getByText } = render(
+      <QueryClientProvider client={client}>
+        <ItemChip
+          name="kicalk-mk04"
+          kind="item"
+          display="Kicalk MK 04"
+          rate={0.19}
+          probability={0.4}
+          amountExpected={1.2}
+          amountMin={3}
+          amountMax={3}
+          link="export"
+          onClick={() => {}}
+        />
+      </QueryClientProvider>,
+    );
+
+    expect(getByText("40%").getAttribute("data-product-probability")).not.toBeNull();
+    const chip = getByRole("button");
+    expect(chip.getAttribute("aria-label")).toContain("40% chance");
+    fireEvent.mouseEnter(chip);
+    expect(getByText("40% chance per craft")).toBeTruthy();
+    expect(getByText("3 on success · 1.2 expected per craft")).toBeTruthy();
+  });
+
   it("makes a finite campaign total the primary chip value", () => {
     const { getByRole, getByText } = render(
       <ItemChip
diff --git a/app/src/components/block/item-chip.tsx b/app/src/components/block/item-chip.tsx
@@ -2,7 +2,7 @@ import { Flame, Timer } from "lucide-react";
 import type { ReactNode } from "react";
 import { ItemHover } from "../../lib/recipe-card";
 import { fmtSpoilTime, Icon } from "../../lib/icons";
-import { quantityLabel, rateLabel } from "./format.ts";
+import { num, quantityLabel, rateLabel } from "./format.ts";
 
 /** A block item's role under the current solve — drives the chip colour so it's
  * obvious which flows are linked internally vs. need a recipe vs. spill out. */
@@ -27,6 +27,10 @@ export function ItemChip({
   display,
   rate,
   total,
+  probability,
+  amountExpected,
+  amountMin,
+  amountMax,
   rateMin,
   rateMax,
   temp,
@@ -48,6 +52,11 @@ export function ItemChip({
   /** Finite campaign amount. Replaces the throughput rate as the chip's
    * primary value; the caller may show the derived average separately. */
   total?: number;
+  /** Per-craft chance and yield context for a recipe product. */
+  probability?: number;
+  amountExpected?: number;
+  amountMin?: number;
+  amountMax?: number;
   /** Variable energy production range; `rate` is the planner average. */
   rateMin?: number;
   rateMax?: number;
@@ -96,11 +105,28 @@ export function ItemChip({
     rate == null ? "" : variableRate ? displayedRate : rateLabel(name, rate, { perSec: true });
   const displayedTotal = total == null ? "" : `${quantityLabel(name, total)} total`;
   const totalRate = total != null && rate != null ? rateLabel(name, rate, { perSec: true }) : "";
+  const chance = probability != null && probability < 1 ? `${num(probability * 100)}%` : "";
+  const chanceContext = chance ? (
+    <div>
+      <div className="text-warning">{chance} chance per craft</div>
+      {amountExpected != null && (
+        <div className="text-muted-foreground">
+          {amountMin != null && amountMax != null
+            ? amountMin === amountMax
+              ? `${num(amountMin)} on success · `
+              : `${num(amountMin)}–${num(amountMax)} on success · `
+            : ""}
+          {num(amountExpected)} expected per craft
+        </div>
+      )}
+    </div>
+  ) : undefined;
   return (
     <span className={`inline-flex items-center gap-1 ${cls}`}>
       <ItemHover
         name={name}
         kind={kind as "item" | "fluid"}
+        extraText={chanceContext}
         className="inline-flex"
         // the rich card (cost, produced-by / used-in) replaces the old native title;
         // role is the chip colour, rate is shown on the chip, actions are on right-click
@@ -112,7 +138,7 @@ export function ItemChip({
             e.preventDefault();
             onContext(e);
           }}
-          aria-label={`${display ?? name}${displayedTotal ? ` ${displayedTotal}${totalRate ? ` · ${totalRate} average` : ""}` : accessibleRate ? ` ${accessibleRate}` : ""}${spoilTime ? ` · spoils in ${spoilTime}` : ""}${incidental ? " · includes estimated incidental spoilage" : ""}${indicatorLabel ? ` · ${indicatorLabel}` : ""} · ${why}`}
+          aria-label={`${display ?? name}${displayedTotal ? ` ${displayedTotal}${totalRate ? ` · ${totalRate} average` : ""}` : accessibleRate ? ` ${accessibleRate}` : ""}${chance ? ` · ${chance} chance` : ""}${spoilTime ? ` · spoils in ${spoilTime}` : ""}${incidental ? " · includes estimated incidental spoilage" : ""}${indicatorLabel ? ` · ${indicatorLabel}` : ""} · ${why}`}
           className="flex items-center gap-1 px-1.5 py-1 text-sm hover:brightness-95"
         >
           <span className="relative flex">
@@ -137,7 +163,16 @@ export function ItemChip({
               )}
             </span>
           ) : rate != null ? (
-            <span data-rate-range={variableRate ? "variable" : undefined}>{displayedRate}</span>
+            chance ? (
+              <span className="flex flex-col items-start leading-tight tabular-nums">
+                <span data-rate-range={variableRate ? "variable" : undefined}>{displayedRate}</span>
+                <span data-product-probability className="text-xs text-warning">
+                  {chance}
+                </span>
+              </span>
+            ) : (
+              <span data-rate-range={variableRate ? "variable" : undefined}>{displayedRate}</span>
+            )
           ) : null}
           {incidental && (
             <span
diff --git a/app/src/components/block/recipe-row.tsx b/app/src/components/block/recipe-row.tsx
@@ -221,17 +221,20 @@ export function RecipeRow({
                   <RecipeSpoilageIndicator products={row.products} spoilables={spoilables} />
                 </span>
               ) : null}
-              {campaign && uncertainProducts.length > 0 && (
+              {uncertainProducts.length > 0 && (
                 <Tooltip
                   content={uncertainProducts
                     .map(
                       (product) =>
-                        `${product.display ?? product.name}: ${num(product.amountMin)}–${num(product.amountMax)} each${product.probability < 1 ? ` · ${num(product.probability * 100)}% chance` : ""} · ${num(product.amountExpected * (row?.rate ?? 0) * campaign.duration)} expected total`,
+                        `${product.display ?? product.name}: ${product.amountMin === product.amountMax ? num(product.amountMin) : `${num(product.amountMin)}–${num(product.amountMax)}`} on success${product.probability < 1 ? ` · ${num(product.probability * 100)}% chance` : ""} · ${num(product.amountExpected)} expected/craft${campaign ? ` · ${num(product.amountExpected * (row?.rate ?? 0) * campaign.duration)} expected total` : ""}`,
                     )
                     .join("\n")}
                 >
-                  <span className="flex items-center gap-1 text-sm text-warning">
-                    <FlaskConical className="size-3" /> Variable result · hover for range and chance
+                  <span
+                    aria-label="Variable recipe results"
+                    className="flex cursor-help text-warning"
+                  >
+                    <FlaskConical className="size-3.5" />
                   </span>
                 </Tooltip>
               )}
@@ -544,10 +547,13 @@ export function RecipeRow({
           </div>
           <div className="flex flex-wrap gap-x-4 gap-y-3">
             <FieldLabel className="w-full md:hidden">Products ↑</FieldLabel>
-            {row?.products.map((c) => {
+            {row?.products.map((c, productIndex) => {
               const incidental = incidentalSpoilage.filter((s) => s.source === c.name);
               return (
-                <div key={c.name} className="flex flex-col items-start gap-1.5">
+                <div
+                  key={`${c.name}:${productIndex}`}
+                  className="flex flex-col items-start gap-1.5"
+                >
                   <div className="flex flex-wrap items-center gap-1.5">
                     <ItemChip
                       name={c.name}
@@ -556,6 +562,10 @@ export function RecipeRow({
                       rate={c.rate}
                       rateMin={c.rateMin}
                       rateMax={c.rateMax}
+                      probability={c.probability}
+                      amountExpected={c.amountExpected}
+                      amountMin={c.amountMin}
+                      amountMax={c.amountMax}
                       temp={c.temp}
                       spoilTicks={spoilables[c.name]}
                       link={linkOf(c.name)}
diff --git a/app/src/db/import-factorio.test.ts b/app/src/db/import-factorio.test.ts
@@ -49,6 +49,47 @@ describe("importFactorioDump — recipe categories", () => {
   });
 });
 
+describe("importFactorioDump — Factorio 2.1 product probability", () => {
+  it("combines independent and shared rolls with legacy and default fallbacks", () => {
+    const db = runImport({
+      recipe: {
+        chance: {
+          results: [
+            { type: "item", name: "default", amount: 1 },
+            { type: "item", name: "legacy", amount: 1, probability: 0.25 },
+            { type: "item", name: "independent", amount: 1, independent_probability: 0.4 },
+            {
+              type: "item",
+              name: "shared",
+              amount: 1,
+              shared_probability: { min: 0.2, max: 0.7 },
+            },
+            {
+              type: "item",
+              name: "both",
+              amount: 1,
+              independent_probability: 0.5,
+              shared_probability: { min: 0.6, max: 0.8 },
+            },
+          ],
+        },
+      },
+    });
+    const rows = db.prepare(`SELECT name, probability FROM recipe_products ORDER BY idx`).all() as {
+      name: string;
+      probability: number;
+    }[];
+    expect(rows[0]).toEqual({ name: "default", probability: 1 });
+    expect(rows[1]).toEqual({ name: "legacy", probability: 0.25 });
+    expect(rows[2]).toEqual({ name: "independent", probability: 0.4 });
+    expect(rows[3].name).toBe("shared");
+    expect(rows[3].probability).toBeCloseTo(0.5);
+    expect(rows[4].name).toBe("both");
+    expect(rows[4].probability).toBeCloseTo(0.1);
+    db.close();
+  });
+});
+
 describe("importFactorioDump — machine footprints", () => {
   it("derives placed tile dimensions from array and named selection boxes", () => {
     const db = runImport({
diff --git a/app/src/db/import-factorio.ts b/app/src/db/import-factorio.ts
@@ -76,6 +76,26 @@ function normComponent(c: unknown): Component {
   if (Array.isArray(c)) return { type: "item", name: c[0], amount: c[1] };
   return c as Component;
 }
+
+/** Effective chance that Factorio gives one product entry. Factorio 2.1 split
+ * the old `probability` into an independent roll and a shared-roll interval;
+ * both tests must pass. Keep the legacy field as the independent fallback so
+ * older dumps remain importable. */
+function productProbability(c: Component): number {
+  const independent =
+    typeof c.independent_probability === "number"
+      ? c.independent_probability
+      : typeof c.probability === "number"
+        ? c.probability
+        : 1;
+  const shared =
+    c.shared_probability && typeof c.shared_probability === "object"
+      ? (c.shared_probability as { min?: unknown; max?: unknown })
+      : null;
+  const min = typeof shared?.min === "number" ? shared.min : 0;
+  const max = typeof shared?.max === "number" ? shared.max : 1;
+  return independent * Math.max(0, max - min);
+}
 /** Lua serializes an empty table as `{}` (object), not `[]`. Coerce to array. */
 const arr = <T = any>(x: unknown): T[] => (Array.isArray(x) ? (x as T[]) : []);
 /** Non-empty string list → JSON text; empty/missing → NULL (= "no restriction"). */
@@ -320,7 +340,7 @@ export function importFactorioDump(
             amount: c.amount ?? null,
             amount_min: (c.amount_min as number) ?? null,
             amount_max: (c.amount_max as number) ?? null,
-            probability: (c.probability as number) ?? 1,
+            probability: productProbability(c),
             temperature: (c.temperature as number) ?? null,
             // Factorio 2.0: an AMOUNT (the catalytic part of the product that
             // productivity never multiplies), not a flag. Kovarex: u-235 out 41
diff --git a/app/src/db/schema.ts b/app/src/db/schema.ts
@@ -94,6 +94,8 @@ export const recipeProducts = sqliteTable(
     amount: real(), // null when amount_min/max used
     amountMin: real("amount_min"),
     amountMax: real("amount_max"),
+    // Effective product chance: independent_probability × shared range width
+    // in Factorio 2.1, with legacy probability support during import.
     probability: real().notNull().default(1),
     temperature: real(), // exact produced temperature (fluids)
     // AMOUNT of this product not scaled by productivity (Factorio 2.0 semantics:
diff --git a/docs/development/data-pipeline.md b/docs/development/data-pipeline.md
@@ -98,7 +98,9 @@ The importer converts Factorio's flexible prototype shapes into stable relationa
 Recipe products with ranges are represented by their expected amount for planning. Product
 probability, temperature, productivity exclusions, and the original range remain available
 where the solver or UI needs them. The parser accepts the prototype variants Factorio may
-emit, including recipe category arrays and singular categories.
+emit, including recipe category arrays and singular categories. For Factorio 2.1 products it
+stores the effective chance: the independent probability multiplied by the width of the shared
+probability range. Legacy dumps with a single probability field remain supported.
 
 Localized display names come from the locale dumps. When a recipe or machine inherits its
 name from a product or placeable item, the importer uses that localized prototype name as a
diff --git a/docs/guide/blocks.md b/docs/guide/blocks.md
@@ -95,6 +95,9 @@ row:
   keep walking the graph.
 - Hover recipe, technology, and item details when you need the precise inputs, outputs, or
   unlock status.
+- A probabilistic product shows its chance as a small percentage beneath its expected rate.
+  Hover the product for its amount on success and expected amount per craft. The flask icon by
+  the recipe rate summarizes every variable result in one tooltip.
 
 The picker puts choices already unlocked in the synced save first, then recipes available
 later in the current planning horizon, and finally locked choices. It sorts each group by
