{
  "version": 3,
  "sources": ["offline_journey_core.js"],
  "sourcesContent": ["// @ts-check\n/*\n * static/js/offline_journey_core.js \u2014 one panel per downloaded area on\n * /offline/: three stages and one verdict (SNOW-1308).\n *\n * The offline report (`offline_audit_core.js`) answers about the app and\n * the map as a whole. What a reader about to lose signal asks is narrower\n * and more useful: *will THIS area work?* So each area the device holds\n * gets a panel above the report, and the panel answers three questions in\n * the order a trip depends on them:\n *\n *   - **The map.** The area's bucket verifies \u2014 its style, TileJSON and\n *     sprite (`areaState`, unchanged, SNOW-843/844), its terrain-class\n *     tiles where it was downloaded with them (SNOW-1138) \u2014 AND its\n *     basemap tiles are all there (`blobFullyCached` over the record's own\n *     tile template and ground, injected as `tiles`). The report never\n *     checked the tiles themselves; a bucket holding its documents and\n *     half its tiles read ready.\n *   - **The conditions.** The bulletins and weather inside the boundary\n *     were fetched today (`areaContentState` is `fresh`). Stale or never\n *     is a No here, not a caveat: the panel's question is whether the area\n *     is ready, and yesterday's bulletin is not. SNOW-1379: an area that\n *     carries the problem-terrain feed (downloaded with terrain tiles, in\n *     a terrain country) adds a \"Problem terrain\" line counting the days\n *     saved, from the urls the last sync stamped (`items.problemTerrain`,\n *     `withProblemTerrain`). SNOW-1387: a day not held makes the stage\n *     No (reason `terrain`), so the area reads \"Needs a refresh\" and Sync\n *     now fetches it again; a line that could not be read makes a Yes\n *     unknown. The stage's own No (stale, never) keeps its reason.\n *   - **Your things.** Each trip and pin in the area, by name, Yes only\n *     when every url it needs is in Cache Storage. What \"needs\" means is\n *     stamped on the record by the sync that fetched them\n *     (`stampContentRecord`, `areaItemExpectation`) \u2014 `/api/area-items/`\n *     is never cached, so this page cannot ask offline. No stamp is\n *     unknown, and a signed-out reader gets no stage at all: they have no\n *     things, and an absent stage must not read as a fault.\n *\n * The verdict is one plain line, from `verdictFor`:\n *\n *   - `ready` \u2014 every stage is Yes.\n *   - `open-map` \u2014 the map stage is No. Tiles and documents can only be\n *     fetched where the basemap style is loaded, so the remedy is the\n *     map's Manage downloads sheet, never a tap here.\n *   - `refresh` \u2014 another stage is No; the tap runs Sync now.\n *   - `unknown` \u2014 a stage could not be read and none is No.\n *\n * A reading that could not be taken is unknown, never a Yes and never a\n * No \u2014 the report's rule, kept here.\n *\n * Pure: no DOM and no storage. Every reading arrives as an argument.\n * Reads `pwaOfflineAuditCore` at call time for `areaState`,\n * `areaContentState`, `completableArea` and `chosenAreas`, so the panels\n * and the report cannot disagree about one area.\n *\n * ## The connection panel (SNOW-1415)\n *\n * The header's connection panel asks the same question of every area on\n * every page, where the audit core is not loaded. `base.html` loads this\n * file globally for it. `stagesFromRecord` builds the stages from the\n * stored record alone: the map stage from a `verified` stamp that the\n * tile-capable pages write (`verifiedFromSync` on the map,\n * `verifiedFromStages` on /offline/), the conditions from `contentAt`,\n * and the reader's things from the same stamp. `verdictFor` is unchanged\n * and stays the one verdict. The record-only path never reads the audit\n * core, so it works where that core is absent.\n */\n\n(function () {\n  'use strict';\n\n  /**\n   * @typedef {'yes'|'no'|'unknown'} StageStatus\n   */\n\n  /**\n   * @typedef {Object} ThingRow\n   * @property {'trip'|'pin'} kind\n   * @property {string} name\n   * @property {StageStatus} status\n   */\n\n  /**\n   * @typedef {Object} TerrainLine\n   * @property {StageStatus} status Yes when every day is held.\n   * @property {number} held The days in Cache Storage.\n   * @property {number} total The days the last sync saved.\n   */\n\n  /**\n   * @typedef {Object} Stage\n   * @property {StageStatus} status\n   * @property {string} [reason]\n   * @property {ThingRow[]} [rows] Your things only.\n   * @property {TerrainLine} [terrain] The conditions stage only (SNOW-1379).\n   */\n\n  /**\n   * @typedef {Object} Panel\n   * @property {string} id The bucket id.\n   * @property {string} name\n   * @property {'region'|'dropzone'|'custom'} kind\n   * @property {boolean} orphaned\n   * @property {string|null} contentAt\n   * @property {{map: Stage, conditions: Stage, things: Stage|null}} stages\n   * @property {'ready'|'open-map'|'refresh'|'unknown'} verdict\n   * @property {boolean} canSync Whether this host can run Sync now for it.\n   * @property {number} bytes The recorded size, 0 where none landed.\n   */\n\n  // Regions first: a region is what most people download, and the ones\n  // they drew themselves are the exceptions. The order the report's Map\n  // downloads section used, kept.\n  /** @type {Array<'region'|'dropzone'|'custom'>} */\n  var KIND_ORDER = ['region', 'dropzone', 'custom'];\n\n  /**\n   * The audit core, read at call time.\n   *\n   * @returns {any}\n   */\n  function audit() {\n    return self.pwaOfflineAuditCore;\n  }\n\n  /**\n   * Fill ``%(key)s`` placeholders.\n   *\n   * @param {string} template\n   * @param {Record<string, string>} values\n   * @returns {string}\n   */\n  function fill(template, values) {\n    return String(template || '').replace(/%\\((\\w+)\\)s/g, function (_m, key) {\n      return Object.prototype.hasOwnProperty.call(values, key) ? values[key] : '';\n    });\n  }\n\n  /**\n   * Which kind of download a record is.\n   *\n   * @param {any} area\n   * @returns {'region'|'dropzone'|'custom'}\n   */\n  function areaKind(area) {\n    if (area && area.kind === 'region') return 'region';\n    return area && area.type === 'dropzone' ? 'dropzone' : 'custom';\n  }\n\n  /**\n   * The name an area is spoken of by: its stored name, the sheet's\n   * \"Custom area N\" default from its ordinal (SNOW-1133), or its id.\n   *\n   * @param {any} area\n   * @param {Record<string, string>} t\n   * @returns {string}\n   */\n  function areaName(area, t) {\n    if (area.name) return String(area.name);\n    if (typeof area.ordinal === 'number' && Number.isFinite(area.ordinal)) {\n      return fill(t['default-custom-name'] || 'Custom area %(n)s', { n: String(area.ordinal) });\n    }\n    return String(area.id);\n  }\n\n  /**\n   * The ground a record's tiles cover, as the blob `blobFullyCached`\n   * walks.\n   *\n   * A region carries the run's own `z` row spans. A custom area carries\n   * `bbox` + `band`, rebuilt the way it was fetched: a drop zone as its\n   * circle (`circleBlobForBBox`, SNOW-1136), a framed box as `buildBlob`.\n   *\n   * @param {any} area\n   * @param {any} download `pwaBasemapDownloadCore`.\n   * @returns {any} Null where the record names no ground.\n   */\n  function areaBlob(area, download) {\n    if (area.z) return { z: area.z };\n    var band = Array.isArray(area.band) ? area.band : null;\n    if (!Array.isArray(area.bbox) || !band) return null;\n    if (area.type === 'dropzone' && typeof download.circleBlobForBBox === 'function') {\n      return download.circleBlobForBBox(area.bbox, band[0], band[1]);\n    }\n    if (typeof download.buildBlob !== 'function') return null;\n    return download.buildBlob(area.bbox, band[0], band[1]);\n  }\n\n  /**\n   * Whether every basemap tile an area's ground implies is in its bucket.\n   *\n   * The reading is injected \u2014 `download` is `pwaBasemapDownloadCore`,\n   * passed by the caller \u2014 because static/offline.html loads no such core\n   * and this module stays pure. Unknown (null) for: no core, a bucket that\n   * did not answer, a record naming no tile template or no ground, or any\n   * throw. Never a No drawn from a reading that was not taken.\n   *\n   * @param {any} area An audit area reading.\n   * @param {any} download `pwaBasemapDownloadCore`, or null.\n   * @returns {boolean|null}\n   */\n  function tileReading(area, download) {\n    if (!area || !download || typeof download.blobFullyCached !== 'function') return null;\n    if (area.bucketReadable === false || area.orphaned) return null;\n    if (!area.template) return null;\n    try {\n      var blob = areaBlob(area, download);\n      if (!blob) return null;\n      return !!download.blobFullyCached(area.template, blob, area.entries || []);\n    } catch (_err) {\n      return null;\n    }\n  }\n\n  /**\n   * The map stage: the bucket verifies AND its tiles are all there.\n   *\n   * @param {any} area\n   * @param {boolean|null|undefined} tiles From `tileReading`.\n   * @returns {Stage}\n   */\n  function mapStage(area, tiles) {\n    var core = audit();\n    if (!core) return { status: 'unknown' };\n    var state = core.areaState(area).status;\n    if (state === 'ready') {\n      if (tiles === true) return { status: 'yes' };\n      if (tiles === false) return { status: 'no', reason: 'tiles' };\n      return { status: 'unknown', reason: 'tiles-unread' };\n    }\n    if (state === 'unreadable' || state === 'unverifiable') {\n      return { status: 'unknown', reason: state };\n    }\n    // `orphaned`, `incomplete`, `missing`.\n    return { status: 'no', reason: state };\n  }\n\n  /**\n   * The conditions stage: today's bulletins and weather are here.\n   *\n   * @param {any} area\n   * @param {string} [now]\n   * @returns {Stage}\n   */\n  function conditionsStage(area, now) {\n    var core = audit();\n    if (!core) return { status: 'unknown' };\n    var content = core.areaContentState(area, now);\n    if (content === 'fresh') return { status: 'yes' };\n    if (content === 'stale') return { status: 'no', reason: 'stale' };\n    if (content === 'never') return { status: 'no', reason: 'never' };\n    // `none`: the tiles do not verify (the map stage already says so) or\n    // an unparseable stamp. Neither is evidence about the content.\n    return { status: 'unknown' };\n  }\n\n  /**\n   * Whether a reader is signed in, from the account the device's queue is\n   * set for (`mutations.principal`, null when signed out).\n   *\n   * @param {any} readings\n   * @returns {boolean}\n   */\n  function isSignedIn(readings) {\n    var p = readings && readings.currentPrincipal;\n    return typeof p === 'string' && p !== '' && p !== 'anonymous' && p !== 'unknown';\n  }\n\n  /**\n   * Every url the shell cache holds, or null where it could not be read.\n   *\n   * @param {any} readings\n   * @returns {Map<string, any>|null} By url, each to its entry.\n   */\n  function shellUrls(readings) {\n    if (!readings || readings.cachesReadable === false || readings.failure) return null;\n    /** @type {Map<string, any>} */\n    var urls = new Map();\n    (Array.isArray(readings.shellEntries) ? readings.shellEntries : []).forEach(\n      /** @param {any} entry */ function (entry) {\n        if (entry && entry.url) urls.set(entry.url, entry);\n      },\n    );\n    return urls;\n  }\n\n  /**\n   * Whether one of your things' urls will open offline for this reader.\n   *\n   * Presence is not enough for the principal-scoped families \u2014 a trip page,\n   * its route, a pin's place sheet (`isPrincipalScoped`): the worker\n   * serves those only under a matching `X-SW-Principal`\n   * (`_principalMatches`), so one cached for another account is a No. A\n   * stamp whose read did not come back is unknown. Public weather sheets\n   * need only be there (SNOW-1308 review).\n   *\n   * @param {string} url Absolute.\n   * @param {Map<string, any>} held\n   * @param {string|null} principal\n   * @returns {StageStatus}\n   */\n  function urlState(url, held, principal) {\n    var entry = held.get(url);\n    if (!entry) return 'no';\n    var core = audit();\n    if (!core || typeof core.isPrincipalScoped !== 'function') return 'unknown';\n    if (!core.isPrincipalScoped(url)) return 'yes';\n    if (entry.stampUnread) return 'unknown';\n    return core.principalMatches(entry.principal, principal) ? 'yes' : 'no';\n  }\n\n  /**\n   * One url as the cache keys it \u2014 absolute, on this origin.\n   *\n   * @param {string} url\n   * @param {string} origin\n   * @returns {string}\n   */\n  function absolute(url, origin) {\n    try {\n      return new URL(url, origin || 'http://localhost').toString();\n    } catch (_err) {\n      return url;\n    }\n  }\n\n  /**\n   * The conditions stage's \"Problem terrain\" line: how many of the days\n   * the last sync saved are in Cache Storage (SNOW-1379).\n   *\n   * Only for an area that carries the feed: one downloaded with terrain\n   * tiles (`area.terrain`) whose last sync stamped a non-empty\n   * `items.problemTerrain` \u2014 the stamp is empty for an area outside the\n   * terrain countries, and absent for one not synced since this ticket.\n   * The feed is public, so presence is enough (`urlState`). A cache that\n   * could not be read counts nothing and is unknown.\n   *\n   * @param {any} area\n   * @param {{urls: Map<string, any>|null, origin: string,\n   *   principal?: string|null}} ctx\n   * @returns {TerrainLine|null} Null where the area carries no feed.\n   */\n  function problemTerrainLine(area, ctx) {\n    if (!area || !area.terrain) return null;\n    var stamped = area.items && area.items.problemTerrain;\n    if (!Array.isArray(stamped) || stamped.length === 0) return null;\n    var total = stamped.length;\n    if (!ctx.urls) return { status: 'unknown', held: 0, total: total };\n    var held = /** @type {Map<string, any>} */ (ctx.urls);\n    var count = stamped.filter(function (/** @type {string} */ url) {\n      return urlState(absolute(url, ctx.origin), held, ctx.principal || null) === 'yes';\n    }).length;\n    return { status: count === total ? 'yes' : 'no', held: count, total: total };\n  }\n\n  /**\n   * The \"your things\" stage: each trip and pin, Yes only when every url\n   * it needs is cached.\n   *\n   * @param {any} area\n   * @param {{signedIn: boolean, urls: Map<string, any>|null, origin: string,\n   *   principal?: string|null}} ctx\n   * @returns {Stage|null} Null for a signed-out reader: no stage at all.\n   */\n  function thingsStage(area, ctx) {\n    if (!ctx.signedIn) return null;\n    var items = area.items;\n    if (!items || !Array.isArray(items.trips) || !Array.isArray(items.pins)) {\n      return { status: 'unknown', reason: 'unrecorded', rows: [] };\n    }\n    // SNOW-1308 review: the names were written by whoever SYNCED, which\n    // need not be the area's downloader (`area.principal`) \u2014 another\n    // account signed in on this device can press Sync now. So the guard is\n    // the principal stamped with the items, and nothing is named unless it\n    // is this reader's: a missing, empty or different stamp is unknown.\n    var stamped = typeof items.principal === 'string' ? items.principal : '';\n    if (!stamped || stamped !== ctx.principal) {\n      return { status: 'unknown', reason: 'other-account', rows: [] };\n    }\n    /** @type {ThingRow[]} */\n    var rows = [];\n    /**\n     * @param {'trip'|'pin'} kind\n     * @param {any} item\n     */\n    var add = function (kind, item) {\n      if (!item) return;\n      var urls = Array.isArray(item.urls) ? item.urls : [];\n      /** @type {StageStatus} */\n      var status = 'unknown';\n      if (urls.length > 0 && ctx.urls) {\n        var held = /** @type {Map<string, any>} */ (ctx.urls);\n        var states = urls.map(function (/** @type {string} */ url) {\n          return urlState(absolute(url, ctx.origin), held, ctx.principal || null);\n        });\n        status =\n          states.indexOf('no') >= 0 ? 'no' : states.indexOf('unknown') >= 0 ? 'unknown' : 'yes';\n      }\n      rows.push({ kind: kind, name: typeof item.name === 'string' ? item.name : '', status: status });\n    };\n    items.trips.forEach(function (/** @type {any} */ trip) {\n      add('trip', trip);\n    });\n    items.pins.forEach(function (/** @type {any} */ pin) {\n      add('pin', pin);\n    });\n    if (rows.length === 0) return { status: 'yes', reason: 'none-here', rows: rows };\n    var statuses = rows.map(function (row) {\n      return row.status;\n    });\n    if (statuses.indexOf('no') >= 0) return { status: 'no', rows: rows };\n    if (statuses.indexOf('unknown') >= 0) return { status: 'unknown', rows: rows };\n    return { status: 'yes', rows: rows };\n  }\n\n  /**\n   * The one line a panel leads with.\n   *\n   * A map No outranks every other answer, because its remedy is somewhere\n   * else: tiles can only be fetched where the style is loaded. Any other\n   * No outranks an unknown, because the tap that fixes it is right here.\n   *\n   * @param {{map: Stage, conditions: Stage, things: Stage|null}} stages\n   * @returns {'ready'|'open-map'|'refresh'|'unknown'}\n   */\n  function verdictFor(stages) {\n    var list = [stages.map, stages.conditions];\n    if (stages.things) list.push(stages.things);\n    if (stages.map.status === 'no') return 'open-map';\n    var any = /** @param {StageStatus} status */ function (status) {\n      return list.some(function (stage) {\n        return stage.status === status;\n      });\n    };\n    if (any('no')) return 'refresh';\n    if (any('unknown')) return 'unknown';\n    return 'ready';\n  }\n\n  /**\n   * A \"tap to fix\" verdict only where a tap can fix it.\n   *\n   * Sync now needs an area whose tiles verify (`completableArea`); one\n   * whose map stage could not be read, with another stage No, would\n   * otherwise promise a tap that is never offered. It reads \"Can't tell\"\n   * instead (SNOW-1308 review).\n   *\n   * @param {'ready'|'open-map'|'refresh'|'unknown'} verdict\n   * @param {boolean} completable\n   * @returns {'ready'|'open-map'|'refresh'|'unknown'}\n   */\n  function tapCanFix(verdict, completable) {\n    return verdict === 'refresh' && !completable ? 'unknown' : verdict;\n  }\n\n  /**\n   * A stage with its \"Problem terrain\" line, where the area has one, and\n   * the line folded into the stage's answer (SNOW-1387, Hugo 2 Nov 2026):\n   * an area missing a day of the bulletin's slopes is not ready for\n   * offline, so a No line makes the stage No and the verdict \"Needs a\n   * refresh\". The stage's own No outranks it and keeps its reason (the\n   * bulletins themselves are stale, which the note says); an unread line\n   * makes a Yes unknown, never a Yes. A `terrain` reason has no note of\n   * its own: the line under the stage already says how many days are\n   * saved.\n   *\n   * @param {Stage} stage\n   * @param {TerrainLine|null} line\n   * @returns {Stage}\n   */\n  function withTerrainLine(stage, line) {\n    if (!line) return stage;\n    var out = Object.assign({}, stage, { terrain: line });\n    if (stage.status === 'no') return out;\n    if (line.status === 'no') return Object.assign(out, { status: 'no', reason: 'terrain' });\n    if (line.status === 'unknown' && stage.status === 'yes') {\n      return Object.assign(out, { status: 'unknown' });\n    }\n    return out;\n  }\n\n  /**\n   * @typedef {Object} Verified\n   * @property {'yes'|'no'|null} [map] Whether the area's tiles verified.\n   * @property {'yes'|'no'|null} [content] Whether everything the area's\n   *   content plan named, the reader's own things included, landed.\n   * @property {string} [reason] Why the map is No, where it is.\n   * @property {string} [principal] The account the content answer was\n   *   read for (the `pwa-user-id` meta). A content answer is only ever\n   *   shown back to that account.\n   * @property {string} at When the reading was taken (ISO).\n   */\n\n  /**\n   * One stamp answer, narrowed: only Yes and No are claims.\n   *\n   * @param {unknown} value\n   * @returns {'yes'|'no'|null}\n   */\n  function answer(value) {\n    return value === 'yes' || value === 'no' ? value : null;\n  }\n\n  /**\n   * SNOW-1415: what one map-page sync learned, as a `verified` stamp.\n   *\n   * `syncArea`'s `tiles` is the map half. `'ok'` and `'none'` say only\n   * that the render dependencies are established\n   * (docs/decisions/a-pre-departure-sync-is-unconditional.md), so a Yes\n   * also needs `tilesHeld === true`: every tile of the area's grid is in\n   * its bucket (`tileReading`). `tilesHeld === false` is a No for the\n   * tiles; null is no reading, and leaves the map answer as it was.\n   * `'absent'`, `'failed'` and `'incomplete'` are No, and `'unknown'` is\n   * no claim at all. `content` is the content half's own answer, stamped\n   * for `principal` and only when there is one (a signed-out sync has no\n   * things of its own to answer for).\n   *\n   * @param {{tiles?: string, tilesHeld?: boolean|null, content?: boolean}|null|undefined} result\n   * @param {string} at\n   * @param {string} [principal] The `pwa-user-id` the sync ran as.\n   * @returns {Verified|null} Null when the sync claimed nothing.\n   */\n  function verifiedFromSync(result, at, principal) {\n    if (!result) return null;\n    /** @type {Verified} */\n    var out = { at: at };\n    var depsOk = result.tiles === 'ok' || result.tiles === 'none';\n    if (depsOk && result.tilesHeld === true) out.map = 'yes';\n    else if (depsOk && result.tilesHeld === false) {\n      out.map = 'no';\n      out.reason = 'tiles';\n    } else if (\n      result.tiles === 'absent' ||\n      result.tiles === 'failed' ||\n      result.tiles === 'incomplete'\n    ) {\n      out.map = 'no';\n      out.reason = result.tiles === 'incomplete' ? 'tiles' : result.tiles;\n    }\n    // An absent bucket is never fetched into, so its content answer is\n    // no reading of the content at all.\n    if (result.tiles !== 'absent' && principal) {\n      out.content = result.content ? 'yes' : 'no';\n      out.principal = principal;\n    }\n    return out.map || out.content ? out : null;\n  }\n\n  /**\n   * SNOW-1415: what one /offline/ panel read, as a `verified` stamp.\n   *\n   * The panel's map stage is the full reading (bucket and tiles); its\n   * things stage is the cache walk over the urls the last sync stamped.\n   * Unknown stages claim nothing, so a host that cannot read tiles\n   * (static/offline.html) never overwrites what the map page learned.\n   *\n   * @param {{map: Stage, things: Stage|null}} stages\n   * @param {string} at\n   * @param {string} [principal] The `pwa-user-id` the page was rendered\n   *   for. With none, the things answer is not stamped.\n   * @returns {Verified|null}\n   */\n  function verifiedFromStages(stages, at, principal) {\n    if (!stages) return null;\n    /** @type {Verified} */\n    var out = { at: at };\n    var map = stages.map ? answer(stages.map.status) : null;\n    if (map) out.map = map;\n    if (map === 'no' && stages.map.reason) out.reason = stages.map.reason;\n    var things = stages.things ? answer(stages.things.status) : null;\n    if (things && principal) {\n      out.content = things;\n      out.principal = principal;\n    }\n    return out.map || out.content ? out : null;\n  }\n\n  /**\n   * SNOW-1415: one record with a `verified` stamp merged in.\n   *\n   * Merged field by field, so a reading that claims only the content (a\n   * map-page sync that could not judge the tiles) keeps the map answer an\n   * earlier reading gave. A map Yes drops a stale map-No reason.\n   *\n   * Synchronous, because every caller runs it inside a `readModifyWrite`\n   * mutator, which must not await. Device-only: `downloads_sync.js` sends\n   * a whitelist of fields, and this is not one of them.\n   *\n   * @param {any} entry The stored record.\n   * @param {Verified|null} verified\n   * @returns {any} A new record, or the entry itself when there is nothing\n   *   to stamp.\n   */\n  function stampVerifiedRecord(entry, verified) {\n    if (!entry || !verified) return entry;\n    var prior = entry.verified && typeof entry.verified === 'object' ? entry.verified : {};\n    var next = Object.assign({}, prior, { at: verified.at });\n    if (verified.map) {\n      next.map = verified.map;\n      if (verified.map === 'no' && verified.reason) next.reason = verified.reason;\n      else delete next.reason;\n    }\n    if (verified.content) {\n      next.content = verified.content;\n      next.principal = verified.principal || '';\n    }\n    return Object.assign({}, entry, { verified: next });\n  }\n\n  /**\n   * SNOW-1415: the stages of one area from its stored record alone.\n   *\n   * The connection panel runs on every page, where neither the audit's\n   * readings nor the tile arithmetic exist. So the pages that CAN read\n   * them stamp what they learned on the record (`verified`, from\n   * `verifiedFromSync` and `verifiedFromStages`), and every other page\n   * reads the stamp back through here. `verdictFor` then gives the same\n   * one-line answer the /offline/ panels give.\n   *\n   *   - **map** \u2014 the stamp's map answer. No stamp is unknown, which is\n   *     the honest answer for a record no tile-capable page has read.\n   *   - **conditions** \u2014 the record's own `contentAt`, by calendar day,\n   *     as `areaContentState` reads it; a fetch that fell short\n   *     (`contentIncomplete`) makes a fresh stamp No.\n   *   - **things** \u2014 the stamp's content answer, signed-in readers only,\n   *     and only when it was read for this reader's account\n   *     (`verified.principal`). Another account's answer is unknown here,\n   *     as `thingsStage` treats another account's items on /offline/.\n   *\n   * @param {any} record A `basemap.regions` or `basemap.customAreas` row.\n   * @param {string|Date} [now]\n   * @param {{signedIn?: boolean, principal?: string}} [options]\n   * @returns {{map: Stage, conditions: Stage, things: Stage|null}}\n   */\n  function stagesFromRecord(record, now, options) {\n    var opts = options || {};\n    var r = record || {};\n    var v = r.verified && typeof r.verified === 'object' ? r.verified : null;\n\n    /** @type {Stage} */\n    var map = { status: 'unknown', reason: 'unverified' };\n    var mapAnswer = v ? answer(v.map) : null;\n    if (mapAnswer === 'yes') map = { status: 'yes' };\n    else if (mapAnswer === 'no') map = { status: 'no', reason: String(v.reason || 'tiles') };\n\n    /** @type {Stage} */\n    var conditions;\n    if (!r.contentAt) {\n      conditions = { status: 'no', reason: 'never' };\n    } else {\n      var fetched = new Date(r.contentAt);\n      var today = now ? new Date(now) : new Date();\n      if (Number.isNaN(fetched.getTime()) || Number.isNaN(today.getTime())) {\n        conditions = { status: 'unknown' };\n      } else if (fetched.toDateString() !== today.toDateString()) {\n        conditions = { status: 'no', reason: 'stale' };\n      } else if (r.contentIncomplete) {\n        conditions = { status: 'no', reason: 'incomplete' };\n      } else {\n        conditions = { status: 'yes' };\n      }\n    }\n\n    /** @type {Stage|null} */\n    var things = null;\n    if (opts.signedIn) {\n      var ours = !!(v && opts.principal && v.principal === opts.principal);\n      var contentAnswer = ours ? answer(v.content) : null;\n      if (contentAnswer === 'yes') things = { status: 'yes', rows: [] };\n      else if (contentAnswer === 'no') things = { status: 'no', reason: 'incomplete', rows: [] };\n      else things = { status: 'unknown', rows: [] };\n    }\n    return { map: map, conditions: conditions, things: things };\n  }\n\n  /**\n   * Every panel, in paint order.\n   *\n   * @param {any} readings What `offline_audit.js` collected.\n   * @param {Record<string, string>} t The journey's strings.\n   * @param {{tiles?: Record<string, boolean|null>, origin?: string,\n   *   canFetch?: boolean}} [options] `tiles` is each area's\n   *   `tileReading`, by id; `canFetch` whether this host can run Sync now.\n   * @returns {Panel[]}\n   */\n  function buildPanels(readings, t, options) {\n    var core = audit();\n    var opts = options || {};\n    var r = readings || {};\n    if (!core) return [];\n    var strings = t || {};\n    var tiles = opts.tiles || {};\n    var failed = !!r.failure;\n    var ctx = {\n      signedIn: isSignedIn(r),\n      urls: shellUrls(r),\n      origin: opts.origin || '',\n      principal: typeof r.currentPrincipal === 'string' ? r.currentPrincipal : null,\n    };\n    /** @type {any[]} */\n    var areas = core.chosenAreas(r);\n    /** @type {Panel[]} */\n    var panels = [];\n    KIND_ORDER.forEach(function (kind) {\n      areas\n        .filter(function (area) {\n          return areaKind(area) === kind;\n        })\n        .forEach(function (area) {\n          /** @type {{map: Stage, conditions: Stage, things: Stage|null}} */\n          var stages = failed\n            ? {\n                map: { status: 'unknown' },\n                conditions: { status: 'unknown' },\n                things: ctx.signedIn ? { status: 'unknown', rows: [] } : null,\n              }\n            : {\n                map: mapStage(area, tiles[area.id]),\n                conditions: withTerrainLine(conditionsStage(area, r.now), problemTerrainLine(area, ctx)),\n                things: thingsStage(area, ctx),\n              };\n          panels.push({\n            id: String(area.id),\n            name: areaName(area, strings),\n            kind: kind,\n            orphaned: !!area.orphaned,\n            contentAt: typeof area.contentAt === 'string' ? area.contentAt : null,\n            stages: stages,\n            verdict: tapCanFix(verdictFor(stages), !failed && core.completableArea(area, r.now)),\n            canSync: !!opts.canFetch && !failed && core.completableArea(area, r.now),\n            bytes: typeof area.bytes === 'number' ? area.bytes : 0,\n          });\n        });\n    });\n    return panels;\n  }\n\n  self.pwaOfflineJourneyCore = Object.freeze({\n    buildPanels: buildPanels,\n    verdictFor: verdictFor,\n    stagesFromRecord: stagesFromRecord,\n    verifiedFromSync: verifiedFromSync,\n    verifiedFromStages: verifiedFromStages,\n    stampVerifiedRecord: stampVerifiedRecord,\n    mapStage: mapStage,\n    conditionsStage: conditionsStage,\n    thingsStage: thingsStage,\n    problemTerrainLine: problemTerrainLine,\n    tileReading: tileReading,\n    isSignedIn: isSignedIn,\n    areaName: areaName,\n  });\n})();\n"],
  "mappings": "CAmEC,UAAY,CACX,aA6CA,IAAIA,EAAa,CAAC,SAAU,WAAY,QAAQ,EAOhD,SAASC,GAAQ,CACf,OAAO,KAAK,mBACd,CASA,SAASC,EAAKC,EAAUC,EAAQ,CAC9B,OAAO,OAAOD,GAAY,EAAE,EAAE,QAAQ,eAAgB,SAAUE,EAAIC,EAAK,CACvE,OAAO,OAAO,UAAU,eAAe,KAAKF,EAAQE,CAAG,EAAIF,EAAOE,CAAG,EAAI,EAC3E,CAAC,CACH,CAQA,SAASC,EAASC,EAAM,CACtB,OAAIA,GAAQA,EAAK,OAAS,SAAiB,SACpCA,GAAQA,EAAK,OAAS,WAAa,WAAa,QACzD,CAUA,SAASC,EAASD,EAAM,EAAG,CACzB,OAAIA,EAAK,KAAa,OAAOA,EAAK,IAAI,EAClC,OAAOA,EAAK,SAAY,UAAY,OAAO,SAASA,EAAK,OAAO,EAC3DN,EAAK,EAAE,qBAAqB,GAAK,oBAAqB,CAAE,EAAG,OAAOM,EAAK,OAAO,CAAE,CAAC,EAEnF,OAAOA,EAAK,EAAE,CACvB,CAcA,SAASE,EAASF,EAAMG,EAAU,CAChC,GAAIH,EAAK,EAAG,MAAO,CAAE,EAAGA,EAAK,CAAE,EAC/B,IAAII,EAAO,MAAM,QAAQJ,EAAK,IAAI,EAAIA,EAAK,KAAO,KAClD,MAAI,CAAC,MAAM,QAAQA,EAAK,IAAI,GAAK,CAACI,EAAa,KAC3CJ,EAAK,OAAS,YAAc,OAAOG,EAAS,mBAAsB,WAC7DA,EAAS,kBAAkBH,EAAK,KAAMI,EAAK,CAAC,EAAGA,EAAK,CAAC,CAAC,EAE3D,OAAOD,EAAS,WAAc,WAAmB,KAC9CA,EAAS,UAAUH,EAAK,KAAMI,EAAK,CAAC,EAAGA,EAAK,CAAC,CAAC,CACvD,CAeA,SAASC,EAAYL,EAAMG,EAAU,CAGnC,GAFI,CAACH,GAAQ,CAACG,GAAY,OAAOA,EAAS,iBAAoB,YAC1DH,EAAK,iBAAmB,IAASA,EAAK,UACtC,CAACA,EAAK,SAAU,OAAO,KAC3B,GAAI,CACF,IAAIM,EAAOJ,EAASF,EAAMG,CAAQ,EAClC,OAAKG,EACE,CAAC,CAACH,EAAS,gBAAgBH,EAAK,SAAUM,EAAMN,EAAK,SAAW,CAAC,CAAC,EADvD,IAEpB,MAAe,CACb,OAAO,IACT,CACF,CASA,SAASO,EAASP,EAAMQ,EAAO,CAC7B,IAAIC,EAAOhB,EAAM,EACjB,GAAI,CAACgB,EAAM,MAAO,CAAE,OAAQ,SAAU,EACtC,IAAIC,EAAQD,EAAK,UAAUT,CAAI,EAAE,OACjC,OAAIU,IAAU,QACRF,IAAU,GAAa,CAAE,OAAQ,KAAM,EACvCA,IAAU,GAAc,CAAE,OAAQ,KAAM,OAAQ,OAAQ,EACrD,CAAE,OAAQ,UAAW,OAAQ,cAAe,EAEjDE,IAAU,cAAgBA,IAAU,eAC/B,CAAE,OAAQ,UAAW,OAAQA,CAAM,EAGrC,CAAE,OAAQ,KAAM,OAAQA,CAAM,CACvC,CASA,SAASC,EAAgBX,EAAMY,EAAK,CAClC,IAAIH,EAAOhB,EAAM,EACjB,GAAI,CAACgB,EAAM,MAAO,CAAE,OAAQ,SAAU,EACtC,IAAII,EAAUJ,EAAK,iBAAiBT,EAAMY,CAAG,EAC7C,OAAIC,IAAY,QAAgB,CAAE,OAAQ,KAAM,EAC5CA,IAAY,QAAgB,CAAE,OAAQ,KAAM,OAAQ,OAAQ,EAC5DA,IAAY,QAAgB,CAAE,OAAQ,KAAM,OAAQ,OAAQ,EAGzD,CAAE,OAAQ,SAAU,CAC7B,CASA,SAASC,EAAWC,EAAU,CAC5B,IAAIC,EAAID,GAAYA,EAAS,iBAC7B,OAAO,OAAOC,GAAM,UAAYA,IAAM,IAAMA,IAAM,aAAeA,IAAM,SACzE,CAQA,SAASC,EAAUF,EAAU,CAC3B,GAAI,CAACA,GAAYA,EAAS,iBAAmB,IAASA,EAAS,QAAS,OAAO,KAE/E,IAAIG,EAAO,IAAI,IACf,OAAC,MAAM,QAAQH,EAAS,YAAY,EAAIA,EAAS,aAAe,CAAC,GAAG,QACxC,SAAUI,EAAO,CACrCA,GAASA,EAAM,KAAKD,EAAK,IAAIC,EAAM,IAAKA,CAAK,CACnD,CACF,EACOD,CACT,CAiBA,SAASE,EAASC,EAAKC,EAAMC,EAAW,CACtC,IAAIJ,EAAQG,EAAK,IAAID,CAAG,EACxB,GAAI,CAACF,EAAO,MAAO,KACnB,IAAIV,EAAOhB,EAAM,EACjB,MAAI,CAACgB,GAAQ,OAAOA,EAAK,mBAAsB,WAAmB,UAC7DA,EAAK,kBAAkBY,CAAG,EAC3BF,EAAM,YAAoB,UACvBV,EAAK,iBAAiBU,EAAM,UAAWI,CAAS,EAAI,MAAQ,KAF1B,KAG3C,CASA,SAASC,EAASH,EAAKI,EAAQ,CAC7B,GAAI,CACF,OAAO,IAAI,IAAIJ,EAAKI,GAAU,kBAAkB,EAAE,SAAS,CAC7D,MAAe,CACb,OAAOJ,CACT,CACF,CAkBA,SAASK,EAAmB1B,EAAM2B,EAAK,CACrC,GAAI,CAAC3B,GAAQ,CAACA,EAAK,QAAS,OAAO,KACnC,IAAI4B,EAAU5B,EAAK,OAASA,EAAK,MAAM,eACvC,GAAI,CAAC,MAAM,QAAQ4B,CAAO,GAAKA,EAAQ,SAAW,EAAG,OAAO,KAC5D,IAAIC,EAAQD,EAAQ,OACpB,GAAI,CAACD,EAAI,KAAM,MAAO,CAAE,OAAQ,UAAW,KAAM,EAAG,MAAOE,CAAM,EACjE,IAAIP,EAAwCK,EAAI,KAC5CG,EAAQF,EAAQ,OAAO,SAAgCP,EAAK,CAC9D,OAAOD,EAASI,EAASH,EAAKM,EAAI,MAAM,EAAGL,EAAMK,EAAI,WAAa,IAAI,IAAM,KAC9E,CAAC,EAAE,OACH,MAAO,CAAE,OAAQG,IAAUD,EAAQ,MAAQ,KAAM,KAAMC,EAAO,MAAOD,CAAM,CAC7E,CAWA,SAASE,EAAY/B,EAAM2B,EAAK,CAC9B,GAAI,CAACA,EAAI,SAAU,OAAO,KAC1B,IAAIK,EAAQhC,EAAK,MACjB,GAAI,CAACgC,GAAS,CAAC,MAAM,QAAQA,EAAM,KAAK,GAAK,CAAC,MAAM,QAAQA,EAAM,IAAI,EACpE,MAAO,CAAE,OAAQ,UAAW,OAAQ,aAAc,KAAM,CAAC,CAAE,EAO7D,IAAIJ,EAAU,OAAOI,EAAM,WAAc,SAAWA,EAAM,UAAY,GACtE,GAAI,CAACJ,GAAWA,IAAYD,EAAI,UAC9B,MAAO,CAAE,OAAQ,UAAW,OAAQ,gBAAiB,KAAM,CAAC,CAAE,EAGhE,IAAIM,EAAO,CAAC,EAKRC,EAAM,SAAUC,EAAMC,EAAM,CAC9B,GAAKA,EACL,KAAIlB,EAAO,MAAM,QAAQkB,EAAK,IAAI,EAAIA,EAAK,KAAO,CAAC,EAE/CC,EAAS,UACb,GAAInB,EAAK,OAAS,GAAKS,EAAI,KAAM,CAC/B,IAAIL,EAAwCK,EAAI,KAC5CW,EAASpB,EAAK,IAAI,SAAgCG,EAAK,CACzD,OAAOD,EAASI,EAASH,EAAKM,EAAI,MAAM,EAAGL,EAAMK,EAAI,WAAa,IAAI,CACxE,CAAC,EACDU,EACEC,EAAO,QAAQ,IAAI,GAAK,EAAI,KAAOA,EAAO,QAAQ,SAAS,GAAK,EAAI,UAAY,KACpF,CACAL,EAAK,KAAK,CAAE,KAAME,EAAM,KAAM,OAAOC,EAAK,MAAS,SAAWA,EAAK,KAAO,GAAI,OAAQC,CAAO,CAAC,EAChG,EAOA,GANAL,EAAM,MAAM,QAAQ,SAA6BO,EAAM,CACrDL,EAAI,OAAQK,CAAI,CAClB,CAAC,EACDP,EAAM,KAAK,QAAQ,SAA6BQ,EAAK,CACnDN,EAAI,MAAOM,CAAG,CAChB,CAAC,EACGP,EAAK,SAAW,EAAG,MAAO,CAAE,OAAQ,MAAO,OAAQ,YAAa,KAAMA,CAAK,EAC/E,IAAIQ,EAAWR,EAAK,IAAI,SAAUS,EAAK,CACrC,OAAOA,EAAI,MACb,CAAC,EACD,OAAID,EAAS,QAAQ,IAAI,GAAK,EAAU,CAAE,OAAQ,KAAM,KAAMR,CAAK,EAC/DQ,EAAS,QAAQ,SAAS,GAAK,EAAU,CAAE,OAAQ,UAAW,KAAMR,CAAK,EACtE,CAAE,OAAQ,MAAO,KAAMA,CAAK,CACrC,CAYA,SAASU,EAAWC,EAAQ,CAC1B,IAAIC,EAAO,CAACD,EAAO,IAAKA,EAAO,UAAU,EAEzC,GADIA,EAAO,QAAQC,EAAK,KAAKD,EAAO,MAAM,EACtCA,EAAO,IAAI,SAAW,KAAM,MAAO,WACvC,IAAIE,EAAyC,SAAUT,EAAQ,CAC7D,OAAOQ,EAAK,KAAK,SAAUE,EAAO,CAChC,OAAOA,EAAM,SAAWV,CAC1B,CAAC,CACH,EACA,OAAIS,EAAI,IAAI,EAAU,UAClBA,EAAI,SAAS,EAAU,UACpB,OACT,CAcA,SAASE,EAAUC,EAASC,EAAa,CACvC,OAAOD,IAAY,WAAa,CAACC,EAAc,UAAYD,CAC7D,CAiBA,SAASE,EAAgBJ,EAAOK,EAAM,CACpC,GAAI,CAACA,EAAM,OAAOL,EAClB,IAAIM,EAAM,OAAO,OAAO,CAAC,EAAGN,EAAO,CAAE,QAASK,CAAK,CAAC,EACpD,OAAIL,EAAM,SAAW,KAAaM,EAC9BD,EAAK,SAAW,KAAa,OAAO,OAAOC,EAAK,CAAE,OAAQ,KAAM,OAAQ,SAAU,CAAC,EACnFD,EAAK,SAAW,WAAaL,EAAM,SAAW,MACzC,OAAO,OAAOM,EAAK,CAAE,OAAQ,SAAU,CAAC,EAE1CA,CACT,CAoBA,SAASC,EAAOC,EAAO,CACrB,OAAOA,IAAU,OAASA,IAAU,KAAOA,EAAQ,IACrD,CAqBA,SAASC,EAAiBC,EAAQC,EAAInC,EAAW,CAC/C,GAAI,CAACkC,EAAQ,OAAO,KAEpB,IAAIJ,EAAM,CAAE,GAAIK,CAAG,EACfC,EAASF,EAAO,QAAU,MAAQA,EAAO,QAAU,OACvD,OAAIE,GAAUF,EAAO,YAAc,GAAMJ,EAAI,IAAM,MAC1CM,GAAUF,EAAO,YAAc,IACtCJ,EAAI,IAAM,KACVA,EAAI,OAAS,UAEbI,EAAO,QAAU,UACjBA,EAAO,QAAU,UACjBA,EAAO,QAAU,gBAEjBJ,EAAI,IAAM,KACVA,EAAI,OAASI,EAAO,QAAU,aAAe,QAAUA,EAAO,OAI5DA,EAAO,QAAU,UAAYlC,IAC/B8B,EAAI,QAAUI,EAAO,QAAU,MAAQ,KACvCJ,EAAI,UAAY9B,GAEX8B,EAAI,KAAOA,EAAI,QAAUA,EAAM,IACxC,CAgBA,SAASO,EAAmBhB,EAAQc,EAAInC,EAAW,CACjD,GAAI,CAACqB,EAAQ,OAAO,KAEpB,IAAIS,EAAM,CAAE,GAAIK,CAAG,EACfG,EAAMjB,EAAO,IAAMU,EAAOV,EAAO,IAAI,MAAM,EAAI,KAC/CiB,IAAKR,EAAI,IAAMQ,GACfA,IAAQ,MAAQjB,EAAO,IAAI,SAAQS,EAAI,OAAST,EAAO,IAAI,QAC/D,IAAIkB,EAASlB,EAAO,OAASU,EAAOV,EAAO,OAAO,MAAM,EAAI,KAC5D,OAAIkB,GAAUvC,IACZ8B,EAAI,QAAUS,EACdT,EAAI,UAAY9B,GAEX8B,EAAI,KAAOA,EAAI,QAAUA,EAAM,IACxC,CAkBA,SAASU,EAAoB5C,EAAO6C,EAAU,CAC5C,GAAI,CAAC7C,GAAS,CAAC6C,EAAU,OAAO7C,EAChC,IAAI8C,EAAQ9C,EAAM,UAAY,OAAOA,EAAM,UAAa,SAAWA,EAAM,SAAW,CAAC,EACjF+C,EAAO,OAAO,OAAO,CAAC,EAAGD,EAAO,CAAE,GAAID,EAAS,EAAG,CAAC,EACvD,OAAIA,EAAS,MACXE,EAAK,IAAMF,EAAS,IAChBA,EAAS,MAAQ,MAAQA,EAAS,OAAQE,EAAK,OAASF,EAAS,OAChE,OAAOE,EAAK,QAEfF,EAAS,UACXE,EAAK,QAAUF,EAAS,QACxBE,EAAK,UAAYF,EAAS,WAAa,IAElC,OAAO,OAAO,CAAC,EAAG7C,EAAO,CAAE,SAAU+C,CAAK,CAAC,CACpD,CA2BA,SAASC,EAAiBC,EAAQxD,EAAKyD,EAAS,CAC9C,IAAIC,EAAOD,GAAW,CAAC,EACnBE,EAAIH,GAAU,CAAC,EACfI,EAAID,EAAE,UAAY,OAAOA,EAAE,UAAa,SAAWA,EAAE,SAAW,KAGhEV,EAAM,CAAE,OAAQ,UAAW,OAAQ,YAAa,EAChDY,EAAYD,EAAIlB,EAAOkB,EAAE,GAAG,EAAI,KAChCC,IAAc,MAAOZ,EAAM,CAAE,OAAQ,KAAM,EACtCY,IAAc,OAAMZ,EAAM,CAAE,OAAQ,KAAM,OAAQ,OAAOW,EAAE,QAAU,OAAO,CAAE,GAGvF,IAAIE,EACJ,GAAI,CAACH,EAAE,UACLG,EAAa,CAAE,OAAQ,KAAM,OAAQ,OAAQ,MACxC,CACL,IAAIC,EAAU,IAAI,KAAKJ,EAAE,SAAS,EAC9BK,EAAQhE,EAAM,IAAI,KAAKA,CAAG,EAAI,IAAI,KAClC,OAAO,MAAM+D,EAAQ,QAAQ,CAAC,GAAK,OAAO,MAAMC,EAAM,QAAQ,CAAC,EACjEF,EAAa,CAAE,OAAQ,SAAU,EACxBC,EAAQ,aAAa,IAAMC,EAAM,aAAa,EACvDF,EAAa,CAAE,OAAQ,KAAM,OAAQ,OAAQ,EACpCH,EAAE,kBACXG,EAAa,CAAE,OAAQ,KAAM,OAAQ,YAAa,EAElDA,EAAa,CAAE,OAAQ,KAAM,CAEjC,CAGA,IAAIZ,EAAS,KACb,GAAIQ,EAAK,SAAU,CACjB,IAAIO,EAAO,CAAC,EAAEL,GAAKF,EAAK,WAAaE,EAAE,YAAcF,EAAK,WACtDQ,EAAgBD,EAAOvB,EAAOkB,EAAE,OAAO,EAAI,KAC3CM,IAAkB,MAAOhB,EAAS,CAAE,OAAQ,MAAO,KAAM,CAAC,CAAE,EACvDgB,IAAkB,KAAMhB,EAAS,CAAE,OAAQ,KAAM,OAAQ,aAAc,KAAM,CAAC,CAAE,EACpFA,EAAS,CAAE,OAAQ,UAAW,KAAM,CAAC,CAAE,CAC9C,CACA,MAAO,CAAE,IAAKD,EAAK,WAAYa,EAAY,OAAQZ,CAAO,CAC5D,CAYA,SAASiB,EAAYhE,EAAU,EAAGsD,EAAS,CACzC,IAAI5D,EAAOhB,EAAM,EACb6E,EAAOD,GAAW,CAAC,EACnBE,EAAIxD,GAAY,CAAC,EACrB,GAAI,CAACN,EAAM,MAAO,CAAC,EACnB,IAAIuE,EAAU,GAAK,CAAC,EAChBxE,EAAQ8D,EAAK,OAAS,CAAC,EACvBW,EAAS,CAAC,CAACV,EAAE,QACb5C,EAAM,CACR,SAAUb,EAAWyD,CAAC,EACtB,KAAMtD,EAAUsD,CAAC,EACjB,OAAQD,EAAK,QAAU,GACvB,UAAW,OAAOC,EAAE,kBAAqB,SAAWA,EAAE,iBAAmB,IAC3E,EAEIW,EAAQzE,EAAK,YAAY8D,CAAC,EAE1BY,EAAS,CAAC,EACd,OAAA3F,EAAW,QAAQ,SAAU2C,EAAM,CACjC+C,EACG,OAAO,SAAUlF,EAAM,CACtB,OAAOD,EAASC,CAAI,IAAMmC,CAC5B,CAAC,EACA,QAAQ,SAAUnC,EAAM,CAEvB,IAAI4C,EAASqC,EACT,CACE,IAAK,CAAE,OAAQ,SAAU,EACzB,WAAY,CAAE,OAAQ,SAAU,EAChC,OAAQtD,EAAI,SAAW,CAAE,OAAQ,UAAW,KAAM,CAAC,CAAE,EAAI,IAC3D,EACA,CACE,IAAKpB,EAASP,EAAMQ,EAAMR,EAAK,EAAE,CAAC,EAClC,WAAYmD,EAAgBxC,EAAgBX,EAAMuE,EAAE,GAAG,EAAG7C,EAAmB1B,EAAM2B,CAAG,CAAC,EACvF,OAAQI,EAAY/B,EAAM2B,CAAG,CAC/B,EACJwD,EAAO,KAAK,CACV,GAAI,OAAOnF,EAAK,EAAE,EAClB,KAAMC,EAASD,EAAMgF,CAAO,EAC5B,KAAM7C,EACN,SAAU,CAAC,CAACnC,EAAK,SACjB,UAAW,OAAOA,EAAK,WAAc,SAAWA,EAAK,UAAY,KACjE,OAAQ4C,EACR,QAASI,EAAUL,EAAWC,CAAM,EAAG,CAACqC,GAAUxE,EAAK,gBAAgBT,EAAMuE,EAAE,GAAG,CAAC,EACnF,QAAS,CAAC,CAACD,EAAK,UAAY,CAACW,GAAUxE,EAAK,gBAAgBT,EAAMuE,EAAE,GAAG,EACvE,MAAO,OAAOvE,EAAK,OAAU,SAAWA,EAAK,MAAQ,CACvD,CAAC,CACH,CAAC,CACL,CAAC,EACMmF,CACT,CAEA,KAAK,sBAAwB,OAAO,OAAO,CACzC,YAAaJ,EACb,WAAYpC,EACZ,iBAAkBwB,EAClB,iBAAkBX,EAClB,mBAAoBI,EACpB,oBAAqBG,EACrB,SAAUxD,EACV,gBAAiBI,EACjB,YAAaoB,EACb,mBAAoBL,EACpB,YAAarB,EACb,WAAYS,EACZ,SAAUb,CACZ,CAAC,CACH,GAAG",
  "names": ["KIND_ORDER", "audit", "fill", "template", "values", "_m", "key", "areaKind", "area", "areaName", "areaBlob", "download", "band", "tileReading", "blob", "mapStage", "tiles", "core", "state", "conditionsStage", "now", "content", "isSignedIn", "readings", "p", "shellUrls", "urls", "entry", "urlState", "url", "held", "principal", "absolute", "origin", "problemTerrainLine", "ctx", "stamped", "total", "count", "thingsStage", "items", "rows", "add", "kind", "item", "status", "states", "trip", "pin", "statuses", "row", "verdictFor", "stages", "list", "any", "stage", "tapCanFix", "verdict", "completable", "withTerrainLine", "line", "out", "answer", "value", "verifiedFromSync", "result", "at", "depsOk", "verifiedFromStages", "map", "things", "stampVerifiedRecord", "verified", "prior", "next", "stagesFromRecord", "record", "options", "opts", "r", "v", "mapAnswer", "conditions", "fetched", "today", "ours", "contentAnswer", "buildPanels", "strings", "failed", "areas", "panels"]
}