@mason-data/cli 0.7.0 → 0.8.0

package/dist/src/duck/explain.js

@@ -1,3 +1,4 @@
+import { agoText, syncText } from "../lib/table-sync.js";
 /** a node of DuckDB's JSON, either form: `name` (EXPLAIN) or `type` with `intermediate_rows` and `timing` (the profile).
  *  The profile's RESULT_COLLECTOR and EXECUTE are the result's plumbing, not the plan's: their child stands for them */
 export function planNodes(json) {
@@ -27,7 +28,7 @@ export function profiled(doc) {
     return { sql: typeof d.query?.sql === "string" ? d.query.sql : null, plan: planNodes(d.operator ?? []) };
 }
 /** what EXPLAIN ANALYZE says of a statement DuckDB's profiler timed no operator of */
-export const UNPROFILED = "DuckDB's profiler recorded no operator of this statement: DuckDB answered it while planning it (as it answers a count(*) of a whole table from the table's row count), so the plan is its EXPLAIN, with the rows it answered";
+export const UNPROFILED = "the engine's profiler recorded no operator of this statement: the engine answered it while planning it (as it answers a count(*) of a whole table from the table's row count), so the plan is its EXPLAIN, with the rows it answered";
 /** DuckDB's operator as DuckDB's own plan prints it (`HASH_GROUP_BY` is `Hash Group By`), a scan `Table Scan` as its
  *  profiler names it: DuckDB's EXPLAIN says SEQ_SCAN for the same operator, and Postgres's `Seq Scan` says otherwise */
 export const operatorName = (type) => type.toLowerCase().split("_").map((w) => w === "n" ? "N" : w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
@@ -35,7 +36,7 @@ export const operatorName = (type) => type.toLowerCase().split("_").map((w) => w
 const quotedName = (s) => /^[a-z_][a-z0-9_$]*$/.test(s) ? s : `"${s.replaceAll('"', '""')}"`;
 /**
  * A TABLE AS POSTGRES WRITES IT, each part quoted where it must be (`public.orders`, `public."Clients"`,
- * `public."x; y"`): the ONE way EXPLAIN names a copy (its line, FORMAT JSON's `Mason.Copies[].Table`), which a statement
+ * `public."x; y"`): the ONE way EXPLAIN names a copy (its line, FORMAT JSON's `Mason.Tables[].Table`), which a statement
  * can read back as it is (`mason mcp`'s tables and describe name tables by it too).
  */
 export const qualifiedName = (t) => `${quotedName(t.schema)}.${quotedName(t.name)}`;
@@ -93,35 +94,39 @@ const utc = (iso) => `${iso.slice(0, 19).replace("T", " ")} UTC`;
 const UNKNOWN = "how it is kept current is unknown: the sync has no record of it";
 /**
  * HOW A COPY IS KEPT CURRENT, in EXPLAIN's words, from the sync's one derivation (src/duck/sync.ts `KeptCurrent`, which
- * `mason status` renders too): a copy not yet copied or whose copy failed says so first; then polled with its last
- * poll, served as copied and skipped by the passes (to be copied again, caught up first, over the poll's row limit),
- * copied again whole, or, in replication mode, its part in the stream, how far the stream has applied and why it is
- * not running. "kept current" is said only of a copy that is (`keptCurrentBy`).
+ * `mason status` renders too): a copy not yet copied or whose copy failed says so first; then its sync and its age —
+ * `off: last synced 3 days ago (…)` with the command that syncs it, `polled every 30s, last 4 s ago (…)` — or served as
+ * copied and skipped by the passes (to be copied again, caught up first), copied again whole, or, in replication mode,
+ * its part in the stream, how far the stream has applied and why it is not running. A copy's age is never left out:
+ * a BI tool or an agent reading a stale count cannot tell it is one. "kept current" is said only of a copy that is
+ * (`keptCurrentBy`). `rows` false says no count of its rows: a filtered table's are every row's, not the role's.
  */
-export function keptText(f) {
+export function keptText(f, now = Date.now(), rows = true) {
     if (f === null)
         return UNKNOWN;
     if (f.phase === "waiting")
-        return "waiting for its copy to start";
+        return "waiting for its first sync to start";
     if (f.phase === "copying")
-        return `being copied (${count(f.rowsSoFar ?? 0)} rows so far): kept current once copied`;
+        return `being read whole${rows ? ` (${count(f.rowsSoFar ?? 0)} rows so far)` : ""}: kept current once synced`;
     if (f.phase === "failed")
-        return `its last copy failed: ${(f.error ?? "mason logs says why").split("\n")[0]}`;
+        return `its first sync failed: ${(f.error ?? "mason logs says why").split("\n")[0]}`;
     const k = f.kept;
     if (k === undefined)
         return UNKNOWN;
     if (k.by === "poll") {
-        const asOf = k.polledAt === null ? "no poll recorded yet" : `as of ${utc(k.polledAt)}`;
+        const synced = k.syncedAt === null ? "never synced" : `last synced ${agoText(k.syncedAt, now)} (${utc(k.syncedAt)})`;
         if (k.pending !== undefined)
-            return `NOT kept current (${asOf}): ${k.pending}`;
-        if (k.unsynced !== undefined)
-            return `NOT kept current (${k.unsynced}; ${asOf}): mason sync ${f.source} polls it now`;
-        return `kept current by polling, ${k.polledAt === null ? "no poll recorded yet" : `last poll ${utc(k.polledAt)}`}`;
+            return `NOT kept current (${synced}): ${k.pending}`;
+        if (k.sync.mode === "off")
+            return `off: ${synced}; mason sync ${f.source} syncs it now`;
+        return `polled every ${k.sync.every}, ${k.syncedAt === null ? "not polled yet" : `last ${agoText(k.syncedAt, now)} (${utc(k.syncedAt)})`}`;
     }
     if (k.by === "recopy")
-        return `kept current by copying it again whole, ${k.copiedAt === null ? "no copy recorded yet" : `last copied ${utc(k.copiedAt)}`}`;
+        return `kept current by reading it again whole, ${k.copiedAt === null ? "no sync recorded yet" : `last synced ${utc(k.copiedAt)}`}`;
     const stream = `logical replication (slot ${k.slot})`;
-    const where = `applied through ${k.position}, ${k.lastCommit === null ? "no change applied this run" : `last change committed ${utc(k.lastCommit)}`}`;
+    // the copy's age as status says it (replicated, at <lsn>, <age>), then the newest change it applied
+    const synced = k.syncedAt === null ? "not synced yet" : `last synced ${agoText(k.syncedAt, now)} (${utc(k.syncedAt)})`;
+    const where = `replicated, at ${k.position}, ${synced}, ${k.lastCommit === null ? "no change applied this run" : `last change committed ${utc(k.lastCommit)}`}`;
     if (k.state === "streamed")
         return k.notRunning === null ? `kept current by ${stream}, ${where}`
             : `streamed by ${stream}, ${where}; NOT kept current now, the stream is not running: ${k.notRunning}`;
@@ -129,54 +134,59 @@ export function keptText(f) {
         : `${stream}, not streamed yet: ${k.why ?? ""}`;
 }
 /** what keeps a copy current NOW, as FORMAT JSON's `Kept Current By` says it: null for a copy nothing does (not copied
- *  yet, skipped by the passes, over the poll's row limit, not streamed, the stream down), so a reader keying on it is
+ *  yet, skipped by the passes, its sync off, not streamed, the stream down), so a reader keying on it is
  *  never told of a mode that is not at work on it */
 export function keptCurrentBy(f) {
     const k = f?.phase === "copied" ? f.kept : undefined;
     if (k === undefined)
         return null;
     if (k.by === "poll")
-        return k.pending === undefined && k.unsynced === undefined ? "polling" : null;
+        return k.pending === undefined && k.sync.mode === "poll" ? "polling" : null;
     if (k.by === "recopy")
         return "copying again";
     return k.state === "streamed" && k.notRunning === null ? "logical replication" : null;
 }
 /** how a copy is kept current, as FORMAT JSON's keys say it (`keptText`'s facts) */
-function keptJson(f) {
+function keptJson(f, rows) {
     const k = f?.phase === "copied" ? f.kept : undefined;
     return {
-        "Kept Current By": keptCurrentBy(f), "Kept Current": keptText(f),
-        ...(k?.by === "poll" ? { "Last Poll": k.polledAt } : {}),
-        ...(k?.by === "replication" ? { Slot: k.slot, "Stream State": k.state, "Applied Through": k.position, "Last Change Committed": k.lastCommit, "Stream Not Running": k.notRunning } : {}),
+        "Kept Current By": keptCurrentBy(f), "Kept Current": keptText(f, undefined, rows),
+        ...(k?.by === "poll" ? { Sync: syncText(k.sync), "Last Synced": k.syncedAt, "Next Poll": k.nextAt } : {}),
+        ...(k?.by === "replication" ? { Sync: "replication", Slot: k.slot, "Stream State": k.state, "Applied Through": k.position, "Last Synced": k.syncedAt, "Last Change Committed": k.lastCommit, "Stream Not Running": k.notRunning } : {}),
     };
 }
+/** what EXPLAIN says of a statement that reads a filtered table, in the place of the engine's plan */
+const FILTERED = "the engine's plan is not shown for a statement that reads a table the role filters: it would say what the engine knows of every row; a user with no row filter reads the full plan";
 const ms = (x) => x.toFixed(3);
 const count = (n) => n.toLocaleString("en-US");
 const detail = (v) => Array.isArray(v) ? v.join(", ") : v;
 /** the details a plan line carries without VERBOSE: everything but the projections and filters, which VERBOSE adds */
 const VERBOSE_ONLY = new Set(["Projections", "Filters", "Table", "Type"]);
+/** a filtered table says no row count: the estimate is every row's, which the role does not read */
 function copyLine(c) {
-    const rows = c.rows === null ? "rows unknown" : `about ${count(c.rows)} rows`;
-    return `${c.table} (${rows}; ${keptText(c.facts)})`;
+    const rows = c.filter !== undefined ? "" : c.rows === null ? "rows unknown; " : `about ${count(c.rows)} rows; `;
+    return `${c.table} (${rows}${keptText(c.facts, undefined, c.filter === undefined)}${c.filter !== undefined ? `; ${c.filter}` : ""})`;
 }
 /** EXPLAIN as Postgres's text format: one line a row */
 export function explainText(e, o) {
     const lines = [];
-    lines.push(e.copies.length === 0 ? "Mason: answered by DuckDB, reading none of its copies"
-        : e.copies.length === 1 ? `Mason: answered by DuckDB from its copy of ${copyLine(e.copies[0])}` : "Mason: answered by DuckDB from its copies of");
+    lines.push(e.copies.length === 0 ? "Mason: answered reading no synced table"
+        : e.copies.length === 1 ? `Mason: answered from the synced table ${copyLine(e.copies[0])}` : "Mason: answered from the synced tables");
     if (e.copies.length > 1)
         for (const c of e.copies)
             lines.push(`  ${copyLine(c)}`);
-    lines.push(`  Sent to DuckDB: ${e.sql}`);
-    lines.push(`  Computed by Mason after DuckDB: ${e.computed.length === 0 ? "nothing" : e.computed.join("; ")}`);
+    lines.push(`  Sent to the engine: ${e.sql}`);
+    lines.push(`  Computed by Mason after the engine: ${e.computed.length === 0 ? "nothing" : e.computed.join("; ")}`);
     if (e.functions.length > 0)
-        lines.push(`  Mason's functions DuckDB calls: ${e.functions.join(", ")}`);
+        lines.push(`  Mason's functions the engine calls: ${e.functions.join(", ")}`);
     for (const name of o.ignored)
-        lines.push(`  Note: ${name} has no DuckDB meaning: ignored`);
+        lines.push(`  Note: ${name} has no meaning to the engine: ignored`);
+    if (e.filtered === true)
+        lines.push(`  Note: ${FILTERED}`);
     if (e.analyzed?.profiled === false)
         lines.push(`  Note: ${UNPROFILED}`);
     else if (e.analyzed !== undefined && o.timing)
-        lines.push("  Note: an operator's thread time is DuckDB's, summed over the threads that ran it and the operators under it: a parallel one's exceeds the Execution Time");
+        lines.push("  Note: an operator's thread time is the engine's, summed over the threads that ran it and the operators under it: a parallel one's exceeds the Execution Time");
     const walk = (n, depth) => {
         const lead = depth === 0 ? "" : `${" ".repeat(6 * depth - 4)}->  `;
         const on = scannedTable(n);
@@ -193,8 +203,8 @@ export function explainText(e, o) {
     e.plan.forEach((n) => walk(n, 0));
     if (e.analyzed !== undefined && o.summary) {
         const p = e.analyzed.planning, x = e.analyzed.execution;
-        lines.push(`Planning Time: ${ms(p.analysisMs + p.rewriteMs + p.duckdbMs)} ms (Postgres's analysis ${ms(p.analysisMs)}, Mason's rewrite ${ms(p.rewriteMs)}, DuckDB's planning ${ms(p.duckdbMs)})`);
-        lines.push(`Execution Time: ${ms(x.duckdbMs + x.masonMs)} ms (DuckDB ${ms(x.duckdbMs)}, Mason's conversion and exact numerics ${ms(x.masonMs)})`);
+        lines.push(`Planning Time: ${ms(p.analysisMs + p.rewriteMs + p.duckdbMs)} ms (Postgres's analysis ${ms(p.analysisMs)}, Mason's rewrite ${ms(p.rewriteMs)}, the engine's planning ${ms(p.duckdbMs)})`);
+        lines.push(`Execution Time: ${ms(x.duckdbMs + x.masonMs)} ms (the engine ${ms(x.duckdbMs)}, Mason's conversion and exact numerics ${ms(x.masonMs)})`);
     }
     return lines;
 }
@@ -208,31 +218,31 @@ export function explainJson(e, o) {
             "Node Type": operatorName(n.type),
             ...(on === null ? {} : { "Relation Name": on.name, Schema: on.schema }),
             ...(o.costs && n.estimate !== null ? { "Plan Rows": n.estimate } : {}),
-            ...(n.actualRows === undefined ? {} : { "Actual Rows": n.actualRows, "Actual Loops": 1, ...(o.timing && n.threadMs !== undefined ? { "DuckDB Thread Time": Number(ms(n.threadMs)) } : {}) }),
-            ...Object.fromEntries(Object.entries(n.extra).filter(([k]) => o.verbose ? k !== "Table" : !VERBOSE_ONLY.has(k)).map(([k, v]) => [`DuckDB ${k}`, v])),
+            ...(n.actualRows === undefined ? {} : { "Actual Rows": n.actualRows, "Actual Loops": 1, ...(o.timing && n.threadMs !== undefined ? { "Engine Thread Time": Number(ms(n.threadMs)) } : {}) }),
+            ...Object.fromEntries(Object.entries(n.extra).filter(([k]) => o.verbose ? k !== "Table" : !VERBOSE_ONLY.has(k)).map(([k, v]) => [`Engine ${k}`, v])),
             ...(n.children.length === 0 ? {} : { Plans: n.children.map(node) }),
         };
     };
     // Postgres's plan has one root; DuckDB's has one too (a statement's), kept as a list should it ever have more
     const roots = e.plan.map(node);
     const top = {
-        Plan: roots.length === 1 ? roots[0] : { "Node Type": "DuckDB Plans", Plans: roots },
+        Plan: e.filtered === true ? { "Node Type": "Plan Not Shown" } : roots.length === 1 ? roots[0] : { "Node Type": "Engine Plans", Plans: roots },
         Mason: {
-            "Answered By": "DuckDB",
-            Copies: e.copies.map((c) => ({ Table: c.table, "Estimated Rows": c.rows, ...keptJson(c.facts) })),
-            "Sent To DuckDB": e.sql,
-            "Computed After DuckDB": e.computed,
-            "Mason Functions DuckDB Calls": e.functions,
-            ...(o.ignored.length === 0 ? {} : { Ignored: o.ignored.map((n) => `${n} has no DuckDB meaning`) }),
-            ...(e.analyzed?.profiled === false ? { Note: UNPROFILED } : {}),
+            "Answered By": "the engine",
+            Tables: e.copies.map((c) => ({ Table: c.table, ...(c.filter === undefined ? { "Estimated Rows": c.rows } : {}), ...keptJson(c.facts, c.filter === undefined), ...(c.filter !== undefined ? { "Row Filter": c.filter } : {}) })),
+            "Sent To Engine": e.sql,
+            "Computed After Engine": e.computed,
+            "Mason Functions Engine Calls": e.functions,
+            ...(o.ignored.length === 0 ? {} : { Ignored: o.ignored.map((n) => `${n} has no meaning to the engine`) }),
+            ...(e.filtered === true ? { Note: FILTERED } : e.analyzed?.profiled === false ? { Note: UNPROFILED } : {}),
         },
     };
     if (e.analyzed !== undefined && o.summary) {
         const p = e.analyzed.planning, x = e.analyzed.execution;
         top["Planning Time"] = Number(ms(p.analysisMs + p.rewriteMs + p.duckdbMs));
         top["Execution Time"] = Number(ms(x.duckdbMs + x.masonMs));
-        top.Mason["Planning"] = { "Postgres Analysis": Number(ms(p.analysisMs)), "Mason Rewrite": Number(ms(p.rewriteMs)), "DuckDB Planning": Number(ms(p.duckdbMs)) };
-        top.Mason["Execution"] = { DuckDB: Number(ms(x.duckdbMs)), "Mason Conversion": Number(ms(x.masonMs)) };
+        top.Mason["Planning"] = { "Postgres Analysis": Number(ms(p.analysisMs)), "Mason Rewrite": Number(ms(p.rewriteMs)), "Engine Planning": Number(ms(p.duckdbMs)) };
+        top.Mason["Execution"] = { Engine: Number(ms(x.duckdbMs)), "Mason Conversion": Number(ms(x.masonMs)) };
     }
     return JSON.stringify([top], null, 2);
 }

package/dist/src/duck/extensions.js

@@ -0,0 +1,160 @@
+/**
+ * THE COPY'S EXTENSIONS SHIP WITH MASON. The copy reads the source through DuckDB's `postgres` extension
+ * (src/duck/sync.ts attach), and a statement that casts a value to inet needs DuckDB's `inet`; DuckDB bundles
+ * neither, and by default downloads one from its extension repository at the first statement that needs it. Mason
+ * ships both instead, ONE npm PACKAGE PER PLATFORM (`@mason-data/extensions-<platform>`), as DuckDB's node bindings ship
+ * their binary: an optional dependency of @mason-data/cli whose `os` / `cpu` / `libc` make npm install the one this
+ * machine runs, built by cli/extensions.ts from the files' checksums pinned in cli/extensions.json. The image installs
+ * the same package (docker/mason-data.Dockerfile).
+ *
+ * - A package found (`findExtensions`): the instance's `extension_directory` IS the package's folder and nothing is
+ *   ever installed (`extensionSettings`): `LOAD postgres` reads it, an inet cast autoloads it from there, and
+ *   autoinstall is off, so no statement downloads anything. DuckDB checks each file's signature at LOAD
+ *   (`allow_unsigned_extensions` stays off: the official extensions are signed), and LOAD writes nothing, so the
+ *   folder may be read-only (a global npm install, the image's /app).
+ * - None (`npm install --omit=optional`, a platform no package is built for — musl, Windows on arm64 — or a checkout):
+ *   DuckDB's own way, said with the reason: the first copy installs the extension from the internet into
+ *   ~/.duckdb/extensions (src/duck/sync.ts attach). `mason doctor` says which (`probeExtensions`).
+ *
+ * tests/duck-extensions.test.ts holds the resolver per platform over a fake package; the integration test
+ * (tests/integration/extensions.itest.ts) holds a copy and an inet cast to the package with nothing downloaded.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { createRequire } from "node:module";
+import { DuckDBInstance, version } from "@duckdb/node-api";
+/** Each platform a package is built for: Node's `<platform>-<arch>` (the package's name) and DuckDB's name for it (the
+ *  folder of the extension repository, and of `extension_directory`). Linux is glibc's: musl has no package. */
+export const EXTENSION_PLATFORMS = {
+    "darwin-arm64": "osx_arm64",
+    "darwin-x64": "osx_amd64",
+    "linux-arm64": "linux_arm64",
+    "linux-x64": "linux_amd64",
+    "win32-x64": "windows_amd64",
+};
+/** The extensions each package holds, by the name DuckDB installs them under (`INSTALL postgres` is `postgres_scanner`). */
+export const EXTENSION_NAMES = ["postgres_scanner", "inet"];
+export const packageName = (p) => `@mason-data/extensions-${p}`;
+/** Where a package keeps the files: `<package>/extensions/<engine>/<DuckDB's platform>/<name>.duckdb_extension`, the
+ *  layout DuckDB reads `extension_directory` in. */
+export const extensionFile = (root, engine, platform, name) => path.join(root, "extensions", engine, EXTENSION_PLATFORMS[platform], `${name}.duckdb_extension`);
+export function thisHost() {
+    // Node's own report names glibc's version where glibc runs; musl (Alpine) has none (detect-libc's first check). Its
+    // network part is left out, as detect-libc leaves it: enumerating the interfaces has taken seconds in a container
+    let header;
+    if (process.platform === "linux") {
+        // `excludeNetwork` is Node's (20+), not yet in @types/node
+        const report = process.report;
+        const network = report.excludeNetwork;
+        report.excludeNetwork = true;
+        try {
+            header = report.getReport().header;
+        }
+        finally {
+            report.excludeNetwork = network;
+        }
+    }
+    return { platform: process.platform, arch: process.arch, musl: process.platform === "linux" && header?.glibcVersionRuntime === undefined };
+}
+/** The platform's key as npm and DuckDB's bindings name it: `linux-x64`, `linux-x64-musl`, `darwin-arm64`. */
+export const hostKey = (h) => `${h.platform}-${h.arch}${h.musl ? "-musl" : ""}`;
+const requireHere = createRequire(import.meta.url);
+/**
+ * THE PACKAGE FOR THIS MACHINE, found where Node would find it from this module (the CLI's node_modules, nested or
+ * hoisted; the image's /app/node_modules), holding both files for THIS engine. Reads two files' existence: no engine
+ * is opened. `resolve` and `host` are a test's.
+ */
+export function findExtensions(o = {}) {
+    const host = o.host ?? thisHost();
+    const engine = o.engine ?? `v${version().replace(/^v/, "")}`;
+    const key = hostKey(host);
+    if (!(key in EXTENSION_PLATFORMS)) {
+        return { shipped: false, package: null, why: `no package of Mason's extensions is built for ${key} (only ${Object.keys(EXTENSION_PLATFORMS).join(", ")})` };
+    }
+    const platform = key;
+    const name = packageName(platform);
+    let manifest;
+    try {
+        manifest = (o.resolve ?? requireHere.resolve)(`${name}/package.json`);
+    }
+    catch (e) {
+        // not installed is the one answer expected here; anything else is said as it is
+        if (e.code !== "MODULE_NOT_FOUND")
+            throw e;
+        return { shipped: false, package: name, why: `${name} is not installed beside Mason (npm installs it with @mason-data/cli unless optional dependencies are left out: --omit=optional)` };
+    }
+    const root = path.dirname(manifest);
+    let pkgVersion;
+    try {
+        pkgVersion = String(JSON.parse(fs.readFileSync(manifest, "utf8")).version ?? "");
+    }
+    catch (e) {
+        // a broken install: refused in Mason's words with the way out, never the parser's error
+        return { shipped: false, package: name, why: `${name}'s package.json at ${manifest} cannot be read (${e.message}): install @mason-data/cli again` };
+    }
+    const missing = EXTENSION_NAMES.filter((n) => !fs.existsSync(extensionFile(root, engine, platform, n)));
+    if (missing.length > 0) {
+        const has = fs.existsSync(path.join(root, "extensions")) ? fs.readdirSync(path.join(root, "extensions")) : [];
+        return { shipped: false, package: name, why: `${name} ${pkgVersion} holds no ${missing.join(" or ")} for the engine Mason runs (${engine}; it holds ${has.length ? has.join(", ") : "none"}): ` +
+                "install @mason-data/cli again, whose packages are released together" };
+    }
+    return { shipped: true, package: name, version: pkgVersion, directory: path.join(root, "extensions"), platform };
+}
+/** The instance's settings for what was found: with the package, its folder and no download, ever; without, DuckDB's
+ *  defaults (the first copy installs into ~/.duckdb/extensions). */
+export function extensionSettings(x) {
+    return x.shipped ? { extension_directory: x.directory, autoinstall_known_extensions: "false", autoload_known_extensions: "true" } : {};
+}
+/** The statement the copy loads its postgres extension with: from the package, a LOAD; without one, DuckDB's INSTALL
+ *  first (a download, once a machine). */
+export const loadPostgresSql = (x) => x.shipped ? "LOAD postgres" : "INSTALL postgres; LOAD postgres;";
+/** What a copy that could not load the postgres extension says (src/duck/sync.ts attach), with the way out. */
+export function extensionFailure(x, error) {
+    return x.shipped
+        ? `Mason could not load its postgres extension from ${x.package} ${x.version} (${x.directory}): ${error}. Install @mason-data/cli again; mason doctor checks it`
+        : `Mason could not load its postgres extension: ${error}. ${x.why}, so the first sync on a machine downloads it ` +
+            "(then ~/.duckdb/extensions): connect to the internet once, and the sync is tried again at the next pass";
+}
+/**
+ * THE PROBE `mason doctor` SAYS (the contract answers a probe, never a file's existence): with the package, both
+ * extensions LOADED by an instance of their own with the run's settings — the signature and the platform checked as
+ * the run's will be; without one, whether DuckDB has them installed in ~/.duckdb/extensions already, and `ok` null when
+ * it has not (the first copy will download them: fine online, which no probe can tell). Downloads nothing.
+ */
+export async function probeExtensions(x = findExtensions()) {
+    let instance;
+    try {
+        instance = await DuckDBInstance.create(":memory:", { autoinstall_known_extensions: "false", ...extensionSettings(x) });
+    }
+    catch (e) {
+        return { ok: null, detail: `could not open an engine to check them: ${e.message}` };
+    }
+    try {
+        const c = await instance.connect();
+        try {
+            if (x.shipped) {
+                for (const n of EXTENSION_NAMES) {
+                    try {
+                        await c.run(`LOAD ${n}`);
+                    }
+                    catch (e) {
+                        return { ok: false, detail: `${x.package} ${x.version} is installed, and its ${n.replace("_scanner", "")} extension does not load: ${e.message.split("\n")[0]}. Install @mason-data/cli again` };
+                    }
+                }
+                return { ok: true, detail: `postgres and inet ship with Mason (${x.package} ${x.version}): nothing is downloaded` };
+            }
+            const rows = (await c.runAndReadAll(`SELECT extension_name, installed FROM duckdb_extensions() WHERE extension_name IN (${EXTENSION_NAMES.map((n) => `'${n}'`).join(", ")})`)).getRowObjects();
+            const absent = EXTENSION_NAMES.filter((n) => !rows.some((r) => r.extension_name === n && r.installed === true)).map((n) => n.replace("_scanner", ""));
+            if (absent.length === 0)
+                return { ok: true, detail: `postgres and inet were downloaded on this machine before (~/.duckdb/extensions), not shipped: ${x.why}` };
+            // not a failure: online, the first copy downloads them; whether this machine will be online then, no probe can tell
+            return { ok: null, detail: `${absent.join(" and ")} not on this machine yet, so the first sync downloads them and needs the internet once: ${x.why}` };
+        }
+        finally {
+            c.closeSync();
+        }
+    }
+    finally {
+        instance.closeSync();
+    }
+}

package/dist/src/duck/functions.js

@@ -23,7 +23,7 @@ import { compare, div, evaluateText, NumericError, numericText, parseNumeric } f
 import { toCharNumber, toCharTime } from "./to-char.js";
 import { atTimeZoneOf } from "../lib/timezone.js";
 import { gapMark } from "./gaps.js";
-import { CANCEL_SLOTS, cancelTable, isCancelled, slotOf } from "./cancel.js";
+import { beat, cancelTable, isCancelled, slotOf } from "./cancel.js";
 // ------------------------------------------------------------------------------------------------- case mapping
 /** one character's simple mapping, as towupper / towlower give it: a character whose full mapping is several (`ß`,
  *  `ʼn`) keeps itself */
@@ -496,6 +496,7 @@ function scalar(conn, name, params, returns, body, opts = {}) {
             const vectors = all.slice(1);
             try {
                 for (let r = 0; r < input.rowCount; r++) {
+                    beat(cancels); // one vector of wide documents is seconds of this loop: the watch must see it run
                     const args = vectors.map((v) => v.getItem(r));
                     out.setItem(r, opts.nulls !== "pass" && args.some((a) => a === null) ? null : body(args));
                 }
@@ -638,17 +639,20 @@ function icuKeysOf(v) {
  * EVERY CALL CARRIES ITS SESSION, FIRST (the test server: a client leaving mid-statement hung the process
  * for good). A scalar function runs on the thread that registered it — the executor worker (src/duck/executor.ts) —
  * while an executor thread waits for it, so that thread can never wait for the executor — and closing a result or a
- * connection does, to cancel the executor's tasks. An interrupt does not end those tasks (they run on until the close),
- * so a statement that calls one of these functions is cancelled another way: its session's cell of the CANCEL TABLE
- * (src/duck/cancel.ts) says it is cancelled, and the statement's next call raises. DuckDB may hand that error back
- * while another task of the query still waits for a call, so the result is closed only once the session's calls have
- * stopped (src/duck/store.ts `cleanUp`; a deadlock under load). The table is shared memory: the listener's thread writes it
+ * connection does, to cancel the executor's tasks. So such a statement is cancelled through its session as well as
+ * interrupted: its session's cell of the CANCEL TABLE (src/duck/cancel.ts) says it is cancelled, the statement's next call
+ * raises, and its result is closed only once DuckDB ended the query off this thread (src/duck/store.ts `cleanUp`; a
+ * deadlock under load). The table is shared memory: the listener's thread writes it
  * while this one is busy with the statement's calls. The rewrite (src/duck/rewrite.ts `fn`) passes
  * `getvariable('__mason_session')` as every `__mason_*` function's first argument, which DuckDB folds to the session's
  * literal at bind time; the session runner sets the variable on its connection (its slot, `s<n>`). A connection without
  * it (the writer, a copy's) passes NULL: never cancelled this way.
  */
 export const SESSION_VARIABLE = "__mason_session";
+/** the session's settings, name to value, as `current_setting(name)` answers them (src/api/postgres/server.ts
+ *  `duckSession`): set on a session's connection before each statement that finds them changed (src/duck/store.ts
+ *  `settle`), read by the rewrite's `settingRead` (src/duck/rewrite.ts) */
+export const SETTINGS_VARIABLE = "__mason_settings";
 export const CANCELLED = "mason[57014]: canceling statement due to user request";
 /** how many vectors each function was called with (a call is a hop to the main thread): what a test or a measurement
  *  reads to know whether a statement reached a function at all (the rewrite answers a `->>` natively where it can) */
@@ -660,16 +664,11 @@ export const FUNCTION_ROWS = new Map();
 let cancels = cancelTable();
 export function useCancelTable(t) { cancels = t; }
 export function cancelsTable() { return cancels; }
-/** when each session's last call was answered (performance.now(), on this thread): what a session's runner reads to know
- *  that no task of a statement still waits for a call before it closes the statement's result (src/duck/store.ts
- *  `cleanUp`) */
-const lastCallAt = new Float64Array(CANCEL_SLOTS);
-export function msSinceCall(slot) { return performance.now() - (lastCallAt[slot] ?? 0); }
-/** the session's vector (the first argument, a constant): raises when the session's statement is cancelled */
+/** the session's vector (the first argument, a constant): raises when the session's statement is cancelled. Every call
+ *  starts here, so every call beats (src/duck/cancel.ts) */
 function cancelled(info, vectors, rows) {
+    beat(cancels);
     const slot = rows > 0 ? slotOf(text(vectors[0]?.getItem(0))) : null;
-    if (slot !== null)
-        lastCallAt[slot] = performance.now();
     if (slot === null || !isCancelled(cancels, slot))
         return false;
     info.setError(CANCELLED);

package/dist/src/duck/gaps.js

@@ -17,11 +17,12 @@
  */
 export const GAPS = {
     // ---------------------------------------------------------------------------------------------- refused
-    unverified: { kind: "refused", what: "a function, operator, cast, type or construct the oracle has not held to Postgres", postgres: "answers", mason: "refused, naming each piece", wayOut: "write the statement without it; report it to have it verified", heldBy: "tests/duck-wire.test.ts" },
+    unverified: { kind: "refused", what: "a function, operator, cast, type or construct Mason has not yet verified against Postgres", postgres: "answers", mason: "refused, naming each piece", wayOut: "write the statement without it; report it to have it verified", heldBy: "tests/duck-wire.test.ts" },
     "explain-option": { kind: "refused", what: "EXPLAIN (FORMAT XML), (FORMAT YAML), (GENERIC_PLAN)", postgres: "the plan in XML or YAML; a plan for unbound parameters", mason: "refused by name: EXPLAIN is DuckDB's plan, in Postgres's text or JSON (docs/DESIGN.md)", wayOut: "FORMAT TEXT or FORMAT JSON; bind the parameters' values and EXPLAIN that" },
+    "set-config-forms": { kind: "refused", what: "set_config() anywhere but alone in a SELECT of no table with literal arguments: beside other columns or a FROM, in a subquery, with an expression, a parameter or NULL, under EXPLAIN", postgres: "sets the parameter (for the transaction, under is_local) and answers its value", mason: "refused (SELECT set_config('name', 'value', false) alone is the session's SET, and with true its SET LOCAL, answered with its value as SHOW answers it)", wayOut: "SET name = 'value', or SELECT set_config('name', 'value', false) on its own" },
     "setop-ordinal-star": { kind: "refused", what: "ORDER BY a column number of a UNION / INTERSECT / EXCEPT whose first SELECT lists *", postgres: "sorts by that column", mason: "refused", wayOut: "ORDER BY the column's name" },
     "with-ties-distinct": { kind: "refused", what: "FETCH FIRST … WITH TIES over SELECT DISTINCT", postgres: "answers", mason: "refused (DuckDB has no WITH TIES; Mason's rank over DISTINCT is not Postgres's)", wayOut: "select the DISTINCT rows in a subquery and FETCH … WITH TIES from it" },
-    "collation-unknown": { kind: "refused", what: "COLLATE with a collation other than C, POSIX, default or an ICU locale DuckDB has", postgres: "sorts and compares under it", mason: "refused", wayOut: "COLLATE \"C\" for byte order, or no COLLATE for the database's" },
+    "collation-unknown": { kind: "refused", what: "COLLATE with a collation other than C, POSIX, default or an ICU locale the engine has", postgres: "sorts and compares under it", mason: "refused", wayOut: "COLLATE \"C\" for byte order, or no COLLATE for the database's" },
     "like-any-array": { kind: "refused", what: "LIKE / ILIKE ANY (or ALL) over an array that is not written out", postgres: "answers", mason: "refused", wayOut: "write the patterns as ARRAY['…', '…'], or OR the LIKEs" },
     "similar-to-forms": { kind: "refused", what: "SIMILAR TO with a pattern or ESCAPE that is not a literal, its substring markers, or substring(… SIMILAR … ESCAPE …)", postgres: "answers", mason: "refused", wayOut: "a literal pattern, or ~ with a POSIX regular expression" },
     "array-remove-type": { kind: "refused", what: "array_remove of an array of a type other than text, integers, floats, booleans, dates or timestamps", postgres: "answers", mason: "refused", wayOut: "array_remove an array of one of those types" },
@@ -55,7 +56,7 @@ export const GAPS = {
     "inet-order": { kind: "refused", what: "ORDER BY, <, >, min or max over an inet", postgres: "orders addresses by network, then host", mason: "refused (equality, IS NULL and the value itself are answered)", wayOut: "sort or compare another column" },
     "citext-forms": { kind: "refused", what: "GROUP BY, DISTINCT, min, max, a set operation, or = ANY (an array) over a citext", postgres: "groups and sorts without regard to case, answering one spelling", mason: "refused (=, <>, <, >, IN (…), LIKE and ORDER BY are answered, case-insensitively)", wayOut: "GROUP BY lower(x), or x::text where case matters" },
     "bytea-forms": { kind: "refused", what: "encode / decode to a format other than hex, base64 or escape, or one not written as a literal; convert_to / convert_from of an encoding other than UTF8", postgres: "answers", mason: "refused", wayOut: "encode(x, 'hex'), 'base64' or 'escape'; the UTF8 encoding" },
-    "row-value": { kind: "refused", what: "a row as a value outside the SELECT list, a cast to text and the json functions (compared, tested with IS NULL, grouped, sorted); a row of a row; a row of a table Mason copied in part", postgres: "compares, tests and groups a row by its columns", mason: "refused", wayOut: "compare, test or sort its columns" },
+    "row-value": { kind: "refused", what: "a row as a value outside the SELECT list, a cast to text and the json functions (compared, tested with IS NULL, grouped, sorted); a row of a row; a row of a table Mason synced in part", postgres: "compares, tests and groups a row by its columns", mason: "refused", wayOut: "compare, test or sort its columns" },
     "zone-abbreviation": { kind: "refused", what: "a time zone written as an abbreviation or a POSIX zone (`CST`, `IST`, `UTC+3`, `+05`) in AT TIME ZONE or date_trunc", postgres: "a fixed offset (`CST` is -06 all year; `UTC+3` is three hours WEST)", mason: "refused, written or held by a row (DuckDB reads several as another zone: `CST` as Chicago's, `IST` as India's, `UTC+3` as east)", wayOut: "an IANA zone name (America/Chicago, Asia/Kolkata), in any case; UT, Z and UTC are UTC", heldBy: "tests/duck-wire.test.ts" },
     "volatile-window": { kind: "refused", what: "a window ordered or partitioned by random() or another volatile function (a random row per group)", postgres: "a new value per row", mason: "refused (DuckDB refuses a volatile expression there, and computes a deterministic one once for every row)", wayOut: "SELECT …, row_number() OVER (ORDER BY r) FROM (SELECT *, random() AS r FROM t) AS s" },
     "numeric-special": { kind: "refused", what: "arithmetic on a numeric NaN or Infinity read from a text", postgres: "NaN and ±Infinity by its own rules (NaN + 1 is NaN)", mason: "refused when a row holds one", wayOut: "filter the special values out first (x <> 'NaN')" },
@@ -67,7 +68,7 @@ export const GAPS = {
     "relative-time-literal": { kind: "refused", what: "a relative time combined with anything else ('today 10:00', 'now'::date + …  written as one literal), or read from a row as a date or a time", postgres: "the transaction's start (a row's value: when the row is read)", mason: "refused (a bare 'now', 'today', 'tomorrow', 'yesterday' literal is answered: the transaction's start at the Parse)", wayOut: "current_date + time '10:00', now(), current_date + 1" },
     // ---------------------------------------------------------------------------------------------- differs
     "limit-errors": { kind: "differs", what: "a value that raises (`'x'::int`, a bad JSON number) in a row a LIMIT leaves out: in the select list, where no index gives the ORDER BY; or in the argument of a LEFT JOIN of a list's rows ON TRUE (unnest(ARRAY[…, 'x'::int]), jsonb_each of a non-object), under a LIMIT with no ORDER BY", postgres: "the select list's raises: its plan sorts every row, its select list computed for each (through an index it stops at the limit and answers); the lateral's answers: it stops at the limit", mason: "the select list's answers: a sorted, limited select list is computed for the rows the limit keeps (src/duck/late.ts), as Postgres's index scan does; the lateral's raises: DuckDB computes its argument for a whole vector of rows (2,048) before the limit stops it", wayOut: "none needed for the select list's answer; filter the bad rows out to have neither raise" },
-    "limit-lateral-filter": { kind: "differs", what: "a LEFT JOIN of a json document's rows ON TRUE (json_each, jsonb_array_elements, …) under a LIMIT, or a row count an Execute sets on the wire, and no ORDER BY, with a filter above the join that DuckDB does not push down to the base: a WHERE on the lateral's own column (d.key <> 'n'), one holding a bound parameter ($1) in a SELECT around the join, or one in a SELECT that reads the join through a CTE", postgres: "the first rows of the base, in its order, each row's members in theirs", mason: "DuckDB plans the lateral under such a filter as a delimiter join and hands the rows back in an order of its own, so the LIMIT keeps other rows (a filter on the base in the join's own SELECT, literal or parameter, or a literal one around it through a derived table, keeps Postgres's)", wayOut: "ORDER BY the base's key before the LIMIT, or filter the base in the SELECT that holds the join", heldBy: "tests/duck-wire.test.ts" },
+    "limit-lateral-filter": { kind: "differs", what: "a LEFT JOIN of a json document's rows ON TRUE (json_each, jsonb_array_elements, …) under a LIMIT, or a row count an Execute sets on the wire, and no ORDER BY, with a filter above the join that is not pushed down to the base: a WHERE on the lateral's own column (d.key <> 'n'), one holding a bound parameter ($1) in a SELECT around the join, or one in a SELECT that reads the join through a CTE", postgres: "the first rows of the base, in its order, each row's members in theirs", mason: "the engine plans the lateral under such a filter as a delimiter join and hands the rows back in an order of its own, so the LIMIT keeps other rows (a filter on the base in the join's own SELECT, literal or parameter, or a literal one around it through a derived table, keeps Postgres's)", wayOut: "ORDER BY the base's key before the LIMIT, or filter the base in the SELECT that holds the join", heldBy: "tests/duck-wire.test.ts" },
     "limit-lateral-argument": { kind: "differs", what: "a LEFT JOIN of a list's rows ON TRUE (unnest, json_each, jsonb_array_elements, …) under a LIMIT, or a row count an Execute sets on the wire, and no ORDER BY, whose argument holds a subquery (unnest(ARRAY(SELECT …))), or reads two or more columns of the row and no array (CASE WHEN t.kind = 'doc' THEN t.body END) in a SELECT whose list is a bare * or inside a join with a name of its own ((a LEFT JOIN … ON TRUE) AS j)", postgres: "the first rows of the base, in its order, each row's members in theirs", mason: "DuckDB plans such a lateral as a delimiter join and hands the rows back in an order of its own, so the LIMIT keeps other rows (elsewhere an argument of two columns is computed in a step of its own before the lateral, which a * would read as a column; a subquery is a delimiter join in every form)", wayOut: "name the columns instead of *, or ORDER BY the base's key before the LIMIT" },
     "window-partition-order": { kind: "differs", what: "a window function that reads its frame in order (row_number, lag, lead, first_value, last_value, nth_value, ntile) over a window with PARTITION BY and no ORDER BY", postgres: "a partition's rows in the order its sort hands them back: in practice the order they came in", mason: "a partition's rows in the order DuckDB's partitioning hands them back, another one", wayOut: "ORDER BY in the window (OVER (PARTITION BY a ORDER BY b))" },
     "mixed-scale-numeric": { kind: "differs", what: "a numeric column whose values have several scales: an integer UNION ALL a numeric, lead(x, 1, 0) beside numeric(2,1) values, an unconstrained column holding 1 and 1.50", postgres: "each value its own scale: 1, 1.5", mason: "one scale per column: 1.0, 1.5", wayOut: "cast to numeric(p, s), or round(x, s)" },
@@ -80,11 +81,12 @@ export const GAPS = {
     "jsonb-equal-text": { kind: "differs", what: "GROUP BY or DISTINCT of jsonb values that are equal but written apart ('1.0' and '1.00', '{\"a\": 1}' and '{\"a\": 1.0}')", postgres: "one group, written as the value its plan reads first", mason: "one group, written as the value DuckDB reads first: either may be any of them", wayOut: "GROUP BY j::text where the text must decide", heldBy: "tests/duck-jsonb-order.test.ts" },
     "char-n-minmax": { kind: "differs", what: "greatest / least of a char(n) beside a text", postgres: "compares without the padding, answers the first of equal values", mason: "compares the padded text", wayOut: "cast the char(n) to text first" },
     "nested-exact-numeric": { kind: "differs", what: "an expression over a numeric a subquery computed exactly (a division, an avg, a round), outside that subquery: SELECT x * 2 FROM (SELECT a / 3 AS x …)", postgres: "exact digits at every step", mason: "the subquery's value as DuckDB computed it (a double's 15 digits) where the outer query computes with it; passed through as it is (SELECT *, s.x), it is exact", wayOut: "compute it in the outermost query, or round(…, n) inside" },
+    "show-all": { kind: "differs", what: "SHOW ALL", postgres: "every server setting with the source database's values", mason: "every setting the listener's catalog Postgres has, with this session's values laid over (search_path, TimeZone, ssl, …): Mason's settings, never your source database's", wayOut: "ask the source database for its settings (SHOW ALL or SHOW <name> there): Mason answers its own" },
     // ---------------------------------------------------------------------------------------------- limits
-    "one-token": { kind: "limit", what: "access", postgres: "roles, grants, row-level security", mason: "every user (mason user) and token reads every copied table: no per-user or per-tenant scope", wayOut: "copy only the tables every user may read" },
-    "poll-full-scan": { kind: "limit", what: "keeping current by the poll (mason start without --replication)", postgres: "-", mason: "the xmin poll scans every added table whole, every poll (no index covers xmin): ~13–17 s for 13 GiB", wayOut: "logical replication: mason start --replication" },
-    "writes": { kind: "limit", what: "INSERT, UPDATE, DELETE, DDL, a read-write transaction", postgres: "answers", mason: "refused by name: the copy is read-only (a read-write transaction: 25006)", wayOut: "write to the source database; the copy follows" },
-    "numeric-over-38-digits": { kind: "limit", what: "a numeric of more than 38 digits, or holding NaN or Infinity: a column, or a constant ('1e400'::numeric) inside DuckDB's arithmetic or a WHERE", postgres: "exact", mason: "a double (15 digits), said in the log for a column; a constant the outermost SELECT answers is exact", wayOut: "numeric(p, s) with p ≤ 38" },
+    roles: { kind: "limit", what: "access", postgres: "roles, grants on tables and columns, row-level security", mason: "a role (mason/roles.yml) grants a user tables and columns, held on the analysed tree and refused as Postgres refuses them (42501 permission denied for table …); information_schema and mason mcp list a role what it may read, pg_catalog still lists every synced column; a role's where: or through: filters a table's rows by the user's attributes (mason user add --set), every read of it filtered on the analysed tree and held by Postgres row security in the catalog behind a security barrier as a Postgres policy is (a statement's own expressions run only on the rows the filter keeps; timing is not guaranteed), a whole row or TABLESAMPLE of a filtered table refused, so is a grouping set relying on its key for a column it does not group, EXPLAIN of a statement reading one said in Mason's lines alone with no engine plan and EXPLAIN ANALYZE of it refused (either would say what the engine knows of every row), a user missing a value refused (42501) at every statement; a user with no role reads as mason/roles.yml's default: role, nothing when the file names none, every synced table when there is no file; a token reads every synced table", wayOut: "mason user add <name> --role <role> --set <attribute>=<value>; name the filtered table's columns in place of its whole row; read the full plan as a user with no row filter", heldBy: "tests/duck-roles-wire.test.ts" },
+    "poll-full-scan": { kind: "limit", what: "keeping current by the poll (a table's sync: poll <interval>)", postgres: "-", mason: "the xmin poll scans its table whole, every poll (no index covers xmin): ~13–17 s for 13 GiB", wayOut: "logical replication for that table: sync: replication on its entry (mason add <table> --sync replication)" },
+    "writes": { kind: "limit", what: "INSERT, UPDATE, DELETE, DDL, a read-write transaction", postgres: "answers", mason: "refused by name: the synced data is read-only (a read-write transaction: 25006)", wayOut: "write to the source database; the synced data follows" },
+    "numeric-over-38-digits": { kind: "limit", what: "a numeric of more than 38 digits, or holding NaN or Infinity: a column, or a constant ('1e400'::numeric) inside Mason's arithmetic or a WHERE", postgres: "exact", mason: "a double (15 digits), said in the log for a column; a constant the outermost SELECT answers is exact", wayOut: "numeric(p, s) with p ≤ 38" },
     "numeric-array": { kind: "limit", what: "an unconstrained numeric[] column", postgres: "exact elements", mason: "double precision elements (15 digits), said in the log", wayOut: "numeric(p, s)[]" },
     "numeric-parameter": { kind: "limit", what: "a numeric parameter ($1) compared in a WHERE", postgres: "exact", mason: "a double (exact to 15 digits)", wayOut: "a literal" },
     "log-literals": { kind: "limit", what: ".mason/mason.log's statement lines", postgres: "-", mason: "each statement DuckDB ran, whole, literals included", wayOut: "keep the log private" },
@@ -92,3 +94,10 @@ export const GAPS = {
 /** the words a runtime refusal carries for the oracle and a reader: `Mason gap <id>` */
 export const gapMark = (id) => `Mason gap ${id}`;
 export const GAP_MARK = /\bMason gap ([a-z0-9-]+)/;
+/** The entry a runtime refusal's TEXT names (`gapMark`), or null: only for a refusal raised inside DuckDB (a Mason
+ *  function's error, src/duck/functions.ts), which crosses DuckDB as its message alone (src/duck/store.ts pgErrorOf);
+ *  a refusal built outside it carries its id on the error (src/api/postgres/server.ts gapRefusal). */
+export function gapIn(text) {
+    const id = GAP_MARK.exec(text)?.[1];
+    return id !== undefined && Object.hasOwn(GAPS, id) ? id : null;
+}