@mason-data/cli 0.0.0-stage → 0.7.0

package/dist/src/lib/project-version.js

@@ -0,0 +1,76 @@
+/**
+ * THE VERSION A PROJECT IS WRITTEN FOR (the journey from a laptop to production). A project's
+ * `mason.yml`, beside its `sources/` and committed with it, names the Mason version the project was
+ * written and checked with:
+ *
+ *   version: 0.5.1
+ *
+ * Before 1.0 a minor version may change the project's format with no compatibility (CLAUDE.md "No backwards
+ * compatibility before v1.0"), so a project written for 0.5 and run by 0.6 would fail on whatever key moved, in words
+ * that never say the versions differ. The pin turns that into one refusal that does: the image of the ClickHouse stack
+ * this was cut from refused to start on a project of another minor version, or of a newer patch than itself
+ * (`imagePinProblem` below), and `mason init` / `mason start` refuse a CLI that is (src/cli/pin.ts). The way out is
+ * always the same pair: run the version the project names, or read the release notes and move the pin.
+ *
+ * A build that is no release (`dev` from a checkout, `main-<sha>` from main) checks nothing: it has no version to hold
+ * a project to. A project with no `mason.yml` (made by an older `mason init`) is unpinned and runs; `mason start` writes one.
+ */
+import * as path from "node:path";
+import { PROJECT_FILE, parseVersion, readProjectSettings } from "./project-file.js";
+export { parseVersion };
+export const PIN_FILE = PROJECT_FILE;
+export const versionText = (v) => `${v.major}.${v.minor}.${v.patch}`;
+/** The line a project's mason.yml is: what `mason init` writes. */
+export function pinFileText(version) {
+    return "# The Mason version this project is written for. The mason image and the mason command refuse another\n" +
+        "# minor version (before 1.0 a minor version may change the project's format): to upgrade, read that release's\n" +
+        "# notes, change what they say, then change this line.\n" +
+        `version: ${version}\n`;
+}
+/** The project's pin: its version, null when it has no mason.yml, or the problem with the file (src/lib/project-file.ts
+ *  reads it whole: a key it does not know is a problem here too). */
+export function readPin(project) {
+    const read = readProjectSettings(project);
+    return "problem" in read ? read : { pin: read.pin, file: read.file };
+}
+/** Same release line: before 1.0 the minor version, from 1.0 the major. */
+export function sameLine(a, b) {
+    return a.major === b.major && (a.major > 0 || a.minor === b.minor);
+}
+const older = (a, b) => a.major !== b.major ? a.major < b.major : a.minor !== b.minor ? a.minor < b.minor : a.patch < b.patch;
+/**
+ * Why `running` (what reads the project: the image, or the CLI) may not run a project pinned to `pin`, or null.
+ * Allowed: the same release line, at the pin's patch or later. `what` names the reader in the message ("the mason
+ * image", "this mason command"); `run` says how to run the pinned version instead.
+ */
+export function pinProblem(pin, running, file, what, run) {
+    if (sameLine(pin, running) && !older(running, pin))
+        return null;
+    const p = versionText(pin), r = versionText(running);
+    if (sameLine(pin, running)) {
+        return `${file} pins Mason ${p}, and ${what} is ${r}, older than it: the project may use a fix or a key ${r} does not have. ${run}`;
+    }
+    const line = pin.major > 0 ? `${pin.major}.x` : `${pin.major}.${pin.minor}.x`;
+    return older(running, pin)
+        ? `${file} pins Mason ${p}, and ${what} is ${r}: the project is written for a newer Mason. ${run}`
+        : `${file} pins Mason ${p}, and ${what} is ${r}, a newer release line than ${line}, which may read the project differently. ` +
+            `${run} Or upgrade the project: read the release notes of every version after ${p} up to ${r} (their "Before you upgrade"), ` +
+            `change what they say, then set version: ${r} in ${path.basename(file)}.`;
+}
+/**
+ * The image's check, as the ClickHouse stack's service ran it at its start: the project's pin against the image's
+ * MASON_VERSION, or null.
+ * An image that is no release (`dev`, `main-<sha>`) holds no project to a version.
+ */
+export function imagePinProblem(project, imageVersion) {
+    const running = parseVersion(imageVersion ?? "");
+    if (running === null)
+        return null;
+    const read = readPin(project);
+    if ("problem" in read)
+        return read.problem;
+    if (read.pin === null)
+        return null;
+    const p = versionText(read.pin);
+    return pinProblem(read.pin, running, read.file, "this mason image", `Run the image the project names (ghcr.io/embeddable-hq/mason-data:${p}).`);
+}

package/dist/src/lib/runnable.js

@@ -0,0 +1,14 @@
+/**
+ * A SCRIPT'S RUNNABLE FILE. This repo runs its TypeScript directly (Node's type stripping, no build), so
+ * every script the service starts, and every template the compiler imports, is named by its `.ts` path. The
+ * `@mason-data/cli` package cannot ship it that way — Node refuses to strip types under node_modules — so it ships the
+ * same sources compiled to `.js` beside each other (cli/build.ts). This picks whichever is there: the `.ts` in a
+ * checkout or the image, the `.js` in the package. Dependency-free.
+ */
+import * as fs from "node:fs";
+export function runnable(file) {
+    if (!file.endsWith(".ts") || fs.existsSync(file))
+        return file;
+    const js = `${file.slice(0, -3)}.js`;
+    return fs.existsSync(js) ? js : file;
+}

package/dist/src/lib/shell-word.js

@@ -0,0 +1,4 @@
+/** A word as the shell reads it back: bare when it is safe, else single-quoted (the `mason …` lines the CLI and the API print). */
+export function shellWord(s) {
+    return /^[\w@%+=:,./-]+$/.test(s) ? s : `'${s.replace(/'/g, "'\\''")}'`;
+}

package/dist/src/lib/timezone.js

@@ -0,0 +1,237 @@
+/**
+ * TIME ZONES, as a request names them (`timezone: "Asia/Kolkata"`, issue #435: "today" or "per day" has to mean the
+ * customer's day). An IANA name, checked against the zone names this product accepts, exactly as spelled
+ * (src/lib/zone-names.ts) and the zones this runtime can do arithmetic in (`Intl`), and the calendar arithmetic a
+ * range and a bucket need in it: the UTC instant of a local wall-clock time, and the local parts of an instant.
+ *
+ * Pure, and free of any dependency: the API's grammar, the fill and the SDK-side generator use it. The zone a
+ * ClickHouse function takes is the same name, spliced only after `isZone` accepted it (the name is from a closed
+ * set, so it cannot carry SQL).
+ */
+import { ZONE_NAMES } from "./zone-names.js";
+/** The name a request writes for UTC: no zone at all, as every bucket and range was before zones. */
+export const UTC = "UTC";
+const NAME_RE = /^[A-Za-z][A-Za-z0-9_+\-]*(\/[A-Za-z0-9_+\-]+){0,2}$/;
+const known = new Map();
+/** Whether `z` is a zone of ZONE_NAMES as written AND this runtime can compute in: `Europe/London`, `Asia/Kolkata`,
+ *  `UTC` — never `asia/kolkata` or `utc` (ZONE_NAMES is case-sensitive, `Intl` is not). */
+export function isZone(z) {
+    if (typeof z !== "string" || !NAME_RE.test(z) || !ZONE_NAMES.has(z))
+        return false;
+    let ok = known.get(z);
+    if (ok === undefined) {
+        try {
+            new Intl.DateTimeFormat("en-US", { timeZone: z });
+            ok = true;
+        }
+        catch (err) {
+            // the one way Intl says "no such zone": a RangeError; anything else is not a verdict on the name
+            if (!(err instanceof RangeError))
+                throw err;
+            ok = false;
+        }
+        known.set(z, ok);
+    }
+    return ok;
+}
+let lowered;
+/** The zone as ZONE_NAMES spells it, from a name in any case (`utc`, `europe/london`: the review of #443 met a 400
+ *  `unknown_timezone` for "utc"); null for a name no spelling of which is a zone. */
+export function canonicalZone(z) {
+    if (typeof z !== "string")
+        return null;
+    const name = z;
+    const exact = isZone(name);
+    if (exact)
+        return name;
+    lowered ??= new Map([...ZONE_NAMES].map((n) => [n.toLowerCase(), n]));
+    const c = lowered.get(name.toLowerCase());
+    return c !== undefined && isZone(c) ? c : null;
+}
+/** UTC and its aliases (compared in any case): a zone that changes nothing. One list, read by isUtc and by the SQL that tests the session zone at execution. */
+export const UTC_NAMES = ["UTC", "Etc/UTC", "Etc/GMT", "GMT", "Etc/Universal", "Universal", "Zulu", "Etc/Zulu"];
+export const isUtc = (z) => UTC_NAMES.some((n) => n.toLowerCase() === z.toLowerCase());
+/**
+ * THE ZONE OF A POSTGRES `AT TIME ZONE '<name>'`, as ClickHouse spells it, where Postgres and ClickHouse read the name
+ * alike (Cube's zoned bucket): an Area/Location name (`Europe/London`, `America/Sao_Paulo`, in any case) or
+ * a UTC alias. Postgres reads a name as a zone ABBREVIATION first (`CET` is a fixed +01 there, tzdata's `CET` keeps a
+ * summer time; `EST`, `MST`, `EET`, `MET` likewise) and a POSIX string (`+02`, `<-03>+3`) with its own sign rule, so a
+ * name of neither form is refused, never read as tzdata reads it. A name nobody knows is Postgres's own 22023.
+ * The rewrite and the functions of the copy (src/duck/rewrite.ts, src/duck/functions.ts) read it here.
+ */
+export function atTimeZoneOf(name) {
+    const zone = canonicalZone(name);
+    const examples = "Europe/London, America/Sao_Paulo, UTC";
+    // Postgres's abbreviations for UTC itself (offset 0, no summer time): UTC, whatever tzdata calls them
+    if (/^(UT|Z|ZULU)$/i.test(name))
+        return { zone: UTC };
+    if (isUtc(name) && zone !== null)
+        return { zone };
+    if (name.includes("/") && zone !== null)
+        return { zone };
+    if (zone !== null || /^[A-Za-z]{3,5}$/.test(name) || /^[<+\-0-9]/.test(name) || /^[A-Za-z]{3,}[+-]?\d/.test(name)) {
+        return { problem: `time zone "${name}": Postgres reads a name without a "/" as an abbreviation or a POSIX zone first, with a fixed offset, where the IANA zone of that name may move; write an IANA name (${examples})`, sqlstate: "0A000" };
+    }
+    return { problem: `time zone "${name}" not recognized: write an IANA name (${examples})`, sqlstate: "22023" };
+}
+/** A few zones every app serves, for a message that lists choices. */
+export const COMMON_ZONES = ["UTC", "America/New_York", "America/Chicago", "America/Los_Angeles", "Europe/London", "Europe/Berlin", "Asia/Kolkata", "Asia/Singapore", "Asia/Tokyo", "Australia/Sydney", "Australia/Adelaide"];
+const formatters = new Map();
+function formatter(z) {
+    let f = formatters.get(z);
+    if (!f) {
+        f = new Intl.DateTimeFormat("en-US", { timeZone: z, hourCycle: "h23", year: "numeric", month: "2-digit", day: "2-digit", hour: "2-digit", minute: "2-digit", second: "2-digit" });
+        formatters.set(z, f);
+    }
+    return f;
+}
+export function localParts(ms, z) {
+    const parts = {};
+    for (const p of formatter(z).formatToParts(new Date(ms)))
+        if (p.type !== "literal")
+            parts[p.type] = Number(p.value);
+    const { year, month, day, hour, minute, second } = parts;
+    const weekday = ((new Date(Date.UTC(year, month - 1, day)).getUTCDay() + 6) % 7) + 1;
+    return { year: year, month: month, day: day, hour: hour, minute: minute, second: second, weekday };
+}
+/** The zone's offset from UTC at the instant `ms`, in SECONDS: a historic offset has them (Monrovia was −0:44:30 until
+ *  1972, Amsterdam +0:19:32 until 1937), Intl keeps them and so does Postgres, so a reading of a time keeps them too. */
+export function offsetSeconds(ms, z) {
+    const p = localParts(ms, z);
+    const asUtc = Date.UTC(p.year, p.month - 1, p.day, p.hour, p.minute, p.second);
+    return Math.round((asUtc - Math.floor(ms / 1000) * 1000) / 1000);
+}
+/** The zone's offset from UTC at the instant `ms`, in whole minutes (Kolkata +330, New York -240 in summer): what the
+ *  hour arithmetic of a range and a bucket reads, which is only asked in a zone a whole number of hours from UTC. */
+export function offsetMinutes(ms, z) {
+    return Math.round(offsetSeconds(ms, z) / 60);
+}
+/**
+ * The instants a wall clock (`wall`: its fields written as if UTC) could mean in `z`: `candidates`, one per offset the
+ * zone has around the time (a zone changes at most once in three days), and `valid`, those of them at which the zone's
+ * offset puts the clock there — one for an ordinary time, two in the hour a clock falls back over, none in the hour it
+ * springs forward over.
+ */
+function readings(z, wall) {
+    const offsets = new Set([offsetSeconds(wall - 129_600_000, z), offsetSeconds(wall, z), offsetSeconds(wall + 129_600_000, z)]);
+    const candidates = [...offsets].map((o) => wall - o * 1000);
+    return { valid: candidates.filter((t) => offsetSeconds(t, z) * 1000 === wall - t), candidates };
+}
+/**
+ * The UTC instant of a local wall-clock TIME in zone `z`: the one reading of a time with no offset, as Postgres reads
+ * `timestamp '…' AT TIME ZONE z` (an app's SQL is Postgres SQL, the Postgres API is held to Postgres, and the oracle
+ * resolves every window bound there), on every path alike — the Postgres API's literals, and in the ClickHouse stack
+ * this was cut from its HTTP API's ranges, buckets, fill and compare — to the second of a historic offset
+ * (`offsetSeconds`: 1970-01-01 00:00 in Monrovia is 00:44:30Z, as Postgres has it). A time that does not exist there
+ * (the hour a clock springs forward over) is moved forward by the gap (02:30 on a 02:00 -> 03:00 night is 03:30); a time that happens twice (the hour it falls back over)
+ * is the LATER of the two, the offset in force after the change (2026-11-01 01:30 in New York is 06:30Z, 01:30 EST).
+ * The doubled hour was once read at the offset in force at the wall clock taken as UTC: the earlier instant
+ * west of UTC (05:30Z) and the later east of it, so the HTTP API and Postgres disagreed on the same body for every zone
+ * west of UTC. ClickHouse's own `toDateTime64(text, 3, z)` reads the doubled hour as the EARLIER instant and moves a
+ * gap BACK, so no path hands it a zone-less literal in a zone: every bound is resolved here and sent as an instant.
+ * A DATE is not a time: its first instant is `dayStart`. Pinned against Postgres by the dashboard tests of the
+ * ClickHouse stack this was cut from.
+ * `ms` is the rest of the minute (seconds and fraction), which never changes which reading applies.
+ */
+export function utcOf(z, year, month, day, hour = 0, minute = 0, ms = 0) {
+    // AS POSTGRES READS IT (`DetermineTimeZoneOffset`, verified on Postgres 18.6), so the Postgres API reads a
+    // wall-clock time with this one function too (it once had a twin, `postgresUtcOf`, written when this one
+    // met a doubled time on whichever pass came first)
+    const { valid, candidates } = readings(z, Date.UTC(year, month - 1, day, hour, minute) + ms);
+    // twice: the later; never: the offset before the gap, which is also the later reading
+    return Math.max(...(valid.length > 0 ? valid : candidates));
+}
+/**
+ * The first instant of the local DATE in `z`: what a date bound (`{"from": "2026-11-01"}`), `today`, the edges of a
+ * day, a week and a month, and a `.day` bucket's start mean. Its midnight; the EARLIER one where a clock falls back
+ * over midnight (Havana, the Azores: the local date begins at the first 00:00, and a `.day` bucket — ClickHouse's
+ * `toDate(col, z)`, Postgres's `(col AT TIME ZONE z)::date` — holds every row from it, so a range starting an hour
+ * later would miss rows its own bucket holds; Postgres's `date::timestamptz` cast reads midnight as a wall-clock TIME,
+ * the later one, which is why this is not `utcOf`); and the first instant after a midnight a clock skips (Santiago,
+ * 2026-09-06: 01:00). Decided in the review of #495; that stack's oracle said it in Postgres's words.
+ */
+export function dayStart(z, year, month, day) {
+    const { valid, candidates } = readings(z, Date.UTC(year, month - 1, day));
+    return valid.length > 0 ? Math.min(...valid) : Math.max(...candidates);
+}
+const wholeHours = new Map();
+/**
+ * Whether every offset `z` has had since 1970 and will have over the next two years is a whole number of hours, so a
+ * UTC hour is a local hour there: what lets an hour stored in UTC be re-bucketed in the zone (Kolkata, +5:30, and
+ * Adelaide, +9:30, are not). Since 1970, not a recent window: an `all_time` query reaches every stored hour, and
+ * Caracas was −4:30 until 2016 (review of #443). Daily, so no half-hour season is stepped over; once per zone.
+ */
+export function isWholeHourZone(z, now = Date.now()) {
+    let ok = wholeHours.get(z);
+    if (ok === undefined) {
+        ok = true;
+        for (let t = 0; t < now + 2 * 365 * 86_400_000; t += 86_400_000) {
+            if (offsetMinutes(t, z) % 60 !== 0) {
+                ok = false;
+                break;
+            }
+        }
+        wholeHours.set(z, ok);
+    }
+    return ok;
+}
+/** Why no time stored in UTC can be re-bucketed in `z`, or null when hours can: the finest grain anything stores is an
+ *  hour, so a zone that is not a whole number of hours from UTC is answered from the table's own rows, never from storage.
+ *  ONE sentence for the compiler's classification, its coverage and `mason status` (the hands-on review of #451). */
+export function hourFoldProblem(z) {
+    return isWholeHourZone(z) ? null : `${z} is not a whole number of hours from UTC, so a stored UTC hour is not one of its hours`;
+}
+const WEEK = 7 * 86_400_000;
+/** The years a change is looked for in: the times a DateTime64 holds (1900 to 2299), as every range and row is. */
+const FIRST_YEAR = 1900, LAST_YEAR = 2299;
+const changesByYear = new Map();
+/** A zone's changes in one UTC year: its offset read once a week, and a week it moved in bisected to the second.
+ *  Once per zone and year. A change undone within the same week is not seen: the tz database has no such week. */
+function changesInYear(z, year) {
+    const key = `${z}\u0000${year}`;
+    let out = changesByYear.get(key);
+    if (out !== undefined)
+        return out;
+    out = [];
+    const end = Date.UTC(year + 1, 0, 1);
+    let t = Date.UTC(year, 0, 1), off = offsetMinutes(t, z);
+    while (t < end) {
+        const u = Math.min(t + WEEK, end);
+        if (offsetMinutes(u, z) === off) {
+            t = u;
+            continue;
+        }
+        let lo = t, hi = u;
+        while (hi - lo > 1000) {
+            const mid = lo + Math.floor((hi - lo) / 2000) * 1000;
+            if (offsetMinutes(mid, z) === off)
+                lo = mid;
+            else
+                hi = mid;
+        }
+        const after = offsetMinutes(hi, z);
+        out.push({ at: hi, before: off, after });
+        t = hi;
+        off = after;
+    }
+    changesByYear.set(key, out);
+    return out;
+}
+/** The changes of `z`'s offset after `from` and before `to`, in order (none for UTC; none outside 1900 to 2299). */
+export function offsetChanges(z, from, to) {
+    if (isUtc(z) || !(to > from))
+        return [];
+    const out = [];
+    const y0 = Math.max(FIRST_YEAR, new Date(Math.max(from, Date.UTC(FIRST_YEAR, 0, 1))).getUTCFullYear());
+    const y1 = Math.min(LAST_YEAR, new Date(Math.min(to, Date.UTC(LAST_YEAR, 11, 31))).getUTCFullYear());
+    for (let y = y0; y <= y1; y++)
+        for (const c of changesInYear(z, y))
+            if (c.at > from && c.at < to)
+                out.push(c);
+    return out;
+}
+const pad = (n, w = 2) => String(n).padStart(w, "0");
+/** A local date as the API writes a Date: `2026-09-01`. */
+export const dateText = (y, m, d) => `${pad(y, 4)}-${pad(m)}-${pad(d)}`;
+/** An instant as ClickHouse's ISO output writes a DateTime: `2026-09-01T10:30:00Z`. */
+export const instantText = (ms) => new Date(ms).toISOString().replace(/\.\d{3}Z$/, "Z");

package/dist/src/lib/zone-names.js

@@ -0,0 +1,114 @@
+/**
+ * THE IANA ZONE NAMES THIS PRODUCT ACCEPTS — in `AT TIME ZONE '<name>'`, `SET TIME ZONE '<name>'` and mason.yml's
+ * `timezones` — exactly as spelled: a name is case-sensitive here (`asia/kolkata` and `utc` are not in it;
+ * `canonicalZone`, src/lib/timezone.ts, finds the spelling a name in another case stands for).
+ *
+ * The list was taken from ClickHouse 26.8's `system.time_zones` in 2026-10, when this product was cut from a stack that
+ * ran on ClickHouse, and it is kept because `Intl` alone is no check: ICU knows zones its tzdata does not
+ * (`SystemV/AST4`), so `Intl` said yes to names the engine underneath then refused, and the caller met a 502 for what
+ * is a 400 (review of #443). Nothing holds it to a server any more: a zone tzdata adds is added here by hand.
+ */
+export const ZONE_NAMES = new Set([
+    "Africa/Abidjan", "Africa/Accra", "Africa/Addis_Ababa", "Africa/Algiers", "Africa/Asmara", "Africa/Asmera",
+    "Africa/Bamako", "Africa/Bangui", "Africa/Banjul", "Africa/Bissau", "Africa/Blantyre", "Africa/Brazzaville",
+    "Africa/Bujumbura", "Africa/Cairo", "Africa/Casablanca", "Africa/Ceuta", "Africa/Conakry", "Africa/Dakar",
+    "Africa/Dar_es_Salaam", "Africa/Djibouti", "Africa/Douala", "Africa/El_Aaiun", "Africa/Freetown", "Africa/Gaborone",
+    "Africa/Harare", "Africa/Johannesburg", "Africa/Juba", "Africa/Kampala", "Africa/Khartoum", "Africa/Kigali",
+    "Africa/Kinshasa", "Africa/Lagos", "Africa/Libreville", "Africa/Lome", "Africa/Luanda", "Africa/Lubumbashi",
+    "Africa/Lusaka", "Africa/Malabo", "Africa/Maputo", "Africa/Maseru", "Africa/Mbabane", "Africa/Mogadishu",
+    "Africa/Monrovia", "Africa/Nairobi", "Africa/Ndjamena", "Africa/Niamey", "Africa/Nouakchott", "Africa/Ouagadougou",
+    "Africa/Porto-Novo", "Africa/Sao_Tome", "Africa/Timbuktu", "Africa/Tripoli", "Africa/Tunis", "Africa/Windhoek",
+    "America/Adak", "America/Anchorage", "America/Anguilla", "America/Antigua", "America/Araguaina",
+    "America/Argentina/Buenos_Aires", "America/Argentina/Catamarca", "America/Argentina/ComodRivadavia",
+    "America/Argentina/Cordoba", "America/Argentina/Jujuy", "America/Argentina/La_Rioja", "America/Argentina/Mendoza",
+    "America/Argentina/Rio_Gallegos", "America/Argentina/Salta", "America/Argentina/San_Juan",
+    "America/Argentina/San_Luis", "America/Argentina/Tucuman", "America/Argentina/Ushuaia", "America/Aruba",
+    "America/Asuncion", "America/Atikokan", "America/Atka", "America/Bahia", "America/Bahia_Banderas",
+    "America/Barbados", "America/Belem", "America/Belize", "America/Blanc-Sablon", "America/Boa_Vista",
+    "America/Bogota", "America/Boise", "America/Buenos_Aires", "America/Cambridge_Bay", "America/Campo_Grande",
+    "America/Cancun", "America/Caracas", "America/Catamarca", "America/Cayenne", "America/Cayman", "America/Chicago",
+    "America/Chihuahua", "America/Ciudad_Juarez", "America/Coral_Harbour", "America/Cordoba", "America/Costa_Rica",
+    "America/Coyhaique", "America/Creston", "America/Cuiaba", "America/Curacao", "America/Danmarkshavn",
+    "America/Dawson", "America/Dawson_Creek", "America/Denver", "America/Detroit", "America/Dominica",
+    "America/Edmonton", "America/Eirunepe", "America/El_Salvador", "America/Ensenada", "America/Fort_Nelson",
+    "America/Fort_Wayne", "America/Fortaleza", "America/Glace_Bay", "America/Godthab", "America/Goose_Bay",
+    "America/Grand_Turk", "America/Grenada", "America/Guadeloupe", "America/Guatemala", "America/Guayaquil",
+    "America/Guyana", "America/Halifax", "America/Havana", "America/Hermosillo", "America/Indiana/Indianapolis",
+    "America/Indiana/Knox", "America/Indiana/Marengo", "America/Indiana/Petersburg", "America/Indiana/Tell_City",
+    "America/Indiana/Vevay", "America/Indiana/Vincennes", "America/Indiana/Winamac", "America/Indianapolis",
+    "America/Inuvik", "America/Iqaluit", "America/Jamaica", "America/Jujuy", "America/Juneau",
+    "America/Kentucky/Louisville", "America/Kentucky/Monticello", "America/Knox_IN", "America/Kralendijk",
+    "America/La_Paz", "America/Lima", "America/Los_Angeles", "America/Louisville", "America/Lower_Princes",
+    "America/Maceio", "America/Managua", "America/Manaus", "America/Marigot", "America/Martinique", "America/Matamoros",
+    "America/Mazatlan", "America/Mendoza", "America/Menominee", "America/Merida", "America/Metlakatla",
+    "America/Mexico_City", "America/Miquelon", "America/Moncton", "America/Monterrey", "America/Montevideo",
+    "America/Montreal", "America/Montserrat", "America/Nassau", "America/New_York", "America/Nipigon", "America/Nome",
+    "America/Noronha", "America/North_Dakota/Beulah", "America/North_Dakota/Center", "America/North_Dakota/New_Salem",
+    "America/Nuuk", "America/Ojinaga", "America/Panama", "America/Pangnirtung", "America/Paramaribo", "America/Phoenix",
+    "America/Port-au-Prince", "America/Port_of_Spain", "America/Porto_Acre", "America/Porto_Velho",
+    "America/Puerto_Rico", "America/Punta_Arenas", "America/Rainy_River", "America/Rankin_Inlet", "America/Recife",
+    "America/Regina", "America/Resolute", "America/Rio_Branco", "America/Rosario", "America/Santa_Isabel",
+    "America/Santarem", "America/Santiago", "America/Santo_Domingo", "America/Sao_Paulo", "America/Scoresbysund",
+    "America/Shiprock", "America/Sitka", "America/St_Barthelemy", "America/St_Johns", "America/St_Kitts",
+    "America/St_Lucia", "America/St_Thomas", "America/St_Vincent", "America/Swift_Current", "America/Tegucigalpa",
+    "America/Thule", "America/Thunder_Bay", "America/Tijuana", "America/Toronto", "America/Tortola",
+    "America/Vancouver", "America/Virgin", "America/Whitehorse", "America/Winnipeg", "America/Yakutat",
+    "America/Yellowknife", "Antarctica/Casey", "Antarctica/Davis", "Antarctica/DumontDUrville", "Antarctica/Macquarie",
+    "Antarctica/Mawson", "Antarctica/McMurdo", "Antarctica/Palmer", "Antarctica/Rothera", "Antarctica/South_Pole",
+    "Antarctica/Syowa", "Antarctica/Troll", "Antarctica/Vostok", "Arctic/Longyearbyen", "Asia/Aden", "Asia/Almaty",
+    "Asia/Amman", "Asia/Anadyr", "Asia/Aqtau", "Asia/Aqtobe", "Asia/Ashgabat", "Asia/Ashkhabad", "Asia/Atyrau",
+    "Asia/Baghdad", "Asia/Bahrain", "Asia/Baku", "Asia/Bangkok", "Asia/Barnaul", "Asia/Beirut", "Asia/Bishkek",
+    "Asia/Brunei", "Asia/Calcutta", "Asia/Chita", "Asia/Choibalsan", "Asia/Chongqing", "Asia/Chungking", "Asia/Colombo",
+    "Asia/Dacca", "Asia/Damascus", "Asia/Dhaka", "Asia/Dili", "Asia/Dubai", "Asia/Dushanbe", "Asia/Famagusta",
+    "Asia/Gaza", "Asia/Harbin", "Asia/Hebron", "Asia/Ho_Chi_Minh", "Asia/Hong_Kong", "Asia/Hovd", "Asia/Irkutsk",
+    "Asia/Istanbul", "Asia/Jakarta", "Asia/Jayapura", "Asia/Jerusalem", "Asia/Kabul", "Asia/Kamchatka", "Asia/Karachi",
+    "Asia/Kashgar", "Asia/Kathmandu", "Asia/Katmandu", "Asia/Khandyga", "Asia/Kolkata", "Asia/Krasnoyarsk",
+    "Asia/Kuala_Lumpur", "Asia/Kuching", "Asia/Kuwait", "Asia/Macao", "Asia/Macau", "Asia/Magadan", "Asia/Makassar",
+    "Asia/Manila", "Asia/Muscat", "Asia/Nicosia", "Asia/Novokuznetsk", "Asia/Novosibirsk", "Asia/Omsk", "Asia/Oral",
+    "Asia/Phnom_Penh", "Asia/Pontianak", "Asia/Pyongyang", "Asia/Qatar", "Asia/Qostanay", "Asia/Qyzylorda",
+    "Asia/Rangoon", "Asia/Riyadh", "Asia/Saigon", "Asia/Sakhalin", "Asia/Samarkand", "Asia/Seoul", "Asia/Shanghai",
+    "Asia/Singapore", "Asia/Srednekolymsk", "Asia/Taipei", "Asia/Tashkent", "Asia/Tbilisi", "Asia/Tehran",
+    "Asia/Tel_Aviv", "Asia/Thimbu", "Asia/Thimphu", "Asia/Tokyo", "Asia/Tomsk", "Asia/Ujung_Pandang",
+    "Asia/Ulaanbaatar", "Asia/Ulan_Bator", "Asia/Urumqi", "Asia/Ust-Nera", "Asia/Vientiane", "Asia/Vladivostok",
+    "Asia/Yakutsk", "Asia/Yangon", "Asia/Yekaterinburg", "Asia/Yerevan", "Atlantic/Azores", "Atlantic/Bermuda",
+    "Atlantic/Canary", "Atlantic/Cape_Verde", "Atlantic/Faeroe", "Atlantic/Faroe", "Atlantic/Jan_Mayen",
+    "Atlantic/Madeira", "Atlantic/Reykjavik", "Atlantic/South_Georgia", "Atlantic/St_Helena", "Atlantic/Stanley",
+    "Australia/ACT", "Australia/Adelaide", "Australia/Brisbane", "Australia/Broken_Hill", "Australia/Canberra",
+    "Australia/Currie", "Australia/Darwin", "Australia/Eucla", "Australia/Hobart", "Australia/LHI",
+    "Australia/Lindeman", "Australia/Lord_Howe", "Australia/Melbourne", "Australia/NSW", "Australia/North",
+    "Australia/Perth", "Australia/Queensland", "Australia/South", "Australia/Sydney", "Australia/Tasmania",
+    "Australia/Victoria", "Australia/West", "Australia/Yancowinna", "Brazil/Acre", "Brazil/DeNoronha", "Brazil/East",
+    "Brazil/West", "CET", "CST6CDT", "Canada/Atlantic", "Canada/Central", "Canada/Eastern", "Canada/Mountain",
+    "Canada/Newfoundland", "Canada/Pacific", "Canada/Saskatchewan", "Canada/Yukon", "Chile/Continental",
+    "Chile/EasterIsland", "Cuba", "EET", "EST", "EST5EDT", "Egypt", "Eire", "Etc/GMT", "Etc/GMT+0", "Etc/GMT+1",
+    "Etc/GMT+10", "Etc/GMT+11", "Etc/GMT+12", "Etc/GMT+2", "Etc/GMT+3", "Etc/GMT+4", "Etc/GMT+5", "Etc/GMT+6",
+    "Etc/GMT+7", "Etc/GMT+8", "Etc/GMT+9", "Etc/GMT-0", "Etc/GMT-1", "Etc/GMT-10", "Etc/GMT-11", "Etc/GMT-12",
+    "Etc/GMT-13", "Etc/GMT-14", "Etc/GMT-2", "Etc/GMT-3", "Etc/GMT-4", "Etc/GMT-5", "Etc/GMT-6", "Etc/GMT-7",
+    "Etc/GMT-8", "Etc/GMT-9", "Etc/GMT0", "Etc/Greenwich", "Etc/UCT", "Etc/UTC", "Etc/Universal", "Etc/Zulu",
+    "Europe/Amsterdam", "Europe/Andorra", "Europe/Astrakhan", "Europe/Athens", "Europe/Belfast", "Europe/Belgrade",
+    "Europe/Berlin", "Europe/Bratislava", "Europe/Brussels", "Europe/Bucharest", "Europe/Budapest", "Europe/Busingen",
+    "Europe/Chisinau", "Europe/Copenhagen", "Europe/Dublin", "Europe/Gibraltar", "Europe/Guernsey", "Europe/Helsinki",
+    "Europe/Isle_of_Man", "Europe/Istanbul", "Europe/Jersey", "Europe/Kaliningrad", "Europe/Kiev", "Europe/Kirov",
+    "Europe/Kyiv", "Europe/Lisbon", "Europe/Ljubljana", "Europe/London", "Europe/Luxembourg", "Europe/Madrid",
+    "Europe/Malta", "Europe/Mariehamn", "Europe/Minsk", "Europe/Monaco", "Europe/Moscow", "Europe/Nicosia",
+    "Europe/Oslo", "Europe/Paris", "Europe/Podgorica", "Europe/Prague", "Europe/Riga", "Europe/Rome", "Europe/Samara",
+    "Europe/San_Marino", "Europe/Sarajevo", "Europe/Saratov", "Europe/Simferopol", "Europe/Skopje", "Europe/Sofia",
+    "Europe/Stockholm", "Europe/Tallinn", "Europe/Tirane", "Europe/Tiraspol", "Europe/Ulyanovsk", "Europe/Uzhgorod",
+    "Europe/Vaduz", "Europe/Vatican", "Europe/Vienna", "Europe/Vilnius", "Europe/Volgograd", "Europe/Warsaw",
+    "Europe/Zagreb", "Europe/Zaporozhye", "Europe/Zurich", "Factory", "GB", "GB-Eire", "GMT", "GMT+0", "GMT-0", "GMT0",
+    "Greenwich", "HST", "Hongkong", "Iceland", "Indian/Antananarivo", "Indian/Chagos", "Indian/Christmas",
+    "Indian/Cocos", "Indian/Comoro", "Indian/Kerguelen", "Indian/Mahe", "Indian/Maldives", "Indian/Mauritius",
+    "Indian/Mayotte", "Indian/Reunion", "Iran", "Israel", "Jamaica", "Japan", "Kwajalein", "Libya", "MET", "MST",
+    "MST7MDT", "Mexico/BajaNorte", "Mexico/BajaSur", "Mexico/General", "NZ", "NZ-CHAT", "Navajo", "PRC", "PST8PDT",
+    "Pacific/Apia", "Pacific/Auckland", "Pacific/Bougainville", "Pacific/Chatham", "Pacific/Chuuk", "Pacific/Easter",
+    "Pacific/Efate", "Pacific/Enderbury", "Pacific/Fakaofo", "Pacific/Fiji", "Pacific/Funafuti", "Pacific/Galapagos",
+    "Pacific/Gambier", "Pacific/Guadalcanal", "Pacific/Guam", "Pacific/Honolulu", "Pacific/Johnston", "Pacific/Kanton",
+    "Pacific/Kiritimati", "Pacific/Kosrae", "Pacific/Kwajalein", "Pacific/Majuro", "Pacific/Marquesas",
+    "Pacific/Midway", "Pacific/Nauru", "Pacific/Niue", "Pacific/Norfolk", "Pacific/Noumea", "Pacific/Pago_Pago",
+    "Pacific/Palau", "Pacific/Pitcairn", "Pacific/Pohnpei", "Pacific/Ponape", "Pacific/Port_Moresby",
+    "Pacific/Rarotonga", "Pacific/Saipan", "Pacific/Samoa", "Pacific/Tahiti", "Pacific/Tarawa", "Pacific/Tongatapu",
+    "Pacific/Truk", "Pacific/Wake", "Pacific/Wallis", "Pacific/Yap", "Poland", "Portugal", "ROC", "ROK", "Singapore",
+    "Turkey", "UCT", "US/Alaska", "US/Aleutian", "US/Arizona", "US/Central", "US/East-Indiana", "US/Eastern",
+    "US/Hawaii", "US/Indiana-Starke", "US/Michigan", "US/Mountain", "US/Pacific", "US/Samoa", "UTC", "Universal",
+    "W-SU", "WET", "Zulu",
+]);

package/dist/src/web/app.css

@@ -0,0 +1,76 @@
+/* The web page of mason start (src/web/app.js). The CLI's palette (src/cli/style.ts): bold for a heading, the type
+   colour for what you can type, dim for a description, green / red / yellow for a state only. No font is fetched:
+   the system's, under the server's default-src 'self'. */
+:root {
+  --bg: #fbfbfa; --fg: #1d1d1b; --dim: #6b6b66; --line: #e3e2de; --panel: #ffffff;
+  --code: #0b6e8a; --ok: #1f7a3a; --bad: #b42318; --warn: #8a5a00; --bar: #0b6e8a;
+  color-scheme: light dark;
+}
+@media (prefers-color-scheme: dark) {
+  :root { --bg: #161615; --fg: #e8e7e3; --dim: #9a9993; --line: #2e2e2b; --panel: #1e1e1c;
+    --code: #5cc3df; --ok: #5fcf80; --bad: #ff7b6e; --warn: #e9b64a; --bar: #5cc3df; }
+}
+* { box-sizing: border-box; }
+body { margin: 0; background: var(--bg); color: var(--fg); font: 15px/1.5 system-ui, -apple-system, "Segoe UI", sans-serif; }
+header, main, #poll { max-width: 1040px; margin: 0 auto; padding: 0 16px; }
+header { display: flex; flex-wrap: wrap; align-items: baseline; gap: 4px 16px; padding-top: 24px; }
+h1 { font-size: 22px; margin: 0; }
+.where { margin: 0; color: var(--dim); }
+.updated { margin: 0 0 0 auto; color: var(--dim); font-size: 13px; }
+section { background: var(--panel); border: 1px solid var(--line); border-radius: 8px; padding: 4px 20px 16px; margin: 16px 0; }
+h2 { font-size: 17px; margin: 14px 0 10px; }
+h3 { font-size: 15px; margin: 18px 0 6px; }
+code, pre { font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; font-size: 13px; }
+code { color: var(--code); overflow-wrap: anywhere; }
+pre { white-space: pre-wrap; margin: 6px 0 0; color: var(--dim); }
+.dim, .lead { color: var(--dim); }
+.facts { display: grid; grid-template-columns: max-content 1fr; gap: 4px 16px; margin: 0; }
+.facts dt { color: var(--dim); }
+.facts dd { margin: 0; overflow-wrap: anywhere; }
+table { width: 100%; border-collapse: collapse; }
+th, td { text-align: left; vertical-align: top; padding: 6px 8px 6px 0; border-top: 1px solid var(--line); font-weight: normal; }
+thead th { border-top: 0; color: var(--dim); font-size: 13px; }
+td.bar { white-space: nowrap; width: 1%; }
+tbody th code { white-space: nowrap; overflow-wrap: normal; }
+progress { width: 120px; height: 8px; vertical-align: middle; accent-color: var(--bar); }
+.pct { display: inline-block; min-width: 3.2em; text-align: right; font-variant-numeric: tabular-nums; }
+.t-done progress { accent-color: var(--ok); }
+.t-failed progress, .t-failed .what { accent-color: var(--bad); color: var(--bad); }
+.t-unsynced progress, .t-unsynced .what { accent-color: var(--warn); color: var(--warn); }
+.count { margin: 10px 0 0; }
+.readiness { font-weight: 600; margin: 14px 0 4px; }
+.readiness.ok { color: var(--ok); }
+.readiness.bad { color: var(--bad); }
+.bullets { margin: 0; padding-left: 20px; }
+.warn { color: var(--warn); font-size: 13px; }
+td.act { text-align: right; white-space: nowrap; }
+.confirm { white-space: normal; }
+button { font: inherit; font-size: 14px; padding: 4px 12px; border-radius: 6px; border: 1px solid var(--line); background: var(--bg); color: var(--fg); cursor: pointer; }
+button:hover { border-color: var(--dim); }
+button.danger { border-color: var(--bad); color: var(--bad); }
+form { display: flex; flex-wrap: wrap; align-items: center; gap: 8px; margin: 12px 0; }
+input { font: inherit; padding: 4px 8px; border-radius: 6px; border: 1px solid var(--line); background: var(--bg); color: var(--fg); min-width: 14em; }
+.failure { border-left: 3px solid var(--bad); padding: 8px 12px; margin: 12px 0; background: var(--panel); }
+.failure .message { margin: 0; font-weight: 600; }
+.failure .mark { color: var(--bad); }
+.failure dl { display: grid; grid-template-columns: max-content 1fr; gap: 2px 12px; margin: 6px 0 0; }
+.failure dt { color: var(--dim); }
+.failure dd { margin: 0; white-space: pre-line; overflow-wrap: anywhere; }
+.next-head { margin: 8px 0 2px; font-weight: 600; }
+.next { list-style: none; margin: 0; padding: 0; }
+.next li span { color: var(--dim); margin-left: 8px; }
+.added { border: 1px solid var(--ok); border-radius: 8px; padding: 10px 14px; margin: 12px 0; }
+.added .headline { font-weight: 600; margin: 0 0 8px; }
+.added .tip { color: var(--dim); }
+#poll .failure { border: 1px solid var(--bad); border-left-width: 3px; border-radius: 4px; margin-top: 16px; }
+table.catalog td.num { white-space: nowrap; text-align: right; font-variant-numeric: tabular-nums; }
+.c-added .state { color: var(--ok); }
+.c-cannot .state { color: var(--warn); font-size: 13px; }
+tr.under > td { border-top: 0; padding-top: 0; }
+form.pick { display: block; margin: 4px 0 8px; }
+form.pick fieldset { border: 1px solid var(--line); border-radius: 6px; margin: 0 0 8px; padding: 6px 10px; }
+form.pick legend { color: var(--dim); font-size: 13px; padding: 0 4px; }
+label.tick { display: inline-flex; align-items: baseline; gap: 4px; margin: 2px 14px 2px 0; }
+.done { border: 1px solid var(--ok); border-radius: 8px; padding: 8px 12px; margin: 4px 0 8px; }
+.done .headline { font-weight: 600; margin: 0 0 4px; overflow-wrap: anywhere; }
+.done .note, .done .tip { color: var(--dim); margin: 2px 0 6px; }