@mason-data/cli 0.0.0-stage → 0.6.2

package/dist/src/cli/user.js

@@ -0,0 +1,229 @@
+/**
+ * `mason user add | list | remove` — NAMED, REVOCABLE LOGINS FOR THE POSTGRES API, WITH NO EXPIRY
+ * (docs/DESIGN.md "On a server", item 1 of the agreed plan; src/duck/users.ts holds the rules). A BI
+ * tool's datasource stores ONE password: a user's lasts until it is removed.
+ *
+ * It runs as a second process beside the run (or beside `mason serve`: `docker compose exec mason mason user add
+ * metabase`, the data folder's `.mason/`), so it needs the project, never the run: it edits `.mason/users.json` under
+ * the file's lock, and the run's listener reads the change at its next connection or statement. The password is said
+ * ONCE, by `add`, with the URL to paste (one URL builder, pg-url.ts `connectionUrl`) when the run is up and recorded
+ * where it listens. The web page's users (`mason ui`) are the same functions (`addUser`, `listUsers`, `removeUser`),
+ * called by the run's command server.
+ */
+import * as path from "node:path";
+import { failed, jsonText, parseCommand, reportText, withEnd } from "./command.js";
+import { reach } from "./state.js";
+import { connectionUrl, listenerTips, postgresLink, psqlLine } from "./pg-url.js";
+import { changeUsers, keyFingerprint, newUserId, readUsers, underKey, userPassword, USER_NAME_RE, USER_NAME_RULE, USERS_FILE } from "../duck/users.js";
+import { didYouMean } from "../lib/did-you-mean.js";
+import { out as styleOut } from "./style.js";
+const out = (m) => { process.stdout.write(`${m}\n`); };
+export const USER = {
+    needs: "project",
+    name: "user",
+    summary: "the users the Postgres API takes: a name and a password that does not expire, for a BI tool or an app",
+    usage: `usage: mason user add <name> [--json]
+       mason user list [--json]
+       mason user remove <name> [--json]
+
+  A user of this project's Postgres API: a name and a password, as a BI tool's datasource form asks for them
+  (Metabase, Grafana, Superset, Power BI) or an app's DATABASE_URL carries them. Its password does not expire:
+  it connects until mason user remove, which refuses its next connection at once and
+  ends the sessions it holds at their next statement, without a restart. The password is printed once, by add.
+  The user name a tool sends must be the user's own.
+
+  The list is .mason/users.json (names and ids, no password), beside the running Mason, which reads it again by itself.
+  Rotating the API key (apiKey in .mason/config.json, MASON_API_KEY under mason serve) removes every user at once.
+
+    mason user add metabase                    a user for Metabase: its password and the URL to paste
+    mason user list
+    mason user remove metabase                 metabase connects no more
+    docker compose exec mason mason user add grafana   beside mason serve, in its data folder
+
+  <name>    ${USER_NAME_RULE}
+  --json    as data: add { user (the name), id, addedAt, password, database, and once Mason runs url, host, port,
+            sslmode }; list { users: [{ name, id, addedAt, live }] }; remove { removed: { name, id, addedAt } }; next
+`,
+    options: { json: { type: "boolean", default: false } },
+    json: ["user", "id", "addedAt", "password", "url", "host", "port", "database", "sslmode", "users", "removed", "next"],
+};
+/** The users of a project and why one is not live: added under an API key since rotated. */
+const liveOf = (u, apiKey) => underKey(u, apiKey);
+/** What to run after an add: with Mason up, the list and how to end it; with Mason stopped, mason start first. */
+export const addedNext = (name, up) => up
+    ? [["mason user list", "the users"], [`mason user remove ${name}`, "it connects no more"]]
+    : [["mason start", "start Mason: then mason status prints where the Postgres API listens"], ["mason user list", "the users"]];
+/** What to run after a remove. */
+export const REMOVED_NEXT = [["mason user list", "the users left"], ["mason user add <name>", "a new user, with a new password"]];
+/** Why `name` is not one `mason user <verb>` takes (a usage failure), or null. */
+export function userNameProblem(verb, name) {
+    if (name === undefined)
+        return `mason user ${verb} <name>: which user`;
+    if (!USER_NAME_RE.test(name))
+        return `${JSON.stringify(name)} is not a user name: ${USER_NAME_RULE}`;
+    return null;
+}
+const cantChange = (file, e) => ({ message: `the list of users could not be changed: ${e.message}`, code: "failed",
+    fix: `${file} is the list (mason user writes it): repair it, or move it aside, which removes every user` });
+/** The users `file` lists, each with whether it connects under `apiKey`; or why the file cannot be read. */
+export function listUsers(file, apiKey) {
+    const r = readUsers(file);
+    if ("problem" in r)
+        return { message: `the list of users cannot be read: ${r.problem}`, code: "bad_config", why: "no user connects while it cannot be read",
+            fix: `repair ${file}, or move it aside, which removes every user` };
+    return { users: r.users.map((u) => ({ name: u.name, id: u.id, addedAt: u.addedAt, live: liveOf(u, apiKey) })) };
+}
+/**
+ * ADD A USER to `file` under its lock: a new id, its password (said here, once, and kept nowhere), and — `link`, where
+ * the run's Postgres API listens, when it is up — the URL to paste. A name taken by a live user is refused.
+ */
+export function addUser(file, apiKey, name, o) {
+    const usage = userNameProblem("add", name);
+    if (usage !== null)
+        return { message: usage, code: "usage" };
+    const fingerprint = keyFingerprint(apiKey);
+    let added;
+    let replaced = false;
+    let r;
+    try {
+        r = changeUsers(file, (users) => {
+            const was = users.find((u) => u.name === name);
+            // a user added under a key since rotated connects no more: its name is free, said
+            if (was !== undefined && was.key === fingerprint)
+                return { refused: "taken" };
+            replaced = was !== undefined;
+            added = { name, id: newUserId(), addedAt: new Date().toISOString(), key: fingerprint };
+            return [...users.filter((u) => u !== was), added];
+        });
+    }
+    catch (e) {
+        return cantChange(file, e);
+    }
+    if (!Array.isArray(r)) {
+        return { message: `there is already a user ${JSON.stringify(name)}`, code: "refused",
+            why: "a name names one user, so removing it means one thing; its password is not kept, so it cannot be printed again",
+            fix: `mason user remove ${name}, then mason user add ${name} (a new password; the old one stops connecting), or add another name (${name}-2) and remove ${name} once the tool uses it`,
+            next: [["mason user list", "the users"], [`mason user remove ${name}`, "then add it again, with a new password"]] };
+    }
+    const u = added;
+    const password = userPassword(apiKey, u.name, u.id);
+    const { link } = o;
+    return { user: u.name, id: u.id, addedAt: u.addedAt, password, database: link?.database ?? o.database,
+        ...(link !== null ? { url: connectionUrl(link, u.name, password), host: link.host, port: link.port, sslmode: link.sslmode ?? "disable" } : {}), replaced };
+}
+/** REMOVE A USER from `file` under its lock: it connects no more. A name the file lacks is refused with the closest it has. */
+export function removeUser(file, name) {
+    const usage = userNameProblem("remove", name);
+    if (usage !== null)
+        return { message: usage, code: "usage" };
+    let removed;
+    let live = [];
+    let r;
+    try {
+        r = changeUsers(file, (users) => {
+            removed = users.find((u) => u.name === name);
+            live = users.map((u) => u.name);
+            return removed === undefined ? { refused: "unknown" } : users.filter((u) => u !== removed);
+        });
+    }
+    catch (e) {
+        return cantChange(file, e);
+    }
+    if (!Array.isArray(r)) {
+        return { message: `there is no user ${JSON.stringify(name)}${didYouMean(name, live)}`, code: "not_found",
+            why: live.length ? `the users: ${live.join(", ")}` : "this project has no users", next: [["mason user list", "the users"]] };
+    }
+    const gone = removed;
+    return { removed: { name: gone.name, id: gone.id, addedAt: gone.addedAt } };
+}
+// ------------------------------------------------------------------ the command
+export async function user(argv) {
+    const f = parseCommand(USER, argv);
+    if (typeof f === "number")
+        return f;
+    const json = f.values.json === true;
+    const usage = (message) => failed("user", { message, code: "usage", usage: USER.usage }, { json });
+    const [verb, name, ...rest] = f.positionals;
+    if (verb === undefined)
+        return usage("add, list or remove: mason user add <name> makes a user");
+    if (!["add", "list", "remove"].includes(verb))
+        return usage(`there is no mason user ${verb}: add, list or remove${didYouMean(verb, ["add", "list", "remove"])}`);
+    if (verb === "list" ? name !== undefined : rest.length)
+        return usage(`mason user ${verb} takes ${verb === "list" ? "no name" : "one name"}: ${[name, ...rest].filter(Boolean).join(" ")} is too many`);
+    if (verb !== "list") {
+        const problem = userNameProblem(verb, name);
+        if (problem !== null)
+            return usage(problem);
+    }
+    const w = await reach(USER, json);
+    if (w === null || w.project === null)
+        return 1;
+    const project = w.project;
+    const file = path.join(project.dir, USERS_FILE);
+    const apiKey = project.config.apiKey;
+    if (verb === "list") {
+        const r = listUsers(file, apiKey);
+        if ("message" in r)
+            return failed("user", r, { json });
+        const next = [["mason user add <name>", "a user for a tool: its password and URL, printed once"], ...(r.users.length ? [["mason user remove <name>", "that user connects no more"]] : [])];
+        if (json) {
+            out(jsonText(USER, { users: r.users }, next));
+            return 0;
+        }
+        const s = styleOut();
+        if (!r.users.length) {
+            out(withEnd(`${s.bold(`No users yet for ${project.config.name}.`)}`, { next }));
+            return 0;
+        }
+        const width = Math.max(...r.users.map((u) => u.name.length));
+        const lines = r.users.map((u) => `  ${s.cyan(u.name.padEnd(width))}   ${s.dim(`id ${u.id} · added ${u.addedAt.slice(0, 16).replace("T", " ")} UTC`)}` +
+            (u.live ? "" : `   ${s.yellow("does not connect: the API key was rotated since it was added")}`));
+        const rotated = r.users.filter((u) => !u.live);
+        out(withEnd(`${s.bold(`${r.users.length} user${r.users.length === 1 ? "" : "s"} of ${project.config.name}`)}\n${lines.join("\n")}`, { ...(rotated.length ? { tips: [`A user added under another API key does not connect: mason user remove ${rotated[0].name}, then mason user add ${rotated[0].name}.`] } : {}), next }));
+        return 0;
+    }
+    if (verb === "remove") {
+        const r = removeUser(file, name);
+        if ("message" in r)
+            return failed("user", r, { json });
+        const gone = r.removed;
+        const next = REMOVED_NEXT;
+        if (json) {
+            out(jsonText(USER, r, next));
+            return 0;
+        }
+        out(reportText({ headline: `The user ${gone.name} removed: it connects no more`,
+            details: [["user", gone.name], ["added", gone.addedAt], ["sessions", w.state === "up" ? "those it holds end at their next statement" : "none: Mason is not running"]],
+            tips: [`Adding ${gone.name} again makes a new password: the old one never connects again.`], next }));
+        return 0;
+    }
+    // add
+    const run = w.state === "up" ? w.run : null;
+    const link = run ? postgresLink(run.postgresUrl) : null;
+    const r = addUser(file, apiKey, name, { link, database: project.config.name });
+    if ("message" in r)
+        return failed("user", r, { json });
+    const { replaced, ...added } = r;
+    const next = addedNext(r.user, link !== null);
+    if (json) {
+        out(jsonText(USER, added, next));
+        return 0;
+    }
+    out(reportText({
+        headline: `The user ${r.user} added${replaced ? " (in place of one the API key's rotation had removed)" : ""}: its password is printed this once`,
+        details: [
+            ...(r.url !== undefined ? [["url", r.url], ["psql", psqlLine(r.url)]] : []),
+            ["user", r.user], ["password", r.password], ["database", r.database],
+            ...(link !== null ? [["host", link.host], ["port", String(link.port)], ...(link.sslmode ? [["ssl mode", link.sslmode]] : [])] : []),
+        ],
+        tips: [
+            "Paste it into the tool now: Mason keeps no copy of the password. Lost, remove the user and add it again.",
+            ...(link === null ? ["Mason is not running: mason start, then mason status says the host and port this user connects to."] : []),
+            ...listenerTips(run?.postgresListener ?? null),
+            "It never expires: mason user remove ends it, at once and for every session it holds.",
+            "Rotating the API key (apiKey in .mason/config.json, MASON_API_KEY under mason serve) removes every user at once.",
+        ],
+        next,
+    }));
+    return 0;
+}

package/dist/src/cli/version.js

@@ -0,0 +1,23 @@
+/**
+ * The package's version when installed; else the image's (`MASON_VERSION`, stamped at build by images-publish.yml:
+ * `v0.6.1` for a release, said `0.6.1` as the package says it, or `main-<sha>`); a checkout runs as "dev" (and
+ * ClickHouse's `main` image).
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+export function version() {
+    // src/cli/ in a checkout (the repo's package.json, which is not this one), dist/src/cli/ in the package
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    for (const p of [path.join(here, "..", "..", "package.json"), path.join(here, "..", "..", "..", "package.json")]) {
+        if (!fs.existsSync(p))
+            continue;
+        const pkg = JSON.parse(fs.readFileSync(p, "utf8"));
+        if (pkg.name === "@mason-data/cli" && pkg.version)
+            return pkg.version;
+    }
+    const image = process.env.MASON_VERSION?.trim();
+    if (image)
+        return /^v\d+\.\d+\.\d+$/.test(image) ? image.slice(1) : image;
+    return "dev";
+}

package/dist/src/duck/analyze.js

@@ -0,0 +1,113 @@
+/**
+ * POSTGRES DECIDES, DUCKDB COMPUTES (docs/DESIGN.md). Before DuckDB answers a statement, the catalog Postgres
+ * (src/api/postgres/catalog.ts: Postgres 18 itself, holding every copied table under its source types, no rows) parses
+ * and analyses it, and that analysis is the answer's contract:
+ *  - a statement Postgres REFUSES at analysis (an unknown column, a GROUP BY it would not take, `'99.99'` compared with
+ *    an integer, ORDER BY outside a DISTINCT's list) is refused with Postgres's own error, word for word;
+ *  - the result's column NAMES, type OIDs and typmods are Postgres's RowDescription, and the parameters' types its
+ *    ParameterDescription;
+ *  - the analysed tree (`debug_print_parse`, src/duck/pgtree.ts) gives the rewrite every expression's resolved type.
+ * The statement is analysed under the SESSION's search_path (an unqualified table is the one the session would read).
+ *
+ * ONE BATCH, SERIALISED (the catalog's queue): the logging is switched on, the statement is parsed, described and
+ * closed under a name of its own, and everything is set back, before the next session's call runs. Nothing of it is
+ * left in the sidecar between calls — another session's Sync can lose nothing (tests/postgres-api/server.test.ts "a
+ * catalog statement's portal, beside another session's").
+ */
+import { cstr, decodeBackend, frame, int16, int32 } from "../api/postgres/protocol.js";
+import { parseTree, typesByLocation } from "./pgtree.js";
+const NAME = "__mason_analysis";
+/** the catalog's TimeZone, set back after a statement set the session's (src/api/postgres/catalog.ts sets it at start) */
+const CATALOG_ZONE = "SET TimeZone = 'UTC'";
+const query = (sql) => frame("Q", cstr(sql));
+/** Asks the catalog Postgres to analyse `sql` (with these declared parameter OIDs, 0 = infer). */
+export async function analyze(run, sql, paramOids, searchPath = "public", timeZone = "UTC") {
+    const bytes = Buffer.concat([
+        // the session's search_path, pg_catalog after it as the catalog's own setup has it (catalog.ts)
+        // …and its TimeZone: Postgres parses a literal under it ('2026-01-01 12:00'::timestamptz is that zone's noon), and
+        // the rewrite writes the value it parsed (src/duck/rewrite.ts `aConst`)
+        query(`SET search_path = ${searchPath}, pg_catalog; SET TimeZone = '${timeZone.replace(/'/g, "''")}'; SET client_min_messages = log; SET debug_print_parse = on; SET debug_pretty_print = off`),
+        frame("P", cstr(NAME), cstr(sql), int16(paramOids.length), ...paramOids.map(int32)),
+        frame("D", Buffer.from("S"), cstr(NAME)),
+        frame("C", Buffer.from("S"), cstr(NAME)),
+        frame("S"),
+        // the catalog's own TimeZone back (catalog.ts sets UTC at its start): RESET would be the server's boot default, the
+        // machine's zone, under which the catalog then answered what reads no table
+        query(`RESET debug_print_parse; RESET debug_pretty_print; RESET client_min_messages; ${CATALOG_ZONE}; SET search_path = public, pg_catalog`),
+    ]);
+    const messages = decodeBackend(Buffer.from(await run(bytes)));
+    // the replies to the first Query end at its ReadyForQuery; the statement's run to the next one
+    const z = messages.findIndex((m) => m.type === "ReadyForQuery");
+    const end = messages.findIndex((m, i) => i > z && m.type === "ReadyForQuery");
+    if (z < 0 || end < 0)
+        throw new Error(`the catalog Postgres's analysis came back out of step (${messages.map((m) => m.type).join(", ")}): report it`);
+    const mine = messages.slice(z + 1, end);
+    const refused = mine.find((m) => m.type === "ErrorResponse");
+    if (refused?.type === "ErrorResponse")
+        return { refused: refused.fields };
+    const firstError = messages.find((m) => m.type === "ErrorResponse");
+    if (firstError?.type === "ErrorResponse")
+        throw new Error(`the catalog Postgres could not switch its analysis log on or off: ${firstError.fields.M}`);
+    const log = mine.find((m) => m.type === "NoticeResponse" && /^\{QUERY\b/.test(m.fields.D ?? ""));
+    if (log?.type !== "NoticeResponse")
+        throw new Error("the catalog Postgres logged no parse tree for the statement: report it");
+    const tree = parseTree(log.fields.D);
+    const pd = mine.find((m) => m.type === "ParameterDescription");
+    const rd = mine.find((m) => m.type === "RowDescription");
+    return {
+        params: pd?.type === "ParameterDescription" ? pd.oids : [],
+        fields: rd?.type === "RowDescription" ? rd.fields.map((f) => ({ name: f.name, oid: f.typeOid, typmod: f.typeModifier })) : null,
+        types: typesByLocation(tree),
+        tree,
+    };
+}
+/** the types whose input DuckDB reads otherwise than Postgres, as the catalog Postgres writes their value back */
+const PARAM_TYPES = {
+    16: "boolean", 21: "smallint", 23: "integer", 20: "bigint", 700: "real", 701: "double precision", 1700: "numeric",
+    2950: "uuid", 114: "json", 3802: "jsonb", 1083: "time", 1082: "date", 1114: "timestamp", 1184: "timestamptz", 1186: "interval", 869: "inet",
+};
+/**
+ * A statement's parameters as Postgres reads them: each value through its type's input function (the type Postgres
+ * inferred, or the one declared), under the session's TimeZone — so `'1.5'` for a smallint is Postgres's 22P02, and
+ * `'01/02/2026'` for a date is 2026-01-02. A value comes back as text DuckDB reads to the same value: a number, a
+ * boolean or a uuid canonical; a date as days and a timestamp as microseconds since 2000-01-01 (src/duck/rewrite.ts
+ * `datumText` writes them), an interval as its months, days and microseconds; `infinity` as itself.
+ */
+export async function readParameters(run, oids, values, timeZone) {
+    const quote = (s) => `'${s.replace(/'/g, "''")}'`;
+    const items = values.map((v, i) => {
+        const oid = oids[i] ?? 0, type = PARAM_TYPES[oid];
+        if (v === null || type === undefined)
+            return null;
+        const x = `${quote(v)}::${type}`;
+        if (oid === 1082)
+            return `CASE WHEN isfinite(${x}) THEN (${x} - date '2000-01-01')::text ELSE ${x}::text END`;
+        if (oid === 1114 || oid === 1184)
+            return `CASE WHEN isfinite(${x}) THEN (extract(epoch FROM ${x}) * 1000000 - 946684800000000)::int8::text ELSE ${x}::text END`;
+        if (oid === 1186)
+            return `(extract(year FROM ${x}) * 12 + extract(month FROM ${x}))::text || ' ' || extract(day FROM ${x})::text || ' ' || ((extract(hour FROM ${x}) * 60 + extract(minute FROM ${x})) * 60000000 + extract(microseconds FROM ${x}))::int8::text`;
+        return `${x}::text`;
+    });
+    if (items.every((x) => x === null))
+        return { values: values.map(() => null) };
+    const sql = `SET TimeZone = ${quote(timeZone)}; SELECT ${items.map((x) => x ?? "NULL").join(", ")}; ${CATALOG_ZONE}`;
+    const messages = decodeBackend(Buffer.from(await run(query(sql))));
+    const refused = messages.find((m) => m.type === "ErrorResponse");
+    if (refused?.type === "ErrorResponse") {
+        // the value's own error (22P02, 22003, 22008 …) — and the zone set back, which the failed statement skipped
+        await run(query(CATALOG_ZONE));
+        return { refused: refused.fields };
+    }
+    const row = messages.find((m) => m.type === "DataRow");
+    if (row?.type !== "DataRow")
+        throw new Error("the catalog Postgres read the parameters and answered no row: report it");
+    return { values: items.map((x, i) => x === null ? null : { oid: oids[i], text: row.values[i].toString("utf8") }) };
+}
+/** One read of the catalog Postgres's own catalog (a signature from pg_proc, a type's name): its rows as text. */
+export async function catalogRows(run, sql) {
+    const messages = decodeBackend(Buffer.from(await run(query(sql))));
+    const refused = messages.find((m) => m.type === "ErrorResponse");
+    if (refused?.type === "ErrorResponse")
+        throw new Error(`the catalog Postgres refused its own catalog read: ${refused.fields.M} (in: ${sql.slice(0, 200)})`);
+    return messages.flatMap((m) => m.type === "DataRow" ? [m.values.map((v) => v === null ? null : v.toString("utf8"))] : []);
+}

package/dist/src/duck/cancel.js

@@ -0,0 +1,49 @@
+/**
+ * THE CANCEL TABLE (the executor worker: src/duck/executor.ts). A statement that calls a Mason function is
+ * cancelled through its SESSION as well as interrupted (src/duck/functions.ts "every call carries its session"): its
+ * next call reads this table and raises, and its result is closed only once its calls have stopped (store.ts `cleanUp`,
+ * the suite's hang). The calls run on the executor worker, which such a statement keeps busy between
+ * DuckDB's turns for seconds at a time, so a cancel cannot be a message to it: the listener (the main thread) writes
+ * the table directly, in memory both threads share, and the next call sees it at once.
+ *
+ * Two Int32 cells per session SLOT (a wire session's DuckDB connection holds one while it is open): `cancelled`, the
+ * highest statement number of the session cancelled so far, and `running`, the number of the statement its connection
+ * runs now (set by the worker once the one before it has been released). A call is cancelled when `cancelled >=
+ * running`: a cancel of a statement already past never reaches the next one, a cancel that lands before its statement
+ * starts still does, and a statement being drained after its cancel stays cancelled whatever the next one's number.
+ * Dependency-free: the listener's thread loads it without DuckDB.
+ */
+/** how many wire sessions may hold a DuckDB connection at once (a slot each) */
+export const CANCEL_SLOTS = 4096;
+/** a fresh table (the executor makes one and hands it to its worker) */
+export function cancelTable() { return new Int32Array(new SharedArrayBuffer(CANCEL_SLOTS * 2 * 4)); }
+const cancelledAt = (slot) => slot * 2;
+const runningAt = (slot) => slot * 2 + 1;
+/** a slot handed to a new session: nothing cancelled, nothing running */
+export function resetSlot(t, slot) { Atomics.store(t, cancelledAt(slot), 0); Atomics.store(t, runningAt(slot), 0); }
+/** statement `seq` of the session in `slot` is cancelled (and every one before it): monotonic, from either thread */
+export function cancelStatement(t, slot, seq) {
+    for (let was = Atomics.load(t, cancelledAt(slot)); was < seq; was = Atomics.load(t, cancelledAt(slot))) {
+        if (Atomics.compareExchange(t, cancelledAt(slot), was, seq) === was)
+            return;
+    }
+}
+/** statement `seq` is the one the session's connection runs now */
+export function beginStatement(t, slot, seq) { Atomics.store(t, runningAt(slot), seq); }
+/** whether the statement the session's connection runs now is cancelled */
+export function isCancelled(t, slot) {
+    const running = Atomics.load(t, runningAt(slot));
+    return running !== 0 && Atomics.load(t, cancelledAt(slot)) >= running;
+}
+/** whether statement `seq` of the session in `slot` was cancelled (its cancel asked, whether or not a call saw it) */
+export function statementCancelled(t, slot, seq) {
+    return seq !== 0 && Atomics.load(t, cancelledAt(slot)) >= seq;
+}
+/** the session variable's value for a slot, and back (`s<slot>`; null for what is no session's) */
+export const slotName = (slot) => `s${slot}`;
+export function slotOf(name) {
+    if (name === null || !/^s\d+$/.test(name))
+        return null;
+    const n = Number(name.slice(1));
+    return n < CANCEL_SLOTS ? n : null;
+}