diff --git a/app.py b/app.py
index 18a3204..3f9b256 100644
--- a/app.py
+++ b/app.py
@@ -1,1030 +1,1068 @@
 # -*- coding: utf-8 -*-
 
+import cachetools
 import collections
 import decorator
 import flask
 import iiif_prezi.factory
 import json
 from markupsafe import Markup
 import mwapi
 import mwoauth
 import os
 import random
 import re
 import requests
 import requests_oauthlib
 import stat
 import string
+import threading
 import toolforge
 import urllib.parse
 import yaml
 
 from exceptions import WrongDataValueType
 from toolforge_i18n.flask_things import ToolforgeI18n, interface_language_code_from_request, message, pop_html_lang, push_html_lang
 from toolforge_i18n.language_info import lang_autonym
 import messages
 
 
 app = flask.Flask(__name__)
 app.jinja_env.add_extension('jinja2.ext.do')
 
 def interface_language_code(translations):
     if 'uselang' in flask.request.args:
         return interface_language_code_from_request(translations)
     elif flask.session.get('interface_language_code') in translations:
         return flask.session['interface_language_code']
     else:
         return interface_language_code_from_request(translations)
 
 i18n = ToolforgeI18n(app, interface_language_code)
 
 user_agent = toolforge.set_user_agent('lexeme-forms', email='mail@lucaswerkmeister.de')
 
 requests_session = requests.Session()
 requests_session.headers.update({
     'Accept': 'application/json',
     'User-Agent': user_agent,
 })
 
 default_property = 'P18'
 
+# maps property IDs to message keys for “… with no region specified:” list labels
+# note: currently, these must be item-type properties;
+# support for other data types (e.g. P1684 inscription) would need more work
 depicted_properties = {
-    # first label is used in dropdown,
-    # second forms “… with no region specified” list label
-    'P180': ['depicts', 'Depicted'],
-    'P9664': ['named place on map', 'Named places on map'],
-    # note: currently, these must be item-type properties;
-    # support for other data types (e.g. P1684 inscription) needs more work
+    'P180': 'image-depicted-without-region',
+    'P9664': 'image-named-places-on-map-without-region',
 }
 app.add_template_global(lambda: depicted_properties, 'depicted_properties')
+app.add_template_global(
+    lambda: {property_id: message(key) for property_id, key in depicted_properties.items()},
+    'depicted_properties_messages'
+)
 
 @decorator.decorator
 def read_private(func, *args, **kwargs):
     try:
         f = args[0]
         fd = f.fileno()
     except AttributeError:
         pass
     except IndexError:
         pass
     else:
         mode = os.stat(fd).st_mode
         if (stat.S_IRGRP | stat.S_IROTH) & mode:
             raise ValueError(f'{getattr(f, "name", "config file")} is readable to others, '
                              'must be exclusively user-readable!')
     return func(*args, **kwargs)
 
 has_config = app.config.from_file('config.yaml', load=read_private(yaml.safe_load), silent=True)
 if has_config:
     consumer_token = mwoauth.ConsumerToken(app.config['OAUTH']['consumer_key'], app.config['OAUTH']['consumer_secret'])
 else:
     print('config.yaml file not found, assuming local development setup')
     app.secret_key = 'fake'
 
 def anonymous_session(domain):
     host = 'https://' + domain
     return mwapi.Session(host=host, user_agent=user_agent, formatversion=2)
 
 def authenticated_session(domain):
     if 'oauth_access_token' not in flask.session:
         return None
     host = 'https://' + domain
     access_token = mwoauth.AccessToken(**flask.session['oauth_access_token'])
     auth = requests_oauthlib.OAuth1(client_key=consumer_token.key, client_secret=consumer_token.secret,
                                     resource_owner_key=access_token.key, resource_owner_secret=access_token.secret)
     return mwapi.Session(host=host, auth=auth, user_agent=user_agent, formatversion=2)
 
 
 @decorator.decorator
 def enableCORS(func, *args, **kwargs):
     rv = func(*args, **kwargs)
     response = flask.make_response(rv)
     response.headers['Access-Control-Allow-Origin'] = '*'
     return response
 
 
 @app.route('/', methods=['GET', 'POST'])
 def index():
     if flask.request.method == 'POST':
         if 'item_id' in flask.request.form:
             item_id = parse_item_id_input(flask.request.form['item_id'])
             property_id = flask.request.form.get('property_id')
             if 'manifest' in flask.request.form or 'preview' in flask.request.form:
                 manifest_url = full_url('iiif_manifest_with_property', item_id=item_id, property_id=property_id or default_property)
                 if 'manifest' in flask.request.form:
                     return flask.redirect(manifest_url)
                 else:
                     mirador_protocol = 'https' if manifest_url.startswith('https') else 'http'
                     mirador_url = mirador_protocol + '://tools.wmflabs.org/mirador/?manifest=' + manifest_url
                     return flask.redirect(mirador_url)
             else:
                 if property_id:
                     return flask.redirect(flask.url_for('item_and_property', item_id=item_id, property_id=property_id))
                 else:
                     return flask.redirect(flask.url_for('item', item_id=item_id))
         if 'iiif_region' in flask.request.form:
             iiif_region = flask.request.form['iiif_region']
             property_id = flask.request.form.get('property_id')
             if property_id:
                 return flask.redirect(flask.url_for('iiif_region_and_property', iiif_region=iiif_region, property_id=property_id))
             else:
                 return flask.redirect(flask.url_for('iiif_region', iiif_region=iiif_region))
         if 'image_title' in flask.request.form:
             image_title = parse_image_title_input(flask.request.form['image_title'])
             return flask.redirect(flask.url_for('file', image_title=image_title))
     return flask.render_template('index.html',
                                  labels=load_labels(['P2677', 'P180', 'P9664', 'P18']))
 
 def parse_item_id_input(input):
     # note: “item” here (and elsewhere in the tool, though not sure if *everywhere* else) refers to any non-MediaInfo entity type
     pattern = r'''
     (?: # can begin with a wd:, data:, or entity page URL prefix
     http://www\.wikidata\.org/entity/ |
     https://www\.wikidata\.org/wiki/Special:EntityData/ |
     https://www\.wikidata\.org/wiki/
     )?
     ( # the entity ID itself
     [QPL][1-9][0-9]* |
     L[1-9][0-9]*-[FS][1-9][0-9]*
     )
     (?: # optional remaining URL parts
     [?#].*
     )?
     '''
     if match := re.fullmatch(pattern, input, re.VERBOSE):
         return match.group(1)  # unquote() not needed, group 1 cannot contain % characters
 
     url = urllib.parse.urlparse(input)
     if url.scheme == 'https' and url.hostname == 'www.wikidata.org' and url.path == '/w/index.php':
         query = urllib.parse.parse_qs(url.query)
         title = query.get('title', [''])[-1]
         pattern = r'''
         (Q[1-9][0-9]*) |
         Property:(P[1-9][0-9]*) |
         Lexeme:(L[1-9][0-9]*)
         '''
         if match := re.fullmatch(pattern, title, re.VERBOSE):
             return match.group(1)
 
     flask.abort(400, Markup(r'Cannot parse an entity ID from <kbd>{}</kbd>.').format(input))
 
 def parse_image_title_input(input):
     if '.' in input and ':' not in input:
         return input.replace(" ", "_")
 
     if input.startswith('File:'):
         return input[len('File:'):].replace(' ', '_')
 
     pattern = r'''
     (?: # URL prefix
     https://commons\.wikimedia\.org/wiki/File: |
     https://commons\.wikimedia\.org/wiki/Special:FilePath/
     )
     ( # the file name itself, without File:
     [^/?#]* # very lenient :)
     )
     (?: # optional remaining URL parts
     [?#].*
     )?
     '''
     if match := re.fullmatch(pattern, input, re.VERBOSE):
         return urllib.parse.unquote(match.group(1))
 
     url = urllib.parse.urlparse(input)
     if url.scheme == 'https' and url.hostname == 'commons.wikimedia.org' and url.path == '/w/index.php':
         query = urllib.parse.parse_qs(url.query)
         title = query.get('title', [''])[-1]
         if title.startswith('File:'):
             return title[len('File:'):]
 
     pattern = r'''
     (?: # can begin with an sdc: or sdcdata: URL prefix
     https://commons\.wikimedia\.org/entity/ |
     https://commons\.wikimedia\.org/wiki/Special:EntityData/
     )?
     ( # the entity ID itself
     M[1-9][0-9]*
     )
     '''
     if match := re.fullmatch(pattern, input, re.VERBOSE):
         entity_id = match.group(1)  # unquote() not needed, group 1 cannot contain % characters
         session = anonymous_session('commons.wikimedia.org')
         title = session.get(action='query',
                             pageids=[entity_id[1:]],
                             redirects=True,
                             formatversion=2)['query']['pages'][0]['title']
         return title[len('File:'):].replace(' ', '_')
 
     flask.abort(400, Markup(r'Cannot parse a file name from <kbd>{}</kbd>.').format(input))
 
 @app.get('/settings/')
 def settings():
     return flask.render_template(
         'settings.html',
         languages={
             language_code: lang_autonym(language_code)
             for language_code in i18n.translations
         },
     )
 
 @app.post('/settings/')
 def settings_save():
     if 'interface-language-code' in flask.request.form:
         flask.session['interface_language_code'] = flask.request.form['interface-language-code'][:20]
     return flask.redirect(flask.url_for('index'))
 
 @app.route('/login')
 def login():
     redirect, request_token = mwoauth.initiate('https://www.wikidata.org/w/index.php', consumer_token, user_agent=user_agent)
     flask.session['oauth_request_token'] = dict(zip(request_token._fields, request_token))
     return flask.redirect(redirect)
 
 @app.route('/oauth/callback')
 def oauth_callback():
     oauth_request_token = flask.session.pop('oauth_request_token', None)
     if oauth_request_token is None:
         return flask.render_template('oauth-callback-without-request-token.html',
                                      already_logged_in='oauth_access_token' in flask.session,
                                      query_string=flask.request.query_string.decode('utf8'))
     access_token = mwoauth.complete('https://www.wikidata.org/w/index.php', consumer_token, mwoauth.RequestToken(**oauth_request_token), flask.request.query_string, user_agent=user_agent)
     flask.session['oauth_access_token'] = dict(zip(access_token._fields, access_token))
     flask.session.permanent = True
     flask.session.pop('_csrf_token', None)
     return flask.redirect(flask.url_for('index'))
 
 @app.route('/logout')
 def logout():
     flask.session.pop('oauth_request_token', None)
     flask.session.permanent = False
     return flask.redirect(flask.url_for('index'))
 
 @app.route('/item/<item_id>')
 def item(item_id):
     return item_and_property(item_id, property_id=default_property)
 
 @app.route('/item/<item_id>/<property_id>')
 def item_and_property(item_id, property_id):
     item = load_item_and_property(item_id, property_id, include_depicteds=True)
     if 'image_title' not in item:
         return flask.render_template('item-without-image.html', **item)
     return flask.render_template('item.html', **item)
 
 @app.route('/iiif/<item_id>/manifest.json')
 def iiif_manifest(item_id):
     return flask.redirect(flask.url_for('iiif_manifest_with_property', item_id=item_id, property_id=default_property))
 
 @app.route('/iiif/<item_id>/<property_id>/manifest.json')
 @enableCORS
 def iiif_manifest_with_property(item_id, property_id):
     item = load_item_and_property(item_id, property_id, include_description=True, include_metadata=True)
     if 'image_title' not in item:
         return '', 404
     manifest = build_manifest(item)
     return flask.jsonify(manifest.toJSON(top=True))
 
 @app.route('/iiif/<item_id>/list/annotations.json')
 def iiif_annotations(item_id):
     return iiif_annotations_with_property(item_id, property_id=default_property)
 
 @app.route('/iiif/<item_id>/<property_id>/list/annotations.json')
 @enableCORS
 def iiif_annotations_with_property(item_id, property_id):
     item = load_item_and_property(item_id, property_id, include_depicteds=True)
 
     url = flask.url_for('iiif_annotations_with_property',
                         item_id=item_id,
                         property_id=property_id,
                         _external=True,
                         _scheme=flask.request.headers.get('X-Forwarded-Proto', 'http'))
     annolist = {
         '@id': url,
         '@type': 'sc:AnnotationList',
         'label': 'Annotations for ' + item['label']['value'],
         'resources': []
     }
 
     if 'image_title' not in item:
         return flask.jsonify(annolist)
 
     canvas_url = url[:-len('list/annotations.json')] + 'canvas/c0.json'
     # Although the pct canvas is OK for the image API, we need to target
     # canvas coordinates with the annotations, so we need the w,h
     image_info = load_image_info(item['image_title'])
     width, height = int(image_info['thumbwidth']), int(image_info['thumbheight'])
 
     for depicted in item['depicteds']:
         if 'item_id' not in depicted:
             continue  # somevalue/novalue not supported for now
         link = 'http://www.wikidata.org/entity/' + Markup.escape(depicted['item_id'])
         label = depicted['label']['value']
         # We can put a lot more in here, but minimum for now, and ensure works in Mirador
         anno = {
             '@id': '#' + depicted['statement_id'],
             '@type': 'oa:Annotation',
             'motivation': 'identifying',
             'on': canvas_url,
             'resource': {
                 '@id': link,
                 'format': 'text/plain',
                 'chars': label
             }
         }
         iiif_region = depicted.get('iiif_region', None)
         if iiif_region:
             parts = iiif_region.replace('pct:', '').split(',')
             x = int(float(parts[0]) * width / 100)
             y = int(float(parts[1]) * height / 100)
             w = int(float(parts[2]) * width / 100)
             h = int(float(parts[3]) * height / 100)
             anno['on'] = anno['on'] + '#xywh=' + ','.join(str(d) for d in [x, y, w, h])
         annolist['resources'].append(anno)
     return flask.jsonify(annolist)
 
 @app.route('/iiif_region/<iiif_region>')
 def iiif_region(iiif_region):
     return iiif_region_and_property(iiif_region, default_property)
 
 @app.route('/iiif_region/<iiif_region>/<property_id>')
 def iiif_region_and_property(iiif_region, property_id):
     iiif_region_string = '"' + iiif_region.replace('\\', '\\\\').replace('"', '\\"') + '"'
     property_claim_predicates = ' '.join(f'p:{property_id}' for property_id in depicted_properties)
     query = '''
       SELECT DISTINCT ?item WHERE {
         VALUES ?p { %s }
         ?item ?p [ pq:P2677 %s ].
       }
     ''' % (property_claim_predicates, iiif_region_string)
     query_results = requests_session.get('https://query.wikidata.org/sparql',
                                          params={'query': query}).json()
 
     items = []
     items_without_image = []
     for result in query_results['results']['bindings']:
         item_id = result['item']['value'][len('http://www.wikidata.org/entity/'):]
         item = load_item_and_property(item_id, property_id, include_depicteds=True)
         if 'image_title' not in item:
             items_without_image.append(item_id)
         else:
             items.append(item)
 
     return flask.render_template('iiif_region.html', items=items, items_without_image=items_without_image)
 
 @app.route('/file/<image_title>')
 def file(image_title):
     image_title_ = image_title.replace(' ', '_')
     if image_title_.startswith('File:'):
         image_title_ = image_title_[len('File:'):]
     if image_title_ != image_title:
         return flask.redirect(flask.url_for('file', image_title=image_title_, **flask.request.args))
     file = load_file(image_title.replace('_', ' '))
     if not file:
         return flask.render_template('file-not-found.html', title=image_title), 404
     return flask.render_template('file.html', **file)
 
 @app.route('/api/v1/depicteds_html/file/<image_title>')
 @enableCORS
 def file_depicteds_html(image_title):
     file = load_file(image_title.replace('_', ' '))
     if not file:
         return flask.render_template('file-not-found.html', title=image_title), 404
     return flask.render_template('depicteds.html', depicteds=file['depicteds'])
 
 @app.route('/api/v1/add_statement/<domain>', methods=['POST'])
 def api_add_statement(domain):
     entity_id = flask.request.form.get('entity_id')
     snaktype = flask.request.form.get('snaktype')
     item_id = flask.request.form.get('item_id')
     property_id = flask.request.form.get('property_id', 'P180')
     request_csrf_token = flask.request.form.get('_csrf_token')
     if not entity_id or not snaktype or not request_csrf_token:
         return 'Incomplete form data', 400
     if (snaktype == 'value') != (item_id is not None):
         return 'Inconsistent form data', 400
     if snaktype not in {'value', 'somevalue', 'novalue'}:
         return 'Bad snaktype', 400
     if property_id not in depicted_properties:
         return 'Bad property ID', 400
 
     if request_csrf_token != csrf_token():
         return 'Wrong CSRF token (try reloading the page).', 403
 
     if not flask.request.referrer.startswith(full_url('index')):
         return 'Wrong Referer header', 403
 
     if domain not in {'www.wikidata.org', 'commons.wikimedia.org'}:
         return 'Unsupported domain', 403
 
     session = authenticated_session(domain)
     if session is None:
         return 'Not logged in', 403
 
     token = session.get(action='query', meta='tokens', type='csrf')['query']['tokens']['csrftoken']
     depicted = {
         'snaktype': snaktype,
         'property_id': property_id,
     }
     if snaktype == 'value':
         value = json.dumps({'entity-type': 'item', 'id': item_id})
         depicted['item_id'] = item_id
         labels = load_labels([item_id])
         depicted['label'] = labels[item_id]
     else:
         value = None
         if snaktype == 'somevalue':
             depicted['label'] = messages.somevalue(flask.g.interface_language_code)
         elif snaktype == 'novalue':
             depicted['label'] = messages.novalue(flask.g.interface_language_code)
         else:
             raise ValueError('Unknown snaktype')
     try:
         response = session.post(action='wbcreateclaim',
                                 entity=entity_id,
                                 snaktype=snaktype,
                                 property=property_id,
                                 value=value,
                                 token=token)
     except mwapi.errors.APIError as error:
         return str(error), 500
     statement_id = response['claim']['id']
     depicted['statement_id'] = statement_id
     return flask.jsonify(depicted=depicted,
                          depicted_item_link=depicted_item_link(depicted))
 
 @app.route('/api/v2/add_qualifier/<domain>', methods=['POST'])
 def api_add_qualifier(domain):
     statement_id = flask.request.form.get('statement_id')
     iiif_region = flask.request.form.get('iiif_region')
     request_csrf_token = flask.request.form.get('_csrf_token')
     qualifier_hash = flask.request.form.get('qualifier_hash')  # optional
     if not statement_id or not iiif_region or not request_csrf_token:
         return 'Incomplete form data', 400
 
     if request_csrf_token != csrf_token():
         return 'Wrong CSRF token (try reloading the page).', 403
 
     if not flask.request.referrer.startswith(full_url('index')):
         return 'Wrong Referer header', 403
 
     if domain not in {'www.wikidata.org', 'commons.wikimedia.org'}:
         return 'Unsupported domain', 403
 
     session = authenticated_session(domain)
     if session is None:
         return 'Not logged in', 403
 
     token = session.get(action='query', meta='tokens', type='csrf')['query']['tokens']['csrftoken']
     try:
         response = session.post(action='wbsetqualifier', claim=statement_id, property='P2677',
                                 snaktype='value', value=('"' + iiif_region + '"'),
                                 **({'snakhash': qualifier_hash} if qualifier_hash else {}),
                                 summary='region drawn manually using [[d:User:Lucas Werkmeister/Wikidata Image Positions|Wikidata Image Positions tool]]',
                                 token=token)
     except mwapi.errors.APIError as error:
         if error.code == 'no-such-qualifier':
             return 'This region does not exist (anymore) – it may have been edited in the meantime. Please try reloading the page.', 500
         return str(error), 500
     # find hash of qualifier
     for qualifier in response['claim']['qualifiers']['P2677']:
         if qualifier['snaktype'] == 'value' and qualifier['datavalue']['value'] == iiif_region:
             return flask.jsonify(qualifier_hash=qualifier['hash'])
     return flask.jsonify(qualifier_hash=None)
 
 
 # https://iiif.io/api/image/2.0/#region
 @app.template_filter()
 def iiif_region_to_style(iiif_region):
     try:
         if iiif_region == 'full':
             return 'left: 0px; top: 0px; width: 100%; height: 100%;'
         if iiif_region.startswith('pct:'):
             left, top, width, height = iiif_region[len('pct:'):].split(',')
             z_index = int(1_000_000 / (float(width) * float(height)))
             return 'left: %s%%; top: %s%%; width: %s%%; height: %s%%; z-index: %s;' % (left, top, width, height, z_index)
         left, top, width, height = iiif_region.split(',')
         z_index = int(1_000_000_000 / (int(width) * int(height)))
         return 'left: %spx; top: %spx; width: %spx; height: %spx; z-index: %s;' % (left, top, width, height, z_index)
     except ValueError:
         flask.abort(400, Markup('Invalid IIIF region <kbd>{}</kbd> encountered. Remove the invalid qualifier manually, then reload.').format(iiif_region))
 
 @app.template_filter()
 def user_link(user_name):
     return (Markup(r'<a href="https://www.wikidata.org/wiki/User:') +
             Markup.escape(user_name.replace(' ', '_')) +
             Markup(r'">') +
             Markup(r'<bdi>') +
             Markup.escape(user_name) +
             Markup(r'</bdi>') +
             Markup(r'</a>'))
 
 @app.template_global()
 def item_link(item_id, label):
     return (Markup(r'<a href="http://www.wikidata.org/entity/') +
             Markup.escape(item_id) +
             Markup(r'" ') +
             push_html_lang(label['language']) +
             Markup(r' data-entity-id="') +
             Markup.escape(item_id) +
             Markup(r'">') +
             Markup.escape(label['value']) +
             Markup(r'</a') +
             pop_html_lang(label['language']) +
             Markup(r'>'))
 
 @app.template_filter()
 def depicted_item_link(depicted):
     if 'item_id' in depicted:
         return item_link(depicted['item_id'], depicted['label'])
     else:
         return (Markup(r'<span class="wd-image-positions--snaktype-not-value" ') +
                 push_html_lang(depicted['label']['language']) +
                 Markup(r'>') +
                 Markup.escape(depicted['label']['value']) +
                 Markup(r'</span') +
                 pop_html_lang(depicted['label']['language']) +
                 Markup(r'>'))
 
 @app.template_global()
 def csrf_token() -> str:
     if '_csrf_token' not in flask.session:
         flask.session['_csrf_token'] = ''.join(random.choice(string.ascii_letters + string.digits) for _ in range(64))
     return flask.session['_csrf_token']
 
 @app.template_global()
 def authentication_area():
     if 'OAUTH' not in app.config:
         return Markup()
 
     session = authenticated_session('www.wikidata.org')
     if session is None:
         userinfo = None
     else:
         try:
             userinfo = session.get(action='query',
                                    meta='userinfo')['query']['userinfo']
         except mwapi.errors.APIError as e:
             if e.code == 'mwoauth-invalid-authorization':
                 # e. g. consumer version updated, treat as not logged in
                 flask.session.pop('oauth_access_token')
                 userinfo = None
             else:
                 raise e
 
     if userinfo is None:
         return (Markup(r'<a id="login" class="navbar-text" href="') +
                 Markup.escape(flask.url_for('login')) +
                 Markup(r'">') +
                 message('nav-login') +
                 Markup(r'</a>'))
 
     user_name = userinfo['name']
     return (Markup(r'<span class="navbar-text">') +
             Markup(message('nav-logged-in', user_link=user_link(user_name), user_name=user_name)) +
             Markup(r'</span><span id="csrf_token" style="display: none;">') +
             Markup.escape(csrf_token()) +
             Markup(r'</span>'))
 
 @app.template_global()
 def user_logged_in():
     return 'oauth_access_token' in flask.session
 
 @app.errorhandler(WrongDataValueType)
 def handle_wrong_data_value_type(error):
     response = flask.render_template('wrong-data-value-type.html',
                                      expected_data_value_type=error.expected_data_value_type,
                                      actual_data_value_type=error.actual_data_value_type)
     return response, error.status_code
 
 
 def load_item_and_property(item_id, property_id,
                            include_depicteds=False, include_description=False, include_metadata=False):
     props = ['claims']
     if include_description:
         props.append('descriptions')
 
     session = anonymous_session('www.wikidata.org')
     api_response = session.get(action='wbgetentities',
                                props=props,
                                ids=item_id,
                                languages=[flask.g.interface_language_code],
                                languagefallback=True)
     item_data = api_response['entities'][item_id]
     item = {
         'entity_id': item_id,
     }
     entity_ids = [item_id]
 
     if include_description:
         item['description'] = item_data.get('descriptions', {})\
                                        .get(flask.g.interface_language_code)
 
     image_datavalue = best_value(item_data, property_id)
     if image_datavalue is not None:
         if image_datavalue['type'] != 'string':
             raise WrongDataValueType(expected_data_value_type='string', actual_data_value_type=image_datavalue['type'])
         image_title = image_datavalue['value']
         item.update(load_image(image_title))
 
     if include_depicteds:
         depicteds = depicted_items(item_data)
         for depicted in depicteds:
             if 'item_id' in depicted:
                 entity_ids.append(depicted['item_id'])
 
     if include_metadata:
         metadata = entity_metadata(item_data)
         entity_ids += metadata.keys()
 
     labels = load_labels(entity_ids)
     item['label'] = labels[item_id]
 
     if include_depicteds:
         for depicted in depicteds:
             depicted['label'] = depicted_label(depicted, labels)
         item['depicteds'] = depicteds
 
     if include_metadata:
         item['metadata'] = []
         for property_id, values in metadata.items():
             for value in values:
                 item['metadata'].append({
                     'label': labels[property_id],
                     'value': value
                 })
 
     return item
 
 def load_file(image_title):
     image = load_image(image_title)
     if image is None:
         return None
 
     entity_id = 'M' + str(image['image_page_id'])
     file = {
         'entity_id': entity_id,
         **image,
     }
     entity_ids = []
 
     session = anonymous_session('commons.wikimedia.org')
     api_response = session.get(action='wbgetentities',
                                props=['claims'],
                                ids=[entity_id])
     file_data = api_response['entities'][entity_id]
 
     depicteds = depicted_items(file_data)
     for depicted in depicteds:
         if 'item_id' in depicted:
             entity_ids.append(depicted['item_id'])
 
     labels = load_labels(entity_ids)
 
     for depicted in depicteds:
         depicted['label'] = depicted_label(depicted, labels)
     file['depicteds'] = depicteds
 
     return file
 
 def load_image(image_title):
     """Load the metadata of an image file on Commons, without structured data."""
     session = anonymous_session('commons.wikimedia.org')
 
     query_params = query_default_params()
     query_params.setdefault('titles', set()).update(['File:' + image_title])
     image_attribution_query_add_params(query_params, image_title)
     image_url_query_add_params(query_params, image_title)
     image_size_query_add_params(query_params, image_title)
 
     query_response = session.get(**query_params)
     page = query_response_page(query_response, 'File:' + image_title)
     if page.get('missing', False) or page.get('invalid', False):
         return None
 
     page_id = page['pageid']
     attribution = image_attribution_query_process_response(query_response, image_title)
     url = image_url_query_process_response(query_response, image_title)
     width, height = image_size_query_process_response(query_response, image_title)
     return {
         'image_page_id': page_id,
         'image_title': image_title,
         'image_attribution': attribution,
         'image_url': url,
         'image_width': width,
         'image_height': height,
     }
 
 def depicted_label(depicted, labels):
     if 'item_id' in depicted:
         return labels[depicted['item_id']]
     elif depicted['snaktype'] == 'somevalue':
         return messages.somevalue(flask.g.interface_language_code)
     elif depicted['snaktype'] == 'novalue':
         return messages.novalue(flask.g.interface_language_code)
     else:
         raise ValueError('depicted has neither item ID nor somevalue/novalue snaktype')
 
 def load_image_info(image_title):
     file_title = 'File:' + image_title.replace(' ', '_')
     session = anonymous_session('commons.wikimedia.org')
     response = session.get(action='query', prop='imageinfo', iiprop='url|mime',
                            iiurlwidth=8000, titles=file_title)
 
     return response['query']['pages'][0]['imageinfo'][0]
 
 def full_url(endpoint, **kwargs):
     return flask.url_for(endpoint, _external=True, _scheme=flask.request.headers.get('X-Forwarded-Proto', 'http'), **kwargs)
 
 def current_url():
     return full_url(flask.request.endpoint, **flask.request.view_args)
 
 def language_string_wikibase_to_iiif(language_string):
     if language_string is None:
         return None
     return {language_string['language']: language_string['value']}
 
 def build_manifest(item):
     base_url = current_url()[:-len('/manifest.json')]
     fac = iiif_prezi.factory.ManifestFactory()
     fac.set_base_prezi_uri(base_url)
     fac.set_debug('error')
 
     iiif_item_label = language_string_wikibase_to_iiif(item['label'])
     iiif_item_description = language_string_wikibase_to_iiif(item['description'])
 
     manifest = fac.manifest(ident='manifest.json')
     if iiif_item_label is not None:
         manifest.label = iiif_item_label
     if iiif_item_description is not None:
         manifest.description = iiif_item_description
     attribution = image_attribution(item['image_title'])
     if attribution is not None:
         manifest.attribution = attribution['attribution_text']
         manifest.license = attribution['license_url']
     for metadata in item['metadata']:
         manifest.set_metadata({
             'label': language_string_wikibase_to_iiif(metadata['label']),
             'value': metadata['value'],
         })
     sequence = manifest.sequence(ident='normal', label='default order')
     canvas = sequence.canvas(ident='c0')
     if iiif_item_label is not None:
         canvas.label = iiif_item_label
     annolist = fac.annotationList(ident='annotations', label='Things depicted on this canvas')
     canvas.add_annotationList(annolist)
     populate_canvas(canvas, item, fac)
 
     return manifest
 
 def populate_canvas(canvas, item, fac):
     image_info = load_image_info(item['image_title'])
     width, height = image_info['thumbwidth'], image_info['thumbheight']
     canvas.set_hw(height, width)
     anno = canvas.annotation(ident='a0')
     img = anno.image(ident=image_info['thumburl'], iiif=False)
     img.set_hw(height, width)
     img.format = image_info['mime']
 
     # add a thumbnail to the canvas
     thumbs_path = image_info['thumburl'].replace('/wikipedia/commons/', '/wikipedia/commons/thumb/')
     thumb_400 = thumbs_path + '/400px-' + item['image_title']
     canvas.thumbnail = fac.image(ident=thumb_400)
     canvas.thumbnail.format = image_info['mime']
     thumbwidth, thumbheight = 400, int(height * (400 / width))
     canvas.thumbnail.set_hw(thumbheight, thumbwidth)
 
 def best_value(entity_data, property_id):
     if property_id not in entity_data['claims']:
         return None
 
     statements = entity_data['claims'][property_id]
     normal_value = None
     deprecated_value = None
 
     for statement in statements:
         if statement['mainsnak']['snaktype'] != 'value':
             continue
 
         datavalue = statement['mainsnak']['datavalue']
         if statement['rank'] == 'preferred':
             return datavalue
         if statement['rank'] == 'normal':
             normal_value = datavalue
         else:
             deprecated_value = datavalue
 
     return normal_value or deprecated_value
 
 def best_values(entity_data, property_id):
     if property_id not in entity_data['claims']:
         return []
 
     statements = entity_data['claims'][property_id]
     preferred_values = []
     normal_values = []
     deprecated_values = []
 
     for statement in statements:
         if statement['mainsnak']['snaktype'] != 'value':
             continue
 
         datavalue = statement['mainsnak']['datavalue']
         if statement['rank'] == 'preferred':
             preferred_values.append(datavalue)
         elif statement['rank'] == 'normal':
             normal_values.append(datavalue)
         else:
             deprecated_values.append(datavalue)
 
     return preferred_values or normal_values or deprecated_values
 
 def depicted_items(entity_data):
     depicteds = []
 
     statements = entity_data.get('claims', entity_data.get('statements', {}))
     if statements == []:
         statements = {}  # T222159
     for property_id in depicted_properties:
         for statement in statements.get(property_id, []):
             snaktype = statement['mainsnak']['snaktype']
             depicted = {
                 'snaktype': snaktype,
                 'statement_id': statement['id'],
                 'property_id': property_id,
             }
             if snaktype == 'value':
                 depicted['item_id'] = statement['mainsnak']['datavalue']['value']['id']
 
             for qualifier in statement.get('qualifiers', {}).get('P2677', []):
                 if qualifier['snaktype'] != 'value':
                     continue
                 depicted['iiif_region'] = qualifier['datavalue']['value']
                 depicted['qualifier_hash'] = qualifier['hash']
                 break
 
             depicteds.append(depicted)
     return depicteds
 
 def entity_metadata(entity_data):
     # property IDs based on https://www.wikidata.org/wiki/Wikidata:WikiProject_Visual_arts/Item_structure#Describing_individual_objects
     property_ids = [
         'P170',  # creator
         'P1476',  # title
         'P571',  # inception
         'P186',  # material used
         'P2079',  # fabrication method
         'P2048',  # height
         'P2049',  # width
         'P2610',  # thickness
         'P88',  # commissioned by
         'P1071',  # location of final assembly
         'P127',  # owned by
         'P1259',  # coordinates of the point of view
         'P195',  # collection
         'P276',  # location
         'P635',  # coordinate location
         'P1684',  # inscription
         'P136',  # genre
         'P135',  # movement
         'P921',  # main subject
         'P144',  # based on
         'P941',  # inspired by
     ]
     metadata = collections.defaultdict(list)
 
     session = anonymous_session('www.wikidata.org')
     for property_id in property_ids:
         for value in best_values(entity_data, property_id):
             response = session.get(action='wbformatvalue',
                                    generate='text/html',
                                    datavalue=json.dumps(value),
                                    property=property_id)
             metadata[property_id].append(response['result'])
 
     return metadata
 
 def load_labels(entity_ids):
     """Load the labels of the given entity IDs in the interface language."""
     entity_ids = list(set(entity_ids))
     labels = {}
     session = anonymous_session('www.wikidata.org')
     for chunk in [entity_ids[i:i + 50] for i in range(0, len(entity_ids), 50)]:
         items_data = session.get(action='wbgetentities',
                                  props='labels',
                                  languages=[flask.g.interface_language_code],
                                  languagefallback=True,
                                  ids=chunk)['entities']
         for entity_id, item_data in items_data.items():
             labels[entity_id] = item_data.get('labels', {})\
                                          .get(flask.g.interface_language_code,
                                               {'language': 'zxx', 'value': entity_id})
     return labels
 
+@cachetools.cached(cache=cachetools.TTLCache(maxsize=1000, ttl=7 * 24 * 60 * 60),
+                   lock=threading.RLock())
+def depicted_properties_labels():
+    """Load the labels of the depicted_properties in all available interface languages.
+
+    This is implemented separately from load_labels() because we can cache this data much better;
+    the depicted_properties labels are needed for almost every request,
+    whereas individual entity labels loaded by load_labels()
+    are probably only needed for one request.
+    """
+    assert len(depicted_properties) <= 50
+    property_ids = list(depicted_properties.keys())
+    languages = list(i18n.translations.keys())
+    labels = {}
+    session = anonymous_session('www.wikidata.org')
+    for chunk in [languages[i:i + 50] for i in range(0, len(languages), 50)]:
+        properties_data = session.get(action='wbgetentities',
+                                      props='labels',
+                                      languages=chunk,
+                                      languagefallback=True,
+                                      ids=property_ids)['entities']
+        for property_id, property_data in properties_data.items():
+            labels[property_id] = property_data['labels']
+    return labels
+
+@app.template_global(name='depicted_properties_labels')
+def depicted_properties_labels_in_interface_language():
+    return {
+        property_id: labels.get(flask.g.interface_language_code,
+                                labels['en'])
+        for property_id, labels in depicted_properties_labels().items()
+    }
+
 def image_attribution(image_title):
     params = query_default_params()
     image_attribution_query_add_params(params, image_title)
     session = anonymous_session('commons.wikimedia.org')
     response = session.get(**params)
     return image_attribution_query_process_response(response, image_title)
 
 def image_attribution_query_add_params(params, image_title):
     params.setdefault('prop', set()).update(['imageinfo'])
     params.setdefault('iiprop', set()).update(['extmetadata'])
     params['iiextmetadatalanguage'] = flask.g.interface_language_code
     params.setdefault('titles', set()).update(['File:' + image_title])
 
 def image_attribution_query_process_response(response, image_title):
     page = query_response_page(response, 'File:' + image_title)
     imageinfo = page['imageinfo'][0]
     metadata = imageinfo['extmetadata']
     no_value = {'value': None}
 
     attribution_required = metadata.get('AttributionRequired', no_value)['value']
     if attribution_required != 'true':
         return None
 
     attribution = Markup()
 
     artist = metadata.get('Artist', no_value)['value']
     if artist:
         attribution += Markup(r', ') + Markup(artist)
 
     license_short_name = metadata.get('LicenseShortName', no_value)['value']
     license_url = metadata.get('LicenseUrl', no_value)['value']
     if license_short_name and license_url:
         attribution += (Markup(r', <a href="') + Markup.escape(license_url) + Markup(r'">') +
                         Markup.escape(license_short_name) +
                         Markup(r'</a>'))
 
     credit = metadata.get('Credit', no_value)['value']
     if credit:
         attribution += Markup(r' (') + Markup(credit) + Markup(r')')
 
     attribution = attribution[len(', '):]
 
     return {
         'license_url': license_url,
         'attribution_text': attribution.striptags(),
         'attribution_html': attribution,
     }
 
 def image_url(image_title):
     params = query_default_params()
     image_url_query_add_params(params, image_title)
     session = anonymous_session('commons.wikimedia.org')
     response = session.get(**params)
     return image_url_query_process_response(response, image_title)
 
 def image_url_query_add_params(params, image_title):
     params.setdefault('prop', set()).update(['imageinfo'])
     params.setdefault('iiprop', set()).update(['url'])
     params.setdefault('titles', set()).update(['File:' + image_title])
 
 def image_url_query_process_response(response, image_title):
     page = query_response_page(response, 'File:' + image_title)
     imageinfo = page['imageinfo'][0]
     url = imageinfo['url']
 
     return url
 
 def image_size(image_title):
     params = query_default_params()
     image_size_query_add_params(params, image_title)
     session = anonymous_session('commons.wikimedia.org')
     response = session.get(**params)
     return image_size_query_process_response(response, image_title)
 
 def image_size_query_add_params(params, image_title):
     params.setdefault('prop', set()).update(['imageinfo'])
     params.setdefault('iiprop', set()).update(['size'])
     params.setdefault('titles', set()).update(['File:' + image_title])
 
 def image_size_query_process_response(response, image_title):
     page = query_response_page(response, 'File:' + image_title)
     imageinfo = page['imageinfo'][0]
     width = imageinfo['width']
     height = imageinfo['height']
 
     return width, height
 
 def query_default_params():
     return {'action': 'query', 'formatversion': 2}
 
 def query_response_page(response, title):
     """Get the page corresponding to a title from a query response."""
     for normalized in response['query'].get('normalized', []):
         if normalized['from'] == title:
             title = normalized['to']
             break
     pages = response['query']['pages']
     return next(page for page in pages if page['title'] == title)
 
 @app.after_request
 def denyFrame(response):
     """Disallow embedding the tool’s pages in other websites.
 
     If other websites can embed this tool’s pages, e. g. in <iframe>s,
     other tools hosted on tools.wmflabs.org can send arbitrary web
     requests from this tool’s context, bypassing the referrer-based
     CSRF protection.
     """
     response.headers['X-Frame-Options'] = 'deny'
     return response
diff --git a/i18n/en.json b/i18n/en.json
index 81227e8..530b9a5 100644
--- a/i18n/en.json
+++ b/i18n/en.json
@@ -1,34 +1,36 @@
 {
 	"@metadata": {
 		"authors": [
 			"Lucas Werkmeister"
 		]
 	},
 	"tool-name": "Wikidata Image Positions",
 	"skip-to-main-content": "Skip to main content",
 	"nav-documentation": "Documentation",
 	"nav-toolforge": "Wikimedia Toolforge",
 	"nav-source-code": "Source code",
 	"nav-login": "Log in",
 	"nav-logged-in": "{{GENDER:$2|Logged in}} as $1.",
 	"index-paragraph-1": "This tool shows $1 qualifiers on $2 or $3 statements as areas on the relevant image.",
 	"index-paragraph-2": "For statements on [$1 Wikidata] items, they are shown on the item’s $2 (or other property). For statements on [$3 Structured Data on Commons] files, they are shown on the file itself.",
 	"index-heading-by-item-and-property": "By item and property",
 	"index-label-item-id": "Item ID",
 	"index-placeholder-item-id": "$1 or $2 or similar",
 	"index-label-property-id-optional": "Property ID <small>(optional)</small>",
 	"index-button-load": "Load",
 	"index-button-preview-iiif": "Preview IIIF",
 	"index-button-iiif-manifest": "IIIF Manifest",
 	"index-heading-by-file": "By file",
 	"index-label-file-title": "File title",
 	"index-placeholder-file-title": "$1 or $2 or $3 or similar",
 	"index-heading-by-iiif": "By IIIF region and property",
 	"index-label-iiif-region": "<abbr title=\"International Image Interoperability Framework\">IIIF</abbr> region",
 	"image-scale": "Image scale:&#32;",
+	"image-depicted-without-region": "Depicted with no region specified:",
+	"image-named-places-on-map-without-region": "Named places on map with no region specified:",
 	"alert-not-logged-in": "You are not logged in<noscript> and JavaScript is disabled</noscript>, so you can only view existing regions and statements. To add new statements or regions or edit existing ones, [$1 log in]<noscript> and enable JavaScript</noscript>.",
 	"alert-noscript": "JavaScript is disabled, so you can only view existing regions and statements. To add new statements or regions or edit existing ones, enable JavaScript.",
 	"settings": "Settings",
 	"settings-label-interface-language-code": "User interface language",
 	"settings-save": "Save"
 }
diff --git a/i18n/qqq.json b/i18n/qqq.json
index b32f435..c2a798e 100644
--- a/i18n/qqq.json
+++ b/i18n/qqq.json
@@ -1,36 +1,38 @@
 {
 	"@metadata": {
 		"authors": [
 			"Amire80",
 			"Lucas Werkmeister",
 			"Siebrand"
 		]
 	},
 	"tool-name": "The name of the tool. This message is currently used for the page title, navigation bar / menu, and heading on the index page. Those uses could later be split up into separate messages if necessary.",
 	"skip-to-main-content": "Text for a link that allows users of assistive technologies to skip unimportant parts of the page (the navigation section).",
 	"nav-documentation": "Text for a link to the tool’s documentation in its navigation bar / menu.\n{{Identical|Documentation}}",
 	"nav-toolforge": "Text for a link to the tool’s hosting platform, Wikimedia Toolforge, in its navigation bar / menu.",
 	"nav-source-code": "Text for a link to the tool’s source code in its navigation bar / menu.",
 	"nav-login": "Text for a link to log into the tool in its navigation bar / menu.\n{{Identical|Log in}}",
 	"nav-logged-in": "Indicator in the navbar that the user is logged in.\n\nParameters:\n* $1 – the user name as a link to the user page.\n* $2 – the user name as plain text. Can be used with the GENDER magic word. If GENDER is not needd, the translation can leave out $2 completely.",
 	"index-paragraph-1": "First paragraph on the tool’s index page, describing the tool.\n\nParameters:\n* $1 - link to the [[:d:Property:P2677|relative position within image]] property on Wikidata (with localized label)\n* $2 - link to the [[:d:Property:P180|depicts]] property on Wikidata (with localized label)\n* $3 - link to the [[:d:Property:P9664|named place on map]] property on Wikidata (with localized label)",
 	"index-paragraph-2": "Second paragraph of the tool’s index page, further describing how the tool works.\n\nParameters:\n* $1 - URL for linking to Wikidata\n* $2 - link to the [[:d:Property:P18|image]] property on Wikidata (with localized label)\n* $3 - URL for linking to Structured Data on Commons",
 	"index-heading-by-item-and-property": "Heading on the tool’s index page. “Item” and “property” refer to Wikidata entities ({{msg-mw|wikibase-entity-item}}, {{msg-mw|wikibase-entity-property}}). “By” has the same meaning as in e.g. {{msg-mw|special-itembytitle}}.",
 	"index-label-item-id": "Label for an input for a Wikidata item ID.",
 	"index-placeholder-item-id": "Placeholder for an input for a Wikidata item ID.\n\nParameters:\n* $1 - one possible format (item ID)\n* $2 - another possible format (full item URL)",
 	"index-label-property-id-optional": "Label for an optional input for a Wikidata property ID.",
 	"index-button-load": "Label for several buttons to load data.",
 	"index-button-preview-iiif": "Label for a button to preview an IIIF manifest on another tool. IIIF ([[:w:International Image Interoperability Framework|International Image Interoperability Framework]]) is not usually translated.",
 	"index-button-iiif-manifest": "Label for a button to generate a IIIF manifest. IIIF ([[:w:International Image Interoperability Framework|International Image Interoperability Framework]]) is not usually translated.",
 	"index-heading-by-file": "Heading on the tool’s index page. “File” refers to media files on Wikimedia Commons. “By” has the same meaning as in e.g. {{msg-mw|special-itembytitle}}.",
 	"index-label-file-title": "Label for an input for a Wikimedia Commons file.",
 	"index-placeholder-file-title": "Placeholder for an input for a Wikimedia Commons file.\n\nParameters:\n* $1 - one possible format (file name)\n* $2 - another possible format (MediaInfo entity ID)\n* $3 - another possible format (full file URL)",
 	"index-heading-by-iiif": "Heading on the tool’s index page. IIIF ([[:w:International Image Interoperability Framework|International Image Interoperability Framework]]) is not usually translated. “Property” refers to Wikidata entities ({{msg-mw|wikibase-entity-property}}). “By” has the same meaning as in e.g. {{msg-mw|special-itembytitle}}.",
 	"index-label-iiif-region": "Label for an input for a IIIF region. The whole message is wrapped in a link to the relevant IIIF specification. IIIF ([[:w:International Image Interoperability Framework|International Image Interoperability Framework]]) is not usually translated.",
 	"image-scale": "Label for an input (or set of inputs) that let the user scale the size of the image between 0× and 5× (a kind of “zoom in” or “zoom out”).",
+	"image-depicted-without-region": "Message above a list of one or more items that are linked using the [[:d:Property:P2677|depicts]] property on Wikidata, but without a [[:d:Property:P2677|relative position within image]] qualifier. The translation should follow the label of the “depicts” property on Wikidata. (See also {{msg-wm|wikidata-image-positions-image-named-places-on-map-without-region}}.)",
+	"image-named-places-on-map-without-region": "Message above a list of one or more items that are linked using the [[:d:Property:P9664|named place on map]] property on Wikidata, but without a [[:d:Property:P2677|relative position within image]] qualifier. The translation should follow the label of the “named place on map” property on Wikidata. (See also {{msg-wm|wikidata-image-positions-image-depicted-without-region}}.)",
 	"alert-not-logged-in": "Message shown when the user is not logged into the tool. The parts in &lt;noscript&gt; are additionally only shown to users who have JavaScript disabled, and effectively duplicate the information from {{msg-wm|wikidata-image-positions-alert-noscript}}.\n\nParameters:\n* $1 - URL for the login link",
 	"alert-noscript": "Message shown when the user is logged in, but has JavaScript disabled. The entire message is wrapped in &lt;noscript&gt; by the tool; compare also {{msg-wm|wikidata-image-positions-alert-not-logged-in}}.",
 	"settings": "The tool’s settings (preferences, options, etc.). This message is currently used for the heading on the settings page as well as the link in the navigation bar / menu; those uses could later be split up into separate messages if necessary.",
 	"settings-label-interface-language-code": "Label for one of the tool’s settings, for the language the tool’s user interface is in.",
 	"settings-save": "Label for the button to save the settings."
 }
diff --git a/static/image-edit.js b/static/image-edit.js
index cc7e485..2abf9a3 100644
--- a/static/image-edit.js
+++ b/static/image-edit.js
@@ -1,545 +1,547 @@
 import { createApp } from 'vue';
 import * as codex from 'codex';
 import * as codexIcons from 'codex-icons';
 import Session, { set } from 'm3api/browser.js';
 
 function setup() {
     'use strict';
 
     const csrfTokenElement = document.getElementById('csrf_token'),
           baseUrl = document.querySelector('link[rel=index]').href.replace(/\/$/, ''),
-          depictedProperties = JSON.parse(document.getElementsByTagName('main')[0].dataset.depictedProperties);
+          mainDataset = document.getElementsByTagName('main')[0].dataset,
+          depictedPropertiesLabels = JSON.parse(mainDataset.depictedPropertiesLabels),
+          depictedPropertiesMessages = JSON.parse(mainDataset.depictedPropertiesMessages);
 
     /** Make a key event handler that calls the given callback when Esc is pressed. */
     function onEscape(callback) {
         return function(eKey) {
             if (eKey.key === 'Escape') {
                 return callback.apply(this, arguments);
             }
         };
     }
 
     function addEditButtons() {
         document.querySelectorAll('.wd-image-positions--depicted-without-region').forEach(addEditButton);
     }
 
     function addEditButton(element) {
         const entity = element.closest('.wd-image-positions--entity'),
               depictedId = element.firstChild.dataset.entityId,
               scaleInput = entity.querySelector('.wd-image-positions--scale'),
               wrapper = entity.querySelector('.wd-image-positions--wrapper'),
               image = wrapper.firstElementChild;
 
         const button = document.createElement('button');
         button.type = 'button';
         button.classList.add('btn', 'btn-secondary', 'btn-sm', 'ms-2');
         button.textContent = 'add region';
         button.addEventListener('click', onClick);
         element.append(button);
 
         let cropper = null;
         let doneCallback = null;
         const onKeyDown = onEscape(cancelEditing);
         let cancelButton = null;
 
         function onClick() {
             if (cropper === null) {
                 button.textContent = 'loading...';
                 wrapper.classList.add('wd-image-positions--active');
                 image.classList.add('wd-image-positions--active');
                 button.classList.add('wd-image-positions--active');
                 scaleInput.disabled = true;
                 doneCallback = ensureImageCroppable(image);
                 cropper = new Cropper(image.firstElementChild, {
                     viewMode: 2,
                     movable: false,
                     rotatable: true, // we don’t rotate the image ourselves, but this allows cropper.js to respect JPEG orientation
                     scalable: false,
                     zoomable: false,
                     checkCrossOrigin: false,
                     autoCrop: false,
                     ready: function() {
                         button.textContent = 'use this region';
 
                         cancelButton = document.createElement('button');
                         cancelButton.type = 'button';
                         cancelButton.classList.add('btn', 'btn-secondary', 'btn-sm', 'wd-image-positions--active', 'ms-2');
                         cancelButton.textContent = 'cancel';
                         cancelButton.addEventListener('click', cancelEditing);
                         element.append(cancelButton);
                     },
                 });
                 document.addEventListener('keydown', onKeyDown);
             } else {
                 if (button.textContent === 'loading...') {
                     return;
                 }
                 const cropData = cropper.getData();
                 if (!cropData.width || !cropData.height) {
                     window.alert('Please select a region first. (Drag the mouse across an area, then adjust as needed.)');
                     return;
                 }
 
                 const depicted = document.createElement('div');
                 depicted.classList.add('wd-image-positions--depicted')
                 const propertyId = [...element.closest('.wd-image-positions--depicteds-without-region').classList]
                       .filter(klass => klass.startsWith('wd-image-positions--depicteds-without-region__'))
                       .map(klass => klass.slice('wd-image-positions--depicteds-without-region__'.length))[0];
                 depicted.classList.add(`wd-image-positions--depicted__${propertyId}`)
                 if (depictedId !== undefined) {
                     depicted.dataset.entityId = depictedId;
                 }
                 depicted.dataset.statementId = element.dataset.statementId;
                 depicted.append(element.firstChild.cloneNode(true));
                 image.append(depicted);
                 button.textContent = 'editing statement…';
                 const subject = { id: entity.dataset.entityId, domain: entity.dataset.entityDomain };
                 saveCropper(subject, image, depicted, cropper).then(
                     function() {
                         element.remove();
                         if (image.querySelectorAll('.wd-image-positions--depicted').length === 1) {
                             addEditRegionButton(entity);
                         }
                     },
                     function() {
                         element.remove();
                     },
                 ).then(doneCallback).finally(() => {
                     document.removeEventListener('keydown', onKeyDown);
                     scaleInput.disabled = false;
                 });
                 cropper = null;
             }
         }
 
         function cancelEditing() {
             cropper.destroy();
             cropper = null;
             doneCallback();
             wrapper.classList.remove('wd-image-positions--active');
             image.classList.remove('wd-image-positions--active');
             document.removeEventListener('keydown', onKeyDown);
             button.textContent = 'add region';
             button.classList.remove('wd-image-positions--active');
             scaleInput.disabled = false;
             if (cancelButton !== null) {
                 cancelButton.remove();
                 cancelButton = null;
             }
         }
     }
 
     /**
      * Ensure that the image element is suitable for cropper.js,
      * by temporarily changing its src to the last (presumed highest-resolution) srcset entry.
      * The srcset is assumed to contain PNG/JPG thumbs,
      * whereas the src may be in an unsupported image format, such as TIFF.
      *
      * @param {HTMLElement} image The .wd-image-positions--image containing the <img>
      * (*not* the <img> itself)
      * @return {function} Callback to restore the image to its original src,
      * to be called after the cropper has been destroyed.
      */
     function ensureImageCroppable(image) {
         const img = image.querySelector('img'),
               originalSrc = img.src;
 
         if (!/\.(?:jpe?g|png|gif)$/i.test(originalSrc)) {
             img.src = img.srcset.split(' ').slice(-2)[0];
         }
 
         return function() {
             img.src = originalSrc;
         };
     }
 
     /**
      * Save the cropper as a region qualifier for the depicted.
      *
      * @param {{ id: string, domain: string}} subject The subject entity
      * @param {HTMLElement} image The .wd-image-positions--image (*not* the <img>)
      * @param {HTMLElement} depicted The .wd-image-positions--depicted,
      * with a dataset containing a statementId, optional entityId and optional qualifierHash
      * @param {Cropper} cropper The cropper (will be destroyed)
      * @return {Promise}
      */
     function saveCropper(subject, image, depicted, cropper) {
         const wrapper = image.parentElement;
         wrapper.classList.remove('wd-image-positions--active');
         image.classList.remove('wd-image-positions--active');
         const cropData = cropper.getData(),
               canvasData = cropper.getCanvasData(),
               x = 100 * cropData.x / canvasData.naturalWidth,
               y = 100 * cropData.y / canvasData.naturalHeight,
               w = 100 * cropData.width / canvasData.naturalWidth,
               h = 100 * cropData.height / canvasData.naturalHeight;
         // note: the browser rounds the percentages a bit,
         // and we’ll use the rounded values for the IIIF region
         depicted.style.left = `${x}%`;
         depicted.style.top = `${y}%`;
         depicted.style.width = `${w}%`;
         depicted.style.height = `${h}%`;
         cropper.destroy();
         function pct(name) {
             return depicted.style[name].replace('%', '');
         }
         const iiifRegion = `pct:${pct('left')},${pct('top')},${pct('width')},${pct('height')}`;
 
         const statementId = depicted.dataset.statementId,
               qualifierHash = depicted.dataset.qualifierHash,
               csrfToken = csrfTokenElement.textContent,
               formData = new FormData();
         formData.append('statement_id', statementId);
         if (qualifierHash) {
             formData.append('qualifier_hash', qualifierHash);
         }
         formData.append('iiif_region', iiifRegion);
         formData.append('_csrf_token', csrfToken);
         return fetch(`${baseUrl}/api/v2/add_qualifier/${subject.domain}`, {
             method: 'POST',
             body: formData,
             credentials: 'include',
         }).then(response => {
             if (response.ok) {
                 return response.json().then(json => {
                     depicted.dataset.qualifierHash = json.qualifier_hash;
                 });
             } else {
                 return response.text().then(text => {
                     window.alert(`An error occurred:\n\n${text}\n\nThe region drawn is ${iiifRegion}, if you want to add it manually.`);
                     throw new Error('Saving failed');
                 });
             }
         });
     }
 
     function addEditRegionButtons() {
         document.querySelectorAll('.wd-image-positions--entity').forEach(addEditRegionButton);
     }
 
     function addEditRegionButton(entityElement) {
         const wrapper = entityElement.querySelector('.wd-image-positions--wrapper'),
               image = wrapper.firstElementChild;
         if (!image.querySelector('.wd-image-positions--depicted')) {
             return;
         }
         const scaleInput = entityElement.querySelector('.wd-image-positions--scale');
         const button = document.createElement('button');
         button.type = 'button';
         button.classList.add('btn', 'btn-secondary');
         button.textContent = 'Edit a region';
         button.addEventListener('click', addEditRegionListeners);
         const cancelButton = document.createElement('button');
         cancelButton.type = 'button';
         cancelButton.classList.add('btn', 'btn-secondary', 'wd-image-positions--active', 'ms-2');
         cancelButton.textContent = 'cancel';
         const buttonWrapper = document.createElement('div');
         buttonWrapper.append(button);
         // cancelButton is not appended yet
         entityElement.append(buttonWrapper);
         const fieldSet = entityElement.querySelector('fieldset');
         if (fieldSet) {
             entityElement.append(fieldSet); // move after buttonWrapper
         }
         let onKeyDown = null;
 
         function addEditRegionListeners() {
             button.textContent = 'Select a region to edit';
             button.classList.add('wd-image-positions--active');
             for (const depicted of entityElement.querySelectorAll('.wd-image-positions--depicted')) {
                 depicted.addEventListener('click', editRegion);
             }
             button.removeEventListener('click', addEditRegionListeners);
             onKeyDown = onEscape(cancelSelectRegion);
             document.addEventListener('keydown', onKeyDown);
             buttonWrapper.append(cancelButton);
             cancelButton.addEventListener('click', cancelSelectRegion);
         }
 
         function editRegion(event) {
             event.preventDefault();
             wrapper.classList.add('wd-image-positions--active');
             image.classList.add('wd-image-positions--active');
             scaleInput.disabled = true;
             for (const depicted of entityElement.querySelectorAll('.wd-image-positions--depicted')) {
                 depicted.removeEventListener('click', editRegion);
             }
             const depicted = event.target.closest('.wd-image-positions--depicted');
             document.removeEventListener('keydown', onKeyDown);
             cancelButton.removeEventListener('click', cancelSelectRegion);
             onKeyDown = onEscape(cancelEditRegion);
             document.addEventListener('keydown', onKeyDown);
             cancelButton.addEventListener('click', cancelEditRegion);
             const doneCallback = ensureImageCroppable(image);
             const cropper = new Cropper(image.firstElementChild, {
                 viewMode: 2,
                 movable: false,
                 rotatable: true, // we don’t rotate the image ourselves, but this allows cropper.js to respect JPEG orientation
                 scalable: false,
                 zoomable: false,
                 checkCrossOrigin: false,
                 ready: function() {
                     const canvasData = cropper.getCanvasData();
                     cropper.setData({
                         x: Math.round(parseFloat(depicted.style.left) * canvasData.naturalWidth / 100),
                         y: Math.round(parseFloat(depicted.style.top) * canvasData.naturalHeight / 100),
                         width: Math.round(parseFloat(depicted.style.width) * canvasData.naturalWidth / 100),
                         height: Math.round(parseFloat(depicted.style.height) * canvasData.naturalHeight / 100),
                     });
                     button.textContent = 'use this region';
                     button.addEventListener('click', doEditRegion);
                 },
             });
 
             function doEditRegion() {
                 button.removeEventListener('click', doEditRegion);
                 button.textContent = 'editing statement…';
                 const subject = { id: entityElement.dataset.entityId, domain: entityElement.dataset.entityDomain };
                 saveCropper(subject, image, depicted, cropper).then(
                     function() {
                         button.textContent = 'Edit a region';
                         button.classList.remove('wd-image-positions--active');
                         button.addEventListener('click', addEditRegionListeners);
                     },
                     function() {
                         button.textContent = 'Edit a region';
                         button.classList.remove('wd-image-positions--active');
                         button.addEventListener('click', addEditRegionListeners);
                     },
                 ).then(doneCallback).finally(() => {
                     document.removeEventListener('keydown', onKeyDown);
                     scaleInput.disabled = false;
                     cancelButton.remove();
                 });
             }
 
             function cancelEditRegion() {
                 cropper.destroy();
                 doneCallback();
                 wrapper.classList.remove('wd-image-positions--active');
                 image.classList.remove('wd-image-positions--active');
                 button.removeEventListener('click', doEditRegion);
                 button.textContent = 'Edit a region';
                 button.addEventListener('click', addEditRegionListeners);
                 button.classList.remove('wd-image-positions--active');
                 document.removeEventListener('keydown', onKeyDown);
                 scaleInput.disabled = false;
                 cancelButton.remove();
             }
         }
 
         function cancelSelectRegion() {
             for (const depicted of entityElement.querySelectorAll('.wd-image-positions--depicted')) {
                 depicted.removeEventListener('click', editRegion);
             }
             button.textContent = 'Edit a region';
             button.addEventListener('click', addEditRegionListeners);
             button.classList.remove('wd-image-positions--active');
             document.removeEventListener('keydown', onKeyDown);
             cancelButton.remove();
         }
     }
 
     function addNewDepictedForm(entityElement) {
         const session = new Session( 'www.wikidata.org', {
             formatversion: 2,
             origin: '*',
         }, {
             userAgent: 'Wikidata-Image-Positions (https://wd-image-positions.toolforge.org/)',
         } );
         const entity = entityElement.closest('.wd-image-positions--entity'),
               subjectId = entity.dataset.entityId,
               subjectDomain = entity.dataset.entityDomain,
               newDepictedFormRoot = document.createElement('div');
         entityElement.append(newDepictedFormRoot);
 
         createApp({
             template: `
 <form class="wd-image-positions--add-new-depicted-form">
     <h3>Add more statements:</h3>
     <div class="wd-image-positions--add-new-depicted-form-row">
         <cdx-select
             v-model:selected="selectedProperty"
             :menu-items="properties"
         />
     </div>
     <div class="wd-image-positions--add-new-depicted-form-row">
         <cdx-lookup
             v-model:selected="selectedItem"
             :menu-items="searchResults"
             :menu-config="{'visible-item-limit': searchLimit}"
             :disabled="disabled"
             @input="onSearchInput"
             @load-more="onSearchLoadMore"
         />
         <cdx-button
             :disabled="disabled"
             @click.prevent="onAddItem"
         >
             <cdx-icon :icon="cdxIconAdd" />
             Add statement
         </cdx-button>
     </div>
     <div class="wd-image-positions--add-new-depicted-form-row">
         <cdx-button
             :disabled="disabled"
             @click.prevent="onAddNonValue('somevalue')"
         >
             <cdx-icon :icon="cdxIconAdd" />
             Add “unknown value” statement
         </cdx-button>
         <!-- there’s no technical reason not to implement this, but it’s not really useful
         <cdx-button
             :disabled="disabled"
             @click.prevent="onAddNonValue('novalue')"
         >
             No value
         </cdx-button>
         -->
     </div>
 </form>
 `,
             components: codex,
             data() {
-                const properties = Object.entries(depictedProperties).map(entry => ({
+                const properties = Object.entries(depictedPropertiesLabels).map(entry => ({
                     value: entry[0],
-                    label: entry[1][0],
+                    label: entry[1].value,
                 }));
                 return {
                     disabled: false,
                     properties,
                     selectedProperty: properties[0].value,
                     selectedItem: null,
                     searchResults: [],
                     searchValue: '',
                     searchLimit: 5,
                     searchOffset: 0,
                     ...codexIcons,
                 };
             },
             methods: {
                 async onSearchInput(value) {
                     this.searchValue = value;
                     this.searchOffset = 0;
                     if (!value) {
                         this.searchResults = [];
                         return;
                     }
                     const searchResults = await this.doSearch(value, this.searchOffset);
                     if (this.searchValue !== value) {
                         return; // changed during the request
                     }
                     this.searchResults = searchResults;
                     this.searchOffset += this.searchLimit;
                 },
 
                 async onSearchLoadMore() {
                     const value = this.searchValue;
                     const moreResults = await this.doSearch(value, this.searchOffset);
                     if (this.searchValue !== value) {
                         return; // changed during the request
                     }
                     this.searchResults.push(...moreResults);
                     this.searchOffset += this.searchLimit;
                 },
 
                 async doSearch(value, offset) {
                     const response = await session.request({
                         action: 'wbsearchentities',
                         search: value,
                         language: 'en',
                         type: 'item',
                         limit: this.searchLimit,
                         continue: this.searchOffset,
                         props: set(),
                     });
                     return response.search.map(result => ({
                         value: result.id,
                         label: result.display?.label?.value,
                         description: result.display?.description?.value,
                         match: result.match.type === 'alias' ? `(${result.match.text})` : '',
                         language: {
                             label: result.display?.label?.language,
                             description: result.display?.description?.language,
                             match: result.match.type === 'alias' ? result.match.language : undefined,
                         },
                     }));
                 },
 
                 onAddItem() {
                     if (!this.selectedItem) {
                         return;
                     }
                     const formData = new FormData();
                     formData.append('snaktype', 'value');
                     formData.append('property_id', this.selectedProperty);
                     formData.append('item_id', this.selectedItem);
                     this.addStatement(formData);
                 },
 
                 onAddNonValue(snakType) {
                     const formData = new FormData();
                     formData.append('snaktype', snakType);
                     this.addStatement(formData);
                 },
 
                 addStatement(formData) {
                     this.disabled = true;
                     formData.append('entity_id', subjectId);
                     formData.append('_csrf_token', csrfTokenElement.textContent);
                     fetch(`${baseUrl}/api/v1/add_statement/${subjectDomain}`, {
                         method: 'POST',
                         body: formData,
                         credentials: 'include',
                     }).then(response => {
                         if (response.ok) {
                             return response.json().then(json => {
                                 const statementId = json.depicted.statement_id;
                                 const propertyId = json.depicted.property_id;
                                 let depictedsWithoutRegionList = entityElement.querySelector(
                                     `.wd-image-positions--depicteds-without-region__${propertyId} ul`,
                                 );
                                 if (!depictedsWithoutRegionList) {
                                     const depictedsWithoutRegionDiv = document.createElement('div'),
                                           depictedsWithoutRegionText = document.createTextNode(
-                                              `${depictedProperties[propertyId]?.[1] || propertyId} with no region specified:`,
+                                              depictedPropertiesMessages[propertyId],
                                           );
                                     depictedsWithoutRegionList = document.createElement('ul');
                                     depictedsWithoutRegionDiv.classList.add('wd-image-positions--depicteds-without-region');
                                     depictedsWithoutRegionDiv.classList.add(`wd-image-positions--depicteds-without-region__${propertyId}`);
                                     depictedsWithoutRegionDiv.append(depictedsWithoutRegionText, depictedsWithoutRegionList);
                                     newDepictedFormRoot.insertAdjacentElement('beforebegin', depictedsWithoutRegionDiv);
                                 }
                                 const depicted = document.createElement('li');
                                 depicted.classList.add('wd-image-positions--depicted-without-region');
                                 depicted.dataset.statementId = statementId;
                                 depicted.innerHTML = json.depicted_item_link;
                                 depictedsWithoutRegionList.append(depicted);
                                 addEditButton(depicted);
                             });
                         } else {
                             return response.text().then(error => {
                                 window.alert(`An error occurred:\n\n${error}`);
                             });
                         }
                     }).finally(() => {
                         this.disabled = false;
                     });
                 }
 
             },
         }).mount(newDepictedFormRoot);
     }
 
     function addNewDepictedForms() {
         document.querySelectorAll('.wd-image-positions--entity').forEach(entityElement => {
             addNewDepictedForm(entityElement);
         });
     }
 
     addEditButtons();
     addEditRegionButtons();
     addNewDepictedForms();
 }
 
 setup();
diff --git a/templates/image.html b/templates/image.html
index 2a91051..feb7032 100644
--- a/templates/image.html
+++ b/templates/image.html
@@ -1,67 +1,62 @@
 {% from "depicted.html" import depicted_div %}
 {% macro _scale_radio(image_title, scale) %}
 <input
   name="scale-{{ image_title }}"
   type="radio"
   id="scale-{{ scale }}-{{ image_title }}"
   class="wd-image-positions--scale"
   value="{{ scale }}"
   {% if scale == 1 %}checked{% endif %}
   >
 <label for="scale-{{ scale }}-{{ image_title }}" class="me-1">{{ scale }}×</label>
 {% endmacro %}
-{% macro _depicteds_without_region(depicteds_without_region, property_id, property_label) %}
+{% macro _depicteds_without_region(depicteds_without_region, property_id, message_key) %}
 <!-- the following HTML (modulo whitespace) is also synthesized by static/image-edit.js, keep in sync -->
 <div class="wd-image-positions--depicteds-without-region wd-image-positions--depicteds-without-region__{{ property_id }}">
-  {{ property_label }} with no region specified:
+  {{ message(message_key) }}
   <ul>
     {% for depicted in depicteds_without_region %}
     <li class="wd-image-positions--depicted-without-region" data-statement-id="{{ depicted.statement_id }}">{{ depicted | depicted_item_link }}</li>
     {% endfor %}
   </ul>
 </div>
 {% endmacro %}
 {% macro image(image_title, image_attribution, image_url, image_width, image_height, depicteds, heading="h2") %}
 {% set image_title_ = image_title.replace(' ', '_') %}
 <{{ heading }}><a href="https://commons.wikimedia.org/wiki/File:{{ image_title_ | urlencode }}">{{ image_title }}</a></{{ heading }}>
 {% if image_attribution %}
 <p class="lead">
   {{ image_attribution.attribution_html }}
 </p>
 {% endif %}
 {{ message('image-scale') }}
 {% for scale in [1, 2, 3, 4, 5] %}
 {{ _scale_radio(image_title, scale) }}
 {% endfor %}
 <br>
 <div class="wd-image-positions--wrapper"> <!-- scrollable wrapper; note: CSS + JS assume image is first direct child element of wrapper -->
   <div class="wd-image-positions--image" data-width="{{ image_width }}" data-height="{{ image_height }}">
     <img src="{{ image_url }}"
          width="{{ image_width }}"
          height="{{ image_height }}"
          style="--width: {{ image_width }}px; --height: {{ image_height }}px; --aspect-ratio: {{ image_width }} / {{ image_height }};"
          srcset="{% for width in [220, 320, 640, 800, 1024, 1280, 1920, 2560, 2880, image_width] | select('<=', image_width) | unique %}
                  https://commons.wikimedia.org/wiki/Special:FilePath/{{ image_title_ | urlencode }}?width={{ width }} {{ width }}w{% if not loop.last %},{% endif %}
                  {% endfor %}">
     {% set depicteds_without_region_by_property_id = {} %}
     {% for depicted in depicteds %}
     {% if depicted.iiif_region %}
     {{ depicted_div(depicted) }}
     {% else %}
     {% do depicteds_without_region_by_property_id.setdefault(depicted.property_id, []).append(depicted) %}
     {% endif %}
     {% endfor %}
   </div>
 </div>
-<!-- add the depicteds without region: first, the ones for well-known properties with a label -->
-{% for property_id, property_labels in depicted_properties().items() %}
+<!-- add the depicteds without region (grouped by property) -->
+{% for property_id, message_key in depicted_properties().items() %}
 {% if depicteds_without_region_by_property_id[property_id] %}
-{% set depicteds_without_region = depicteds_without_region_by_property_id.pop(property_id) %}
-{{ _depicteds_without_region(depicteds_without_region, property_id, property_labels[1]) }}
+{{ _depicteds_without_region(depicteds_without_region, property_id, message_key) }}
 {% endif %}
 {% endfor %}
-<!-- and then the remaining ones (that weren’t popped off the dict above), just in case -->
-{% for property_id, depicteds_without_region in depicteds_without_region_by_property_id %}
-{{ _depicteds_without_region(depicteds_without_region, property_id, property_id) }}
-{% endfor %}
 {% endmacro %}
diff --git a/templates/images.html b/templates/images.html
index b83154c..3ddaee5 100644
--- a/templates/images.html
+++ b/templates/images.html
@@ -1,27 +1,27 @@
 {% extends "base.html" %}
 {% block head %}
 {{ super() }}
 <link rel="stylesheet" href="{{ url_for('static', filename='image.css') }}">
 <link rel="stylesheet" href="{{ url_for('static', filename='depicted.css') }}">
 <script src="{{ url_for('static', filename='image.js') }}" defer></script>
 {% if user_logged_in() %}
 <link rel="stylesheet" href="https://tools-static.wmflabs.org/cdnjs/ajax/libs/cropperjs/1.5.12/cropper.min.css">
 <script src="https://tools-static.wmflabs.org/cdnjs/ajax/libs/cropperjs/1.5.12/cropper.min.js" defer></script>
 <link rel="stylesheet" href="https://tools-static.wmflabs.org/cdnjs/ajax/libs/codex/1.0.0/codex.style.css">
 <link rel="stylesheet" href="https://tools-static.wmflabs.org/cdnjs/ajax/libs/codex-design-tokens/1.0.0/theme-wikimedia-ui.css">
 <script type="importmap">
   {
       "imports": {
           "vue": "https://tools-static.wmflabs.org/cdnjs/ajax/libs/vue/3.3.4/vue.esm-browser.min.js",
           "codex": "https://tools-static.wmflabs.org/cdnjs/ajax/libs/codex/1.0.0/codex.mjs",
           "codex-icons": "https://tools-static.wmflabs.org/cdnjs/ajax/libs/codex-icons/1.0.0/codex-icons.mjs",
           "m3api/": "{{ url_for('static', filename='node_modules/m3api/') }}"
       }
   }
 </script>
 <script src="{{ url_for('static', filename='image-edit.js') }}" defer type="module"></script>
 {% endif %}
 {% endblock head %}
-{% block main_tag_attributes %}{{ super() }} data-depicted-properties='{{ depicted_properties() | tojson }}' data-translations='{{ {
+{% block main_tag_attributes %}{{ super() }} data-depicted-properties-labels='{{ depicted_properties_labels() | tojson }}' data-depicted-properties-messages='{{ depicted_properties_messages() | tojson }}' data-translations='{{ {
   'image-scale': message('image-scale'),
 } | tojson }}'{% endblock main_tag_attributes %}
diff --git a/test_translations.py b/test_translations.py
index 57ceb92..e8c1b75 100644
--- a/test_translations.py
+++ b/test_translations.py
@@ -1 +1,24 @@
+import pytest
+
 from toolforge_i18n.translations_tests import *  # noqa: F401, F403
+
+import app as wdip
+
+
+@pytest.mark.parametrize('message_key', wdip.depicted_properties.values())
+def test_with_no_region_specified_unformatted(language_code, message_key):
+    """Test the image-*-without-region messages.
+
+    The "$1 with no region specified:" messages are also used in JS,
+    so they must be completely plain text,
+    with no kind of formatting or parameter substitution.
+    (We could actually contain let them HTML if we adjusted the JS code,
+    but at the moment it’s not necessary.)
+    """
+    try:
+        translation = translations[language_code][message_key]  # noqa: F405
+    except KeyError:
+        return
+
+    assert '{' not in translation
+    assert '<' not in translation