@superrouteca/smap 1.1.5 → 1.1.6

package/dist/smap.js

@@ -1,4 +1,4 @@
-/*! sMap Web SDK 1.1.5. Bundles maplibre-gl 6.16.0 (BSD-3-Clause), see vendor-licenses.txt. */
+/*! sMap Web SDK 1.1.6. Bundles maplibre-gl 6.16.0 (BSD-3-Clause), see vendor-licenses.txt. */
 (function () {
 function smapCreateEngine() {
   var SMAP_BASE_URL = (typeof document !== 'undefined' && document.baseURI) || (typeof location !== 'undefined' && location.href) || 'about:blank';
@@ -28325,12 +28325,1634 @@ function smapCreateInterop() {
 
   return module.exports;
 }
-function smapCreateSdk(engine, interop) {
+function smapCreatePlan() {
+  var module = { exports: {} };
+  var exports = module.exports;
+  var define;
+  var self = {};
+/*!
+ * sMap plan editor (OPEN-ROUTE-EDIT E10): edits a plan the caller holds through the Open Platform's plan.* calls.
+ *
+ *   // /plan-token on your own server calls POST /v1/plan/token with its API token and hands the answer on.
+ *   const editor = map.planEditor({ credentials: { token: () => fetch('/plan-token').then((r) => r.json()) }, plan });
+ *   editor.on('change', (e) => save(e.plan));
+ *
+ * The editor keeps no plan on any server: every call carries the whole plan and the answer replaces the plan drawn.
+ * It opens a distance snapshot (POST /v1/plan/matrix) and names it in every call, opening a new one by itself when
+ * the snapshot expired. Three parts, each usable alone:
+ *   PlanEditor     the state, the calls, undo / redo and the events; needs no map and no page
+ *   attachToMap    draws the plan on an sMap map and lets stops be dragged within and between routes
+ *   createPanel    the ready-made panel (routes, totals, violations, undo / redo, insert choices) in 14 languages
+ */
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) {
+    module.exports = factory();
+  } else {
+    root.smapPlan = factory();
+  }
+})(typeof self !== 'undefined' ? self : this, function () {
+  'use strict';
+
+  // ------------------------------------------------------------------ credentials and transport
+  //
+  // The one place that knows where plan calls go and how they are authorised (Superroute OPEN-ROUTE-EDIT §2e): a
+  // short-lived plan editor token (`sr_pet_…`) that the customer's own server mints with POST /v1/plan/token, or a
+  // map key (`smk_…`) with plan editing switched on. Both are sent as `Authorization: Bearer …`. A browser is known by
+  // its Origin; a native app also names itself with X-SMap-App (and X-SMap-App-Cert on Android).
+
+  var DEFAULT_BASE = 'https://open.superroute.ca';
+  // A token whose expiry can be read is renewed this many seconds before it ends.
+  var RENEW_BEFORE = 30;
+  var TOKEN_PREFIX = 'sr_pet_';
+
+  function base64Json(part) {
+    var b64 = String(part).replace(/-/g, '+').replace(/_/g, '/');
+    while (b64.length % 4) { b64 += '='; }
+    return JSON.parse(atob(b64));
+  }
+
+  /** The expiry (Unix seconds) of a plan editor token (`sr_pet_<payload>.<signature>`) or a JWT-shaped token; 0 if unreadable. */
+  function tokenExpiry(token) {
+    try {
+      var t = String(token);
+      var payload = t.indexOf(TOKEN_PREFIX) === 0 ? t.slice(TOKEN_PREFIX.length).split('.')[0] : t.split('.')[1];
+      return Number(base64Json(payload).exp) || 0;
+    } catch (e) { return 0; }
+  }
+
+  /**
+   * What a token provider gave: the token string, or the token answer of POST /v1/plan/token
+   * ({ access_token, token_type, expires_in, expires_at, scopes, origins }, or that answer's `{ data }` envelope).
+   * Returns { token, exp } with exp in Unix seconds (0 when it cannot be told).
+   */
+  function readToken(t) {
+    if (t && typeof t === 'object' && t.data && typeof t.data === 'object' && !t.access_token) { t = t.data; }
+    if (typeof t === 'string' && t) { return { token: t, exp: tokenExpiry(t) }; }
+    if (t && typeof t === 'object' && typeof t.access_token === 'string' && t.access_token) {
+      var exp = t.expires_at ? Date.parse(t.expires_at) / 1000 : 0;
+      if (!exp && typeof t.expires_in === 'number') { exp = Date.now() / 1000 + t.expires_in; }
+      return { token: t.access_token, exp: exp || tokenExpiry(t.access_token) };
+    }
+    return null;
+  }
+
+  /** The app headers of a native app: options.app is 'android:<package>' / 'apple:<bundle id>' / 'windows:<id>', or { id, cert }. */
+  function appHeaders(app) {
+    var h = {};
+    if (!app) { return h; }
+    var id = typeof app === 'string' ? app : app.id;
+    if (id) { h['X-SMap-App'] = String(id); }
+    if (app && typeof app === 'object' && app.cert) { h['X-SMap-App-Cert'] = String(app.cert); }
+    return h;
+  }
+
+  /**
+   * Credentials: { token: () => Promise<string | TokenAnswer> } (called at first use, again before the expiry it
+   * gives and after a 401 SESSION_EXPIRED), or { key: 'smk_…' } (a map key with plan editing switched on).
+   */
+  function credentialsOf(c) {
+    if (c && typeof c.token === 'function') {
+      var token = null;
+      var exp = 0;
+      var pending = null;
+      var fetchToken = function () {
+        if (!pending) {
+          pending = Promise.resolve().then(function () { return c.token(); }).then(function (t) {
+            pending = null;
+            var read = readToken(t);
+            if (!read) { throw new Error('sMap plan editor: the token provider gave no token'); }
+            token = read.token;
+            exp = read.exp;
+            return token;
+          }, function (e) { pending = null; throw e; });
+        }
+        return pending;
+      };
+      return {
+        kind: 'token',
+        headers: function () {
+          var fresh = token && (!exp || exp - Date.now() / 1000 > RENEW_BEFORE);
+          return (fresh ? Promise.resolve(token) : fetchToken()).then(function (t) { return { Authorization: 'Bearer ' + t }; });
+        },
+        // After a 401 SESSION_EXPIRED: forget the token so the next call asks the provider again. True when a retry may help.
+        renew: function () { token = null; exp = 0; return true; },
+      };
+    }
+    if (c && typeof c.key === 'string' && c.key) {
+      return {
+        kind: 'key',
+        headers: function () { return Promise.resolve({ Authorization: 'Bearer ' + c.key }); },
+        renew: function () { return false; },
+      };
+    }
+    throw new Error('sMap plan editor: credentials are { token: () => Promise<string | TokenAnswer> } or { key: string }');
+  }
+
+  /** An error answered by the Open Platform (status, code, reason, details) or raised on the way. */
+  function PlanError(message, o) {
+    var e = new Error(message);
+    e.name = 'PlanError';
+    o = o || {};
+    e.status = o.status || 0;
+    e.code = o.code || null;
+    e.details = o.details || null;
+    e.reason = o.reason || null;
+    e.path = o.path || null;
+    return e;
+  }
+
+  function isAbort(e) { return !!e && (e.name === 'AbortError' || e.cancelled === true); }
+  function cancelled() { var e = new Error('cancelled'); e.name = 'AbortError'; e.cancelled = true; return e; }
+
+  /**
+   * The transport: send(method, path, body, signal) resolves { status, body, data, matrix } (matrix: the X-Plan-Matrix
+   * header) or rejects with a PlanError. A 401 SESSION_EXPIRED with a token provider asks for a new token and repeats
+   * the call once; every other refusal (SESSION_REVOKED, TOKEN_INVALID, 403 NOT_AUTHORIZED with its reason) is raised.
+   */
+  function createTransport(o) {
+    o = o || {};
+    var base = String(o.baseUrl || DEFAULT_BASE).replace(/\/$/, '');
+    var creds = credentialsOf(o.credentials);
+    var app = appHeaders(o.app);
+    var fetchFn = o.fetch || (typeof fetch === 'function' ? function (url, init) { return fetch(url, init); } : null);
+    if (!fetchFn) { throw new Error('sMap plan editor: no fetch; pass options.fetch'); }
+
+    function send(method, path, body, signal, retried) {
+      return creds.headers().then(function (h) {
+        var headers = { Accept: 'application/json' };
+        Object.keys(app).forEach(function (k) { headers[k] = app[k]; });
+        Object.keys(h).forEach(function (k) { headers[k] = h[k]; });
+        var init = { method: method, headers: headers };
+        if (body !== undefined) { headers['Content-Type'] = 'application/json'; init.body = JSON.stringify(body); }
+        if (signal) { init.signal = signal; }
+        return fetchFn(base + path, init);
+      }).then(function (res) {
+        return res.text().then(function (text) {
+          var json = null;
+          try { json = text ? JSON.parse(text) : null; } catch (e) { json = null; }
+          var matrix = res.headers && typeof res.headers.get === 'function' ? res.headers.get('X-Plan-Matrix') : null;
+          if (!res.ok) {
+            var err = (json && json.error) || {};
+            if (res.status === 401 && err.code === 'SESSION_EXPIRED' && !retried && creds.renew()) { return send(method, path, body, signal, true); }
+            throw PlanError(err.message || ('HTTP ' + res.status), {
+              status: res.status, code: err.code || null, details: err.details || null, reason: err.reason || (json && json.reason) || null, path: path,
+            });
+          }
+          return { status: res.status, body: json, data: json && json.data, matrix: matrix };
+        });
+      });
+    }
+    return { send: send, kind: creds.kind, baseUrl: base };
+  }
+
+  // ------------------------------------------------------------------ plans
+
+  function clone(v) { return v === undefined ? undefined : JSON.parse(JSON.stringify(v)); }
+
+  function routesOf(routes) {
+    return (routes || []).map(function (r) {
+      var stops = (r.stops || []).map(String);
+      // A route sent with `reverse` is held in driving order, as the plan calls answer it.
+      if (r.reverse) { stops.reverse(); }
+      return { vehicle_id: String(r.vehicle_id), stops: stops };
+    });
+  }
+
+  // Every vehicle keeps a route to drop stops on: an empty one, last, where the plan gives none.
+  function withAllVehicles(routes, vehicles) {
+    var out = routes.slice();
+    vehicles.forEach(function (v) {
+      if (!out.some(function (r) { return r.vehicle_id === String(v.id); })) { out.push({ vehicle_id: String(v.id), stops: [] }); }
+    });
+    return out;
+  }
+
+  function unassignedOf(jobs, routes) {
+    var on = {};
+    routes.forEach(function (r) { r.stops.forEach(function (s) { on[s] = true; }); });
+    return jobs.filter(function (j) { return !on[String(j.id)]; }).map(function (j) { return String(j.id); });
+  }
+
+  function findStop(routes, id) {
+    for (var i = 0; i < routes.length; i++) {
+      var k = routes[i].stops.indexOf(id);
+      if (k >= 0) { return { route: i, vehicle_id: routes[i].vehicle_id, position: k + 1 }; }
+    }
+    return null;
+  }
+
+  function idList(v) { return (Array.isArray(v) ? v : [v]).map(String); }
+
+  /** The routes after giving vehicleId's route the stops in `stops` (every stop of the route once, no other). */
+  function applyResequence(routes, vehicleId, stops) {
+    var out = clone(routes);
+    var r = out.filter(function (x) { return x.vehicle_id === vehicleId; })[0];
+    if (!r) { throw PlanError('sMap plan editor: no route of vehicle ' + vehicleId); }
+    var want = idList(stops);
+    if (want.length !== r.stops.length || want.slice().sort().join('\u0000') !== r.stops.slice().sort().join('\u0000')) {
+      throw PlanError('sMap plan editor: a new order holds every stop of the route once, and no other');
+    }
+    r.stops = want;
+    return out;
+  }
+
+  /** The routes after moving `stops` to vehicleId's route at `position` (from 1, counted without them; none: last). */
+  function applyMove(routes, stops, vehicleId, position) {
+    var out = clone(routes);
+    var ids = idList(stops);
+    out.forEach(function (r) { r.stops = r.stops.filter(function (s) { return ids.indexOf(s) < 0; }); });
+    var target = out.filter(function (x) { return x.vehicle_id === vehicleId; })[0];
+    if (!target) { target = { vehicle_id: vehicleId, stops: [] }; out.push(target); }
+    var at = position === undefined || position === null ? target.stops.length : Math.max(0, Math.min(target.stops.length, position - 1));
+    Array.prototype.splice.apply(target.stops, [at, 0].concat(ids));
+    return out;
+  }
+
+  /** The routes after taking `stops` off their routes (each must be on a route). */
+  function applyRemove(routes, stops) {
+    var ids = idList(stops);
+    ids.forEach(function (id) { if (!findStop(routes, id)) { throw PlanError('sMap plan editor: ' + id + ' is on no route'); } });
+    var out = clone(routes);
+    out.forEach(function (r) { r.stops = r.stops.filter(function (s) { return ids.indexOf(s) < 0; }); });
+    return out;
+  }
+
+  /**
+   * Where a stop dropped before the stop at `position` of vehicleId's route (as drawn, the stop itself included; past
+   * the last stop = after it) ends up: { kind: 'resequence', vehicle_id, stops } within its route, { kind: 'move',
+   * vehicle_id, position } to another route or from the unassigned, or null when nothing changes.
+   */
+  function dropEdit(routes, stopId, vehicleId, position) {
+    var from = findStop(routes, stopId);
+    var target = routes.filter(function (r) { return r.vehicle_id === vehicleId; })[0];
+    var length = target ? target.stops.length : 0;
+    if (from && from.vehicle_id === vehicleId) {
+      var stops = target.stops.slice();
+      stops.splice(from.position - 1, 1);
+      var at = Math.max(1, Math.min(position, length + 1));
+      if (from.position < at) { at -= 1; }
+      stops.splice(at - 1, 0, stopId);
+      if (stops.join('\u0000') === target.stops.join('\u0000')) { return null; }
+      return { kind: 'resequence', vehicle_id: vehicleId, stops: stops };
+    }
+    var p = Math.max(1, position);
+    return { kind: 'move', vehicle_id: vehicleId, position: p > length ? null : p };
+  }
+
+  /** [lng, lat] of a location given as { lng, lat } / { lon, lat } / [lng, lat]; null when unreadable. */
+  function lngLat(v) {
+    if (!v) { return null; }
+    if (Array.isArray(v)) { return v.length >= 2 ? [Number(v[0]), Number(v[1])] : null; }
+    var lng = v.lng !== undefined ? v.lng : (v.lon !== undefined ? v.lon : v.longitude);
+    var lat = v.lat !== undefined ? v.lat : v.latitude;
+    return lng === undefined || lat === undefined ? null : [Number(lng), Number(lat)];
+  }
+
+  /** An encoded polyline (precision 5, as plan.recost answers legs) as [[lng, lat], …]. */
+  function decodePolyline(text, precision) {
+    var factor = Math.pow(10, precision || 5);
+    var out = [];
+    var index = 0;
+    var lat = 0;
+    var lng = 0;
+    text = String(text);
+    while (index < text.length) {
+      var values = [0, 0];
+      for (var n = 0; n < 2; n++) {
+        var shift = 0;
+        var result = 0;
+        var b;
+        do {
+          b = text.charCodeAt(index++) - 63;
+          result |= (b & 0x1f) << shift;
+          shift += 5;
+        } while (b >= 0x20 && index <= text.length);
+        values[n] = (result & 1) ? ~(result >> 1) : (result >> 1);
+      }
+      lat += values[0];
+      lng += values[1];
+      out.push([lng / factor, lat / factor]);
+    }
+    return out;
+  }
+
+  // ------------------------------------------------------------------ the editor
+
+  var EVENTS = ['change', 'busy', 'error', 'snapshot', 'preview', 'destroy'];
+  var PATHS = {
+    recost: '/v1/plan/recost', resequence: '/v1/plan/resequence', move: '/v1/plan/move', remove: '/v1/plan/remove',
+    insert: '/v1/plan/insert', refine: '/v1/plan/refine', matrix: '/v1/plan/matrix',
+  };
+  // Answer fields that describe the edit itself, beside routes, summary and plan.
+  var ANSWERS = { resequence: 'resequence', move: 'move', remove: 'removed', insert: 'insert', refine: 'refine' };
+  // A snapshot that could not be opened is asked for again after this long; calls go on without one meanwhile.
+  var SNAPSHOT_RETRY_MS = 60000;
+
+  function newController() { return typeof AbortController === 'function' ? new AbortController() : null; }
+
+  /**
+   * The plan editor's state and calls, without a map.
+   * @param {Object} options
+   * @param {Object} options.credentials   { token: () => Promise<string | TokenAnswer> } or { key: string }
+   * @param {string|Object} [options.app]  a native app's identity: 'android:<package>' / 'apple:<bundle id>' / 'windows:<id>', or { id, cert }
+   * @param {string} [options.baseUrl]     the Open Platform (default https://open.superroute.ca)
+   * @param {Function} [options.fetch]     fetch to use (default the page's)
+   * @param {Object} [options.plan]        the starting plan: { vehicles, jobs, routes, region?, profile?, departed_at? }
+   * @param {string} [options.region]      used when the plan names none
+   * @param {string} [options.profile]     used when the plan names none
+   * @param {boolean} [options.snapshot=true]  open and use a distance snapshot
+   * @param {boolean} [options.geometry=true]  ask for each leg's line (for drawing)
+   * @param {number} [options.insertLimit=3]   positions offered per inserted job (1-10)
+   * @param {'duration'|'distance'} [options.objective]  what insert ranks by (the server's default: duration)
+   */
+  function PlanEditor(options) {
+    if (!(this instanceof PlanEditor)) { return new PlanEditor(options); }
+    options = options || {};
+    this._transport = createTransport(options);
+    this._options = options;
+    this._snapshotOn = options.snapshot !== false;
+    this._geometry = options.geometry !== false;
+    this._handlers = {};
+    EVENTS.forEach(function (t) { this._handlers[t] = []; }, this);
+    this._history = [];
+    this._at = -1;
+    this._vehicles = [];
+    this._context = {};
+    this._locked = {};
+    this._choices = null;
+    this._last = null;
+    this._inflight = null;
+    this._previewing = null;
+    this._previewResult = null;
+    this._busy = false;
+    this._error = null;
+    this._matrix = null;
+    this._matrixKey = null;
+    this._opening = null;
+    this._openingKey = null;
+    this._matrixRetryAt = 0;
+    this._destroyed = false;
+    if (options.plan) { this.setPlan(options.plan).catch(function () {}); }
+  }
+
+  PlanEditor.prototype.on = function (type, fn) {
+    if (!this._handlers[type]) { throw new Error('sMap plan editor: unknown event "' + type + '"'); }
+    this._handlers[type].push(fn);
+    return this;
+  };
+  PlanEditor.prototype.off = function (type, fn) {
+    if (this._handlers[type]) { this._handlers[type] = this._handlers[type].filter(function (h) { return h !== fn; }); }
+    return this;
+  };
+  PlanEditor.prototype._emit = function (type, payload) {
+    (this._handlers[type] || []).slice().forEach(function (h) {
+      try { h(payload); } catch (e) { if (typeof console !== 'undefined') { console.error(e); } }
+    });
+  };
+
+  /** Replaces the plan: the history starts again from it, and it is priced (plan.recost). */
+  PlanEditor.prototype.setPlan = function (plan) {
+    if (!plan || !Array.isArray(plan.vehicles) || !Array.isArray(plan.jobs)) {
+      return Promise.reject(PlanError('sMap plan editor: a plan has vehicles and jobs'));
+    }
+    this._supersede();
+    this.clearPreview();
+    this._vehicles = clone(plan.vehicles);
+    this._context = {};
+    var o = this._options;
+    var region = plan.region || o.region;
+    var profile = plan.profile || o.profile;
+    if (region) { this._context.region = region; }
+    if (profile) { this._context.profile = profile; }
+    if (plan.departed_at) { this._context.departed_at = plan.departed_at; }
+    var routes = withAllVehicles(routesOf(plan.routes), this._vehicles);
+    var jobs = clone(plan.jobs);
+    var known = {};
+    jobs.forEach(function (j) { known[String(j.id)] = true; });
+    Object.keys(this._locked).forEach(function (id) { if (!known[id]) { delete this._locked[id]; } }, this);
+    this._history = [{ kind: 'set', routes: routes, jobs: jobs, result: null, answer: null }];
+    this._at = 0;
+    this._choices = null;
+    this._last = null;
+    this._error = null;
+    this._changed('set');
+    return this._price(this._history[0]);
+  };
+
+  /** The plan in the shape it is sent: vehicles, jobs, routes (stops in driving order), unassigned and its context. */
+  PlanEditor.prototype.getPlan = function () {
+    var e = this._history[this._at];
+    if (!e) { return null; }
+    var plan = { vehicles: clone(this._vehicles), jobs: clone(e.jobs), routes: clone(e.routes), unassigned: unassignedOf(e.jobs, e.routes) };
+    Object.keys(this._context).forEach(function (k) { plan[k] = this._context[k]; }, this);
+    return plan;
+  };
+
+  /** The plan's prices and judgement as the last answer gave them ({ routes, summary }), or null before one. */
+  PlanEditor.prototype.getResult = function () {
+    var e = this._history[this._at];
+    return e && e.result ? clone(e.result) : null;
+  };
+
+  /** Everything a panel shows, in one object. */
+  PlanEditor.prototype.state = function () {
+    return {
+      plan: this.getPlan(), result: this.getResult(), busy: this._busy, error: this._error, canUndo: this.canUndo(),
+      canRedo: this.canRedo(), choices: clone(this._choices), locked: this.locked(), last: clone(this._last),
+      preview: this._previewResult ? clone(this._previewResult) : null,
+    };
+  };
+
+  PlanEditor.prototype.canUndo = function () { return this._at > 0; };
+  PlanEditor.prototype.canRedo = function () { return this._at >= 0 && this._at < this._history.length - 1; };
+  PlanEditor.prototype.isBusy = function () { return this._busy; };
+
+  /** Gives vehicleId's route the stops in a new driving order (plan.resequence). */
+  PlanEditor.prototype.resequence = function (vehicleId, stops) {
+    vehicleId = String(vehicleId);
+    var order = idList(stops);
+    return this._run('resequence', { vehicle_id: vehicleId, stops: order }, function (routes) { return applyResequence(routes, vehicleId, order); });
+  };
+
+  /** Moves stops to vehicleId's route at `position` (from 1, counted without them; omitted: last) (plan.move). */
+  PlanEditor.prototype.move = function (stops, vehicleId, position) {
+    vehicleId = String(vehicleId);
+    var ids = idList(stops);
+    var body = { vehicle_id: vehicleId, stops: ids };
+    if (position !== undefined && position !== null) { body.position = position; }
+    return this._run('move', body, function (routes) { return applyMove(routes, ids, vehicleId, position); });
+  };
+
+  /** Takes stops off their routes; they become unassigned (plan.remove). */
+  PlanEditor.prototype.remove = function (stops) {
+    var ids = idList(stops);
+    return this._run('remove', { stops: ids }, function (routes) { return applyRemove(routes, ids); });
+  };
+
+  /**
+   * Places a stop where it was dropped: before the stop at `position` of vehicleId's route as drawn (past the last
+   * stop: after it). Within its route this is a resequence, otherwise a move. Resolves null when nothing changes.
+   */
+  PlanEditor.prototype.dropStop = function (stopId, vehicleId, position) {
+    var e = this._history[this._at];
+    if (!e) { return Promise.resolve(null); }
+    var edit = dropEdit(e.routes, String(stopId), String(vehicleId), position);
+    if (!edit) { return Promise.resolve(null); }
+    return edit.kind === 'resequence' ? this.resequence(edit.vehicle_id, edit.stops) : this.move([String(stopId)], edit.vehicle_id, edit.position);
+  };
+
+  /**
+   * Inserts new jobs (each like a job of the plan, with an id the plan does not have) at their cheapest positions, or
+   * places jobs of the plan that are on no route (given by id) (plan.insert). The ranked positions answered are kept
+   * in choices(); choose() takes another one.
+   * @param {Object|string|Array} jobs
+   * @param {Object} [o] limit (1-10), objective ('duration' | 'distance'), nearest (1-50)
+   */
+  PlanEditor.prototype.insert = function (jobs, o) {
+    try { return this._insert(jobs, o || {}); } catch (err) { return Promise.reject(err); }
+  };
+  PlanEditor.prototype._insert = function (jobs, o) {
+    var e = this._history[this._at];
+    if (!e) { return Promise.reject(PlanError('sMap plan editor: no plan; call setPlan first')); }
+    var list = Array.isArray(jobs) ? jobs : [jobs];
+    var byId = {};
+    e.jobs.forEach(function (j) { byId[String(j.id)] = j; });
+    var placing = list.map(function (j) {
+      if (typeof j === 'string' || typeof j === 'number') {
+        var known = byId[String(j)];
+        if (!known) { throw PlanError('sMap plan editor: no job ' + j); }
+        if (findStop(e.routes, String(j))) { throw PlanError('sMap plan editor: ' + j + ' is already on a route'); }
+        return clone(known);
+      }
+      return clone(j);
+    });
+    var ids = placing.map(function (j) { return String(j.id); });
+    var rest = e.jobs.filter(function (j) { return ids.indexOf(String(j.id)) < 0; });
+    var body = { insert: placing, limit: o.limit || this._options.insertLimit || 3 };
+    var objective = o.objective || this._options.objective;
+    if (objective) { body.objective = objective; }
+    if (o.nearest) { body.nearest = o.nearest; }
+    return this._run('insert', body, null, { jobs: rest, after: rest.concat(placing) });
+  };
+
+  /** The positions the last insert answered: [{ job, placed, reason?, choices: […], chosen }]; null when none. */
+  PlanEditor.prototype.choices = function () { return clone(this._choices); };
+  PlanEditor.prototype.clearChoices = function () { this._choices = null; this._changed('choices'); return this; };
+
+  /** Puts an inserted job at another of its answered positions (plan.move). */
+  PlanEditor.prototype.choose = function (jobId, index) {
+    jobId = String(jobId);
+    var item = (this._choices || []).filter(function (c) { return c.job === jobId; })[0];
+    var choice = item && item.choices[index];
+    if (!choice) { return Promise.reject(PlanError('sMap plan editor: no such position for ' + jobId)); }
+    var self = this;
+    var kept = this._choices;
+    var before = item.chosen;
+    var moving = this.move([jobId], choice.vehicle_id, choice.position);
+    item.chosen = index;
+    this._choices = kept;
+    this._changed('choices');
+    return moving.then(function (answer) {
+      if (answer) { self._choices = kept; self._changed('choices'); }
+      return answer;
+    }, function (e) { item.chosen = before; self._choices = kept; self._changed('choices'); throw e; });
+  };
+
+  /**
+   * Re-orders the stops of chosen routes around the locked stops (plan.refine). The new order is kept only when the
+   * service finds it better; otherwise the plan stays and `last.answer.changed` is false.
+   * @param {Object} [o] vehicleIds (default every route), freeze (default the locked stops on those routes)
+   */
+  PlanEditor.prototype.refine = function (o) {
+    o = o || {};
+    var e = this._history[this._at];
+    if (!e) { return Promise.reject(PlanError('sMap plan editor: no plan; call setPlan first')); }
+    var body = {};
+    var vehicles = o.vehicleIds ? idList(o.vehicleIds) : null;
+    if (vehicles) { body.vehicle_ids = vehicles; }
+    var freeze = o.freeze ? idList(o.freeze) : this.locked().filter(function (id) {
+      var at = findStop(e.routes, id);
+      return at && (!vehicles || vehicles.indexOf(at.vehicle_id) >= 0);
+    });
+    if (freeze.length) { body.freeze = freeze; }
+    return this._run('refine', body, null, {});
+  };
+
+  /** Prices the plan again as it is (plan.recost). */
+  PlanEditor.prototype.recost = function () {
+    var e = this._history[this._at];
+    if (!e) { return Promise.resolve(null); }
+    this._supersede();
+    return this._price(e);
+  };
+
+  /** Locks stops so that refine keeps them on their route, in their order. */
+  PlanEditor.prototype.lock = function (stops) { idList(stops).forEach(function (id) { this._locked[id] = true; }, this); this._changed('lock'); return this; };
+  PlanEditor.prototype.unlock = function (stops) { idList(stops).forEach(function (id) { delete this._locked[id]; }, this); this._changed('lock'); return this; };
+  PlanEditor.prototype.locked = function () { return Object.keys(this._locked); };
+  PlanEditor.prototype.isLocked = function (id) { return !!this._locked[String(id)]; };
+
+  /** Goes back one edit. The plan drawn is the one answered then; a plan never priced is priced again. */
+  PlanEditor.prototype.undo = function () {
+    if (!this.canUndo()) { return Promise.resolve(null); }
+    return this._step(-1);
+  };
+  PlanEditor.prototype.redo = function () {
+    if (!this.canRedo()) { return Promise.resolve(null); }
+    return this._step(1);
+  };
+  PlanEditor.prototype._step = function (by) {
+    this._supersede();
+    this.clearPreview();
+    this._at += by;
+    this._choices = null;
+    this._last = null;
+    this._error = null;
+    var e = this._history[this._at];
+    this._changed(by < 0 ? 'undo' : 'redo');
+    return e.result ? Promise.resolve(this.getResult()) : this._price(e);
+  };
+
+  /**
+   * Prices other routes for the current jobs without changing the plan (plan.recost, no geometry), e.g. while a stop
+   * is dragged; a newer preview cancels the one before. Reported as the `preview` event.
+   */
+  PlanEditor.prototype.preview = function (routes) {
+    var e = this._history[this._at];
+    if (!e || this._destroyed) { return Promise.resolve(null); }
+    this._cancelPreview();
+    var controller = newController();
+    var ticket = { controller: controller };
+    this._previewing = ticket;
+    var body = this._body({ routes: routesOf(routes), jobs: e.jobs }, {}, false);
+    var self = this;
+    return this._call(PATHS.recost, body, controller && controller.signal).then(function (res) {
+      if (self._previewing !== ticket) { return null; }
+      self._previewing = null;
+      self._previewResult = { routes: routesOf(routes), result: { routes: (res.data || {}).routes || [], summary: (res.data || {}).summary || null } };
+      self._emit('preview', clone(self._previewResult));
+      return clone(self._previewResult);
+    }, function (err) {
+      if (self._previewing === ticket) { self._previewing = null; }
+      if (!isAbort(err) && self._previewing === null && !self._destroyed) { self._emit('error', { error: err, kind: 'preview' }); }
+      return null;
+    });
+  };
+  PlanEditor.prototype.clearPreview = function () {
+    var had = this._previewing || this._previewResult;
+    this._cancelPreview();
+    this._previewResult = null;
+    if (had) { this._emit('preview', null); }
+    return this;
+  };
+  PlanEditor.prototype._cancelPreview = function () {
+    if (this._previewing && this._previewing.controller) { this._previewing.controller.abort(); }
+    this._previewing = null;
+  };
+
+  /** Ends the editor: cancels its calls, closes its snapshot, and tells its map layer and panel to leave. */
+  PlanEditor.prototype.destroy = function () {
+    if (this._destroyed) { return; }
+    this._supersede();
+    this._cancelPreview();
+    this._destroyed = true;
+    var matrix = this._matrix;
+    this._matrix = null;
+    if (matrix) { this._transport.send('DELETE', PATHS.matrix + '/' + encodeURIComponent(matrix)).catch(function () {}); }
+    this._emit('destroy', null);
+    EVENTS.forEach(function (t) { this._handlers[t] = []; }, this);
+  };
+
+  // --- internals
+
+  PlanEditor.prototype._changed = function (kind) {
+    var e = this._history[this._at] || {};
+    this._emit('change', {
+      kind: kind, plan: this.getPlan(), result: this.getResult(), answer: this._last ? clone(this._last.answer) : null,
+      pending: !e.result, canUndo: this.canUndo(), canRedo: this.canRedo(),
+    });
+  };
+
+  PlanEditor.prototype._setBusy = function (on) {
+    if (this._busy === on) { return; }
+    this._busy = on;
+    this._emit('busy', { busy: on });
+  };
+
+  // Cancels the call in flight. An edit drawn ahead of its answer stays in the history unpriced, and is priced when
+  // it is shown again; a search (insert, refine) that was cancelled never happened.
+  PlanEditor.prototype._supersede = function () {
+    var t = this._inflight;
+    if (!t) { return; }
+    this._inflight = null;
+    if (t.controller) { t.controller.abort(); }
+    this._setBusy(false);
+  };
+
+  PlanEditor.prototype._body = function (entry, extra, geometry) {
+    // Routes without stops are kept here as drop targets and not sent (an empty route would be priced start to end).
+    var routes = entry.routes.filter(function (r) { return r.stops.length; });
+    if (!routes.length) { routes = entry.routes.slice(0, 1); }
+    var body = { vehicles: this._vehicles, jobs: entry.jobs, routes: routes };
+    Object.keys(this._context).forEach(function (k) { body[k] = this._context[k]; }, this);
+    body.options = { geometry: geometry === undefined ? this._geometry : geometry };
+    Object.keys(extra || {}).forEach(function (k) { body[k] = extra[k]; });
+    return body;
+  };
+
+  // One edit: drawn at once when its outcome is known here (`local`), sent with the plan it changes, and replaced by
+  // the answer. `search` (insert, refine) is pushed to the history only when answered.
+  PlanEditor.prototype._run = function (kind, extra, local, search) {
+    if (this._destroyed) { return Promise.reject(PlanError('sMap plan editor: destroyed')); }
+    var base = this._history[this._at];
+    if (!base) { return Promise.reject(PlanError('sMap plan editor: no plan; call setPlan first')); }
+    this._supersede();
+    this.clearPreview();
+    var entry = null;
+    if (local) {
+      var routes;
+      try { routes = local(base.routes); } catch (err) { return Promise.reject(err); }
+      entry = { kind: kind, routes: routes, jobs: base.jobs, result: null, answer: null };
+      this._history.splice(this._at + 1);
+      this._history.push(entry);
+      this._at = this._history.length - 1;
+      this._choices = null;
+      this._last = null;
+      this._error = null;
+      this._changed(kind);
+    }
+    var body = this._body(search && search.jobs ? { routes: base.routes, jobs: search.jobs } : base, extra);
+    return this._request(kind, PATHS[kind], body, entry, search ? { base: base, jobs: search.after || base.jobs } : null);
+  };
+
+  PlanEditor.prototype._price = function (entry) {
+    return this._request('recost', PATHS.recost, this._body(entry, {}), entry, null);
+  };
+
+  PlanEditor.prototype._request = function (kind, path, body, entry, search) {
+    var self = this;
+    var controller = newController();
+    var ticket = { controller: controller, kind: kind };
+    this._inflight = ticket;
+    this._setBusy(true);
+    return this._call(path, body, controller && controller.signal).then(function (res) {
+      if (self._inflight !== ticket) { return null; }
+      self._inflight = null;
+      var data = res.data || {};
+      var answer = ANSWERS[kind] ? (data[ANSWERS[kind]] === undefined ? null : data[ANSWERS[kind]]) : null;
+      var target = entry;
+      if (search) {
+        if (self._history[self._at] !== search.base) { self._setBusy(false); return null; }
+        if (kind === 'refine' && answer && answer.changed === false) {
+          // The plan as sent stays; its prices are the ones answered.
+          target = search.base;
+        } else {
+          target = { kind: kind, routes: search.base.routes, jobs: clone(search.jobs), result: null, answer: null };
+          self._history.splice(self._at + 1);
+          self._history.push(target);
+          self._at = self._history.length - 1;
+        }
+      }
+      if (data.plan && Array.isArray(data.plan.routes)) { target.routes = withAllVehicles(routesOf(data.plan.routes), self._vehicles); }
+      target.result = { routes: data.routes || [], summary: data.summary || null };
+      if (kind !== 'recost') {
+        target.answer = answer;
+        self._last = { kind: kind, answer: answer };
+      }
+      if (kind === 'insert') {
+        self._choices = (answer || []).map(function (item) {
+          var c = clone(item);
+          c.chosen = c.placed ? 0 : null;
+          return c;
+        });
+      }
+      self._error = null;
+      self._setBusy(false);
+      if (self._history[self._at] === target || kind !== 'recost') { self._changed(kind); }
+      return { kind: kind, plan: self.getPlan(), result: self.getResult(), answer: clone(answer) };
+    }, function (err) {
+      var current = self._inflight === ticket;
+      if (current) { self._inflight = null; self._setBusy(false); }
+      if (isAbort(err) || !current || self._destroyed) { return null; }
+      // A failed edit drawn ahead of its answer is taken back.
+      if (entry && entry !== self._history[0] && kind !== 'recost') {
+        var i = self._history.indexOf(entry);
+        if (i > 0) {
+          self._history.splice(i, 1);
+          if (self._at >= i) { self._at -= 1; }
+        }
+      }
+      self._error = { kind: kind, status: err.status || 0, code: err.code || null, message: err.message, reason: err.reason || null };
+      self._changed('error');
+      self._emit('error', { error: err, kind: kind });
+      throw err;
+    });
+  };
+
+  // A call with the snapshot: opened first when needed, named as `matrix`, and opened again after it expired. A
+  // snapshot never makes a call fail (E2): a 410 is repeated with a new snapshot, then without one.
+  PlanEditor.prototype._call = function (path, body, signal, attempt) {
+    var self = this;
+    attempt = attempt || 0;
+    var opening = attempt >= 2 ? Promise.resolve(null) : this._ensureMatrix();
+    return opening.then(function (matrix) {
+      if (signal && signal.aborted) { throw cancelled(); }
+      if (matrix) { body.matrix = matrix; } else { delete body.matrix; }
+      return self._transport.send('POST', path, body, signal);
+    }).then(function (res) {
+      if (body.matrix) { self._snapshotSeen(res.matrix, body.matrix); }
+      return res;
+    }, function (err) {
+      if (err && err.status === 410 && body.matrix && attempt < 2) {
+        self._dropMatrix(body.matrix, 'expired');
+        return self._call(path, body, signal, attempt + 1);
+      }
+      throw err;
+    });
+  };
+
+  PlanEditor.prototype._snapshotSeen = function (header, sent) {
+    var status = header || 'used';
+    this._emit('snapshot', { status: status, matrix: sent });
+    if (status === 'expired' || status === 'mismatch') {
+      this._dropMatrix(sent, null);
+      // Opened now, for the next call; this call was already answered without it.
+      this._ensureMatrix();
+    }
+  };
+
+  PlanEditor.prototype._dropMatrix = function (id, status) {
+    if (this._matrix === id) { this._matrix = null; this._matrixKey = null; }
+    if (status) { this._emit('snapshot', { status: status, matrix: id }); }
+  };
+
+  PlanEditor.prototype._ensureMatrix = function () {
+    if (!this._snapshotOn || this._destroyed) { return Promise.resolve(null); }
+    var key = (this._context.region || '') + '|' + (this._context.profile || '');
+    if (this._matrix && this._matrixKey === key) { return Promise.resolve(this._matrix); }
+    if (this._opening && this._openingKey === key) { return this._opening; }
+    if (this._matrixRetryAt && Date.now() < this._matrixRetryAt) { return Promise.resolve(null); }
+    var self = this;
+    var old = this._matrix;
+    if (old) {
+      this._matrix = null;
+      this._transport.send('DELETE', PATHS.matrix + '/' + encodeURIComponent(old)).catch(function () {});
+    }
+    var body = {};
+    if (this._context.region) { body.region = this._context.region; }
+    if (this._context.profile) { body.profile = this._context.profile; }
+    this._openingKey = key;
+    var opening = this._transport.send('POST', PATHS.matrix, body).then(function (res) {
+      var id = res.data && res.data.matrix;
+      if (!id) { throw PlanError('sMap plan editor: the snapshot answer has no id'); }
+      if (self._destroyed) {
+        self._transport.send('DELETE', PATHS.matrix + '/' + encodeURIComponent(id)).catch(function () {});
+        return null;
+      }
+      self._matrixRetryAt = 0;
+      if (self._openingKey === key) { self._matrix = id; self._matrixKey = key; }
+      self._emit('snapshot', { status: 'opened', matrix: id, expires_at: res.data.expires_at || null, node: res.data.node || null });
+      return id;
+    }, function (err) {
+      self._matrixRetryAt = Date.now() + SNAPSHOT_RETRY_MS;
+      if (!self._destroyed) { self._emit('snapshot', { status: 'failed', matrix: null, error: err }); }
+      return null;
+    }).then(function (id) {
+      if (self._opening === opening) { self._opening = null; self._openingKey = null; }
+      return id;
+    });
+    this._opening = opening;
+    return opening;
+  };
+
+  // ------------------------------------------------------------------ texts (14 languages)
+
+  var TEXT_KEYS = ['editor', 'busy', 'undo', 'redo', 'refine', 'total', 'distance', 'drivingTime', 'stops', 'violations',
+    'unreachable', 'unassigned', 'noStops', 'place', 'remove', 'lock', 'unlock', 'choicesFor', 'choice', 'added', 'arrival',
+    'choose', 'chosen', 'close', 'notPlaced', 'preview', 'refined', 'notRefined', 'error', 'pending', 'km', 'hours',
+    'minutes', 'rule.capacity', 'rule.max_tasks', 'rule.max_distance', 'rule.max_travel_time', 'rule.vehicle_time_window',
+    'rule.skills', 'rule.time_window', 'rule.unreachable'];
+
+  function texts(list) {
+    var out = {};
+    TEXT_KEYS.forEach(function (k, i) { out[k] = list[i]; });
+    return out;
+  }
+
+  var TEXTS = {
+    en: texts(['Plan editor', 'Updating the plan', 'Undo', 'Redo', 'Refine', 'Total', 'Distance', 'Driving time', 'Stops',
+      'Violations', 'Unreachable legs', 'Unassigned', 'No stops', 'Place', 'Remove', 'Lock', 'Unlock', 'Positions for {job}',
+      '{vehicle}, stop {n}', '+{distance}, +{time}', 'Arrival {time}', 'Choose', 'Chosen', 'Close', 'No position found',
+      'Preview', 'Stops moved: {n}', 'No better order found', 'The plan could not be updated.', 'Not yet priced', '{d} km',
+      '{h} h {m} min', '{m} min', 'Capacity exceeded', 'Too many stops', 'Distance limit exceeded',
+      'Driving time limit exceeded', 'Working hours exceeded', 'Missing skills', 'Time window missed', 'No road to this stop']),
+    'zh-Hans': texts(['计划编辑器', '正在更新计划', '撤销', '重做', '优化', '合计', '距离', '行驶时间', '站点', '违规',
+      '不可达路段', '未分配', '无站点', '安排', '移除', '锁定', '解锁', '{job} 的可选位置', '{vehicle}，第 {n} 站',
+      '+{distance}，+{time}', '到达 {time}', '选择', '已选', '关闭', '未找到可用位置', '预览', '已移动站点：{n}',
+      '未找到更优的顺序', '计划未能更新。', '尚未计算', '{d} 公里', '{h} 小时 {m} 分钟', '{m} 分钟', '超出载量', '站点过多',
+      '超出距离上限', '超出行驶时间上限', '超出工作时间', '缺少技能', '错过时间窗', '无法到达此站点']),
+    'zh-Hant': texts(['計劃編輯器', '正在更新計劃', '復原', '重做', '優化', '合計', '距離', '行駛時間', '站點', '違規',
+      '不可達路段', '未分配', '無站點', '安排', '移除', '鎖定', '解鎖', '{job} 的可選位置', '{vehicle}，第 {n} 站',
+      '+{distance}，+{time}', '到達 {time}', '選擇', '已選', '關閉', '未找到可用位置', '預覽', '已移動站點：{n}',
+      '未找到更優的順序', '計劃未能更新。', '尚未計算', '{d} 公里', '{h} 小時 {m} 分鐘', '{m} 分鐘', '超出載量', '站點過多',
+      '超出距離上限', '超出行駛時間上限', '超出工作時間', '缺少技能', '錯過時間窗', '無法到達此站點']),
+    de: texts(['Planeditor', 'Plan wird aktualisiert', 'Rückgängig', 'Wiederholen', 'Optimieren', 'Gesamt', 'Strecke',
+      'Fahrzeit', 'Stopps', 'Verstöße', 'Nicht erreichbare Abschnitte', 'Nicht zugewiesen', 'Keine Stopps', 'Einplanen',
+      'Entfernen', 'Sperren', 'Entsperren', 'Positionen für {job}', '{vehicle}, Stopp {n}', '+{distance}, +{time}',
+      'Ankunft {time}', 'Auswählen', 'Ausgewählt', 'Schließen', 'Keine Position gefunden', 'Vorschau',
+      'Verschobene Stopps: {n}', 'Keine bessere Reihenfolge gefunden', 'Der Plan konnte nicht aktualisiert werden.',
+      'Noch nicht berechnet', '{d} km', '{h} Std. {m} Min.', '{m} Min.', 'Kapazität überschritten', 'Zu viele Stopps',
+      'Streckenlimit überschritten', 'Fahrzeitlimit überschritten', 'Arbeitszeit überschritten', 'Fehlende Fähigkeiten',
+      'Zeitfenster verpasst', 'Kein Weg zu diesem Stopp']),
+    es: texts(['Editor de planes', 'Actualizando el plan', 'Deshacer', 'Rehacer', 'Optimizar', 'Total', 'Distancia',
+      'Tiempo de conducción', 'Paradas', 'Infracciones', 'Tramos inalcanzables', 'Sin asignar', 'Sin paradas', 'Asignar',
+      'Quitar', 'Bloquear', 'Desbloquear', 'Posiciones para {job}', '{vehicle}, parada {n}', '+{distance}, +{time}',
+      'Llegada {time}', 'Elegir', 'Elegida', 'Cerrar', 'No se encontró ninguna posición', 'Vista previa',
+      'Paradas movidas: {n}', 'No se encontró un orden mejor', 'No se pudo actualizar el plan.', 'Aún sin calcular',
+      '{d} km', '{h} h {m} min', '{m} min', 'Capacidad superada', 'Demasiadas paradas', 'Límite de distancia superado',
+      'Límite de tiempo de conducción superado', 'Horario de trabajo superado', 'Faltan habilidades',
+      'Ventana horaria incumplida', 'No hay ruta hasta esta parada']),
+    fr: texts(['Éditeur de plan', 'Mise à jour du plan', 'Annuler', 'Rétablir', 'Optimiser', 'Total', 'Distance',
+      'Temps de conduite', 'Arrêts', 'Infractions', 'Tronçons inaccessibles', 'Non affectés', 'Aucun arrêt', 'Placer',
+      'Retirer', 'Verrouiller', 'Déverrouiller', 'Positions pour {job}', '{vehicle}, arrêt {n}', '+{distance}, +{time}',
+      'Arrivée {time}', 'Choisir', 'Choisie', 'Fermer', 'Aucune position trouvée', 'Aperçu', 'Arrêts déplacés : {n}',
+      'Aucun meilleur ordre trouvé', 'Le plan n’a pas pu être mis à jour.', 'Pas encore calculé', '{d} km',
+      '{h} h {m} min', '{m} min', 'Capacité dépassée', 'Trop d’arrêts', 'Limite de distance dépassée',
+      'Limite de temps de conduite dépassée', 'Horaires de travail dépassés', 'Compétences manquantes',
+      'Créneau horaire manqué', 'Aucune route vers cet arrêt']),
+    it: texts(['Editor del piano', 'Aggiornamento del piano', 'Annulla', 'Ripeti', 'Ottimizza', 'Totale', 'Distanza',
+      'Tempo di guida', 'Fermate', 'Violazioni', 'Tratti non raggiungibili', 'Non assegnate', 'Nessuna fermata', 'Assegna',
+      'Rimuovi', 'Blocca', 'Sblocca', 'Posizioni per {job}', '{vehicle}, fermata {n}', '+{distance}, +{time}',
+      'Arrivo {time}', 'Scegli', 'Scelta', 'Chiudi', 'Nessuna posizione trovata', 'Anteprima', 'Fermate spostate: {n}',
+      'Nessun ordine migliore trovato', 'Impossibile aggiornare il piano.', 'Non ancora calcolato', '{d} km',
+      '{h} h {m} min', '{m} min', 'Capacità superata', 'Troppe fermate', 'Limite di distanza superato',
+      'Limite di tempo di guida superato', 'Orario di lavoro superato', 'Competenze mancanti', 'Finestra oraria mancata',
+      'Nessuna strada per questa fermata']),
+    nl: texts(['Planeditor', 'Plan wordt bijgewerkt', 'Ongedaan maken', 'Opnieuw', 'Optimaliseren', 'Totaal', 'Afstand',
+      'Rijtijd', 'Stops', 'Overtredingen', 'Onbereikbare trajecten', 'Niet toegewezen', 'Geen stops', 'Inplannen',
+      'Verwijderen', 'Vergrendelen', 'Ontgrendelen', 'Posities voor {job}', '{vehicle}, stop {n}', '+{distance}, +{time}',
+      'Aankomst {time}', 'Kiezen', 'Gekozen', 'Sluiten', 'Geen positie gevonden', 'Voorbeeld', 'Verplaatste stops: {n}',
+      'Geen betere volgorde gevonden', 'Het plan kon niet worden bijgewerkt.', 'Nog niet berekend', '{d} km',
+      '{h} u {m} min', '{m} min', 'Capaciteit overschreden', 'Te veel stops', 'Afstandslimiet overschreden',
+      'Rijtijdlimiet overschreden', 'Werktijd overschreden', 'Ontbrekende vaardigheden', 'Tijdvenster gemist',
+      'Geen route naar deze stop']),
+    // European Portuguese.
+    pt: texts(['Editor de planos', 'A atualizar o plano', 'Anular', 'Refazer', 'Otimizar', 'Total', 'Distância',
+      'Tempo de condução', 'Paragens', 'Infrações', 'Troços inacessíveis', 'Não atribuídas', 'Sem paragens', 'Atribuir',
+      'Remover', 'Bloquear', 'Desbloquear', 'Posições para {job}', '{vehicle}, paragem {n}', '+{distance}, +{time}',
+      'Chegada {time}', 'Escolher', 'Escolhida', 'Fechar', 'Nenhuma posição encontrada', 'Pré-visualização',
+      'Paragens movidas: {n}', 'Nenhuma ordem melhor encontrada', 'Não foi possível atualizar o plano.',
+      'Ainda não calculado', '{d} km', '{h} h {m} min', '{m} min', 'Capacidade excedida', 'Demasiadas paragens',
+      'Limite de distância excedido', 'Limite de tempo de condução excedido', 'Horário de trabalho excedido',
+      'Competências em falta', 'Janela horária falhada', 'Sem estrada até esta paragem']),
+    // Serbian in the Latin script.
+    sr: texts(['Uređivač plana', 'Plan se ažurira', 'Opozovi', 'Ponovi', 'Optimizuj', 'Ukupno', 'Rastojanje',
+      'Vreme vožnje', 'Stanice', 'Prekršaji', 'Nedostupne deonice', 'Nedodeljeno', 'Nema stanica', 'Rasporedi', 'Ukloni',
+      'Zaključaj', 'Otključaj', 'Pozicije za {job}', '{vehicle}, stanica {n}', '+{distance}, +{time}', 'Dolazak {time}',
+      'Izaberi', 'Izabrano', 'Zatvori', 'Nije pronađena pozicija', 'Pregled', 'Premeštene stanice: {n}',
+      'Nije pronađen bolji redosled', 'Plan nije mogao da se ažurira.', 'Još nije izračunato', '{d} km',
+      '{h} h {m} min', '{m} min', 'Prekoračen kapacitet', 'Previše stanica', 'Prekoračeno ograničenje rastojanja',
+      'Prekoračeno ograničenje vremena vožnje', 'Prekoračeno radno vreme', 'Nedostaju veštine',
+      'Propušten vremenski prozor', 'Nema puta do ove stanice']),
+    hu: texts(['Tervszerkesztő', 'A terv frissítése folyamatban', 'Visszavonás', 'Újra', 'Optimalizálás', 'Összesen',
+      'Távolság', 'Vezetési idő', 'Megállók', 'Szabálysértések', 'Elérhetetlen szakaszok', 'Nincs hozzárendelve',
+      'Nincsenek megállók', 'Beosztás', 'Eltávolítás', 'Zárolás', 'Feloldás', 'Pozíciók ehhez: {job}',
+      '{vehicle}, {n}. megálló', '+{distance}, +{time}', 'Érkezés: {time}', 'Kiválasztás', 'Kiválasztva', 'Bezárás',
+      'Nem található pozíció', 'Előnézet', 'Áthelyezett megállók: {n}', 'Nem található jobb sorrend',
+      'A tervet nem sikerült frissíteni.', 'Még nincs kiszámítva', '{d} km', '{h} óra {m} perc', '{m} perc',
+      'Kapacitás túllépve', 'Túl sok megálló', 'Távolságkorlát túllépve', 'Vezetésiidő-korlát túllépve',
+      'Munkaidő túllépve', 'Hiányzó képességek', 'Időablak elmulasztva', 'Nincs út ehhez a megállóhoz']),
+    pl: texts(['Edytor planu', 'Aktualizowanie planu', 'Cofnij', 'Ponów', 'Optymalizuj', 'Razem', 'Odległość',
+      'Czas jazdy', 'Przystanki', 'Naruszenia', 'Nieosiągalne odcinki', 'Nieprzypisane', 'Brak przystanków', 'Przydziel',
+      'Usuń', 'Zablokuj', 'Odblokuj', 'Pozycje dla {job}', '{vehicle}, przystanek {n}', '+{distance}, +{time}',
+      'Przyjazd {time}', 'Wybierz', 'Wybrano', 'Zamknij', 'Nie znaleziono pozycji', 'Podgląd',
+      'Przeniesione przystanki: {n}', 'Nie znaleziono lepszej kolejności', 'Nie udało się zaktualizować planu.',
+      'Jeszcze nie obliczono', '{d} km', '{h} godz. {m} min', '{m} min', 'Przekroczona ładowność',
+      'Zbyt wiele przystanków', 'Przekroczony limit odległości', 'Przekroczony limit czasu jazdy',
+      'Przekroczony czas pracy', 'Brak umiejętności', 'Pominięte okno czasowe', 'Brak drogi do tego przystanku']),
+    sk: texts(['Editor plánu', 'Plán sa aktualizuje', 'Späť', 'Znova', 'Optimalizovať', 'Spolu', 'Vzdialenosť',
+      'Čas jazdy', 'Zastávky', 'Porušenia', 'Nedosiahnuteľné úseky', 'Nepriradené', 'Žiadne zastávky', 'Zaradiť',
+      'Odstrániť', 'Uzamknúť', 'Odomknúť', 'Pozície pre {job}', '{vehicle}, zastávka {n}', '+{distance}, +{time}',
+      'Príchod {time}', 'Vybrať', 'Vybrané', 'Zavrieť', 'Nenašla sa žiadna pozícia', 'Náhľad', 'Presunuté zastávky: {n}',
+      'Lepšie poradie sa nenašlo', 'Plán sa nepodarilo aktualizovať.', 'Ešte nevypočítané', '{d} km', '{h} h {m} min',
+      '{m} min', 'Prekročená kapacita', 'Príliš veľa zastávok', 'Prekročený limit vzdialenosti',
+      'Prekročený limit času jazdy', 'Prekročený pracovný čas', 'Chýbajúce zručnosti', 'Zmeškané časové okno',
+      'Žiadna cesta k tejto zastávke']),
+    cs: texts(['Editor plánu', 'Plán se aktualizuje', 'Zpět', 'Znovu', 'Optimalizovat', 'Celkem', 'Vzdálenost',
+      'Doba jízdy', 'Zastávky', 'Porušení', 'Nedosažitelné úseky', 'Nepřiřazené', 'Žádné zastávky', 'Zařadit', 'Odebrat',
+      'Zamknout', 'Odemknout', 'Pozice pro {job}', '{vehicle}, zastávka {n}', '+{distance}, +{time}', 'Příjezd {time}',
+      'Vybrat', 'Vybráno', 'Zavřít', 'Nebyla nalezena žádná pozice', 'Náhled', 'Přesunuté zastávky: {n}',
+      'Lepší pořadí nebylo nalezeno', 'Plán se nepodařilo aktualizovat.', 'Dosud nevypočteno', '{d} km', '{h} h {m} min',
+      '{m} min', 'Překročena kapacita', 'Příliš mnoho zastávek', 'Překročen limit vzdálenosti',
+      'Překročen limit doby jízdy', 'Překročena pracovní doba', 'Chybějící dovednosti', 'Zmeškané časové okno',
+      'K této zastávce nevede cesta']),
+  };
+  var LANGUAGES = Object.keys(TEXTS);
+
+  /** The panel's language for a BCP-47 tag: one of the 14, English when none fits. */
+  function panelLanguage(tag) {
+    var t = String(tag || 'en').toLowerCase();
+    if (/^zh-(hant|tw|hk|mo)/.test(t)) { return 'zh-Hant'; }
+    if (/^zh/.test(t)) { return 'zh-Hans'; }
+    var base = t.split(/[-_]/)[0];
+    return TEXTS[base] ? base : 'en';
+  }
+
+  /** The panel's texts in a language, with the caller's own texts (`labels`) over them. */
+  function textsFor(language, labels) {
+    var out = {};
+    var own = TEXTS[panelLanguage(language)];
+    TEXT_KEYS.forEach(function (k) { out[k] = (labels && labels[k]) || own[k]; });
+    return out;
+  }
+
+  function fill(template, values) {
+    return String(template).replace(/\{(\w+)\}/g, function (m, k) { return values[k] === undefined ? m : String(values[k]); });
+  }
+
+  // ------------------------------------------------------------------ the panel
+
+  // The locale numbers are written in: the panel's Portuguese is European Portuguese, so any `pt` tag writes numbers
+  // as `pt-PT` does (`pt` alone is Brazilian grouping); every other tag is used as given.
+  function numberLocale(language) {
+    return panelLanguage(language) === 'pt' ? 'pt-PT' : language;
+  }
+
+  function numberFormat(language, digits) {
+    try {
+      var nf = new Intl.NumberFormat(numberLocale(language), { minimumFractionDigits: digits, maximumFractionDigits: digits });
+      return function (v) { return nf.format(v); };
+    } catch (e) { return function (v) { return Number(v).toFixed(digits); }; }
+  }
+
+  function formatters(language, t) {
+    var one = numberFormat(language, 1);
+    return {
+      distance: function (m) { return fill(t.km, { d: one((Number(m) || 0) / 1000) }); },
+      time: function (s) {
+        var min = Math.round((Number(s) || 0) / 60);
+        var h = Math.floor(min / 60);
+        var m = min % 60;
+        return h > 0 ? fill(t.hours, { h: h, m: (m < 10 ? '0' : '') + m }) : fill(t.minutes, { m: m });
+      },
+      // The clock time of an ISO 8601 time with offset, as the answer gives it (the plan's own time zone).
+      clock: function (iso) { var m = /T(\d\d:\d\d)/.exec(String(iso || '')); return m ? m[1] : ''; },
+    };
+  }
+
+  var COLORS = ['#2563eb', '#dc2626', '#16a34a', '#9333ea', '#ea580c', '#0891b2', '#db2777', '#65a30d', '#4f46e5', '#b45309'];
+
+  function colorOf(editor, vehicleId, colors) {
+    var list = colors || COLORS;
+    var i = 0;
+    editor._vehicles.some(function (v, k) { if (String(v.id) === vehicleId) { i = k; return true; } return false; });
+    return list[i % list.length];
+  }
+
+  /**
+   * The ready-made panel: routes with their totals and stops, violations, undo / redo / refine, the positions an
+   * insert answered, and errors. Stops are dragged between lists, or onto the unassigned list to take them off.
+   * @param {PlanEditor} editor
+   * @param {Object} [o] language (BCP-47), labels (own texts by key), document, colors, className
+   * @returns {{ element: HTMLElement, setLanguage(language: string): void, render(): void, destroy(): void }}
+   */
+  function createPanel(editor, o) {
+    o = o || {};
+    var doc = o.document || (typeof document !== 'undefined' ? document : null);
+    if (!doc) { throw new Error('sMap plan editor: the panel needs a document'); }
+    var language = o.language || 'en';
+    var t = textsFor(language, o.labels);
+    var fmt = formatters(language, t);
+    var root = doc.createElement('div');
+    root.className = 'smap-plan-panel' + (o.className ? ' ' + o.className : '');
+    var dragging = null;
+
+    function el(tag, className, text) {
+      var n = doc.createElement(tag);
+      if (className) { n.className = className; }
+      if (text !== undefined && text !== null) { n.textContent = String(text); }
+      return n;
+    }
+    function button(className, text, onClick, disabled) {
+      var b = el('button', 'smap-plan-button ' + className, text);
+      b.type = 'button';
+      if (disabled) { b.disabled = true; }
+      b.addEventListener('click', function () { var p = onClick(); if (p && p.catch) { p.catch(function () {}); } });
+      return b;
+    }
+    function totals(parent, summary, stops) {
+      var dl = el('dl', 'smap-plan-totals');
+      function row(label, value, className) {
+        var w = el('div', className);
+        w.appendChild(el('dt', null, label));
+        w.appendChild(el('dd', null, value));
+        dl.appendChild(w);
+      }
+      row(t.distance, fmt.distance(summary.distance_meters), 'smap-plan-distance');
+      row(t.drivingTime, fmt.time(summary.duration_seconds), 'smap-plan-time');
+      row(t.stops, String(stops), 'smap-plan-stops');
+      if (summary.violations || summary.violation_count) { row(t.violations, String(summary.violations || summary.violation_count), 'smap-plan-violations'); }
+      if (summary.unreachable_legs) { row(t.unreachable, String(summary.unreachable_legs), 'smap-plan-unreachable'); }
+      parent.appendChild(dl);
+    }
+    function ruleText(v) { return t['rule.' + v.rule] || v.message || v.rule; }
+    function dropZone(node, onDrop) {
+      node.addEventListener('dragover', function (e) { if (dragging) { e.preventDefault(); node.classList.add('smap-plan-over'); } });
+      node.addEventListener('dragleave', function () { node.classList.remove('smap-plan-over'); });
+      node.addEventListener('drop', function (e) {
+        node.classList.remove('smap-plan-over');
+        if (!dragging) { return; }
+        e.preventDefault();
+        e.stopPropagation();
+        var id = dragging;
+        dragging = null;
+        var p = onDrop(id);
+        if (p && p.catch) { p.catch(function () {}); }
+      });
+    }
+    function draggable(node, id) {
+      node.draggable = true;
+      node.setAttribute('data-stop', id);
+      node.addEventListener('dragstart', function (e) {
+        dragging = id;
+        if (e.dataTransfer) { try { e.dataTransfer.setData('text/plain', id); e.dataTransfer.effectAllowed = 'move'; } catch (x) { /* older engines */ } }
+      });
+      node.addEventListener('dragend', function () { dragging = null; });
+    }
+
+    function render() {
+      var s = editor.state();
+      while (root.firstChild) { root.removeChild(root.firstChild); }
+      root.setAttribute('role', 'region');
+      root.setAttribute('aria-label', t.editor);
+      root.setAttribute('aria-busy', s.busy ? 'true' : 'false');
+      root.classList.toggle('smap-plan-busy', s.busy);
+
+      var bar = el('div', 'smap-plan-bar');
+      bar.appendChild(button('smap-plan-undo', t.undo, function () { return editor.undo(); }, !s.canUndo));
+      bar.appendChild(button('smap-plan-redo', t.redo, function () { return editor.redo(); }, !s.canRedo));
+      bar.appendChild(button('smap-plan-refine', t.refine, function () { return editor.refine(); }, !s.plan));
+      var status = el('span', 'smap-plan-status', s.busy ? t.busy : '');
+      status.setAttribute('role', 'status');
+      bar.appendChild(status);
+      root.appendChild(bar);
+
+      if (s.error) {
+        var alert = el('div', 'smap-plan-error');
+        alert.setAttribute('role', 'alert');
+        alert.appendChild(el('span', null, t.error + (s.error.code ? ' (' + s.error.code + (s.error.reason ? ', ' + s.error.reason : '') + ')' : '')));
+        alert.appendChild(button('smap-plan-error-close', t.close, function () { editor._error = null; render(); }));
+        root.appendChild(alert);
+      }
+      if (s.last && s.last.kind === 'refine' && s.last.answer) {
+        root.appendChild(el('div', 'smap-plan-note', s.last.answer.changed ? fill(t.refined, { n: s.last.answer.moved || 0 }) : t.notRefined));
+      }
+      if (!s.plan) { return; }
+
+      var priced = {};
+      ((s.result && s.result.routes) || []).forEach(function (r) { priced[r.vehicle_id] = r; });
+      var summary = s.result && s.result.summary;
+      var total = el('section', 'smap-plan-total');
+      total.appendChild(el('h3', null, t.total));
+      if (summary) { totals(total, summary, summary.tasks !== undefined ? summary.tasks : 0); } else { total.appendChild(el('p', 'smap-plan-pending', t.pending)); }
+      if (s.preview && s.preview.result && s.preview.result.summary) {
+        var pv = el('div', 'smap-plan-preview');
+        pv.appendChild(el('h4', null, t.preview));
+        totals(pv, s.preview.result.summary, s.preview.result.summary.tasks || 0);
+        total.appendChild(pv);
+      }
+      root.appendChild(total);
+
+      var routes = el('div', 'smap-plan-routes');
+      s.plan.routes.forEach(function (r) {
+        var p = priced[r.vehicle_id];
+        var section = el('section', 'smap-plan-route');
+        section.setAttribute('data-vehicle', r.vehicle_id);
+        var head = el('h3', 'smap-plan-route-head');
+        var swatch = el('span', 'smap-plan-swatch');
+        swatch.style.background = colorOf(editor, r.vehicle_id, o.colors);
+        head.appendChild(swatch);
+        head.appendChild(el('span', null, r.vehicle_id));
+        section.appendChild(head);
+        if (p) {
+          totals(section, { distance_meters: p.distance_meters, duration_seconds: p.duration_seconds, violation_count: p.violation_count, unreachable_legs: p.unreachable_legs }, r.stops.length);
+          if (p.violations && p.violations.length) {
+            var ul = el('ul', 'smap-plan-route-violations');
+            p.violations.forEach(function (v) { ul.appendChild(el('li', null, ruleText(v))); });
+            section.appendChild(ul);
+          }
+        }
+        var byId = {};
+        ((p && p.stops) || []).forEach(function (st) { if (st.type === 'job') { byId[st.id] = st; } });
+        var ol = el('ol', 'smap-plan-stops-list');
+        if (!r.stops.length) { ol.appendChild(el('li', 'smap-plan-empty', t.noStops)); }
+        r.stops.forEach(function (id, i) {
+          var st = byId[id];
+          var li = el('li', 'smap-plan-stop' + (editor.isLocked(id) ? ' smap-plan-locked' : ''));
+          draggable(li, id);
+          li.appendChild(el('span', 'smap-plan-seq', String(i + 1)));
+          li.appendChild(el('span', 'smap-plan-id', id));
+          if (st && st.arrival) {
+            // The clock time only, the full text for the pointer and screen readers: a stop row stays on one line.
+            var arrival = el('span', 'smap-plan-arrival', fmt.clock(st.arrival));
+            arrival.title = fill(t.arrival, { time: fmt.clock(st.arrival) });
+            arrival.setAttribute('aria-label', arrival.title);
+            li.appendChild(arrival);
+          }
+          var marks = [];
+          if (st && st.reachable === false) { marks.push(t['rule.unreachable']); }
+          ((st && st.violations) || []).forEach(function (v) { marks.push(ruleText(v)); });
+          if (marks.length) { li.appendChild(el('span', 'smap-plan-stop-violations', marks.join(', '))); }
+          var locked = editor.isLocked(id);
+          li.appendChild(button('smap-plan-lock', locked ? t.unlock : t.lock, function () { return locked ? editor.unlock(id) : editor.lock(id); }));
+          li.appendChild(button('smap-plan-remove', t.remove, function () { return editor.remove([id]); }));
+          dropZone(li, function (dragged) { return editor.dropStop(dragged, r.vehicle_id, i + 1); });
+          ol.appendChild(li);
+        });
+        dropZone(ol, function (dragged) { return editor.dropStop(dragged, r.vehicle_id, r.stops.length + 1); });
+        section.appendChild(ol);
+        routes.appendChild(section);
+      });
+      root.appendChild(routes);
+
+      var un = el('section', 'smap-plan-unassigned');
+      un.appendChild(el('h3', null, t.unassigned + ' (' + s.plan.unassigned.length + ')'));
+      var ulu = el('ul', 'smap-plan-unassigned-list');
+      s.plan.unassigned.forEach(function (id) {
+        var li = el('li', 'smap-plan-job');
+        draggable(li, id);
+        li.appendChild(el('span', 'smap-plan-id', id));
+        li.appendChild(button('smap-plan-place', t.place, function () { return editor.insert(id); }));
+        ulu.appendChild(li);
+      });
+      dropZone(un, function (dragged) { return s.plan.unassigned.indexOf(dragged) >= 0 ? null : editor.remove([dragged]); });
+      un.appendChild(ulu);
+      root.appendChild(un);
+
+      if (s.choices && s.choices.length) {
+        var ch = el('section', 'smap-plan-choices');
+        s.choices.forEach(function (item) {
+          ch.appendChild(el('h3', null, fill(t.choicesFor, { job: item.job })));
+          if (!item.placed && !item.choices.length) { ch.appendChild(el('p', 'smap-plan-not-placed', t.notPlaced)); }
+          var list = el('ol', 'smap-plan-choice-list');
+          item.choices.forEach(function (c, i) {
+            var li = el('li', 'smap-plan-choice' + (c.feasible ? '' : ' smap-plan-infeasible'));
+            li.appendChild(el('span', 'smap-plan-choice-where', fill(t.choice, { vehicle: c.vehicle_id, n: c.position })));
+            li.appendChild(el('span', 'smap-plan-choice-added', fill(t.added, { distance: fmt.distance(c.added_distance_meters), time: fmt.time(c.added_duration_seconds) })));
+            if (c.arrival) { li.appendChild(el('span', 'smap-plan-arrival', fill(t.arrival, { time: fmt.clock(c.arrival) }))); }
+            if (!c.feasible && c.violations && c.violations.length) {
+              li.appendChild(el('span', 'smap-plan-stop-violations', c.violations.map(ruleText).join(', ')));
+            }
+            var chosen = item.chosen === i;
+            li.appendChild(button('smap-plan-choose', chosen ? t.chosen : t.choose, function () { return editor.choose(item.job, i); }, chosen));
+            list.appendChild(li);
+          });
+          ch.appendChild(list);
+        });
+        ch.appendChild(button('smap-plan-choices-close', t.close, function () { editor.clearChoices(); }));
+        root.appendChild(ch);
+      }
+    }
+
+    var onAny = function () { render(); };
+    ['change', 'busy', 'preview'].forEach(function (type) { editor.on(type, onAny); });
+    var gone = function () { api.destroy(); };
+    editor.on('destroy', gone);
+    render();
+    var api = {
+      element: root,
+      render: render,
+      setLanguage: function (lang) { language = lang; t = textsFor(lang, o.labels); fmt = formatters(lang, t); render(); },
+      destroy: function () {
+        ['change', 'busy', 'preview'].forEach(function (type) { editor.off(type, onAny); });
+        editor.off('destroy', gone);
+        if (root.parentNode) { root.parentNode.removeChild(root); }
+      },
+    };
+    return api;
+  }
+
+  // ------------------------------------------------------------------ the map layer (sMap)
+
+  /** The features drawn for the editor's plan: legs, stops, unassigned jobs and vehicle starts. */
+  function planFeatures(editor, id, colors) {
+    var e = editor._history[editor._at];
+    var out = { legs: [], stops: [], unassigned: [], starts: [] };
+    if (!e) { return out; }
+    var jobs = {};
+    e.jobs.forEach(function (j) { jobs[String(j.id)] = j; });
+    var vehicles = {};
+    editor._vehicles.forEach(function (v) { vehicles[String(v.id)] = v; });
+    var priced = {};
+    ((e.result && e.result.routes) || []).forEach(function (r) { priced[r.vehicle_id] = r; });
+    function feature(geometry, props) { props.smap_plan = id; return { type: 'Feature', properties: props, geometry: geometry }; }
+    e.routes.forEach(function (r) {
+      var v = vehicles[r.vehicle_id] || {};
+      var color = colorOf(editor, r.vehicle_id, colors);
+      var start = lngLat(v.start);
+      var end = lngLat(v.end) || (v.return_to_start ? start : null);
+      if (start) { out.starts.push(feature({ type: 'Point', coordinates: start }, { kind: 'start', vehicle_id: r.vehicle_id, position: 1, color: color })); }
+      var p = priced[r.vehicle_id];
+      // The answer's legs (with their lines) while the drawn order is the answered one; straight lines before.
+      var answered = p && p.stops && p.stops.filter(function (s) { return s.type === 'job'; }).map(function (s) { return s.id; }).join('\u0000') === r.stops.join('\u0000');
+      var prev = start;
+      var points = r.stops.map(function (s) { return lngLat(jobs[s] && jobs[s].location); });
+      if (answered) {
+        var k = 0;
+        p.stops.forEach(function (st) {
+          if (st.type === 'start') { return; }
+          var position = st.type === 'job' ? (k += 1) : r.stops.length + 1;
+          var to = st.type === 'job' ? points[position - 1] : end;
+          var line = st.leg_geometry ? decodePolyline(st.leg_geometry) : (prev && to ? [prev, to] : null);
+          if (line && line.length > 1) { out.legs.push(feature({ type: 'LineString', coordinates: line }, { kind: 'leg', vehicle_id: r.vehicle_id, position: position, color: color })); }
+          if (to) { prev = to; }
+        });
+      } else {
+        points.concat(end ? [end] : []).forEach(function (to, i) {
+          if (prev && to) { out.legs.push(feature({ type: 'LineString', coordinates: [prev, to] }, { kind: 'leg', vehicle_id: r.vehicle_id, position: i + 1, color: color })); }
+          if (to) { prev = to; }
+        });
+      }
+      var stopInfo = {};
+      ((p && p.stops) || []).forEach(function (st) { if (st.type === 'job') { stopInfo[st.id] = st; } });
+      r.stops.forEach(function (s, i) {
+        if (!points[i]) { return; }
+        var st = answered ? stopInfo[s] : null;
+        var violated = !!(st && ((st.violations && st.violations.length) || st.reachable === false));
+        var locked = editor.isLocked(s);
+        out.stops.push(feature({ type: 'Point', coordinates: points[i] }, {
+          kind: 'stop', id: s, vehicle_id: r.vehicle_id, position: i + 1, label: String(i + 1), color: color,
+          border: violated ? '#b91c1c' : (locked ? '#111827' : color), locked: locked, violated: violated,
+        }));
+      });
+    });
+    unassignedOf(e.jobs, e.routes).forEach(function (s) {
+      var at = lngLat(jobs[s] && jobs[s].location);
+      if (at) { out.unassigned.push(feature({ type: 'Point', coordinates: at }, { kind: 'unassigned', id: s, color: '#6b7280' })); }
+    });
+    return out;
+  }
+
+  // Where a drop at these features goes: before a stop, into a leg (before the stop it leads to), or first after a start.
+  function dropTarget(hits, dragged) {
+    for (var i = 0; i < hits.length; i++) {
+      var p = hits[i].properties || {};
+      if (p.kind === 'stop' && p.id !== dragged) { return { vehicle_id: p.vehicle_id, position: Number(p.position) }; }
+    }
+    for (var k = 0; k < hits.length; k++) {
+      var q = hits[k].properties || {};
+      if (q.kind === 'leg' || q.kind === 'start') { return { vehicle_id: q.vehicle_id, position: Number(q.position) }; }
+    }
+    return null;
+  }
+
+  var DRAG_PX = 4;
+  var PREVIEW_MS = 250;
+
+  // ------------------------------------------------------------------ parts for other map libraries
+  //
+  // What a binding on another map library (the tool adapters, a page of your own) needs besides the editor: the
+  // features to draw, where a drop lands, a drag with its preview, the panel and its stylesheet.
+
+  /** The routes after dropping stopId at `target` ({ vehicle_id, position } as dropTarget gives it); null: no change. */
+  function dropRoutes(editor, stopId, target) {
+    var e = editor._history[editor._at];
+    if (!e || !target) { return null; }
+    var id = String(stopId);
+    var edit = dropEdit(e.routes, id, String(target.vehicle_id), Number(target.position));
+    if (!edit) { return null; }
+    return edit.kind === 'resequence' ? applyResequence(e.routes, edit.vehicle_id, edit.stops) : applyMove(e.routes, [id], edit.vehicle_id, edit.position);
+  }
+
+  function segmentDistance(p, a, b) {
+    var dx = b.x - a.x;
+    var dy = b.y - a.y;
+    var l = dx * dx + dy * dy;
+    var t = l ? Math.max(0, Math.min(1, ((p.x - a.x) * dx + (p.y - a.y) * dy) / l)) : 0;
+    var x = a.x + t * dx - p.x;
+    var y = a.y + t * dy - p.y;
+    return Math.sqrt(x * x + y * y);
+  }
+
+  /**
+   * The features within `tolerance` pixels of a screen point, nearest first, for libraries that cannot tell which
+   * drawn feature is under the pointer. `features`: planFeatures' answer or a list; `project([lng, lat])` gives
+   * { x, y } in the same pixels as `point`.
+   * @param {Object} [o] tolerance (default 12 px for points, 8 px for lines)
+   */
+  function featuresAt(features, project, point, o) {
+    o = o || {};
+    var list = Array.isArray(features) ? features : [].concat(features.stops || [], features.unassigned || [], features.starts || [], features.legs || []);
+    var hits = [];
+    list.forEach(function (f, order) {
+      var g = f && f.geometry;
+      if (!g) { return; }
+      var d = Infinity;
+      if (g.type === 'Point') {
+        var q = project(g.coordinates);
+        d = Math.sqrt((q.x - point.x) * (q.x - point.x) + (q.y - point.y) * (q.y - point.y));
+        if (d > (o.tolerance === undefined ? 12 : o.tolerance)) { return; }
+      } else if (g.type === 'LineString') {
+        var pts = g.coordinates.map(project);
+        for (var i = 1; i < pts.length; i++) { d = Math.min(d, segmentDistance(point, pts[i - 1], pts[i])); }
+        if (d > (o.tolerance === undefined ? 8 : o.tolerance)) { return; }
+      } else { return; }
+      hits.push({ f: f, d: d, order: order });
+    });
+    hits.sort(function (a, b) { return a.d - b.d || a.order - b.order; });
+    return hits.map(function (h) { return h.f; });
+  }
+
+  /**
+   * A stop dragged on a map: start(stopId, point?) when the pointer goes down on a stop or an unassigned job,
+   * move(hits, point?) with the features under the pointer (it becomes a drag past `threshold` pixels, and the plan
+   * with the stop at the target is priced as a preview after `previewMs`), end(hits?) drops it (editor.dropStop; the
+   * last target when no hits are given), cancel() gives it up.
+   * @param {Object} [o] preview (default true), previewMs (250), threshold (4 px)
+   */
+  function planDrag(editor, o) {
+    o = o || {};
+    var preview = o.preview !== false;
+    var threshold = o.threshold === undefined ? DRAG_PX : o.threshold;
+    var previewMs = o.previewMs === undefined ? PREVIEW_MS : o.previewMs;
+    var drag = null;
+    var timer = null;
+    function stopTimer() { if (timer) { clearTimeout(timer); timer = null; } }
+    return {
+      start: function (stopId, point) {
+        stopTimer();
+        drag = { id: String(stopId), start: point || null, moved: false, target: null, key: null };
+      },
+      move: function (hits, point) {
+        if (!drag) { return null; }
+        if (!drag.moved && point && drag.start && Math.abs(point.x - drag.start.x) + Math.abs(point.y - drag.start.y) < threshold) { return null; }
+        drag.moved = true;
+        var target = dropTarget(hits || [], drag.id);
+        var key = target ? target.vehicle_id + '#' + target.position : null;
+        if (key === drag.key) { return target; }
+        drag.key = key;
+        drag.target = target;
+        stopTimer();
+        if (!preview) { return target; }
+        var routes = dropRoutes(editor, drag.id, target);
+        if (!routes) { editor.clearPreview(); return target; }
+        timer = setTimeout(function () { timer = null; editor.preview(routes); }, previewMs);
+        return target;
+      },
+      end: function (hits) {
+        if (!drag) { return Promise.resolve(null); }
+        var d = drag;
+        drag = null;
+        stopTimer();
+        if (!d.moved) { return Promise.resolve(null); }
+        var target = hits ? dropTarget(hits, d.id) : d.target;
+        editor.clearPreview();
+        if (!target) { return Promise.resolve(null); }
+        return editor.dropStop(d.id, target.vehicle_id, target.position).catch(function () { return null; });
+      },
+      cancel: function () {
+        var d = drag;
+        drag = null;
+        stopTimer();
+        if (d && d.moved) { editor.clearPreview(); }
+      },
+      dragging: function () { return drag ? drag.id : null; },
+      moved: function () { return !!(drag && drag.moved); },
+      target: function () { return drag ? drag.target : null; },
+    };
+  }
+
+  // The panel's stylesheet (the .smap-plan-* rules of smap.css), filled in by js/build.mjs.
+  var PANEL_CSS = "/* Plan editor panel (OPEN-ROUTE-EDIT E10). Restyle through these classes; every colour is set here. */\n.smap-plan-panel {\n  width: 320px; max-width: calc(100vw - 20px); max-height: 70vmin; overflow-y: auto; padding: 10px; box-sizing: border-box;\n  border-radius: 8px; background: #ffffff; color: #1e293b; box-shadow: 0 2px 10px rgba(15, 23, 42, 0.18);\n  font: 12px/1.35 -apple-system, BlinkMacSystemFont, \"Segoe UI\", Roboto, \"Helvetica Neue\", Arial, sans-serif;\n}\n.smap-plan-panel h3 { margin: 10px 0 4px; font-size: 13px; font-weight: 600; }\n.smap-plan-panel h4 { margin: 6px 0 2px; font-size: 12px; font-weight: 600; }\n.smap-plan-bar { display: flex; align-items: center; gap: 4px; flex-wrap: wrap; }\n.smap-plan-button {\n  min-height: 26px; padding: 3px 8px; border: 1px solid rgba(15, 23, 42, 0.18); border-radius: 6px; background: #ffffff;\n  color: inherit; font: inherit; cursor: pointer;\n}\n.smap-plan-button:disabled { opacity: 0.45; cursor: default; }\n.smap-plan-button:focus-visible { outline: 2px solid #2563eb; outline-offset: 1px; }\n.smap-plan-status { margin-left: auto; color: #2563eb; }\n.smap-plan-error { display: flex; align-items: center; gap: 6px; margin-top: 8px; padding: 6px 8px; border-radius: 6px; background: #fef2f2; color: #991b1b; }\n.smap-plan-error span { flex: 1 1 auto; }\n.smap-plan-note { margin-top: 8px; color: #475569; }\n.smap-plan-totals { display: flex; flex-wrap: wrap; gap: 2px 12px; margin: 2px 0 4px; }\n.smap-plan-totals div { display: flex; gap: 4px; }\n.smap-plan-totals dt { color: #64748b; }\n.smap-plan-totals dd { margin: 0; font-weight: 600; }\n.smap-plan-violations dd, .smap-plan-unreachable dd, .smap-plan-route-violations, .smap-plan-stop-violations { color: #b91c1c; }\n.smap-plan-preview { margin-top: 4px; padding: 4px 6px; border-radius: 6px; background: #eff6ff; }\n.smap-plan-pending { margin: 2px 0; color: #64748b; }\n.smap-plan-route-head { display: flex; align-items: center; gap: 6px; }\n.smap-plan-swatch { width: 10px; height: 10px; border-radius: 50%; flex: 0 0 auto; }\n.smap-plan-route-violations { margin: 2px 0; padding-left: 16px; }\n.smap-plan-stops-list, .smap-plan-unassigned-list, .smap-plan-choice-list { margin: 0; padding: 0; list-style: none; min-height: 8px; }\n.smap-plan-stop, .smap-plan-job, .smap-plan-choice {\n  display: flex; flex-wrap: wrap; align-items: center; gap: 4px 6px; padding: 3px 4px; border-radius: 4px;\n}\n.smap-plan-stop, .smap-plan-job { flex-wrap: nowrap; }\n.smap-plan-stop .smap-plan-id, .smap-plan-job .smap-plan-id { min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }\n.smap-plan-stop .smap-plan-arrival { white-space: nowrap; }\n.smap-plan-stop .smap-plan-stop-violations { white-space: nowrap; overflow: hidden; text-overflow: ellipsis; min-width: 0; }\n.smap-plan-stop, .smap-plan-job { cursor: grab; }\n.smap-plan-stop:hover, .smap-plan-job:hover { background: #f1f5f9; }\n.smap-plan-over { outline: 2px dashed #2563eb; outline-offset: -2px; }\n.smap-plan-seq { min-width: 18px; color: #64748b; text-align: right; }\n.smap-plan-id { font-weight: 600; }\n.smap-plan-arrival { color: #475569; }\n.smap-plan-stop .smap-plan-button, .smap-plan-job .smap-plan-button, .smap-plan-choice .smap-plan-button { min-height: 22px; padding: 1px 6px; }\n.smap-plan-stop .smap-plan-lock { margin-left: auto; }\n.smap-plan-job .smap-plan-place, .smap-plan-choice .smap-plan-choose { margin-left: auto; }\n.smap-plan-locked .smap-plan-id::after { content: \" \\1F512\"; font-weight: 400; }\n.smap-plan-empty { color: #94a3b8; cursor: default; }\n.smap-plan-infeasible .smap-plan-choice-where { color: #b91c1c; }\n.smap-plan-choices { margin-top: 8px; padding-top: 4px; border-top: 1px solid rgba(15, 23, 42, 0.12); }\n.smap-plan-choices-close { margin-top: 6px; }\n.smap-style-dark .smap-plan-panel, .smap-style-black .smap-plan-panel { background: #1f2430; color: #e5e7eb; }\n.smap-style-dark .smap-plan-button, .smap-style-black .smap-plan-button { background: #1f2430; border-color: rgba(229, 231, 235, 0.2); }\n.smap-style-dark .smap-plan-stop:hover, .smap-style-black .smap-plan-stop:hover,\n.smap-style-dark .smap-plan-job:hover, .smap-style-black .smap-plan-job:hover { background: #2b3242; }\n";
+
+  /** Adds the panel's stylesheet to a document once (pages that load smap.css have it already). */
+  function injectCss(doc) {
+    if (!doc || !doc.head || PANEL_CSS.indexOf('__SMAP') === 0 || doc.getElementById('smap-plan-css')) { return; }
+    var style = doc.createElement('style');
+    style.id = 'smap-plan-css';
+    style.textContent = PANEL_CSS;
+    doc.head.appendChild(style);
+  }
+
+  /**
+   * Draws the editor's plan on an sMap map as layers `<id>:legs`, `<id>:starts`, `<id>:stops`, `<id>:unassigned`, and
+   * lets a stop (or an unassigned job) be dragged before another stop or onto a route's line.
+   * @returns {{ remove(): void, features(): Object }}
+   */
+  function attachToMap(map, editor, o) {
+    o = o || {};
+    var id = o.id || 'plan';
+    var ids = { legs: id + ':legs', starts: id + ':starts', stops: id + ':stops', unassigned: id + ':unassigned', drag: id + ':drag' };
+    var added = false;
+    var removed = false;
+    var drag = planDrag(editor, { preview: o.preview !== false });
+
+    function draw() {
+      if (removed) { return; }
+      var f = planFeatures(editor, id, o.colors);
+      var fc = function (list) { return { type: 'FeatureCollection', features: list }; };
+      if (!added) {
+        map.addLines(ids.legs, fc(f.legs), { color: { property: 'color' }, width: 4, casing: true, arrows: true, zIndex: o.zIndex });
+        map.addPoints(ids.starts, fc(f.starts), { marker: { shape: 'circle', fill: { property: 'color' }, border: '#ffffff', size: 18, text: '', overlap: false } });
+        map.addPoints(ids.unassigned, fc(f.unassigned), { marker: { shape: 'circle', fill: '#9ca3af', border: '#ffffff', size: 18, text: '', overlap: false } });
+        map.addPoints(ids.stops, fc(f.stops), { marker: { shape: 'pin', fill: { property: 'color' }, border: { property: 'border' }, text: { property: 'label' }, overlap: false } });
+        map.addPoints(ids.drag, fc([]), { marker: { shape: 'circle', fill: '#111827', border: '#ffffff', size: 16, text: '', overlap: false } });
+        added = true;
+      } else {
+        map.setData(ids.legs, fc(f.legs));
+        map.setData(ids.starts, fc(f.starts));
+        map.setData(ids.unassigned, fc(f.unassigned));
+        map.setData(ids.stops, fc(f.stops));
+      }
+    }
+
+    function engine() { return map.engine; }
+    function hitsAt(point) {
+      var eng = engine();
+      if (!eng || typeof eng.queryRenderedFeatures !== 'function') { return []; }
+      var box = [[point.x - 6, point.y - 6], [point.x + 6, point.y + 6]];
+      return (eng.queryRenderedFeatures(box) || []).filter(function (f) { return f && f.properties && f.properties.smap_plan === id; });
+    }
+    function setPan(on) {
+      var eng = engine();
+      if (eng && eng.dragPan) { if (on) { eng.dragPan.enable(); } else { eng.dragPan.disable(); } }
+    }
+
+    function down(e) {
+      if (removed || (e.originalEvent && e.originalEvent.button) || !e.point) { return; }
+      var hit = hitsAt(e.point).filter(function (f) { return f.properties.kind === 'stop' || f.properties.kind === 'unassigned'; })[0];
+      if (!hit) { return; }
+      drag.start(hit.properties.id, e.point);
+      setPan(false);
+      if (e.preventDefault) { e.preventDefault(); }
+    }
+    function move(e) {
+      if (!drag.dragging() || !e.point) { return; }
+      drag.move(hitsAt(e.point), e.point);
+      if (drag.moved() && e.lngLat) { map.setData(ids.drag, [{ lng: e.lngLat.lng, lat: e.lngLat.lat }]); }
+    }
+    function up(e) {
+      if (!drag.dragging()) { return; }
+      setPan(true);
+      map.setData(ids.drag, []);
+      drag.end(e && e.point ? hitsAt(e.point) : null);
+    }
+
+    var listening = false;
+    function listen() {
+      var eng = engine();
+      if (!eng || listening || removed) { return; }
+      listening = true;
+      eng.on('mousedown', down);
+      eng.on('mousemove', move);
+      eng.on('mouseup', up);
+      eng.on('touchstart', down);
+      eng.on('touchmove', move);
+      eng.on('touchend', up);
+    }
+    function onChange() { if (ready) { draw(); } }
+    editor.on('change', onChange);
+    var gone = function () { api.remove(); };
+    editor.on('destroy', gone);
+    var ready = false;
+    var started = map.ready && typeof map.ready.then === 'function' ? map.ready : Promise.resolve(map);
+    started.then(function () { ready = true; if (!removed) { draw(); listen(); } });
+
+    var api = {
+      features: function () { return planFeatures(editor, id, o.colors); },
+      remove: function () {
+        if (removed) { return; }
+        removed = true;
+        drag.cancel();
+        editor.off('change', onChange);
+        editor.off('destroy', gone);
+        var eng = engine();
+        if (eng && listening) {
+          eng.off('mousedown', down); eng.off('mousemove', move); eng.off('mouseup', up);
+          eng.off('touchstart', down); eng.off('touchmove', move); eng.off('touchend', up);
+          setPan(true);
+        }
+        if (added) { Object.keys(ids).forEach(function (k) { try { map.removeLayer(ids[k]); } catch (x) { /* already gone */ } }); }
+      },
+      // For tests and adapters: a drag as the map reports it.
+      _down: down, _move: move, _up: up,
+    };
+    return api;
+  }
+
+  /**
+   * An editor on an sMap map: its layers, and the panel as the map tool `plan-editor` (unless `panel: false`).
+   * options as PlanEditor, plus id (layer prefix), colors, preview (default true), panel (true | false |
+   * { position, label, labels, className }), language (default the map's).
+   */
+  function attach(map, options) {
+    options = options || {};
+    var editor = new PlanEditor(Object.assign({}, options, { plan: null }));
+    var layer = attachToMap(map, editor, options);
+    var toolId = null;
+    var destroyed = false;
+    editor.panel = null;
+    editor.layer = layer;
+    // The panel is made from the map's own page (the engine's container), so it waits for the map's engine.
+    function mountPanel() {
+      if (destroyed || options.panel === false) { return; }
+      var po = typeof options.panel === 'object' && options.panel ? options.panel : {};
+      var container = map.engine && map.engine.getContainer ? map.engine.getContainer() : null;
+      var doc = options.document || (container && container.ownerDocument) || (typeof document !== 'undefined' ? document : null);
+      if (!doc) { return; }
+      var language = options.language || map._language || 'en';
+      var labels = po.labels || options.labels;
+      editor.panel = createPanel(editor, { language: language, labels: labels, document: doc, colors: options.colors, className: po.className });
+      toolId = po.id || ((options.id || 'plan') + '-editor');
+      map.addTool(toolId, editor.panel.element, { label: po.label || textsFor(language, labels).editor, position: po.position || 'top-left' });
+    }
+    if (map.engine || options.document) { mountPanel(); }
+    else if (map.ready && typeof map.ready.then === 'function') { map.ready.then(mountPanel, function () {}); }
+    var destroy = editor.destroy;
+    editor.destroy = function () {
+      destroyed = true;
+      if (toolId) { try { map.removeTool(toolId); } catch (x) { /* map removed */ } }
+      destroy.call(editor);
+    };
+    if (options.plan) { editor.setPlan(options.plan).catch(function () {}); }
+    return editor;
+  }
+
+  return {
+    PlanEditor: PlanEditor,
+    attach: attach,
+    attachToMap: attachToMap,
+    createPanel: createPanel,
+    createTransport: createTransport,
+    planFeatures: planFeatures,
+    dropEdit: dropEdit,
+    applyResequence: applyResequence,
+    applyMove: applyMove,
+    applyRemove: applyRemove,
+    decodePolyline: decodePolyline,
+    texts: TEXTS,
+    textKeys: TEXT_KEYS,
+    languages: LANGUAGES,
+    panelLanguage: panelLanguage,
+    numberLocale: numberLocale,
+    formatters: formatters,
+    // The parts a binding on another map library builds on (exported as planEditorParts).
+    parts: {
+      planFeatures: planFeatures, dropTarget: dropTarget, dropEdit: dropEdit, dropRoutes: dropRoutes,
+      featuresAt: featuresAt, planDrag: planDrag, createPanel: createPanel, injectCss: injectCss, textsFor: textsFor,
+      panelLanguage: panelLanguage, decodePolyline: decodePolyline, colors: COLORS.slice(),
+    },
+  };
+});
+
+  return module.exports;
+}
+function smapCreateSdk(engine, interop, plan) {
   var module = { exports: {} };
   var exports = module.exports;
   var define;
   var require = function (name) { throw new Error('sMap: unexpected require of ' + name); };
-  var self = { maplibregl: engine, smapInterop: interop };
+  var self = { maplibregl: engine, smapInterop: interop, smapPlan: plan };
 /*!
  * sMap Web SDK — maps from Superroute's sMap service.
  *
@@ -28343,14 +29965,15 @@ function smapCreateSdk(engine, interop) {
 (function (root, factory) {
   if (typeof module === 'object' && module.exports) {
     module.exports = factory(root.maplibregl !== undefined ? root.maplibregl : require('maplibre-gl'),
-      root.smapInterop !== undefined ? root.smapInterop : require('./smap-interop.js'));
+      root.smapInterop !== undefined ? root.smapInterop : require('./smap-interop.js'),
+      root.smapPlan !== undefined ? root.smapPlan : (typeof require === 'function' ? require('./smap-plan.js') : null));
   } else {
-    root.sMap = factory(root.maplibregl, root.smapInterop);
+    root.sMap = factory(root.maplibregl, root.smapInterop, root.smapPlan);
   }
-})(typeof self !== 'undefined' ? self : this, function (engine, interop) {
+})(typeof self !== 'undefined' ? self : this, function (engine, interop, plan) {
   'use strict';
 
-  var VERSION = '1.1.5';
+  var VERSION = '1.1.6';
   var FLAVORS = ['light', 'white', 'grayscale', 'dark', 'black'];
   var BASEMAP_SOURCE = 'basemap';
   var BUILDINGS_LAYER = 'smap-buildings-3d';
@@ -28808,7 +30431,9 @@ function smapCreateSdk(engine, interop) {
     this._tools = [];
     this._toolsHidden = {};
     (toolOptions.hidden || []).forEach(function (id) { this._toolsHidden[id] = true; }, this);
-    this._toolsControlAt = toolOptions.control === undefined ? 'top-right' : toolOptions.control;
+    // 1.1.6: by default the tools control is the last button of the map's toolbar (the corner holding the
+    // navigation control, top left without one); a corner given by the caller is kept as in 1.1.5.
+    this._toolsControlAt = toolOptions.control === undefined || toolOptions.control === true ? 'toolbar' : toolOptions.control;
     this._toolsLabels = toolOptions.labels || {};
     this._toolsControl = null;
     this._toolHandlers = [];
@@ -28850,7 +30475,7 @@ function smapCreateSdk(engine, interop) {
         badge._place();
       }
       self._mountTools();
-      self.engine.on('style.load', function () { self._styleReady = true; self._restore(); });
+      self.engine.on('style.load', function () { self._styleReady = true; self._restore(); self._hideLayerTools(); });
       self._keyboard3D();
       // One click handler for every layer's popup: the engine's hit test over those layers, the top feature opens.
       self.engine.on('click', function (e) { self._popupClick(e); });
@@ -29288,6 +30913,7 @@ function smapCreateSdk(engine, interop) {
     if (!def) { return this; }
     def.hidden = !visible;
     var m = this.engine;
+    if (!m) { return this; }
     def.engineLayers.forEach(function (l) { if (m.getLayer(l)) { m.setLayoutProperty(l, 'visibility', visible ? 'visible' : 'none'); } });
     return this;
   };
@@ -29390,9 +31016,13 @@ function smapCreateSdk(engine, interop) {
    *   map.addTool('legend', document.getElementById('legend'), { label: 'Legend', position: 'bottom-left' })
    *   map.addTool('zoom', 'navigation', { options: { showCompass: false } })
    * @param {string} id  1-64 letters, digits, '-', '_', '.'; adding an id again replaces the first
-   * @param {Element|Object|string} target  a page element, an engine control (onAdd / onRemove), or a kind the SDK
+   *   map.addTool('stops', { layer: ['stops', 'stop-labels'] }, { label: 'Stops' })
+   * @param {Element|Object|string} target  a page element, an engine control (onAdd / onRemove), a kind the SDK
    *        makes: 'navigation', 'geolocate', 'fullscreen', 'scale', or the mobile SDKs' 'zoom' (navigation without the
-   *        compass), 'compass' (without the zoom buttons) and 'locate' (geolocate)
+   *        compass), 'compass' (without the zoom buttons) and 'locate' (geolocate); or data layers, `{ layer: id }` or
+   *        `{ layer: [ids] }`: layers of addPoints / addLines / addPolygons / addData / addStyleLayer and the external
+   *        layers, or of the basemap. Hiding the tool hides the layers (layout visibility), showing it shows them; a
+   *        layer added later under one of the ids follows a hidden tool, and an id without a layer is left alone.
    * @param {Object} [o]  label (shown on its button), position ('top-left', 'top-right', 'bottom-left', 'bottom-right',
    *        or 'none': an element stays where the page put it), options (of a kind's engine control)
    */
@@ -29400,6 +31030,17 @@ function smapCreateSdk(engine, interop) {
     o = o || {};
     if (typeof id !== 'string' || !TOOL_ID.test(id)) { throw new Error('sMap: a tool id is 1-64 letters, digits, "-", "_" or "."'); }
     var kind = typeof target === 'string' ? TOOL_KINDS[target] : null;
+    var layers = layerTarget(target);
+    if (layers) {
+      if (o.position !== undefined && o.position !== 'none') { throw new Error('sMap: a data-layer tool is not placed in a corner'); }
+      if (this._toolIndex(id) >= 0) { this.removeTool(id); }
+      var layerTool = { id: id, label: String(o.label || id), position: 'none', el: null, control: null, layers: layers };
+      this._tools.push(layerTool);
+      if (!this._toolVisible(layerTool)) { this._applyLayerTool(layerTool, false); }
+      if (this.engine) { this._mountTool(layerTool); }
+      this._renderToolsControl();
+      return this;
+    }
     if (typeof target === 'string') {
       if (!kind) { throw new Error('sMap: unknown tool kind "' + target + '"'); }
       if (!engine[kind.control]) { throw new Error('sMap: the rendering engine has no ' + kind.control); }
@@ -29428,6 +31069,8 @@ function smapCreateSdk(engine, interop) {
     var tool = this._tools[i];
     this._tools.splice(i, 1);
     if (tool.el) { tool.el.classList.remove('smap-tool-hidden'); }
+    // A data-layer tool leaves its layers shown, as a removed element is shown again.
+    if (tool.layers && !this._toolVisible(tool)) { this._applyLayerTool(tool, true); }
     if (tool.control && this.engine && tool.mounted) { this.engine.removeControl(tool.control); }
     this._renderToolsControl();
     return this;
@@ -29473,6 +31116,35 @@ function smapCreateSdk(engine, interop) {
   SMap.prototype._setHidden = function (tool, hidden) {
     if (hidden) { this._toolsHidden[tool.id] = true; } else { delete this._toolsHidden[tool.id]; }
     if (tool.el) { tool.el.classList.toggle('smap-tool-hidden', hidden); }
+    if (tool.layers) { this._applyLayerTool(tool, !hidden); }
+  };
+
+  // { layer: 'id' } or { layer: ['id', ...] }: the layer ids of a data-layer tool, or null for any other target.
+  function layerTarget(target) {
+    if (!target || typeof target !== 'object' || isElement(target) || typeof target.onAdd === 'function' || !('layer' in target)) { return null; }
+    var ids = Array.isArray(target.layer) ? target.layer : [target.layer];
+    if (!ids.length || ids.some(function (x) { return typeof x !== 'string' || !x; })) { throw new Error('sMap: a data-layer tool names one or more layer ids'); }
+    return ids.filter(function (x, i) { return ids.indexOf(x) === i; });
+  }
+
+  // Shows or hides a data-layer tool's layers: the SDK's own through setVisible, any other (the basemap's) through its
+  // layout visibility. A layer that is not there (removed, or not added yet) is left alone.
+  SMap.prototype._applyLayerTool = function (tool, visible) {
+    tool.layers.forEach(function (layerId) {
+      if (this._layers[layerId]) { this.setVisible(layerId, visible); return; }
+      var m = this.engine;
+      if (m && m.getLayer && m.getLayer(layerId)) { this.setLayout(layerId, 'visibility', visible ? 'visible' : 'none'); }
+    }, this);
+  };
+
+  // After a style loads: the basemap layers of hidden data-layer tools are hidden (the SDK's own layers already are).
+  SMap.prototype._hideLayerTools = function () {
+    this._tools.forEach(function (t) { if (t.layers && !this._toolVisible(t)) { this._applyLayerTool(t, false); } }, this);
+  };
+
+  // Is a layer id covered by a hidden data-layer tool? A layer added later under that id starts hidden.
+  SMap.prototype._layerToolHides = function (layerId) {
+    return this._tools.some(function (t) { return t.layers && t.layers.indexOf(layerId) >= 0 && !this._toolVisible(t); }, this);
   };
   SMap.prototype._toolsChanged = function (id) {
     var hidden = this._tools.filter(function (t) { return !this._toolVisible(t); }, this).map(function (t) { return t.id; });
@@ -29483,10 +31155,12 @@ function smapCreateSdk(engine, interop) {
     // The tools control joins the map with its first tool, so a map without tools is exactly as before.
     if (this._toolsControlAt && !this._toolsControl && this.engine.addControl) {
       this._toolsControl = toolsControl(this);
-      this.engine.addControl(this._toolsControl, this._toolsControlAt);
+      this.engine.addControl(this._toolsControl, this._toolsControlAt === 'toolbar' ? 'top-left' : this._toolsControlAt);
+      if (this._toolsControlAt === 'toolbar') { this._toolsControl._follow(); }
     }
     if (tool.control && this.engine.addControl) { this.engine.addControl(tool.control, tool.position); tool.mounted = true; }
     if (tool.el) { tool.el.classList.toggle('smap-tool-hidden', !this._toolVisible(tool)); }
+    if (this._toolsControl) { this._toolsControl._place(); }
   };
 
   // Called once the engine exists: every tool registered before it.
@@ -29505,9 +31179,39 @@ function smapCreateSdk(engine, interop) {
     var drawn = null;
     var text = {};
     Object.keys(TOOLS_TEXT).forEach(function (k) { text[k] = map._toolsLabels[k] || TOOLS_TEXT[k]; });
+    var observer = null;
+    var openCorner = null;
     function open(on) {
       panel.hidden = !on;
       button.setAttribute('aria-expanded', on ? 'true' : 'false');
+      // While the panel is open its corner is drawn above the map's other corners.
+      if (openCorner) { openCorner.classList.remove('smap-tools-open'); openCorner = null; }
+      if (on && el.parentNode) { openCorner = el.parentNode; openCorner.classList.add('smap-tools-open'); }
+    }
+    function cornerOf(node, root) {
+      for (; node && node !== root; node = node.parentNode) {
+        if (node.nodeType === 1 && /\bmaplibregl-ctrl-(top|bottom)-(left|right)\b/.test(node.className)) { return node; }
+      }
+      return null;
+    }
+    // The map's toolbar: the corner holding a navigation control (zoom buttons or compass), top left without one.
+    function toolbarCorner(root) {
+      var navs = root.querySelectorAll('.maplibregl-ctrl-zoom-in, .maplibregl-ctrl-zoom-out, .maplibregl-ctrl-compass');
+      for (var i = 0; i < navs.length; i++) {
+        if (el.contains(navs[i])) { continue; }
+        var c = cornerOf(navs[i], root);
+        if (c) { return c; }
+      }
+      return root.querySelector('.maplibregl-ctrl-top-left');
+    }
+    // Where the control goes in a corner: last, but in a bottom corner before the attribution and the sMap badge,
+    // which keep the map's edge.
+    function edgeOf(corner) {
+      if (!/\bmaplibregl-ctrl-bottom-/.test(corner.className)) { return null; }
+      for (var c = corner.firstElementChild; c; c = c.nextElementSibling) {
+        if (c !== el && (c.classList.contains('maplibregl-ctrl-attrib') || c.classList.contains('smap-badge'))) { return c; }
+      }
+      return null;
     }
     function close() { if (panel && !panel.hidden) { open(false); } }
     function key(e) { if (e.key === 'Escape' && !panel.hidden) { open(false); button.focus(); } }
@@ -29540,10 +31244,35 @@ function smapCreateSdk(engine, interop) {
       },
       onRemove: function (m) {
         m.off('click', close);
+        if (observer) { observer.disconnect(); observer = null; }
+        if (openCorner) { openCorner.classList.remove('smap-tools-open'); openCorner = null; }
         if (el && el.parentNode) { el.parentNode.removeChild(el); }
         el = null;
         drawn = null;
       },
+      // The default place (1.1.6): the last button of the map's toolbar, kept last when controls join it later.
+      _place: function () {
+        if (!el || map._toolsControlAt !== 'toolbar' || !map.engine || !map.engine.getContainer) { return; }
+        var root = map.engine.getContainer();
+        var corner = toolbarCorner(root);
+        if (!corner) { return; }
+        var edge = edgeOf(corner);
+        var inPlace = el.parentNode === corner && (edge ? el.nextElementSibling === edge : !el.nextElementSibling);
+        if (inPlace) { return; }
+        corner.insertBefore(el, edge);
+        if (openCorner && openCorner !== corner) { openCorner.classList.remove('smap-tools-open'); openCorner = corner; corner.classList.add('smap-tools-open'); }
+      },
+      // Watches the map's corners, so a control the app adds later (to the engine itself too) leaves this one last.
+      _follow: function () {
+        if (observer || !el || !map.engine.getContainer) { return; }
+        var root = map.engine.getContainer();
+        var view = root.ownerDocument && root.ownerDocument.defaultView;
+        var Observer = view && view.MutationObserver;
+        if (!Observer) { return; }
+        var watched = root.querySelector('.maplibregl-control-container') || root;
+        observer = new Observer(function () { control._place(); });
+        observer.observe(watched, { childList: true, subtree: true });
+      },
       _render: function () {
         if (!el) { return; }
         var doc = el.ownerDocument;
@@ -29576,6 +31305,19 @@ function smapCreateSdk(engine, interop) {
     return control;
   }
 
+  // ------------------------------------------------------------------ plan editor (OPEN-ROUTE-EDIT E10)
+
+  /**
+   * A plan editor on this map: the plan drawn as layers, stops dragged within and between routes, and the ready-made
+   * panel as the map tool `<id>-editor` (unless `panel: false`). Every edit is a plan.* call of the Open Platform.
+   *   const editor = map.planEditor({ credentials: { token: () => fetch('/plan-token').then((r) => r.json()) }, plan });
+   * See PlanEditorOptions in the types for every option.
+   */
+  SMap.prototype.planEditor = function (options) {
+    if (!plan) { throw new Error('sMap: the plan editor is not loaded'); }
+    return plan.attach(this, options);
+  };
+
   // ------------------------------------------------------------------ Style Specification sources and layers (M24)
 
   function clone(v) { return v === undefined ? undefined : JSON.parse(JSON.stringify(v)); }
@@ -30143,6 +31885,7 @@ function smapCreateSdk(engine, interop) {
     def.popupFn = typeof o.popup === 'string' ? popupTemplate(o.popup) : null;
     def.zIndex = def.o.zIndex || 0;
     def.engineLayers = [];
+    if (this._layerToolHides(id)) { def.hidden = true; }
     this._layers[id] = def;
     this._order = this._order.filter(function (x) { return x !== id; });
     this._order.push(id);
@@ -30523,10 +32266,13 @@ function smapCreateSdk(engine, interop) {
     parseWmtsCapabilities: interop.parseWmtsCapabilities,
     PMTilesArchive: interop.PMTilesArchive,
     useDeck: interop.useDeck,
+    PlanEditor: plan ? plan.PlanEditor : undefined,
+    planTexts: plan ? plan.texts : undefined,
+    planEditorParts: plan ? plan.parts : undefined,
   };
 });
 
   return module.exports;
 }
-(typeof globalThis !== 'undefined' ? globalThis : window).sMap = smapCreateSdk(smapCreateEngine(), smapCreateInterop());
+(typeof globalThis !== 'undefined' ? globalThis : window).sMap = smapCreateSdk(smapCreateEngine(), smapCreateInterop(), smapCreatePlan());
 })();