feat(app): sushi planner for block belt loops

Sizes one mixed belt loop carrying everything a block moves — imports,
exports, and row-to-row intermediates (a good's belt rate is
max(production, consumption) across the rows). Opens from the Block
balance header: feasibility verdict against the selected belt tier +
stacking (comfortable / tight / fragile / over capacity / loop too
small), per-item on-belt set-points (stock = rate x lap time, floored
so trace items keep cycling), pass frequency with sparse flags, and
spoil-dwell warnings via Little's law. Loop length in tiles drives lap
time and slot capacity; items untick to stay off the loop.

Delivery: "to cursor in game" sends a constant combinator over the
bridge; "copy blueprint" yields the same as an importable string
(lib/blueprint.ts — 2.0 blueprint JSON + zlib string encoding, built
client-side). The combinator holds one logistic section per role with
only block inputs enabled — imports are the injected flows that need
gating; outputs and intermediates free-flow, their set-points parked
in disabled sections as flippable reference.

Author: ApocDev

app/e2e/mut/sushi.e2e.ts

@@ -0,0 +1,45 @@
+import { expect, test } from "@playwright/test";
+import { addGoal, createBlock } from "./helpers";
+
+/**
+ * Sushi planner (block balance header): with a plate + ore chain the block has
+ * an internal flow (ore) and boundary flows, so the planner opens with per-item
+ * rows, a verdict, and set-points that react to the loop-length input.
+ */
+test("sushi planner sizes one mixed loop for the block's flows", async ({ page }) => {
+  await createBlock(page);
+  await addGoal(page, "iron plate", "Iron plate");
+
+  // plate recipe, then a producer for its ore ingredient → ore becomes internal
+  await page.locator('button[title^="click to add a recipe that makes this goal"]').click();
+  const platePicker = page.getByRole("dialog", { name: /Recipes that make/ });
+  await platePicker.getByRole("button", { name: /Iron plate/ }).first().click();
+  await expect(platePicker).toBeHidden();
+  await page.getByRole("button", { name: /^Iron ore.*(raw input|craftable)/ }).first().click();
+  const orePicker = page.getByRole("dialog", { name: /Recipes that make/ });
+  await orePicker.getByRole("button", { name: /Iron ore/ }).first().click();
+  await expect(orePicker).toBeHidden();
+
+  await page.getByRole("button", { name: "sushi" }).click();
+  const dialog = page.getByRole("dialog", { name: "Sushi planner" });
+  await expect(dialog).toBeVisible();
+
+  // a verdict callout and the ore row (internal flow) with a set-point
+  await expect(dialog.getByText(/comfortable|workable|fragile|over capacity|loop too small/)).toBeVisible();
+  const oreRow = dialog.locator("div").filter({ hasText: /^.*Iron ore/ }).last();
+  await expect(oreRow.getByText("int")).toBeVisible();
+
+  // loop length drives the lap/slot readout
+  const tiles = dialog.getByLabel("loop length in belt tiles");
+  await tiles.fill("200");
+  await expect(dialog.getByText(/lap ≈ .* s · \d+\/\d+ slots/)).toBeVisible();
+
+  // unticking a flow keeps the planner live (recomputes without it)
+  await dialog.getByRole("checkbox").first().click();
+  await expect(dialog.getByText(/lap ≈/)).toBeVisible();
+
+  // delivery: bridge send is gated on a connected mod (none here), the
+  // blueprint-string copy works without one
+  await expect(dialog.getByRole("button", { name: "to cursor in game" })).toBeDisabled();
+  await expect(dialog.getByRole("button", { name: "copy blueprint" })).toBeEnabled();
+});

app/src/components/block/balance-card.tsx

@@ -9,6 +9,7 @@ import { fmtSpoilTime, Icon, useSpoilables } from "../../lib/icons";
 import { fmtTemp } from "../../lib/format";
 import { ItemChip, type Link as ItemLink } from "./item-chip.tsx";
 import { LogiTag } from "./logi-tag.tsx";
+import { SushiPlanner, type SushiPlannerFlow } from "./sushi-planner.tsx";
 import type { BlockDocStore } from "./doc-store.ts";
 import type { LogiView, SolveResult } from "./solve-view.ts";
 import { num } from "./format.ts";
@@ -56,12 +57,65 @@ export function BalanceCard({
   onOpenSpoilDialog: (name: string) => void;
 }) {
   const spoilRates = useStore(doc.store, (s) => s.spoilRates);
+  const blockName = useStore(doc.store, (s) => s.blockName);
   const spoilables = useSpoilables();
+  // One mixed loop candidate: every solid item touching a belt in this block —
+  // imports, exports, AND internal row-to-row flows all ride the same loop in
+  // the "everything on one belt" pattern. A good's belt rate is
+  // max(production, consumption) across the rows (that identity covers all
+  // three roles); boundary-only goods (e.g. a stock goal with no row) are
+  // topped up from the import/export lists.
+  const sushiFlows: SushiPlannerFlow[] = (() => {
+    const solid = (f: { name: string; kind: string }) =>
+      f.kind === "item" && !f.name.startsWith("pyops-");
+    const prod = new Map<string, number>();
+    const cons = new Map<string, number>();
+    const disp = new Map<string, string | null>();
+    for (const row of res?.rows ?? []) {
+      for (const c of row.ingredients) {
+        if (!solid(c)) continue;
+        cons.set(c.name, (cons.get(c.name) ?? 0) + c.rate);
+        disp.set(c.name, c.display ?? res?.display?.[c.name] ?? null);
+      }
+      for (const c of row.products) {
+        if (!solid(c)) continue;
+        prod.set(c.name, (prod.get(c.name) ?? 0) + c.rate);
+        disp.set(c.name, c.display ?? res?.display?.[c.name] ?? null);
+      }
+    }
+    for (const f of res?.imports ?? []) {
+      if (!solid(f) || cons.has(f.name) || prod.has(f.name)) continue;
+      cons.set(f.name, f.rate);
+      disp.set(f.name, res?.display?.[f.name] ?? null);
+    }
+    for (const f of res?.exports ?? []) {
+      if (!solid(f) || cons.has(f.name) || prod.has(f.name)) continue;
+      prod.set(f.name, f.rate);
+      disp.set(f.name, res?.display?.[f.name] ?? null);
+    }
+    return [...new Set([...prod.keys(), ...cons.keys()])]
+      .map((name) => {
+        const p = prod.get(name) ?? 0;
+        const c = cons.get(name) ?? 0;
+        return {
+          name,
+          display: disp.get(name) ?? null,
+          rate: Math.max(p, c),
+          role:
+            p > 1e-9 && c > 1e-9 ? ("int" as const) : c > 1e-9 ? ("in" as const) : ("out" as const),
+        };
+      })
+      .filter((f) => f.rate > 1e-9)
+      .sort((a, b) => b.rate - a.rate);
+  })();
   return (
     <Card className="lg:col-span-2">
       <CardHeader className="justify-between">
         <CardTitle>Block balance</CardTitle>
         <div className="flex items-center gap-4 text-sm">
+          {logi.resolved && sushiFlows.length >= 2 && (
+            <SushiPlanner flows={sushiFlows} resolved={logi.resolved} blockName={blockName} />
+          )}
           {/* Pollution rides in the header (#23) to save a whole body row —
               electricity/heat aren't shown here at all: both surface as their
               own import chips below (pyops-electricity / pyops-heat). */}