diff --git a/README.md b/README.md
index bbe36b4..70e0cd4 100644
--- a/README.md
+++ b/README.md
@@ -36,7 +36,6 @@ Query string `?gameId=<game>` may be added to quickly open desired game, for exa
 
 # TODO list
 
-- Conveyors/Robotic arms/Pipes/etc.. support for link
 - Color/Icon states for link and item (overflow, underflow, warning, etc..)
 - Move/Delete entire blueprint, production chain or multiple factories (selection, edit)
 - Apply counts calculated in locked mode to current factories
diff --git a/data/evospace/calculator/calculator.ts b/data/evospace/calculator/calculator.ts
index 738c83e..98473c1 100644
--- a/data/evospace/calculator/calculator.ts
+++ b/data/evospace/calculator/calculator.ts
@@ -3,7 +3,7 @@ Author: Alexey Usov (dax@xdax.ru, https://github.com/doubleaxe)
 Please don't remove this comment if you use unmodified file
 */
 import type {Calculator} from '#types/calculator';
-import type {GameRecipeDictionary} from '#types/game-data';
+import type {FromatCountPerSecond, GameItem, GameRecipeDictionary} from '#types/game-data';
 import {GameItemType} from '#types/contants';
 import {GameRecipeDictionaryExData, GameRecipeIOType} from '../types/custom-game-data';
 
@@ -48,8 +48,8 @@ export function useCalculator(): Calculator {
         return (io.count * unitMul * Math.pow(1.5, tierDiff) * TICKS_PER_SECOND) / io.recipe.time;
     };
 
-    const formatCountPerSecond: Calculator['formatCountPerSecond'] = function(io, count) {
-        const productType = io.product.type;
+    function formatCount(item: GameItem, count: number): FromatCountPerSecond {
+        const productType = item.type;
         if(productType == GameItemType.Energy) {
             //energy measured in Watts, 1 Resource Item [R] * 20 = 20 Watt
             count *= 20;
@@ -62,6 +62,14 @@ export function useCalculator(): Calculator {
             count,
             unit: 'ps',
         };
+    }
+
+    const formatCountPerSecond: Calculator['formatCountPerSecond'] = function(io, count) {
+        return formatCount(io.product, count);
+    };
+
+    const formatTransportFlow: Calculator['formatTransportFlow'] = function(transport, flow) {
+        return formatCount(transport.item, flow);
     };
 
     const isCommonIo: Calculator['isCommonIo'] = function(io) {
@@ -73,6 +81,7 @@ export function useCalculator(): Calculator {
     return {
         getCountPerSecond,
         formatCountPerSecond,
+        formatTransportFlow,
         isCommonIo,
     };
 }
diff --git a/data/evospace/static/custom-data.ts b/data/evospace/static/custom-data.ts
index f6a1bf6..5c2e847 100644
--- a/data/evospace/static/custom-data.ts
+++ b/data/evospace/static/custom-data.ts
@@ -2,6 +2,7 @@ import type {GameLogisticSerialized} from '#types/game-data-serialized';
 
 export const logistic: GameLogisticSerialized[] = [{
     name: 'RobotArm90',
+    label: 'Robot Arm 90°',
     items: [{
         name: 'AnySolidStaticItem',
     }],
@@ -38,6 +39,7 @@ export const logistic: GameLogisticSerialized[] = [{
     stackable: true,
 }, {
     name: 'RobotArm180',
+    label: 'Robot Arm 180°',
     items: [{
         name: 'AnySolidStaticItem',
     }],
diff --git a/data/sample/calculator/calculator.ts b/data/sample/calculator/calculator.ts
index 521b30a..7236861 100644
--- a/data/sample/calculator/calculator.ts
+++ b/data/sample/calculator/calculator.ts
@@ -5,17 +5,25 @@ Please don't remove this comment if you use unmodified file
 import type {
     Calculator,
 } from '#types/calculator';
+import type {FromatCountPerSecond, GameItem} from '#types/game-data';
 
 export function useCalculator(): Calculator {
     const getCountPerSecond: Calculator['getCountPerSecond'] = function(item, io) {
         return io.count * (item.recipe?.tier || 1) / io.recipe.time;
     };
 
-    const formatCountPerSecond: Calculator['formatCountPerSecond'] = function(io, count) {
+    function formatCount(item: GameItem, count: number): FromatCountPerSecond {
         return {
             count,
-            unit: (io.product.name == 'R') ? 'W' : 'ps',
+            unit: (item.name == 'R') ? 'W' : 'ps',
         };
+    }
+    const formatCountPerSecond: Calculator['formatCountPerSecond'] = function(io, count) {
+        return formatCount(io.product, count);
+    };
+
+    const formatTransportFlow: Calculator['formatTransportFlow'] = function(transport, flow) {
+        return formatCount(transport.item, flow);
     };
 
     const isCommonIo: Calculator['isCommonIo'] = function(io) {
@@ -25,6 +33,7 @@ export function useCalculator(): Calculator {
     return {
         getCountPerSecond,
         formatCountPerSecond,
+        formatTransportFlow,
         isCommonIo,
     };
 }
diff --git a/site/data/types/calculator.ts b/site/data/types/calculator.ts
index 14b397e..ffc43ca 100644
--- a/site/data/types/calculator.ts
+++ b/site/data/types/calculator.ts
@@ -6,11 +6,13 @@ Please don't remove this comment if you use unmodified file
 import type {
     FromatCountPerSecond,
     GameItem,
+    GameLogisticTransport,
     GameRecipeIO,
 } from './game-data';
 
 export interface Calculator {
     getCountPerSecond: (item: GameItem, io: GameRecipeIO) => number;
     formatCountPerSecond: (io: GameRecipeIO, count: number) => FromatCountPerSecond;
+    formatTransportFlow: (transport: GameLogisticTransport, flow: number) => FromatCountPerSecond;
     isCommonIo: (io: GameRecipeIO) => boolean;
 }
diff --git a/site/data/types/game-data-serialized.ts b/site/data/types/game-data-serialized.ts
index f6e654b..a9523b2 100644
--- a/site/data/types/game-data-serialized.ts
+++ b/site/data/types/game-data-serialized.ts
@@ -85,6 +85,7 @@ export interface GameLogisticTransportSerialized {
 export interface GameLogisticSerialized {
     name: string;
     longName?: string;
+    label?: string;
     items: GameLogisticItemSerialized[];
     transport: GameLogisticTransportSerialized[];
     time: number;
diff --git a/site/data/types/game-data.ts b/site/data/types/game-data.ts
index 790b9c9..9d5e8e1 100644
--- a/site/data/types/game-data.ts
+++ b/site/data/types/game-data.ts
@@ -68,6 +68,7 @@ export interface GameLogisticTransportRaw extends GameLogisticTransportSerialize
     logistic: GameLogistic;
     item: GameItem;
     countPerSecond: number;
+    formatCountPerSecond: (count: number) => FromatCountPerSecond;
 }
 export type GameLogisticTransport = Readonly<GameLogisticTransportRaw>;
 
diff --git a/site/src/components/main-panel/link-menu.vue b/site/src/components/main-panel/link-menu.vue
index 8814feb..2ef89a0 100644
--- a/site/src/components/main-panel/link-menu.vue
+++ b/site/src/components/main-panel/link-menu.vue
@@ -4,7 +4,7 @@ Please don't remove this comment if you use unmodified file
 -->
 <script setup lang="ts">
 import type {LinkModel} from '@/scripts/model/store';
-import {computed, ref} from 'vue';
+import {computed, ref, watch} from 'vue';
 import {mdiLinkOff} from '@mdi/js';
 import {formatIo} from '@/scripts/format';
 
@@ -23,8 +23,16 @@ const logisticSet = computed(() => {
     }
     return [..._logistic.logistic];
 });
-const flowTotal = computed(() => props.link?.input ? formatIo(props.link.flow, props.link.input) : '');
+const flowTotal = computed(() => {
+    const io = props.link?.input || props.link?.output;
+    return io ? formatIo(props.link.flow, io) : '';
+});
 
+watch(menuOpened, (value, oldValue) => {
+    if(!oldValue && value) {
+        props.link?.logistic?.resetSelectedTransport();
+    }
+});
 </script>
 
 <template>
@@ -41,7 +49,13 @@ const flowTotal = computed(() => props.link?.input ? formatIo(props.link.flow, p
                 @click="props.link?.deleteThis(); menuOpened = false;"
             />
             <template v-if="logisticSet.length">
-                <v-list-item :title="flowTotal" />
+                <v-list-item class="minwidth">
+                    <v-list-item-title>
+                        <div class="transport-menu-item">
+                            <icon-component :image="props.link?.input?.image" /> {{ flowTotal }}
+                        </div>
+                    </v-list-item-title>
+                </v-list-item>
                 <template v-for="logistic in logisticSet" :key="logistic.name">
                     <logistic-panel :logistic="logistic" />
                 </template>
@@ -51,4 +65,8 @@ const flowTotal = computed(() => props.link?.input ? formatIo(props.link.flow, p
 </template>
 
 <style scoped>
+.transport-menu-item {
+    display: flex;
+    align-items: center;
+}
 </style>
diff --git a/site/src/components/main-panel/logistic-panel.vue b/site/src/components/main-panel/logistic-panel.vue
index 632263d..b40b198 100644
--- a/site/src/components/main-panel/logistic-panel.vue
+++ b/site/src/components/main-panel/logistic-panel.vue
@@ -4,19 +4,68 @@ Please don't remove this comment if you use unmodified file
 -->
 <script setup lang="ts">
 import type {LogisticModel} from '@/scripts/model/store';
-import {computed} from 'vue';
+import {computed, unref} from 'vue';
+import {formatTransport} from '@/scripts/format';
+import {mdiTransferLeft, mdiTransferRight, mdiLock, mdiLockOpenVariant} from '@mdi/js';
 
 const props = defineProps<{
     logistic?: LogisticModel;
 }>();
-
-const countPerSecond = computed(() => props.logistic?.calculateTransport()?.countPerSecond);
+const selectedTransport = computed(() => props.logistic?.selectedTransport);
+const count = computed(() => unref(selectedTransport)?.count || 0);
+const countPerSecond = computed(() => {
+    const _selectedTransport = unref(selectedTransport);
+    const _count = unref(count) || 0;
+    if(_selectedTransport && (_count > 1)) {
+        return formatTransport(_selectedTransport.countPerSecond, _selectedTransport);
+    }
+    return '';
+});
+const totalCountPerSecond = computed(() => {
+    const _selectedTransport = unref(selectedTransport);
+    const _count = unref(count) || 0;
+    if(_selectedTransport) {
+        const _countPerSecond = _count * _selectedTransport.countPerSecond;
+        return formatTransport(_countPerSecond, _selectedTransport);
+    }
+    return '';
+});
+const isLocked = computed(() => props.logistic?.isLocked);
 
 </script>
 
 <template>
-    <v-list-item :title="countPerSecond" />
+    <v-list-item>
+        <v-list-item-title>
+            <div class="font-weight-bold text-caption">
+                {{ selectedTransport?.label }}
+            </div>
+            <div class="transport-menu-item">
+                {{ count }}&nbsp;x&nbsp;
+                <icon-component :image="selectedTransport?.item?.image" />&nbsp;
+                {{ totalCountPerSecond }}&nbsp;
+                <span class="text-caption">{{ countPerSecond }}</span>
+            </div>
+        </v-list-item-title>
+        <template #prepend>
+            <v-btn icon size="x-small" @click="props.logistic?.switchSelectedTransport(-1)">
+                <v-icon :icon="mdiTransferLeft" />
+            </v-btn>
+            <v-btn icon size="x-small" class="mr-2" @click="props.logistic?.switchSelectedTransport(1)">
+                <v-icon :icon="mdiTransferRight" />
+            </v-btn>
+        </template>
+        <template #append>
+            <v-btn icon size="x-small" class="ml-2" @click="props.logistic?.toggleLockSelected()">
+                <v-icon :icon="isLocked ? mdiLock : mdiLockOpenVariant" :color="isLocked ? 'success' : ''" />
+            </v-btn>
+        </template>
+    </v-list-item>
 </template>
 
 <style scoped>
+.transport-menu-item {
+    display: flex;
+    align-items: center;
+}
 </style>
diff --git a/site/src/scripts/data/game-data-holder.ts b/site/src/scripts/data/game-data-holder.ts
index c87c7eb..71c01f8 100644
--- a/site/src/scripts/data/game-data-holder.ts
+++ b/site/src/scripts/data/game-data-holder.ts
@@ -72,7 +72,7 @@ export function useGameDataHolder(gameImplementation: GameImplementation) {
 
     const emptyRecipeDictionary = parsedGameData.emptyRecipeDictionary;
 
-    return {
+    const gameData = {
         gameItemsMap,
         gameItemsArray,
         gameAbstractItems: freezeMap(gameAbstractItems),
@@ -91,6 +91,8 @@ export function useGameDataHolder(gameImplementation: GameImplementation) {
         getImage: (name: string) => parsedGameData.images[name],
         gameDescription: parsedGameData.description,
     };
+    Object.freeze(gameData);
+    return gameData;
 }
 
 export type GameData = ReturnType<typeof useGameDataHolder>;
diff --git a/site/src/scripts/data/game-data-parser.ts b/site/src/scripts/data/game-data-parser.ts
index 7d388b2..d9f0506 100644
--- a/site/src/scripts/data/game-data-parser.ts
+++ b/site/src/scripts/data/game-data-parser.ts
@@ -238,37 +238,52 @@ function createRecipeDictionaryImpl(calculator: Calculator, _recipeDictionary: G
     return recipeDictionaryImpl;
 }
 
-function createLogisticTransportImpl(logistic: GameLogistic, _transport: GameLogisticTransportSerialized, item: GameItem) {
-    const transportImpl: GameLogisticTransportRaw = {
+function createLogisticTransportImpl(logisticImpl: Readonly<GameLogisticImpl>, _transport: GameLogisticTransportSerialized, item: GameItem) {
+    const {calculator, logistic} = logisticImpl;
+    const transport: GameLogisticTransportRaw = {
         ..._transport,
         logistic,
         item,
         countPerSecond: _transport.count / logistic.time,
+        formatCountPerSecond(count: number) {
+            return calculator.formatTransportFlow(this, count);
+        },
     };
-    Object.freeze(transportImpl);
-    const transport: GameLogisticTransport = transportImpl;
-    return transport;
+    Object.freeze(transport);
+    const transportResult: GameLogisticTransport = transport;
+    return transportResult;
 }
 
-function createLogisticImpl(_logistic: GameLogisticSerialized, parsedItems: ParsedItems) {
-    const logisticImpl: GameLogisticRaw = {
+//package private recipe dictionary
+type GameLogisticImpl = {
+    logistic: GameLogistic;
+    calculator: Calculator;
+};
+function createLogisticImpl(_logistic: GameLogisticSerialized, parsedItems: ParsedItems, calculator: Calculator) {
+    const logistic: GameLogisticRaw = {
         ..._logistic,
         transport: [],
     };
+    const logisticImpl: GameLogisticImpl = {
+        logistic,
+        calculator,
+    };
 
-    for(const transport of logisticImpl.transport) {
+    for(const transport of _logistic.transport) {
         const item = parsedItems.get(transport.name);
         if(!item)
             continue;
         const transportImpl = createLogisticTransportImpl(logisticImpl, transport, item);
-        logisticImpl.transport.push(transportImpl);
+        logistic.transport.push(transportImpl);
     }
 
-    logisticImpl.transport.sort((a, b) => (a.countPerSecond - b.countPerSecond));
+    logistic.transport.sort((a, b) => (a.countPerSecond - b.countPerSecond));
 
-    Object.freeze(logisticImpl);
-    const logistic: GameLogistic = logisticImpl;
-    return logistic;
+    Object.freeze(logistic);
+    Object.freeze(logistic.transport);
+    Object.freeze(logistic.items);
+    const logisticResult: GameLogistic = logistic;
+    return logisticResult;
 }
 
 type DescriptionData = {
@@ -338,7 +353,7 @@ export function useGameDataParser(gameImplementation: GameImplementation): Parse
         recipeDictionaryImpl._postInit(parsedItemsImpl);
     }
 
-    const parsedLogistic = gameData.logistic?.map((logistic) => createLogisticImpl(logistic, parsedItems)) || [];
+    const parsedLogistic = gameData.logistic?.map((logistic) => createLogisticImpl(logistic, parsedItems, calculator)) || [];
     Object.freeze(parsedLogistic);
 
     const description = createDescriptionImpl(gameData.description, {minTier, maxTier});
diff --git a/site/src/scripts/filter.ts b/site/src/scripts/filter.ts
index b44ff95..e064915 100644
--- a/site/src/scripts/filter.ts
+++ b/site/src/scripts/filter.ts
@@ -2,6 +2,7 @@
 Author: Alexey Usov (dax@xdax.ru, https://github.com/doubleaxe)
 Please don't remove this comment if you use unmodified file
 */
+import type {GameItemType} from '#types/contants';
 import type {GameItem} from '#types/game-data';
 import {type InjectionKey, provide, reactive, inject} from 'vue';
 import type {GameData} from './data';
@@ -13,6 +14,7 @@ class Filter {
     private _tierEqual = 0;
     private _groupTier = true;
     private _key?: string;
+    private _type?: GameItemType;
     private _direction = 0;
     private _filtered?: GameItem[][];
 
@@ -32,6 +34,9 @@ class Filter {
     get key() { return this._key; }
     set key(key: string | undefined) { this._key = key; this._filtered = undefined; }
 
+    get type() { return this._type; }
+    set type(type: GameItemType | undefined) { this._type = type; this._filtered = undefined; }
+
     get direction() { return this._direction; }
     set direction(direction: number) { this._direction = direction; this._filtered = undefined; }
 
diff --git a/site/src/scripts/format.ts b/site/src/scripts/format.ts
index 6739371..a6be4a2 100644
--- a/site/src/scripts/format.ts
+++ b/site/src/scripts/format.ts
@@ -2,7 +2,7 @@
 Author: Alexey Usov (dax@xdax.ru, https://github.com/doubleaxe)
 Please don't remove this comment if you use unmodified file
 */
-import type {RecipeIOModel} from './model/store';
+import type {RecipeIOModel, TransportModel} from './model/store';
 
 const decimals = 3;
 const upperPrefixes = ['k', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y', 'R', 'Q'];
@@ -49,3 +49,10 @@ export function formatIo(n: number | undefined, io: RecipeIOModel) {
     const format = io.formatCountPerSecond(n);
     return formatNumber(format.count, format.unit);
 }
+
+export function formatTransport(n: number | undefined, transport: TransportModel) {
+    if(n === undefined)
+        return '';
+    const format = transport.formatCountPerSecond(n);
+    return formatNumber(format.count, format.unit);
+}
diff --git a/site/src/scripts/model/blueprint.ts b/site/src/scripts/model/blueprint.ts
index 60a90a8..af02fa4 100644
--- a/site/src/scripts/model/blueprint.ts
+++ b/site/src/scripts/model/blueprint.ts
@@ -30,6 +30,7 @@ export class BlueprintModelImpl {
     private _bulkUpdate = false;
     //could be used by vue to watch items added/removed
     private _itemsGenerationNumber = 0;
+    private readonly _lockedTransport = new Map<string, string>();
 
     public blueprintName = '';
     getDefaultBlueprintName() {
@@ -54,7 +55,21 @@ export class BlueprintModelImpl {
     get solvePrecision() { return this._solvePrecision; }
     set solvePrecision(solvePrecision: number) { this._solvePrecision = solvePrecision; this._$graphChanged(true); }
     get autoSolveGraph() { return this._autoSolveGraph; }
-    set autoSolveGraph(autoSolveGraph: boolean) { this._autoSolveGraph = autoSolveGraph; this._$graphChanged(true); }
+    set autoSolveGraph(autoSolveGraph: boolean) {
+        this._autoSolveGraph = autoSolveGraph;
+        if(autoSolveGraph) {
+            this._$graphChanged(true);
+        }
+    }
+
+    getLockedTransport(logisticName: string) { return this._lockedTransport.get(logisticName); }
+    lockTransport(logisticName: string, transportName: string | undefined) {
+        if(!transportName) {
+            this._lockedTransport.delete(logisticName);
+        } else {
+            this._lockedTransport.set(logisticName, transportName);
+        }
+    }
 
     //types are compatible, just don't use instanceof
     //ReactiveBlueprintItemModel, ReactiveLinkModel are too complex and too mess to implement
@@ -201,31 +216,29 @@ export class BlueprintModelImpl {
     }
 
     private readonly _dirtyItems = new Set<BlueprintItemModel>();
+    private _calculateAll = false;
     solveGraph(manualExecution: boolean) {
-        if(manualExecution) {
-            this._dirtyItems.clear();
+        let dirtyItems: BlueprintItemModel[] = [...this._items.values()];
+        if(!manualExecution && !this._calculateAll) {
+            //filter, because may be already deleted
+            dirtyItems = [...this._dirtyItems].filter((item) => this._items.has(item.key));
         }
-        let items: IterableIterator<BlueprintItemModel> | undefined;
-        //filter, because may be already deleted
-        if(this._dirtyItems.size) {
-            const filteredItems = [...this._dirtyItems].filter((item) => this._items.has(item.key));
-            this._dirtyItems.clear();
-            if(!filteredItems.length) {
-                return;
-            }
-            items = filteredItems.values();
+        this._dirtyItems.clear();
+        this._calculateAll = false;
+        if(!dirtyItems.length) {
+            return;
         }
-        if(!items) {
-            if(!this._items.size) {
-                return;
-            }
-            items = this._items.values();
+
+        const mustSolve = manualExecution || this._autoSolveGraph;
+        //if we just need to reset, and all dirty items are already reset, do nothing
+        if(!mustSolve && dirtyItems.every((item) => (item.solvedCount === undefined))) {
+            return;
         }
 
         const _bulkUpdate = this._bulkUpdate;
         this._bulkUpdate = true;
         try {
-            resetOrSolveGraph(this, items, manualExecution || this._autoSolveGraph, this._solvePrecision);
+            resetOrSolveGraph(this, dirtyItems.values(), mustSolve, this._solvePrecision);
         } finally {
             this._bulkUpdate = _bulkUpdate;
         }
@@ -237,18 +250,23 @@ export class BlueprintModelImpl {
             return;
         }
 
-        let haveItems = false;
-        if(items) {
+        //no items = update all
+        if(items && items.length) {
+            let haveItems = false;
             for(const item of items) {
                 if(item) {
                     this._dirtyItems.add(item);
                     haveItems = true;
                 }
             }
+            if(!haveItems) {
+                //array of undefined
+                return;
+            }
+        } else {
+            this._calculateAll = true;
         }
-        if(!haveItems) {
-            this._dirtyItems.clear();
-        }
+
         if(immediate) {
             this.solveGraph(false);
         } else {
diff --git a/site/src/scripts/model/link.ts b/site/src/scripts/model/link.ts
index 80fe937..b8b0260 100644
--- a/site/src/scripts/model/link.ts
+++ b/site/src/scripts/model/link.ts
@@ -70,34 +70,15 @@ export class LinkModelImpl {
         return undefined;
     }
     _$save(input?: number, output?: number): SavedLink {
-        let selectedTransport: Record<string, string> | undefined = undefined;
-        if(this._logistic.logisticCount) {
-            const _selectedTransport: Record<string, string> = {};
-            for(const logistic of this._logistic.logistic) {
-                if(logistic.selectedTransport) {
-                    _selectedTransport[logistic.name] = logistic.selectedTransport.name;
-                }
-            }
-            if(Object.keys(_selectedTransport).length) {
-                selectedTransport = _selectedTransport;
-            }
-        }
         return {
             l: [
                 input || 0,
                 output || 0,
             ],
-            t: selectedTransport,
         };
     }
     _$load(l: SavedLink, errorCollector: ErrorCollector) {
-        for(const [logisticName, transportName] of Object.entries(l.t || {})) {
-            try {
-                this._logistic.selectTransport(logisticName, transportName);
-            } catch(err) {
-                errorCollector.collectError(err);
-            }
-        }
+        //was used to load transport, now empty
     }
 
     setFlow(_flow?: number) {
diff --git a/site/src/scripts/model/logistic.ts b/site/src/scripts/model/logistic.ts
index 62bd994..adf1b99 100644
--- a/site/src/scripts/model/logistic.ts
+++ b/site/src/scripts/model/logistic.ts
@@ -5,68 +5,111 @@ Please don't remove this comment if you use unmodified file
 
 import type {GameLogistic, GameLogisticTransport} from '#types/game-data';
 import {binarySearch} from '../util';
-import type {LinkModel, LogisticModel, LogisticSetModel, TransportModel} from './store';
+import type {BlueprintModel, LinkModel, LogisticModel, LogisticSetModel, TransportModel} from './store';
 
 
 export class TransportModelImpl {
     private readonly _transport: GameLogisticTransport;
-    private readonly _flow: number;
-    private readonly _count: number;
+    private readonly _index: number;
+    private readonly _link: LinkModel;
 
-    constructor(transport: GameLogisticTransport, flow: number) {
-        this._transport = transport;
-        this._flow = flow;
-        this._count = Math.ceil(flow / transport.countPerSecond);
+    constructor(_transport: GameLogisticTransport, _index: number, _link: LinkModel) {
+        this._transport = _transport;
+        this._index = _index;
+        this._link = _link;
     }
 
-    get flow() { return this._flow; }
-    get transport() { return this._transport; }
-    get count() { return this._count; }
+    get name() { return this._transport.name; }
+    get index() { return this._index; }
     get countPerSecond() { return this._transport.countPerSecond; }
+    get count() {
+        const flow = this._link.flow;
+        return Math.ceil((flow || 0) / this._transport.countPerSecond);
+    }
+    get item() { return this._transport.item; }
+    get label() { return this._transport.label || this._transport.item.label; }
+    formatCountPerSecond(count: number) { return this._transport.formatCountPerSecond(count); }
 }
 
 
 export class LogisticModelImpl {
     private readonly _logistic: GameLogistic;
-    private _selectedTransport?: GameLogisticTransport;
     private readonly _link: LinkModel;
-    private _cachedTransport?: TransportModel;
+    private readonly _globals: BlueprintModel;
 
-    constructor(_logistic: GameLogistic, _link: LinkModel) {
+    private _selectedTransport?: TransportModel;
+
+    constructor(_logistic: GameLogistic, _link: LinkModel, _globals: BlueprintModel) {
         this._logistic = _logistic;
         this._link = _link;
+        this._globals = _globals;
     }
 
-    selectTransport(transportName: string | undefined) {
-        if(transportName) {
-            const selectedTransport = this._logistic.transport.find((t) => (t.name == transportName));
-            if(!selectedTransport) {
-                throw new Error(`Transport ${transportName} not found, for logistic ${this._logistic.name}`);
-            }
-            this._selectedTransport = selectedTransport;
-        } else {
-            this._selectedTransport = undefined;
-        }
+    get isLocked() {
+        const selectedTransport = this.selectedTransport;
+        if(!selectedTransport)
+            return false;
+        const lockedTransportName = this._globals.getLockedTransport(this._logistic.name);
+        return lockedTransportName == selectedTransport.name;
+    }
+    toggleLockSelected() {
+        const selectedTransport = this.selectedTransport;
+        if(!selectedTransport)
+            return;
+        const isLocked = this.isLocked;
+        this._globals.lockTransport(
+            this._logistic.name,
+            isLocked ? undefined : selectedTransport.name,
+        );
     }
-    get selectedTransport() { return this._selectedTransport; }
-    get transport() { return this._logistic.transport; }
     get name() { return this._logistic.name; }
+    get label() { return this._logistic.label; }
+    get selectedTransport() {
+        if(!this._selectedTransport) {
+            this.resetSelectedTransport();
+        }
+        return this._selectedTransport;
+    }
 
-    calculateTransport() {
+    resetSelectedTransport() {
         const flow = this._link.flow;
         if(!flow)
             return undefined;
-        if(this._cachedTransport?.flow === flow)
-            return this._cachedTransport;
 
-        let selectedTransport = this._selectedTransport;
-        if(!selectedTransport) {
-            const transport = this._logistic.transport;
+        const transport = this._logistic.transport;
+        let selectedIndex = -1;
+        const lockedTransportName = this._globals.getLockedTransport(this._logistic.name);
+        if(lockedTransportName) {
+            selectedIndex = transport.findIndex((t) => (t.name == lockedTransportName));
+        }
+        if(selectedIndex < 0) {
             const index = binarySearch(transport, (t) => (t.countPerSecond >= flow));
-            selectedTransport = (index < transport.length) ? transport[index] : transport[transport.length - 1];
+            selectedIndex = (index < transport.length) ? index : transport.length - 1;
         }
-        this._cachedTransport = new TransportModelImpl(selectedTransport, flow);
-        return this._cachedTransport;
+        const selectedGameTransport = transport[selectedIndex];
+        this._selectedTransport = new TransportModelImpl(
+            selectedGameTransport,
+            selectedIndex,
+            this._link,
+        );
+        return this._selectedTransport;
+    }
+    switchSelectedTransport(offset: number) {
+        const selectedTransport = this.selectedTransport;
+        if(!selectedTransport)
+            return;
+        const transport = this._logistic.transport;
+        let selectedIndex = selectedTransport.index + offset;
+        if(selectedIndex < 0)
+            selectedIndex = 0;
+        if(selectedIndex >= transport.length)
+            selectedIndex = transport.length - 1;
+        const selectedGameTransport = transport[selectedIndex];
+        this._selectedTransport = new TransportModelImpl(
+            selectedGameTransport,
+            selectedIndex,
+            this._link,
+        );
     }
 }
 
@@ -75,9 +118,9 @@ export class LogisticSetModelImpl {
     private readonly _logisticMap = new Map<string, LogisticModel>();
 
     constructor(link?: LinkModel, logistic?: GameLogistic[]) {
-        if(link && logistic) {
+        if(link && link.input?.owner && logistic) {
             for(const logisticItem of logistic) {
-                const logisticModel = new LogisticModelImpl(logisticItem, link);
+                const logisticModel = new LogisticModelImpl(logisticItem, link, link.input?.owner);
                 this._logisticMap.set(logisticItem.name, logisticModel);
             }
         }
@@ -86,13 +129,10 @@ export class LogisticSetModelImpl {
     get logistic() { return this._logisticMap.values(); }
     get logisticCount() { return this._logisticMap.size; }
     logisticByName(name: string) { return this._logisticMap.get(name); }
-
-    selectTransport(logisticName: string, transportName: string | undefined) {
-        const logisticModel = this._logisticMap.get(logisticName);
-        if(!logisticModel) {
-            throw new Error(`Logistic ${logisticName} not found`);
+    resetSelectedTransport() {
+        for(const logisticModel of this.logistic) {
+            logisticModel.resetSelectedTransport();
         }
-        logisticModel.selectTransport(transportName);
     }
 
     private static _emptyLogisticSet = new LogisticSetModelImpl();
diff --git a/site/src/scripts/model/saved-blueprint.ts b/site/src/scripts/model/saved-blueprint.ts
index 05b6772..6bb0dbf 100644
--- a/site/src/scripts/model/saved-blueprint.ts
+++ b/site/src/scripts/model/saved-blueprint.ts
@@ -24,5 +24,4 @@ export type SavedItem = {
 
 export type SavedLink = {
     l: number[];
-    t?: Record<string, string>;
 };