postgresai 0.15.0-rc.2 → 0.15.0-rc.3

package/dist/bin/postgres-ai.js

@@ -1020,7 +1020,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         this._exitCallback = (err) => {
           if (err.code !== "commander.executeSubCommandAsync") {
             throw err;
-          } else {}
+          }
         };
       }
       return this;
@@ -13423,7 +13423,7 @@ var {
 // package.json
 var package_default = {
   name: "postgresai",
-  version: "0.15.0-rc.2",
+  version: "0.15.0-rc.3",
   description: "postgres_ai CLI",
   license: "Apache-2.0",
   private: false,
@@ -16234,7 +16234,7 @@ var safeLoadAll = renamed("safeLoadAll", "loadAll");
 var safeDump = renamed("safeDump", "dump");
 
 // bin/postgres-ai.ts
-import * as fs7 from "fs";
+import * as fs8 from "fs";
 import * as path7 from "path";
 import * as os3 from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -16254,7 +16254,7 @@ var Result = import_lib.default.Result;
 var TypeOverrides = import_lib.default.TypeOverrides;
 var defaults = import_lib.default.defaults;
 // package.json
-var version = "0.15.0-rc.2";
+var version = "0.15.0-rc.3";
 var package_default2 = {
   name: "postgresai",
   version,
@@ -20968,7 +20968,7 @@ function finalize(ctx, schema2) {
     result.$schema = "http://json-schema.org/draft-07/schema#";
   } else if (ctx.target === "draft-04") {
     result.$schema = "http://json-schema.org/draft-04/schema#";
-  } else if (ctx.target === "openapi-3.0") {} else {}
+  } else if (ctx.target === "openapi-3.0") {}
   if (ctx.external?.uri) {
     const id = ctx.external.registry.get(schema2)?.id;
     if (!id)
@@ -21187,7 +21187,7 @@ var literalProcessor = (schema2, ctx, json2, _params) => {
     if (val === undefined) {
       if (ctx.unrepresentable === "throw") {
         throw new Error("Literal `undefined` cannot be represented in JSON Schema");
-      } else {}
+      }
     } else if (typeof val === "bigint") {
       if (ctx.unrepresentable === "throw") {
         throw new Error("BigInt literals cannot be represented in JSON Schema");
@@ -30541,395 +30541,3176 @@ function summarizeG003(nodeData) {
   };
 }
 
-// bin/postgres-ai.ts
-var nodeVersion = parseInt(process.versions.node.split(".")[0], 10);
-if (nodeVersion < 18) {
-  console.error(`\x1B[31mError: postgresai requires Node 18 or higher.\x1B[0m`);
-  console.error(`You are running Node.js ${process.versions.node}.`);
-  console.error(`Please upgrade to Node.js 20 LTS or Node.js 22 for security updates.`);
-  console.error(`
-Download: https://nodejs.org/`);
-  process.exit(1);
+// lib/instances.ts
+import * as fs7 from "fs";
+
+// node_modules/js-yaml/dist/js-yaml.mjs
+/*! js-yaml 4.1.1 https://github.com/nodeca/js-yaml @license MIT */
+function isNothing2(subject) {
+  return typeof subject === "undefined" || subject === null;
 }
-var rl = null;
-function getReadline() {
-  if (!rl) {
-    rl = createInterface({ input: process.stdin, output: process.stdout });
-  }
-  return rl;
+function isObject3(subject) {
+  return typeof subject === "object" && subject !== null;
 }
-function closeReadline() {
-  if (rl) {
-    rl.close();
-    rl = null;
-  }
+function toArray2(sequence) {
+  if (Array.isArray(sequence))
+    return sequence;
+  else if (isNothing2(sequence))
+    return [];
+  return [sequence];
 }
-function stripMatchingQuotes(value) {
-  const trimmed = value.trim();
-  const quote = trimmed[0];
-  if (trimmed.length >= 2 && (quote === '"' || quote === "'") && trimmed.endsWith(quote)) {
-    return trimmed.slice(1, -1);
+function extend4(target, source) {
+  var index, length, key, sourceKeys;
+  if (source) {
+    sourceKeys = Object.keys(source);
+    for (index = 0, length = sourceKeys.length;index < length; index += 1) {
+      key = sourceKeys[index];
+      target[key] = source[key];
+    }
   }
-  return trimmed;
-}
-async function execFilePromise(file, args) {
-  return new Promise((resolve8, reject) => {
-    childProcess.execFile(file, args, (error2, stdout, stderr) => {
-      if (error2) {
-        const err = error2;
-        err.code = typeof error2.code === "number" ? error2.code : 1;
-        reject(err);
-      } else {
-        resolve8({ stdout, stderr });
-      }
-    });
-  });
-}
-function spawnSync2(cmd, args, options) {
-  const result = childProcess.spawnSync(cmd, args, {
-    stdio: options?.stdio === "inherit" ? "inherit" : "pipe",
-    env: options?.env,
-    cwd: options?.cwd,
-    encoding: "utf8"
-  });
-  return {
-    status: result.status,
-    stdout: typeof result.stdout === "string" ? result.stdout : "",
-    stderr: typeof result.stderr === "string" ? result.stderr : ""
-  };
-}
-function spawn2(cmd, args, options) {
-  const proc = childProcess.spawn(cmd, args, {
-    stdio: options?.stdio ?? "pipe",
-    env: options?.env,
-    cwd: options?.cwd,
-    detached: options?.detached
-  });
-  return {
-    on(event, cb) {
-      if (event === "close" || event === "exit") {
-        proc.on(event, (code, signal) => cb(code, signal ?? undefined));
-      } else if (event === "error") {
-        proc.on("error", (err) => cb(null, String(err)));
-      }
-      return this;
-    },
-    unref() {
-      proc.unref();
-    },
-    pid: proc.pid
-  };
-}
-async function question(prompt) {
-  return new Promise((resolve8) => {
-    getReadline().question(prompt, (answer) => {
-      resolve8(answer);
-    });
-  });
+  return target;
 }
-function expandHomePath(p) {
-  const s = (p || "").trim();
-  if (!s)
-    return s;
-  if (s === "~")
-    return os3.homedir();
-  if (s.startsWith("~/") || s.startsWith("~\\")) {
-    return path7.join(os3.homedir(), s.slice(2));
+function repeat2(string4, count) {
+  var result = "", cycle;
+  for (cycle = 0;cycle < count; cycle += 1) {
+    result += string4;
   }
-  return s;
+  return result;
 }
-function createTtySpinner(enabled, initialText) {
-  if (!enabled) {
-    return {
-      update: () => {},
-      stop: () => {}
-    };
+function isNegativeZero2(number4) {
+  return number4 === 0 && Number.NEGATIVE_INFINITY === 1 / number4;
+}
+var isNothing_12 = isNothing2;
+var isObject_12 = isObject3;
+var toArray_12 = toArray2;
+var repeat_12 = repeat2;
+var isNegativeZero_12 = isNegativeZero2;
+var extend_12 = extend4;
+var common2 = {
+  isNothing: isNothing_12,
+  isObject: isObject_12,
+  toArray: toArray_12,
+  repeat: repeat_12,
+  isNegativeZero: isNegativeZero_12,
+  extend: extend_12
+};
+function formatError3(exception2, compact) {
+  var where = "", message = exception2.reason || "(unknown reason)";
+  if (!exception2.mark)
+    return message;
+  if (exception2.mark.name) {
+    where += 'in "' + exception2.mark.name + '" ';
   }
-  const frames = ["|", "/", "-", "\\"];
-  const startTs = Date.now();
-  let text = initialText;
-  let frameIdx = 0;
-  let stopped = false;
-  const render = () => {
-    if (stopped)
-      return;
-    const elapsedSec = ((Date.now() - startTs) / 1000).toFixed(1);
-    const frame = frames[frameIdx % frames.length] ?? frames[0] ?? "\u283F";
-    frameIdx += 1;
-    process.stdout.write(`\r\x1B[2K${frame} ${text} (${elapsedSec}s)`);
-  };
-  const timer = setInterval(render, 120);
-  render();
-  return {
-    update: (t) => {
-      text = t;
-      render();
-    },
-    stop: (finalText) => {
-      if (stopped)
-        return;
-      stopped = true;
-      clearInterval(timer);
-      process.stdout.write("\r\x1B[2K");
-      if (finalText && finalText.trim()) {
-        process.stdout.write(finalText);
-      }
-      process.stdout.write(`
-`);
-    }
-  };
+  where += "(" + (exception2.mark.line + 1) + ":" + (exception2.mark.column + 1) + ")";
+  if (!compact && exception2.mark.snippet) {
+    where += `
+
+` + exception2.mark.snippet;
+  }
+  return message + " " + where;
 }
-function prepareOutputDirectory(outputOpt) {
-  if (!outputOpt)
-    return;
-  const outputDir = expandHomePath(outputOpt);
-  const outputPath = path7.isAbsolute(outputDir) ? outputDir : path7.resolve(process.cwd(), outputDir);
-  if (!fs7.existsSync(outputPath)) {
-    try {
-      fs7.mkdirSync(outputPath, { recursive: true });
-    } catch (e) {
-      const errAny = e;
-      const code = typeof errAny?.code === "string" ? errAny.code : "";
-      const msg = errAny instanceof Error ? errAny.message : String(errAny);
-      if (code === "EACCES" || code === "EPERM" || code === "ENOENT") {
-        console.error(`Error: Failed to create output directory: ${outputPath}`);
-        console.error(`Reason: ${msg}`);
-        console.error("Tip: choose a writable path, e.g. --output ./reports or --output ~/reports");
-        return null;
-      }
-      throw e;
-    }
+function YAMLException$12(reason, mark) {
+  Error.call(this);
+  this.name = "YAMLException";
+  this.reason = reason;
+  this.mark = mark;
+  this.message = formatError3(this, false);
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(this, this.constructor);
+  } else {
+    this.stack = new Error().stack || "";
   }
-  return outputPath;
 }
-function prepareUploadConfig(opts, rootOpts, shouldUpload, uploadExplicitlyRequested) {
-  if (!shouldUpload)
-    return;
-  const { apiKey } = getConfig(rootOpts);
-  if (!apiKey) {
-    if (uploadExplicitlyRequested) {
-      console.error("Error: API key is required for upload");
-      console.error("Tip: run 'postgresai auth' or pass --api-key / set PGAI_API_KEY");
-      return null;
-    }
-    return;
+YAMLException$12.prototype = Object.create(Error.prototype);
+YAMLException$12.prototype.constructor = YAMLException$12;
+YAMLException$12.prototype.toString = function toString2(compact) {
+  return this.name + ": " + formatError3(this, compact);
+};
+var exception2 = YAMLException$12;
+function getLine2(buffer, lineStart, lineEnd, position, maxLineLength) {
+  var head = "";
+  var tail = "";
+  var maxHalfLength = Math.floor(maxLineLength / 2) - 1;
+  if (position - lineStart > maxHalfLength) {
+    head = " ... ";
+    lineStart = position - maxHalfLength + head.length;
   }
-  const cfg = readConfig();
-  const { apiBaseUrl } = resolveBaseUrls2(rootOpts, cfg);
-  let project = (opts.project || cfg.defaultProject || "").trim();
-  let projectWasGenerated = false;
-  if (!project) {
-    project = `project_${crypto2.randomBytes(6).toString("hex")}`;
-    projectWasGenerated = true;
-    try {
-      writeConfig({ defaultProject: project });
-    } catch (e) {
-      const message = e instanceof Error ? e.message : String(e);
-      console.error(`Warning: Failed to save generated default project: ${message}`);
-    }
+  if (lineEnd - position > maxHalfLength) {
+    tail = " ...";
+    lineEnd = position + maxHalfLength - tail.length;
   }
   return {
-    config: { apiKey, apiBaseUrl, project },
-    projectWasGenerated
+    str: head + buffer.slice(lineStart, lineEnd).replace(/\t/g, "→") + tail,
+    pos: position - lineStart + head.length
   };
 }
-async function uploadCheckupReports(uploadCfg, reports, spinner, logUpload) {
-  spinner.update("Creating remote checkup report");
-  const created = await withRetry(() => createCheckupReport({
-    apiKey: uploadCfg.apiKey,
-    apiBaseUrl: uploadCfg.apiBaseUrl,
-    project: uploadCfg.project
-  }), { maxAttempts: 3 }, (attempt, err, delayMs) => {
-    const errMsg = err instanceof Error ? err.message : String(err);
-    logUpload(`[Retry ${attempt}/3] createCheckupReport failed: ${errMsg}, retrying in ${delayMs}ms...`);
-  });
-  const reportId = created.reportId;
-  const uploaded = [];
-  for (const [checkId, report] of Object.entries(reports)) {
-    spinner.update(`Uploading ${checkId}.json`);
-    const jsonText = JSON.stringify(report, null, 2);
-    const r = await withRetry(() => uploadCheckupReportJson({
-      apiKey: uploadCfg.apiKey,
-      apiBaseUrl: uploadCfg.apiBaseUrl,
-      reportId,
-      filename: `${checkId}.json`,
-      checkId,
-      jsonText
-    }), { maxAttempts: 3 }, (attempt, err, delayMs) => {
-      const errMsg = err instanceof Error ? err.message : String(err);
-      logUpload(`[Retry ${attempt}/3] Upload ${checkId}.json failed: ${errMsg}, retrying in ${delayMs}ms...`);
-    });
-    uploaded.push({ checkId, filename: `${checkId}.json`, chunkId: r.reportChunkId });
-  }
-  return { project: uploadCfg.project, reportId, uploaded };
-}
-function writeReportFiles(reports, outputPath) {
-  for (const [checkId, report] of Object.entries(reports)) {
-    const filePath = path7.join(outputPath, `${checkId}.json`);
-    fs7.writeFileSync(filePath, JSON.stringify(report, null, 2), "utf8");
-    const title = report.checkTitle || checkId;
-    console.log(`\u2713 ${checkId} ${title}: ${filePath}`);
-  }
+function padStart2(string4, max) {
+  return common2.repeat(" ", max - string4.length) + string4;
 }
-function printUploadSummary(summary, projectWasGenerated, useStderr, reports) {
-  const out = useStderr ? console.error : console.log;
-  out(`
-Checkup report uploaded`);
-  out(`======================
-`);
-  if (projectWasGenerated) {
-    out(`Project: ${summary.project} (generated and saved as default)`);
-  } else {
-    out(`Project: ${summary.project}`);
-  }
-  out(`Report ID: ${summary.reportId}`);
-  out("View in Console: console.postgres.ai \u2192 Checkup \u2192 checkup reports");
-  out("");
-  const summaries = [];
-  let skippedCount = 0;
-  for (const item of summary.uploaded) {
-    const report = reports[item.checkId];
-    if (report) {
-      const { status, message } = generateCheckSummary(item.checkId, report);
-      const title = report.checkTitle || item.checkId;
-      const isSignificant = status !== "info" || /\d/.test(message) || message.includes("PostgreSQL") || message.includes("Version");
-      if (isSignificant) {
-        summaries.push({ checkId: item.checkId, title, status, message });
-      } else {
-        skippedCount++;
-      }
+function makeSnippet2(mark, options) {
+  options = Object.create(options || null);
+  if (!mark.buffer)
+    return null;
+  if (!options.maxLength)
+    options.maxLength = 79;
+  if (typeof options.indent !== "number")
+    options.indent = 1;
+  if (typeof options.linesBefore !== "number")
+    options.linesBefore = 3;
+  if (typeof options.linesAfter !== "number")
+    options.linesAfter = 2;
+  var re = /\r?\n|\r|\0/g;
+  var lineStarts = [0];
+  var lineEnds = [];
+  var match;
+  var foundLineNo = -1;
+  while (match = re.exec(mark.buffer)) {
+    lineEnds.push(match.index);
+    lineStarts.push(match.index + match[0].length);
+    if (mark.position <= match.index && foundLineNo < 0) {
+      foundLineNo = lineStarts.length - 2;
     }
   }
-  for (const { checkId, title, message } of summaries) {
-    out(`  ${checkId} (${title}): ${message}`);
+  if (foundLineNo < 0)
+    foundLineNo = lineStarts.length - 1;
+  var result = "", i2, line;
+  var lineNoLength = Math.min(mark.line + options.linesAfter, lineEnds.length).toString().length;
+  var maxLineLength = options.maxLength - (options.indent + lineNoLength + 3);
+  for (i2 = 1;i2 <= options.linesBefore; i2++) {
+    if (foundLineNo - i2 < 0)
+      break;
+    line = getLine2(mark.buffer, lineStarts[foundLineNo - i2], lineEnds[foundLineNo - i2], mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo - i2]), maxLineLength);
+    result = common2.repeat(" ", options.indent) + padStart2((mark.line - i2 + 1).toString(), lineNoLength) + " | " + line.str + `
+` + result;
   }
-  if (skippedCount > 0) {
-    out(`  ${skippedCount} other check${skippedCount > 1 ? "s" : ""} completed`);
+  line = getLine2(mark.buffer, lineStarts[foundLineNo], lineEnds[foundLineNo], mark.position, maxLineLength);
+  result += common2.repeat(" ", options.indent) + padStart2((mark.line + 1).toString(), lineNoLength) + " | " + line.str + `
+`;
+  result += common2.repeat("-", options.indent + lineNoLength + 3 + line.pos) + "^" + `
+`;
+  for (i2 = 1;i2 <= options.linesAfter; i2++) {
+    if (foundLineNo + i2 >= lineEnds.length)
+      break;
+    line = getLine2(mark.buffer, lineStarts[foundLineNo + i2], lineEnds[foundLineNo + i2], mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo + i2]), maxLineLength);
+    result += common2.repeat(" ", options.indent) + padStart2((mark.line + i2 + 1).toString(), lineNoLength) + " | " + line.str + `
+`;
   }
+  return result.replace(/\n$/, "");
 }
-function getDefaultMonitoringProjectDir() {
-  const override = process.env.PGAI_PROJECT_DIR;
-  if (override && override.trim())
-    return override.trim();
-  return path7.join(getConfigDir(), "monitoring");
+var snippet2 = makeSnippet2;
+var TYPE_CONSTRUCTOR_OPTIONS2 = [
+  "kind",
+  "multi",
+  "resolve",
+  "construct",
+  "instanceOf",
+  "predicate",
+  "represent",
+  "representName",
+  "defaultStyle",
+  "styleAliases"
+];
+var YAML_NODE_KINDS2 = [
+  "scalar",
+  "sequence",
+  "mapping"
+];
+function compileStyleAliases2(map3) {
+  var result = {};
+  if (map3 !== null) {
+    Object.keys(map3).forEach(function(style) {
+      map3[style].forEach(function(alias) {
+        result[String(alias)] = style;
+      });
+    });
+  }
+  return result;
 }
-async function downloadText(url) {
-  const controller = new AbortController;
-  const timeout = setTimeout(() => controller.abort(), 15000);
-  try {
-    const response = await fetch(url, { signal: controller.signal });
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status} for ${url}`);
+function Type$12(tag, options) {
+  options = options || {};
+  Object.keys(options).forEach(function(name) {
+    if (TYPE_CONSTRUCTOR_OPTIONS2.indexOf(name) === -1) {
+      throw new exception2('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.');
     }
-    return await response.text();
-  } finally {
-    clearTimeout(timeout);
+  });
+  this.options = options;
+  this.tag = tag;
+  this.kind = options["kind"] || null;
+  this.resolve = options["resolve"] || function() {
+    return true;
+  };
+  this.construct = options["construct"] || function(data) {
+    return data;
+  };
+  this.instanceOf = options["instanceOf"] || null;
+  this.predicate = options["predicate"] || null;
+  this.represent = options["represent"] || null;
+  this.representName = options["representName"] || null;
+  this.defaultStyle = options["defaultStyle"] || null;
+  this.multi = options["multi"] || false;
+  this.styleAliases = compileStyleAliases2(options["styleAliases"] || null);
+  if (YAML_NODE_KINDS2.indexOf(this.kind) === -1) {
+    throw new exception2('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.');
   }
 }
-async function ensureDefaultMonitoringProject() {
-  const projectDir = getDefaultMonitoringProjectDir();
-  const composeFile = path7.resolve(projectDir, "docker-compose.yml");
-  const instancesFile = path7.resolve(projectDir, "instances.yml");
-  if (!fs7.existsSync(projectDir)) {
-    fs7.mkdirSync(projectDir, { recursive: true, mode: 448 });
-  }
-  if (!fs7.existsSync(composeFile)) {
-    const refs = [
-      process.env.PGAI_PROJECT_REF,
-      package_default.version,
-      `v${package_default.version}`,
-      "main"
-    ].filter((v) => Boolean(v && v.trim()));
-    let lastErr;
-    for (const ref of refs) {
-      const url = `https://gitlab.com/postgres-ai/postgres_ai/-/raw/${encodeURIComponent(ref)}/docker-compose.yml`;
-      try {
-        const text = await downloadText(url);
-        fs7.writeFileSync(composeFile, text, { encoding: "utf8", mode: 384 });
-        break;
-      } catch (err) {
-        lastErr = err;
+var type2 = Type$12;
+function compileList2(schema2, name) {
+  var result = [];
+  schema2[name].forEach(function(currentType) {
+    var newIndex = result.length;
+    result.forEach(function(previousType, previousIndex) {
+      if (previousType.tag === currentType.tag && previousType.kind === currentType.kind && previousType.multi === currentType.multi) {
+        newIndex = previousIndex;
       }
+    });
+    result[newIndex] = currentType;
+  });
+  return result;
+}
+function compileMap2() {
+  var result = {
+    scalar: {},
+    sequence: {},
+    mapping: {},
+    fallback: {},
+    multi: {
+      scalar: [],
+      sequence: [],
+      mapping: [],
+      fallback: []
     }
-    if (!fs7.existsSync(composeFile)) {
-      const msg = lastErr instanceof Error ? lastErr.message : String(lastErr);
-      throw new Error(`Failed to bootstrap docker-compose.yml: ${msg}`);
+  }, index, length;
+  function collectType(type3) {
+    if (type3.multi) {
+      result.multi[type3.kind].push(type3);
+      result.multi["fallback"].push(type3);
+    } else {
+      result[type3.kind][type3.tag] = result["fallback"][type3.tag] = type3;
     }
   }
-  if (fs7.existsSync(instancesFile) && fs7.lstatSync(instancesFile).isDirectory()) {
-    fs7.rmSync(instancesFile, { recursive: true, force: true });
-  }
-  if (!fs7.existsSync(instancesFile)) {
-    const header = `# PostgreSQL instances to monitor
-` + `# Add your instances using: pgai mon targets add <connection-string> <name>
-
-`;
-    fs7.writeFileSync(instancesFile, header, { encoding: "utf8", mode: 384 });
-  }
-  const pgwatchConfig = path7.resolve(projectDir, ".pgwatch-config");
-  if (!fs7.existsSync(pgwatchConfig)) {
-    fs7.writeFileSync(pgwatchConfig, "", { encoding: "utf8", mode: 384 });
-  }
-  const envFile = path7.resolve(projectDir, ".env");
-  if (!fs7.existsSync(envFile)) {
-    const envText = `PGAI_TAG=${package_default.version}
-# PGAI_REGISTRY=registry.gitlab.com/postgres-ai/postgres_ai
-`;
-    fs7.writeFileSync(envFile, envText, { encoding: "utf8", mode: 384 });
+  for (index = 0, length = arguments.length;index < length; index += 1) {
+    arguments[index].forEach(collectType);
   }
-  return { fs: fs7, path: path7, projectDir, composeFile, instancesFile };
+  return result;
 }
-function getConfig(opts) {
-  let apiKey = opts.apiKey || process.env.PGAI_API_KEY || "";
-  if (!apiKey) {
-    const fileConfig = readConfig();
-    if (!apiKey)
-      apiKey = fileConfig.apiKey || "";
-  }
-  return { apiKey };
+function Schema$12(definition) {
+  return this.extend(definition);
 }
-function printResult(result, json2) {
-  if (typeof result === "string") {
-    process.stdout.write(result);
-    if (!/\n$/.test(result))
-      console.log();
-    return;
-  }
-  if (json2 || !process.stdout.isTTY) {
-    console.log(JSON.stringify(result, null, 2));
+Schema$12.prototype.extend = function extend5(definition) {
+  var implicit = [];
+  var explicit = [];
+  if (definition instanceof type2) {
+    explicit.push(definition);
+  } else if (Array.isArray(definition)) {
+    explicit = explicit.concat(definition);
+  } else if (definition && (Array.isArray(definition.implicit) || Array.isArray(definition.explicit))) {
+    if (definition.implicit)
+      implicit = implicit.concat(definition.implicit);
+    if (definition.explicit)
+      explicit = explicit.concat(definition.explicit);
   } else {
-    let text = dump(result);
-    if (Array.isArray(result)) {
-      text = text.replace(/\n- /g, `
-
-- `);
+    throw new exception2("Schema.extend argument should be a Type, [ Type ], " + "or a schema definition ({ implicit: [...], explicit: [...] })");
+  }
+  implicit.forEach(function(type$1) {
+    if (!(type$1 instanceof type2)) {
+      throw new exception2("Specified list of YAML types (or a single Type object) contains a non-Type object.");
     }
-    console.log(text);
+    if (type$1.loadKind && type$1.loadKind !== "scalar") {
+      throw new exception2("There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.");
+    }
+    if (type$1.multi) {
+      throw new exception2("There is a multi type in the implicit list of a schema. Multi tags can only be listed as explicit.");
+    }
+  });
+  explicit.forEach(function(type$1) {
+    if (!(type$1 instanceof type2)) {
+      throw new exception2("Specified list of YAML types (or a single Type object) contains a non-Type object.");
+    }
+  });
+  var result = Object.create(Schema$12.prototype);
+  result.implicit = (this.implicit || []).concat(implicit);
+  result.explicit = (this.explicit || []).concat(explicit);
+  result.compiledImplicit = compileList2(result, "implicit");
+  result.compiledExplicit = compileList2(result, "explicit");
+  result.compiledTypeMap = compileMap2(result.compiledImplicit, result.compiledExplicit);
+  return result;
+};
+var schema2 = Schema$12;
+var str2 = new type2("tag:yaml.org,2002:str", {
+  kind: "scalar",
+  construct: function(data) {
+    return data !== null ? data : "";
   }
-}
-var program2 = new Command;
-program2.name("postgres-ai").description("PostgresAI CLI").version(package_default.version).option("--api-key <key>", "API key (overrides PGAI_API_KEY)").option("--api-base-url <url>", "API base URL for backend RPC (overrides PGAI_API_BASE_URL)").option("--ui-base-url <url>", "UI base URL for browser routes (overrides PGAI_UI_BASE_URL)").option("--storage-base-url <url>", "Storage base URL for file uploads (overrides PGAI_STORAGE_BASE_URL)");
-program2.command("set-default-project <project>").description("store default project for checkup uploads").action(async (project) => {
-  const value = (project || "").trim();
-  if (!value) {
-    console.error("Error: project is required");
-    process.exitCode = 1;
-    return;
+});
+var seq2 = new type2("tag:yaml.org,2002:seq", {
+  kind: "sequence",
+  construct: function(data) {
+    return data !== null ? data : [];
   }
-  writeConfig({ defaultProject: value });
-  console.log(`Default project saved: ${value}`);
 });
-program2.command("set-storage-url <url>").description("store storage base URL for file uploads").action(async (url) => {
-  const value = (url || "").trim();
-  if (!value) {
-    console.error("Error: url is required");
-    process.exitCode = 1;
-    return;
+var map3 = new type2("tag:yaml.org,2002:map", {
+  kind: "mapping",
+  construct: function(data) {
+    return data !== null ? data : {};
   }
-  try {
-    const { normalizeBaseUrl: normalizeBaseUrl3 } = await Promise.resolve().then(() => (init_util(), exports_util2));
-    const normalized = normalizeBaseUrl3(value);
-    writeConfig({ storageBaseUrl: normalized });
+});
+var failsafe2 = new schema2({
+  explicit: [
+    str2,
+    seq2,
+    map3
+  ]
+});
+function resolveYamlNull2(data) {
+  if (data === null)
+    return true;
+  var max = data.length;
+  return max === 1 && data === "~" || max === 4 && (data === "null" || data === "Null" || data === "NULL");
+}
+function constructYamlNull2() {
+  return null;
+}
+function isNull2(object4) {
+  return object4 === null;
+}
+var _null5 = new type2("tag:yaml.org,2002:null", {
+  kind: "scalar",
+  resolve: resolveYamlNull2,
+  construct: constructYamlNull2,
+  predicate: isNull2,
+  represent: {
+    canonical: function() {
+      return "~";
+    },
+    lowercase: function() {
+      return "null";
+    },
+    uppercase: function() {
+      return "NULL";
+    },
+    camelcase: function() {
+      return "Null";
+    },
+    empty: function() {
+      return "";
+    }
+  },
+  defaultStyle: "lowercase"
+});
+function resolveYamlBoolean2(data) {
+  if (data === null)
+    return false;
+  var max = data.length;
+  return max === 4 && (data === "true" || data === "True" || data === "TRUE") || max === 5 && (data === "false" || data === "False" || data === "FALSE");
+}
+function constructYamlBoolean2(data) {
+  return data === "true" || data === "True" || data === "TRUE";
+}
+function isBoolean2(object4) {
+  return Object.prototype.toString.call(object4) === "[object Boolean]";
+}
+var bool2 = new type2("tag:yaml.org,2002:bool", {
+  kind: "scalar",
+  resolve: resolveYamlBoolean2,
+  construct: constructYamlBoolean2,
+  predicate: isBoolean2,
+  represent: {
+    lowercase: function(object4) {
+      return object4 ? "true" : "false";
+    },
+    uppercase: function(object4) {
+      return object4 ? "TRUE" : "FALSE";
+    },
+    camelcase: function(object4) {
+      return object4 ? "True" : "False";
+    }
+  },
+  defaultStyle: "lowercase"
+});
+function isHexCode2(c) {
+  return 48 <= c && c <= 57 || 65 <= c && c <= 70 || 97 <= c && c <= 102;
+}
+function isOctCode2(c) {
+  return 48 <= c && c <= 55;
+}
+function isDecCode2(c) {
+  return 48 <= c && c <= 57;
+}
+function resolveYamlInteger2(data) {
+  if (data === null)
+    return false;
+  var max = data.length, index = 0, hasDigits = false, ch;
+  if (!max)
+    return false;
+  ch = data[index];
+  if (ch === "-" || ch === "+") {
+    ch = data[++index];
+  }
+  if (ch === "0") {
+    if (index + 1 === max)
+      return true;
+    ch = data[++index];
+    if (ch === "b") {
+      index++;
+      for (;index < max; index++) {
+        ch = data[index];
+        if (ch === "_")
+          continue;
+        if (ch !== "0" && ch !== "1")
+          return false;
+        hasDigits = true;
+      }
+      return hasDigits && ch !== "_";
+    }
+    if (ch === "x") {
+      index++;
+      for (;index < max; index++) {
+        ch = data[index];
+        if (ch === "_")
+          continue;
+        if (!isHexCode2(data.charCodeAt(index)))
+          return false;
+        hasDigits = true;
+      }
+      return hasDigits && ch !== "_";
+    }
+    if (ch === "o") {
+      index++;
+      for (;index < max; index++) {
+        ch = data[index];
+        if (ch === "_")
+          continue;
+        if (!isOctCode2(data.charCodeAt(index)))
+          return false;
+        hasDigits = true;
+      }
+      return hasDigits && ch !== "_";
+    }
+  }
+  if (ch === "_")
+    return false;
+  for (;index < max; index++) {
+    ch = data[index];
+    if (ch === "_")
+      continue;
+    if (!isDecCode2(data.charCodeAt(index))) {
+      return false;
+    }
+    hasDigits = true;
+  }
+  if (!hasDigits || ch === "_")
+    return false;
+  return true;
+}
+function constructYamlInteger2(data) {
+  var value = data, sign = 1, ch;
+  if (value.indexOf("_") !== -1) {
+    value = value.replace(/_/g, "");
+  }
+  ch = value[0];
+  if (ch === "-" || ch === "+") {
+    if (ch === "-")
+      sign = -1;
+    value = value.slice(1);
+    ch = value[0];
+  }
+  if (value === "0")
+    return 0;
+  if (ch === "0") {
+    if (value[1] === "b")
+      return sign * parseInt(value.slice(2), 2);
+    if (value[1] === "x")
+      return sign * parseInt(value.slice(2), 16);
+    if (value[1] === "o")
+      return sign * parseInt(value.slice(2), 8);
+  }
+  return sign * parseInt(value, 10);
+}
+function isInteger2(object4) {
+  return Object.prototype.toString.call(object4) === "[object Number]" && (object4 % 1 === 0 && !common2.isNegativeZero(object4));
+}
+var int3 = new type2("tag:yaml.org,2002:int", {
+  kind: "scalar",
+  resolve: resolveYamlInteger2,
+  construct: constructYamlInteger2,
+  predicate: isInteger2,
+  represent: {
+    binary: function(obj) {
+      return obj >= 0 ? "0b" + obj.toString(2) : "-0b" + obj.toString(2).slice(1);
+    },
+    octal: function(obj) {
+      return obj >= 0 ? "0o" + obj.toString(8) : "-0o" + obj.toString(8).slice(1);
+    },
+    decimal: function(obj) {
+      return obj.toString(10);
+    },
+    hexadecimal: function(obj) {
+      return obj >= 0 ? "0x" + obj.toString(16).toUpperCase() : "-0x" + obj.toString(16).toUpperCase().slice(1);
+    }
+  },
+  defaultStyle: "decimal",
+  styleAliases: {
+    binary: [2, "bin"],
+    octal: [8, "oct"],
+    decimal: [10, "dec"],
+    hexadecimal: [16, "hex"]
+  }
+});
+var YAML_FLOAT_PATTERN2 = new RegExp("^(?:[-+]?(?:[0-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?" + "|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?" + "|[-+]?\\.(?:inf|Inf|INF)" + "|\\.(?:nan|NaN|NAN))$");
+function resolveYamlFloat2(data) {
+  if (data === null)
+    return false;
+  if (!YAML_FLOAT_PATTERN2.test(data) || data[data.length - 1] === "_") {
+    return false;
+  }
+  return true;
+}
+function constructYamlFloat2(data) {
+  var value, sign;
+  value = data.replace(/_/g, "").toLowerCase();
+  sign = value[0] === "-" ? -1 : 1;
+  if ("+-".indexOf(value[0]) >= 0) {
+    value = value.slice(1);
+  }
+  if (value === ".inf") {
+    return sign === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
+  } else if (value === ".nan") {
+    return NaN;
+  }
+  return sign * parseFloat(value, 10);
+}
+var SCIENTIFIC_WITHOUT_DOT2 = /^[-+]?[0-9]+e/;
+function representYamlFloat2(object4, style) {
+  var res;
+  if (isNaN(object4)) {
+    switch (style) {
+      case "lowercase":
+        return ".nan";
+      case "uppercase":
+        return ".NAN";
+      case "camelcase":
+        return ".NaN";
+    }
+  } else if (Number.POSITIVE_INFINITY === object4) {
+    switch (style) {
+      case "lowercase":
+        return ".inf";
+      case "uppercase":
+        return ".INF";
+      case "camelcase":
+        return ".Inf";
+    }
+  } else if (Number.NEGATIVE_INFINITY === object4) {
+    switch (style) {
+      case "lowercase":
+        return "-.inf";
+      case "uppercase":
+        return "-.INF";
+      case "camelcase":
+        return "-.Inf";
+    }
+  } else if (common2.isNegativeZero(object4)) {
+    return "-0.0";
+  }
+  res = object4.toString(10);
+  return SCIENTIFIC_WITHOUT_DOT2.test(res) ? res.replace("e", ".e") : res;
+}
+function isFloat2(object4) {
+  return Object.prototype.toString.call(object4) === "[object Number]" && (object4 % 1 !== 0 || common2.isNegativeZero(object4));
+}
+var float2 = new type2("tag:yaml.org,2002:float", {
+  kind: "scalar",
+  resolve: resolveYamlFloat2,
+  construct: constructYamlFloat2,
+  predicate: isFloat2,
+  represent: representYamlFloat2,
+  defaultStyle: "lowercase"
+});
+var json2 = failsafe2.extend({
+  implicit: [
+    _null5,
+    bool2,
+    int3,
+    float2
+  ]
+});
+var core3 = json2;
+var YAML_DATE_REGEXP2 = new RegExp("^([0-9][0-9][0-9][0-9])" + "-([0-9][0-9])" + "-([0-9][0-9])$");
+var YAML_TIMESTAMP_REGEXP2 = new RegExp("^([0-9][0-9][0-9][0-9])" + "-([0-9][0-9]?)" + "-([0-9][0-9]?)" + "(?:[Tt]|[ \\t]+)" + "([0-9][0-9]?)" + ":([0-9][0-9])" + ":([0-9][0-9])" + "(?:\\.([0-9]*))?" + "(?:[ \\t]*(Z|([-+])([0-9][0-9]?)" + "(?::([0-9][0-9]))?))?$");
+function resolveYamlTimestamp2(data) {
+  if (data === null)
+    return false;
+  if (YAML_DATE_REGEXP2.exec(data) !== null)
+    return true;
+  if (YAML_TIMESTAMP_REGEXP2.exec(data) !== null)
+    return true;
+  return false;
+}
+function constructYamlTimestamp2(data) {
+  var match, year, month, day, hour, minute, second, fraction = 0, delta = null, tz_hour, tz_minute, date4;
+  match = YAML_DATE_REGEXP2.exec(data);
+  if (match === null)
+    match = YAML_TIMESTAMP_REGEXP2.exec(data);
+  if (match === null)
+    throw new Error("Date resolve error");
+  year = +match[1];
+  month = +match[2] - 1;
+  day = +match[3];
+  if (!match[4]) {
+    return new Date(Date.UTC(year, month, day));
+  }
+  hour = +match[4];
+  minute = +match[5];
+  second = +match[6];
+  if (match[7]) {
+    fraction = match[7].slice(0, 3);
+    while (fraction.length < 3) {
+      fraction += "0";
+    }
+    fraction = +fraction;
+  }
+  if (match[9]) {
+    tz_hour = +match[10];
+    tz_minute = +(match[11] || 0);
+    delta = (tz_hour * 60 + tz_minute) * 60000;
+    if (match[9] === "-")
+      delta = -delta;
+  }
+  date4 = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
+  if (delta)
+    date4.setTime(date4.getTime() - delta);
+  return date4;
+}
+function representYamlTimestamp2(object4) {
+  return object4.toISOString();
+}
+var timestamp2 = new type2("tag:yaml.org,2002:timestamp", {
+  kind: "scalar",
+  resolve: resolveYamlTimestamp2,
+  construct: constructYamlTimestamp2,
+  instanceOf: Date,
+  represent: representYamlTimestamp2
+});
+function resolveYamlMerge2(data) {
+  return data === "<<" || data === null;
+}
+var merge3 = new type2("tag:yaml.org,2002:merge", {
+  kind: "scalar",
+  resolve: resolveYamlMerge2
+});
+var BASE64_MAP2 = `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=
+\r`;
+function resolveYamlBinary2(data) {
+  if (data === null)
+    return false;
+  var code, idx, bitlen = 0, max = data.length, map4 = BASE64_MAP2;
+  for (idx = 0;idx < max; idx++) {
+    code = map4.indexOf(data.charAt(idx));
+    if (code > 64)
+      continue;
+    if (code < 0)
+      return false;
+    bitlen += 6;
+  }
+  return bitlen % 8 === 0;
+}
+function constructYamlBinary2(data) {
+  var idx, tailbits, input = data.replace(/[\r\n=]/g, ""), max = input.length, map4 = BASE64_MAP2, bits = 0, result = [];
+  for (idx = 0;idx < max; idx++) {
+    if (idx % 4 === 0 && idx) {
+      result.push(bits >> 16 & 255);
+      result.push(bits >> 8 & 255);
+      result.push(bits & 255);
+    }
+    bits = bits << 6 | map4.indexOf(input.charAt(idx));
+  }
+  tailbits = max % 4 * 6;
+  if (tailbits === 0) {
+    result.push(bits >> 16 & 255);
+    result.push(bits >> 8 & 255);
+    result.push(bits & 255);
+  } else if (tailbits === 18) {
+    result.push(bits >> 10 & 255);
+    result.push(bits >> 2 & 255);
+  } else if (tailbits === 12) {
+    result.push(bits >> 4 & 255);
+  }
+  return new Uint8Array(result);
+}
+function representYamlBinary2(object4) {
+  var result = "", bits = 0, idx, tail, max = object4.length, map4 = BASE64_MAP2;
+  for (idx = 0;idx < max; idx++) {
+    if (idx % 3 === 0 && idx) {
+      result += map4[bits >> 18 & 63];
+      result += map4[bits >> 12 & 63];
+      result += map4[bits >> 6 & 63];
+      result += map4[bits & 63];
+    }
+    bits = (bits << 8) + object4[idx];
+  }
+  tail = max % 3;
+  if (tail === 0) {
+    result += map4[bits >> 18 & 63];
+    result += map4[bits >> 12 & 63];
+    result += map4[bits >> 6 & 63];
+    result += map4[bits & 63];
+  } else if (tail === 2) {
+    result += map4[bits >> 10 & 63];
+    result += map4[bits >> 4 & 63];
+    result += map4[bits << 2 & 63];
+    result += map4[64];
+  } else if (tail === 1) {
+    result += map4[bits >> 2 & 63];
+    result += map4[bits << 4 & 63];
+    result += map4[64];
+    result += map4[64];
+  }
+  return result;
+}
+function isBinary2(obj) {
+  return Object.prototype.toString.call(obj) === "[object Uint8Array]";
+}
+var binary2 = new type2("tag:yaml.org,2002:binary", {
+  kind: "scalar",
+  resolve: resolveYamlBinary2,
+  construct: constructYamlBinary2,
+  predicate: isBinary2,
+  represent: representYamlBinary2
+});
+var _hasOwnProperty$32 = Object.prototype.hasOwnProperty;
+var _toString$22 = Object.prototype.toString;
+function resolveYamlOmap2(data) {
+  if (data === null)
+    return true;
+  var objectKeys = [], index, length, pair, pairKey, pairHasKey, object4 = data;
+  for (index = 0, length = object4.length;index < length; index += 1) {
+    pair = object4[index];
+    pairHasKey = false;
+    if (_toString$22.call(pair) !== "[object Object]")
+      return false;
+    for (pairKey in pair) {
+      if (_hasOwnProperty$32.call(pair, pairKey)) {
+        if (!pairHasKey)
+          pairHasKey = true;
+        else
+          return false;
+      }
+    }
+    if (!pairHasKey)
+      return false;
+    if (objectKeys.indexOf(pairKey) === -1)
+      objectKeys.push(pairKey);
+    else
+      return false;
+  }
+  return true;
+}
+function constructYamlOmap2(data) {
+  return data !== null ? data : [];
+}
+var omap2 = new type2("tag:yaml.org,2002:omap", {
+  kind: "sequence",
+  resolve: resolveYamlOmap2,
+  construct: constructYamlOmap2
+});
+var _toString$12 = Object.prototype.toString;
+function resolveYamlPairs2(data) {
+  if (data === null)
+    return true;
+  var index, length, pair, keys, result, object4 = data;
+  result = new Array(object4.length);
+  for (index = 0, length = object4.length;index < length; index += 1) {
+    pair = object4[index];
+    if (_toString$12.call(pair) !== "[object Object]")
+      return false;
+    keys = Object.keys(pair);
+    if (keys.length !== 1)
+      return false;
+    result[index] = [keys[0], pair[keys[0]]];
+  }
+  return true;
+}
+function constructYamlPairs2(data) {
+  if (data === null)
+    return [];
+  var index, length, pair, keys, result, object4 = data;
+  result = new Array(object4.length);
+  for (index = 0, length = object4.length;index < length; index += 1) {
+    pair = object4[index];
+    keys = Object.keys(pair);
+    result[index] = [keys[0], pair[keys[0]]];
+  }
+  return result;
+}
+var pairs2 = new type2("tag:yaml.org,2002:pairs", {
+  kind: "sequence",
+  resolve: resolveYamlPairs2,
+  construct: constructYamlPairs2
+});
+var _hasOwnProperty$22 = Object.prototype.hasOwnProperty;
+function resolveYamlSet2(data) {
+  if (data === null)
+    return true;
+  var key, object4 = data;
+  for (key in object4) {
+    if (_hasOwnProperty$22.call(object4, key)) {
+      if (object4[key] !== null)
+        return false;
+    }
+  }
+  return true;
+}
+function constructYamlSet2(data) {
+  return data !== null ? data : {};
+}
+var set3 = new type2("tag:yaml.org,2002:set", {
+  kind: "mapping",
+  resolve: resolveYamlSet2,
+  construct: constructYamlSet2
+});
+var _default3 = core3.extend({
+  implicit: [
+    timestamp2,
+    merge3
+  ],
+  explicit: [
+    binary2,
+    omap2,
+    pairs2,
+    set3
+  ]
+});
+var _hasOwnProperty$12 = Object.prototype.hasOwnProperty;
+var CONTEXT_FLOW_IN2 = 1;
+var CONTEXT_FLOW_OUT2 = 2;
+var CONTEXT_BLOCK_IN2 = 3;
+var CONTEXT_BLOCK_OUT2 = 4;
+var CHOMPING_CLIP2 = 1;
+var CHOMPING_STRIP2 = 2;
+var CHOMPING_KEEP2 = 3;
+var PATTERN_NON_PRINTABLE2 = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
+var PATTERN_NON_ASCII_LINE_BREAKS2 = /[\x85\u2028\u2029]/;
+var PATTERN_FLOW_INDICATORS2 = /[,\[\]\{\}]/;
+var PATTERN_TAG_HANDLE2 = /^(?:!|!!|![a-z\-]+!)$/i;
+var PATTERN_TAG_URI2 = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i;
+function _class2(obj) {
+  return Object.prototype.toString.call(obj);
+}
+function is_EOL2(c) {
+  return c === 10 || c === 13;
+}
+function is_WHITE_SPACE2(c) {
+  return c === 9 || c === 32;
+}
+function is_WS_OR_EOL2(c) {
+  return c === 9 || c === 32 || c === 10 || c === 13;
+}
+function is_FLOW_INDICATOR2(c) {
+  return c === 44 || c === 91 || c === 93 || c === 123 || c === 125;
+}
+function fromHexCode2(c) {
+  var lc;
+  if (48 <= c && c <= 57) {
+    return c - 48;
+  }
+  lc = c | 32;
+  if (97 <= lc && lc <= 102) {
+    return lc - 97 + 10;
+  }
+  return -1;
+}
+function escapedHexLen2(c) {
+  if (c === 120) {
+    return 2;
+  }
+  if (c === 117) {
+    return 4;
+  }
+  if (c === 85) {
+    return 8;
+  }
+  return 0;
+}
+function fromDecimalCode2(c) {
+  if (48 <= c && c <= 57) {
+    return c - 48;
+  }
+  return -1;
+}
+function simpleEscapeSequence2(c) {
+  return c === 48 ? "\x00" : c === 97 ? "\x07" : c === 98 ? "\b" : c === 116 ? "\t" : c === 9 ? "\t" : c === 110 ? `
+` : c === 118 ? "\v" : c === 102 ? "\f" : c === 114 ? "\r" : c === 101 ? "\x1B" : c === 32 ? " " : c === 34 ? '"' : c === 47 ? "/" : c === 92 ? "\\" : c === 78 ? "…" : c === 95 ? " " : c === 76 ? "\u2028" : c === 80 ? "\u2029" : "";
+}
+function charFromCodepoint2(c) {
+  if (c <= 65535) {
+    return String.fromCharCode(c);
+  }
+  return String.fromCharCode((c - 65536 >> 10) + 55296, (c - 65536 & 1023) + 56320);
+}
+function setProperty2(object4, key, value) {
+  if (key === "__proto__") {
+    Object.defineProperty(object4, key, {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value
+    });
+  } else {
+    object4[key] = value;
+  }
+}
+var simpleEscapeCheck2 = new Array(256);
+var simpleEscapeMap2 = new Array(256);
+for (i2 = 0;i2 < 256; i2++) {
+  simpleEscapeCheck2[i2] = simpleEscapeSequence2(i2) ? 1 : 0;
+  simpleEscapeMap2[i2] = simpleEscapeSequence2(i2);
+}
+var i2;
+function State$12(input, options) {
+  this.input = input;
+  this.filename = options["filename"] || null;
+  this.schema = options["schema"] || _default3;
+  this.onWarning = options["onWarning"] || null;
+  this.legacy = options["legacy"] || false;
+  this.json = options["json"] || false;
+  this.listener = options["listener"] || null;
+  this.implicitTypes = this.schema.compiledImplicit;
+  this.typeMap = this.schema.compiledTypeMap;
+  this.length = input.length;
+  this.position = 0;
+  this.line = 0;
+  this.lineStart = 0;
+  this.lineIndent = 0;
+  this.firstTabInLine = -1;
+  this.documents = [];
+}
+function generateError2(state, message) {
+  var mark = {
+    name: state.filename,
+    buffer: state.input.slice(0, -1),
+    position: state.position,
+    line: state.line,
+    column: state.position - state.lineStart
+  };
+  mark.snippet = snippet2(mark);
+  return new exception2(message, mark);
+}
+function throwError2(state, message) {
+  throw generateError2(state, message);
+}
+function throwWarning2(state, message) {
+  if (state.onWarning) {
+    state.onWarning.call(null, generateError2(state, message));
+  }
+}
+var directiveHandlers2 = {
+  YAML: function handleYamlDirective2(state, name, args) {
+    var match, major, minor;
+    if (state.version !== null) {
+      throwError2(state, "duplication of %YAML directive");
+    }
+    if (args.length !== 1) {
+      throwError2(state, "YAML directive accepts exactly one argument");
+    }
+    match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
+    if (match === null) {
+      throwError2(state, "ill-formed argument of the YAML directive");
+    }
+    major = parseInt(match[1], 10);
+    minor = parseInt(match[2], 10);
+    if (major !== 1) {
+      throwError2(state, "unacceptable YAML version of the document");
+    }
+    state.version = args[0];
+    state.checkLineBreaks = minor < 2;
+    if (minor !== 1 && minor !== 2) {
+      throwWarning2(state, "unsupported YAML version of the document");
+    }
+  },
+  TAG: function handleTagDirective2(state, name, args) {
+    var handle, prefix;
+    if (args.length !== 2) {
+      throwError2(state, "TAG directive accepts exactly two arguments");
+    }
+    handle = args[0];
+    prefix = args[1];
+    if (!PATTERN_TAG_HANDLE2.test(handle)) {
+      throwError2(state, "ill-formed tag handle (first argument) of the TAG directive");
+    }
+    if (_hasOwnProperty$12.call(state.tagMap, handle)) {
+      throwError2(state, 'there is a previously declared suffix for "' + handle + '" tag handle');
+    }
+    if (!PATTERN_TAG_URI2.test(prefix)) {
+      throwError2(state, "ill-formed tag prefix (second argument) of the TAG directive");
+    }
+    try {
+      prefix = decodeURIComponent(prefix);
+    } catch (err) {
+      throwError2(state, "tag prefix is malformed: " + prefix);
+    }
+    state.tagMap[handle] = prefix;
+  }
+};
+function captureSegment2(state, start, end, checkJson) {
+  var _position, _length2, _character, _result;
+  if (start < end) {
+    _result = state.input.slice(start, end);
+    if (checkJson) {
+      for (_position = 0, _length2 = _result.length;_position < _length2; _position += 1) {
+        _character = _result.charCodeAt(_position);
+        if (!(_character === 9 || 32 <= _character && _character <= 1114111)) {
+          throwError2(state, "expected valid JSON character");
+        }
+      }
+    } else if (PATTERN_NON_PRINTABLE2.test(_result)) {
+      throwError2(state, "the stream contains non-printable characters");
+    }
+    state.result += _result;
+  }
+}
+function mergeMappings2(state, destination, source, overridableKeys) {
+  var sourceKeys, key, index, quantity;
+  if (!common2.isObject(source)) {
+    throwError2(state, "cannot merge mappings; the provided source object is unacceptable");
+  }
+  sourceKeys = Object.keys(source);
+  for (index = 0, quantity = sourceKeys.length;index < quantity; index += 1) {
+    key = sourceKeys[index];
+    if (!_hasOwnProperty$12.call(destination, key)) {
+      setProperty2(destination, key, source[key]);
+      overridableKeys[key] = true;
+    }
+  }
+}
+function storeMappingPair2(state, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startLineStart, startPos) {
+  var index, quantity;
+  if (Array.isArray(keyNode)) {
+    keyNode = Array.prototype.slice.call(keyNode);
+    for (index = 0, quantity = keyNode.length;index < quantity; index += 1) {
+      if (Array.isArray(keyNode[index])) {
+        throwError2(state, "nested arrays are not supported inside keys");
+      }
+      if (typeof keyNode === "object" && _class2(keyNode[index]) === "[object Object]") {
+        keyNode[index] = "[object Object]";
+      }
+    }
+  }
+  if (typeof keyNode === "object" && _class2(keyNode) === "[object Object]") {
+    keyNode = "[object Object]";
+  }
+  keyNode = String(keyNode);
+  if (_result === null) {
+    _result = {};
+  }
+  if (keyTag === "tag:yaml.org,2002:merge") {
+    if (Array.isArray(valueNode)) {
+      for (index = 0, quantity = valueNode.length;index < quantity; index += 1) {
+        mergeMappings2(state, _result, valueNode[index], overridableKeys);
+      }
+    } else {
+      mergeMappings2(state, _result, valueNode, overridableKeys);
+    }
+  } else {
+    if (!state.json && !_hasOwnProperty$12.call(overridableKeys, keyNode) && _hasOwnProperty$12.call(_result, keyNode)) {
+      state.line = startLine || state.line;
+      state.lineStart = startLineStart || state.lineStart;
+      state.position = startPos || state.position;
+      throwError2(state, "duplicated mapping key");
+    }
+    setProperty2(_result, keyNode, valueNode);
+    delete overridableKeys[keyNode];
+  }
+  return _result;
+}
+function readLineBreak2(state) {
+  var ch;
+  ch = state.input.charCodeAt(state.position);
+  if (ch === 10) {
+    state.position++;
+  } else if (ch === 13) {
+    state.position++;
+    if (state.input.charCodeAt(state.position) === 10) {
+      state.position++;
+    }
+  } else {
+    throwError2(state, "a line break is expected");
+  }
+  state.line += 1;
+  state.lineStart = state.position;
+  state.firstTabInLine = -1;
+}
+function skipSeparationSpace2(state, allowComments, checkIndent) {
+  var lineBreaks = 0, ch = state.input.charCodeAt(state.position);
+  while (ch !== 0) {
+    while (is_WHITE_SPACE2(ch)) {
+      if (ch === 9 && state.firstTabInLine === -1) {
+        state.firstTabInLine = state.position;
+      }
+      ch = state.input.charCodeAt(++state.position);
+    }
+    if (allowComments && ch === 35) {
+      do {
+        ch = state.input.charCodeAt(++state.position);
+      } while (ch !== 10 && ch !== 13 && ch !== 0);
+    }
+    if (is_EOL2(ch)) {
+      readLineBreak2(state);
+      ch = state.input.charCodeAt(state.position);
+      lineBreaks++;
+      state.lineIndent = 0;
+      while (ch === 32) {
+        state.lineIndent++;
+        ch = state.input.charCodeAt(++state.position);
+      }
+    } else {
+      break;
+    }
+  }
+  if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) {
+    throwWarning2(state, "deficient indentation");
+  }
+  return lineBreaks;
+}
+function testDocumentSeparator2(state) {
+  var _position = state.position, ch;
+  ch = state.input.charCodeAt(_position);
+  if ((ch === 45 || ch === 46) && ch === state.input.charCodeAt(_position + 1) && ch === state.input.charCodeAt(_position + 2)) {
+    _position += 3;
+    ch = state.input.charCodeAt(_position);
+    if (ch === 0 || is_WS_OR_EOL2(ch)) {
+      return true;
+    }
+  }
+  return false;
+}
+function writeFoldedLines2(state, count) {
+  if (count === 1) {
+    state.result += " ";
+  } else if (count > 1) {
+    state.result += common2.repeat(`
+`, count - 1);
+  }
+}
+function readPlainScalar2(state, nodeIndent, withinFlowCollection) {
+  var preceding, following, captureStart, captureEnd, hasPendingContent, _line, _lineStart, _lineIndent, _kind = state.kind, _result = state.result, ch;
+  ch = state.input.charCodeAt(state.position);
+  if (is_WS_OR_EOL2(ch) || is_FLOW_INDICATOR2(ch) || ch === 35 || ch === 38 || ch === 42 || ch === 33 || ch === 124 || ch === 62 || ch === 39 || ch === 34 || ch === 37 || ch === 64 || ch === 96) {
+    return false;
+  }
+  if (ch === 63 || ch === 45) {
+    following = state.input.charCodeAt(state.position + 1);
+    if (is_WS_OR_EOL2(following) || withinFlowCollection && is_FLOW_INDICATOR2(following)) {
+      return false;
+    }
+  }
+  state.kind = "scalar";
+  state.result = "";
+  captureStart = captureEnd = state.position;
+  hasPendingContent = false;
+  while (ch !== 0) {
+    if (ch === 58) {
+      following = state.input.charCodeAt(state.position + 1);
+      if (is_WS_OR_EOL2(following) || withinFlowCollection && is_FLOW_INDICATOR2(following)) {
+        break;
+      }
+    } else if (ch === 35) {
+      preceding = state.input.charCodeAt(state.position - 1);
+      if (is_WS_OR_EOL2(preceding)) {
+        break;
+      }
+    } else if (state.position === state.lineStart && testDocumentSeparator2(state) || withinFlowCollection && is_FLOW_INDICATOR2(ch)) {
+      break;
+    } else if (is_EOL2(ch)) {
+      _line = state.line;
+      _lineStart = state.lineStart;
+      _lineIndent = state.lineIndent;
+      skipSeparationSpace2(state, false, -1);
+      if (state.lineIndent >= nodeIndent) {
+        hasPendingContent = true;
+        ch = state.input.charCodeAt(state.position);
+        continue;
+      } else {
+        state.position = captureEnd;
+        state.line = _line;
+        state.lineStart = _lineStart;
+        state.lineIndent = _lineIndent;
+        break;
+      }
+    }
+    if (hasPendingContent) {
+      captureSegment2(state, captureStart, captureEnd, false);
+      writeFoldedLines2(state, state.line - _line);
+      captureStart = captureEnd = state.position;
+      hasPendingContent = false;
+    }
+    if (!is_WHITE_SPACE2(ch)) {
+      captureEnd = state.position + 1;
+    }
+    ch = state.input.charCodeAt(++state.position);
+  }
+  captureSegment2(state, captureStart, captureEnd, false);
+  if (state.result) {
+    return true;
+  }
+  state.kind = _kind;
+  state.result = _result;
+  return false;
+}
+function readSingleQuotedScalar2(state, nodeIndent) {
+  var ch, captureStart, captureEnd;
+  ch = state.input.charCodeAt(state.position);
+  if (ch !== 39) {
+    return false;
+  }
+  state.kind = "scalar";
+  state.result = "";
+  state.position++;
+  captureStart = captureEnd = state.position;
+  while ((ch = state.input.charCodeAt(state.position)) !== 0) {
+    if (ch === 39) {
+      captureSegment2(state, captureStart, state.position, true);
+      ch = state.input.charCodeAt(++state.position);
+      if (ch === 39) {
+        captureStart = state.position;
+        state.position++;
+        captureEnd = state.position;
+      } else {
+        return true;
+      }
+    } else if (is_EOL2(ch)) {
+      captureSegment2(state, captureStart, captureEnd, true);
+      writeFoldedLines2(state, skipSeparationSpace2(state, false, nodeIndent));
+      captureStart = captureEnd = state.position;
+    } else if (state.position === state.lineStart && testDocumentSeparator2(state)) {
+      throwError2(state, "unexpected end of the document within a single quoted scalar");
+    } else {
+      state.position++;
+      captureEnd = state.position;
+    }
+  }
+  throwError2(state, "unexpected end of the stream within a single quoted scalar");
+}
+function readDoubleQuotedScalar2(state, nodeIndent) {
+  var captureStart, captureEnd, hexLength, hexResult, tmp, ch;
+  ch = state.input.charCodeAt(state.position);
+  if (ch !== 34) {
+    return false;
+  }
+  state.kind = "scalar";
+  state.result = "";
+  state.position++;
+  captureStart = captureEnd = state.position;
+  while ((ch = state.input.charCodeAt(state.position)) !== 0) {
+    if (ch === 34) {
+      captureSegment2(state, captureStart, state.position, true);
+      state.position++;
+      return true;
+    } else if (ch === 92) {
+      captureSegment2(state, captureStart, state.position, true);
+      ch = state.input.charCodeAt(++state.position);
+      if (is_EOL2(ch)) {
+        skipSeparationSpace2(state, false, nodeIndent);
+      } else if (ch < 256 && simpleEscapeCheck2[ch]) {
+        state.result += simpleEscapeMap2[ch];
+        state.position++;
+      } else if ((tmp = escapedHexLen2(ch)) > 0) {
+        hexLength = tmp;
+        hexResult = 0;
+        for (;hexLength > 0; hexLength--) {
+          ch = state.input.charCodeAt(++state.position);
+          if ((tmp = fromHexCode2(ch)) >= 0) {
+            hexResult = (hexResult << 4) + tmp;
+          } else {
+            throwError2(state, "expected hexadecimal character");
+          }
+        }
+        state.result += charFromCodepoint2(hexResult);
+        state.position++;
+      } else {
+        throwError2(state, "unknown escape sequence");
+      }
+      captureStart = captureEnd = state.position;
+    } else if (is_EOL2(ch)) {
+      captureSegment2(state, captureStart, captureEnd, true);
+      writeFoldedLines2(state, skipSeparationSpace2(state, false, nodeIndent));
+      captureStart = captureEnd = state.position;
+    } else if (state.position === state.lineStart && testDocumentSeparator2(state)) {
+      throwError2(state, "unexpected end of the document within a double quoted scalar");
+    } else {
+      state.position++;
+      captureEnd = state.position;
+    }
+  }
+  throwError2(state, "unexpected end of the stream within a double quoted scalar");
+}
+function readFlowCollection2(state, nodeIndent) {
+  var readNext = true, _line, _lineStart, _pos, _tag = state.tag, _result, _anchor = state.anchor, following, terminator, isPair, isExplicitPair, isMapping, overridableKeys = Object.create(null), keyNode, keyTag, valueNode, ch;
+  ch = state.input.charCodeAt(state.position);
+  if (ch === 91) {
+    terminator = 93;
+    isMapping = false;
+    _result = [];
+  } else if (ch === 123) {
+    terminator = 125;
+    isMapping = true;
+    _result = {};
+  } else {
+    return false;
+  }
+  if (state.anchor !== null) {
+    state.anchorMap[state.anchor] = _result;
+  }
+  ch = state.input.charCodeAt(++state.position);
+  while (ch !== 0) {
+    skipSeparationSpace2(state, true, nodeIndent);
+    ch = state.input.charCodeAt(state.position);
+    if (ch === terminator) {
+      state.position++;
+      state.tag = _tag;
+      state.anchor = _anchor;
+      state.kind = isMapping ? "mapping" : "sequence";
+      state.result = _result;
+      return true;
+    } else if (!readNext) {
+      throwError2(state, "missed comma between flow collection entries");
+    } else if (ch === 44) {
+      throwError2(state, "expected the node content, but found ','");
+    }
+    keyTag = keyNode = valueNode = null;
+    isPair = isExplicitPair = false;
+    if (ch === 63) {
+      following = state.input.charCodeAt(state.position + 1);
+      if (is_WS_OR_EOL2(following)) {
+        isPair = isExplicitPair = true;
+        state.position++;
+        skipSeparationSpace2(state, true, nodeIndent);
+      }
+    }
+    _line = state.line;
+    _lineStart = state.lineStart;
+    _pos = state.position;
+    composeNode2(state, nodeIndent, CONTEXT_FLOW_IN2, false, true);
+    keyTag = state.tag;
+    keyNode = state.result;
+    skipSeparationSpace2(state, true, nodeIndent);
+    ch = state.input.charCodeAt(state.position);
+    if ((isExplicitPair || state.line === _line) && ch === 58) {
+      isPair = true;
+      ch = state.input.charCodeAt(++state.position);
+      skipSeparationSpace2(state, true, nodeIndent);
+      composeNode2(state, nodeIndent, CONTEXT_FLOW_IN2, false, true);
+      valueNode = state.result;
+    }
+    if (isMapping) {
+      storeMappingPair2(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos);
+    } else if (isPair) {
+      _result.push(storeMappingPair2(state, null, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos));
+    } else {
+      _result.push(keyNode);
+    }
+    skipSeparationSpace2(state, true, nodeIndent);
+    ch = state.input.charCodeAt(state.position);
+    if (ch === 44) {
+      readNext = true;
+      ch = state.input.charCodeAt(++state.position);
+    } else {
+      readNext = false;
+    }
+  }
+  throwError2(state, "unexpected end of the stream within a flow collection");
+}
+function readBlockScalar2(state, nodeIndent) {
+  var captureStart, folding, chomping = CHOMPING_CLIP2, didReadContent = false, detectedIndent = false, textIndent = nodeIndent, emptyLines = 0, atMoreIndented = false, tmp, ch;
+  ch = state.input.charCodeAt(state.position);
+  if (ch === 124) {
+    folding = false;
+  } else if (ch === 62) {
+    folding = true;
+  } else {
+    return false;
+  }
+  state.kind = "scalar";
+  state.result = "";
+  while (ch !== 0) {
+    ch = state.input.charCodeAt(++state.position);
+    if (ch === 43 || ch === 45) {
+      if (CHOMPING_CLIP2 === chomping) {
+        chomping = ch === 43 ? CHOMPING_KEEP2 : CHOMPING_STRIP2;
+      } else {
+        throwError2(state, "repeat of a chomping mode identifier");
+      }
+    } else if ((tmp = fromDecimalCode2(ch)) >= 0) {
+      if (tmp === 0) {
+        throwError2(state, "bad explicit indentation width of a block scalar; it cannot be less than one");
+      } else if (!detectedIndent) {
+        textIndent = nodeIndent + tmp - 1;
+        detectedIndent = true;
+      } else {
+        throwError2(state, "repeat of an indentation width identifier");
+      }
+    } else {
+      break;
+    }
+  }
+  if (is_WHITE_SPACE2(ch)) {
+    do {
+      ch = state.input.charCodeAt(++state.position);
+    } while (is_WHITE_SPACE2(ch));
+    if (ch === 35) {
+      do {
+        ch = state.input.charCodeAt(++state.position);
+      } while (!is_EOL2(ch) && ch !== 0);
+    }
+  }
+  while (ch !== 0) {
+    readLineBreak2(state);
+    state.lineIndent = 0;
+    ch = state.input.charCodeAt(state.position);
+    while ((!detectedIndent || state.lineIndent < textIndent) && ch === 32) {
+      state.lineIndent++;
+      ch = state.input.charCodeAt(++state.position);
+    }
+    if (!detectedIndent && state.lineIndent > textIndent) {
+      textIndent = state.lineIndent;
+    }
+    if (is_EOL2(ch)) {
+      emptyLines++;
+      continue;
+    }
+    if (state.lineIndent < textIndent) {
+      if (chomping === CHOMPING_KEEP2) {
+        state.result += common2.repeat(`
+`, didReadContent ? 1 + emptyLines : emptyLines);
+      } else if (chomping === CHOMPING_CLIP2) {
+        if (didReadContent) {
+          state.result += `
+`;
+        }
+      }
+      break;
+    }
+    if (folding) {
+      if (is_WHITE_SPACE2(ch)) {
+        atMoreIndented = true;
+        state.result += common2.repeat(`
+`, didReadContent ? 1 + emptyLines : emptyLines);
+      } else if (atMoreIndented) {
+        atMoreIndented = false;
+        state.result += common2.repeat(`
+`, emptyLines + 1);
+      } else if (emptyLines === 0) {
+        if (didReadContent) {
+          state.result += " ";
+        }
+      } else {
+        state.result += common2.repeat(`
+`, emptyLines);
+      }
+    } else {
+      state.result += common2.repeat(`
+`, didReadContent ? 1 + emptyLines : emptyLines);
+    }
+    didReadContent = true;
+    detectedIndent = true;
+    emptyLines = 0;
+    captureStart = state.position;
+    while (!is_EOL2(ch) && ch !== 0) {
+      ch = state.input.charCodeAt(++state.position);
+    }
+    captureSegment2(state, captureStart, state.position, false);
+  }
+  return true;
+}
+function readBlockSequence2(state, nodeIndent) {
+  var _line, _tag = state.tag, _anchor = state.anchor, _result = [], following, detected = false, ch;
+  if (state.firstTabInLine !== -1)
+    return false;
+  if (state.anchor !== null) {
+    state.anchorMap[state.anchor] = _result;
+  }
+  ch = state.input.charCodeAt(state.position);
+  while (ch !== 0) {
+    if (state.firstTabInLine !== -1) {
+      state.position = state.firstTabInLine;
+      throwError2(state, "tab characters must not be used in indentation");
+    }
+    if (ch !== 45) {
+      break;
+    }
+    following = state.input.charCodeAt(state.position + 1);
+    if (!is_WS_OR_EOL2(following)) {
+      break;
+    }
+    detected = true;
+    state.position++;
+    if (skipSeparationSpace2(state, true, -1)) {
+      if (state.lineIndent <= nodeIndent) {
+        _result.push(null);
+        ch = state.input.charCodeAt(state.position);
+        continue;
+      }
+    }
+    _line = state.line;
+    composeNode2(state, nodeIndent, CONTEXT_BLOCK_IN2, false, true);
+    _result.push(state.result);
+    skipSeparationSpace2(state, true, -1);
+    ch = state.input.charCodeAt(state.position);
+    if ((state.line === _line || state.lineIndent > nodeIndent) && ch !== 0) {
+      throwError2(state, "bad indentation of a sequence entry");
+    } else if (state.lineIndent < nodeIndent) {
+      break;
+    }
+  }
+  if (detected) {
+    state.tag = _tag;
+    state.anchor = _anchor;
+    state.kind = "sequence";
+    state.result = _result;
+    return true;
+  }
+  return false;
+}
+function readBlockMapping2(state, nodeIndent, flowIndent) {
+  var following, allowCompact, _line, _keyLine, _keyLineStart, _keyPos, _tag = state.tag, _anchor = state.anchor, _result = {}, overridableKeys = Object.create(null), keyTag = null, keyNode = null, valueNode = null, atExplicitKey = false, detected = false, ch;
+  if (state.firstTabInLine !== -1)
+    return false;
+  if (state.anchor !== null) {
+    state.anchorMap[state.anchor] = _result;
+  }
+  ch = state.input.charCodeAt(state.position);
+  while (ch !== 0) {
+    if (!atExplicitKey && state.firstTabInLine !== -1) {
+      state.position = state.firstTabInLine;
+      throwError2(state, "tab characters must not be used in indentation");
+    }
+    following = state.input.charCodeAt(state.position + 1);
+    _line = state.line;
+    if ((ch === 63 || ch === 58) && is_WS_OR_EOL2(following)) {
+      if (ch === 63) {
+        if (atExplicitKey) {
+          storeMappingPair2(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
+          keyTag = keyNode = valueNode = null;
+        }
+        detected = true;
+        atExplicitKey = true;
+        allowCompact = true;
+      } else if (atExplicitKey) {
+        atExplicitKey = false;
+        allowCompact = true;
+      } else {
+        throwError2(state, "incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line");
+      }
+      state.position += 1;
+      ch = following;
+    } else {
+      _keyLine = state.line;
+      _keyLineStart = state.lineStart;
+      _keyPos = state.position;
+      if (!composeNode2(state, flowIndent, CONTEXT_FLOW_OUT2, false, true)) {
+        break;
+      }
+      if (state.line === _line) {
+        ch = state.input.charCodeAt(state.position);
+        while (is_WHITE_SPACE2(ch)) {
+          ch = state.input.charCodeAt(++state.position);
+        }
+        if (ch === 58) {
+          ch = state.input.charCodeAt(++state.position);
+          if (!is_WS_OR_EOL2(ch)) {
+            throwError2(state, "a whitespace character is expected after the key-value separator within a block mapping");
+          }
+          if (atExplicitKey) {
+            storeMappingPair2(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
+            keyTag = keyNode = valueNode = null;
+          }
+          detected = true;
+          atExplicitKey = false;
+          allowCompact = false;
+          keyTag = state.tag;
+          keyNode = state.result;
+        } else if (detected) {
+          throwError2(state, "can not read an implicit mapping pair; a colon is missed");
+        } else {
+          state.tag = _tag;
+          state.anchor = _anchor;
+          return true;
+        }
+      } else if (detected) {
+        throwError2(state, "can not read a block mapping entry; a multiline key may not be an implicit key");
+      } else {
+        state.tag = _tag;
+        state.anchor = _anchor;
+        return true;
+      }
+    }
+    if (state.line === _line || state.lineIndent > nodeIndent) {
+      if (atExplicitKey) {
+        _keyLine = state.line;
+        _keyLineStart = state.lineStart;
+        _keyPos = state.position;
+      }
+      if (composeNode2(state, nodeIndent, CONTEXT_BLOCK_OUT2, true, allowCompact)) {
+        if (atExplicitKey) {
+          keyNode = state.result;
+        } else {
+          valueNode = state.result;
+        }
+      }
+      if (!atExplicitKey) {
+        storeMappingPair2(state, _result, overridableKeys, keyTag, keyNode, valueNode, _keyLine, _keyLineStart, _keyPos);
+        keyTag = keyNode = valueNode = null;
+      }
+      skipSeparationSpace2(state, true, -1);
+      ch = state.input.charCodeAt(state.position);
+    }
+    if ((state.line === _line || state.lineIndent > nodeIndent) && ch !== 0) {
+      throwError2(state, "bad indentation of a mapping entry");
+    } else if (state.lineIndent < nodeIndent) {
+      break;
+    }
+  }
+  if (atExplicitKey) {
+    storeMappingPair2(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
+  }
+  if (detected) {
+    state.tag = _tag;
+    state.anchor = _anchor;
+    state.kind = "mapping";
+    state.result = _result;
+  }
+  return detected;
+}
+function readTagProperty2(state) {
+  var _position, isVerbatim = false, isNamed = false, tagHandle, tagName, ch;
+  ch = state.input.charCodeAt(state.position);
+  if (ch !== 33)
+    return false;
+  if (state.tag !== null) {
+    throwError2(state, "duplication of a tag property");
+  }
+  ch = state.input.charCodeAt(++state.position);
+  if (ch === 60) {
+    isVerbatim = true;
+    ch = state.input.charCodeAt(++state.position);
+  } else if (ch === 33) {
+    isNamed = true;
+    tagHandle = "!!";
+    ch = state.input.charCodeAt(++state.position);
+  } else {
+    tagHandle = "!";
+  }
+  _position = state.position;
+  if (isVerbatim) {
+    do {
+      ch = state.input.charCodeAt(++state.position);
+    } while (ch !== 0 && ch !== 62);
+    if (state.position < state.length) {
+      tagName = state.input.slice(_position, state.position);
+      ch = state.input.charCodeAt(++state.position);
+    } else {
+      throwError2(state, "unexpected end of the stream within a verbatim tag");
+    }
+  } else {
+    while (ch !== 0 && !is_WS_OR_EOL2(ch)) {
+      if (ch === 33) {
+        if (!isNamed) {
+          tagHandle = state.input.slice(_position - 1, state.position + 1);
+          if (!PATTERN_TAG_HANDLE2.test(tagHandle)) {
+            throwError2(state, "named tag handle cannot contain such characters");
+          }
+          isNamed = true;
+          _position = state.position + 1;
+        } else {
+          throwError2(state, "tag suffix cannot contain exclamation marks");
+        }
+      }
+      ch = state.input.charCodeAt(++state.position);
+    }
+    tagName = state.input.slice(_position, state.position);
+    if (PATTERN_FLOW_INDICATORS2.test(tagName)) {
+      throwError2(state, "tag suffix cannot contain flow indicator characters");
+    }
+  }
+  if (tagName && !PATTERN_TAG_URI2.test(tagName)) {
+    throwError2(state, "tag name cannot contain such characters: " + tagName);
+  }
+  try {
+    tagName = decodeURIComponent(tagName);
+  } catch (err) {
+    throwError2(state, "tag name is malformed: " + tagName);
+  }
+  if (isVerbatim) {
+    state.tag = tagName;
+  } else if (_hasOwnProperty$12.call(state.tagMap, tagHandle)) {
+    state.tag = state.tagMap[tagHandle] + tagName;
+  } else if (tagHandle === "!") {
+    state.tag = "!" + tagName;
+  } else if (tagHandle === "!!") {
+    state.tag = "tag:yaml.org,2002:" + tagName;
+  } else {
+    throwError2(state, 'undeclared tag handle "' + tagHandle + '"');
+  }
+  return true;
+}
+function readAnchorProperty2(state) {
+  var _position, ch;
+  ch = state.input.charCodeAt(state.position);
+  if (ch !== 38)
+    return false;
+  if (state.anchor !== null) {
+    throwError2(state, "duplication of an anchor property");
+  }
+  ch = state.input.charCodeAt(++state.position);
+  _position = state.position;
+  while (ch !== 0 && !is_WS_OR_EOL2(ch) && !is_FLOW_INDICATOR2(ch)) {
+    ch = state.input.charCodeAt(++state.position);
+  }
+  if (state.position === _position) {
+    throwError2(state, "name of an anchor node must contain at least one character");
+  }
+  state.anchor = state.input.slice(_position, state.position);
+  return true;
+}
+function readAlias2(state) {
+  var _position, alias, ch;
+  ch = state.input.charCodeAt(state.position);
+  if (ch !== 42)
+    return false;
+  ch = state.input.charCodeAt(++state.position);
+  _position = state.position;
+  while (ch !== 0 && !is_WS_OR_EOL2(ch) && !is_FLOW_INDICATOR2(ch)) {
+    ch = state.input.charCodeAt(++state.position);
+  }
+  if (state.position === _position) {
+    throwError2(state, "name of an alias node must contain at least one character");
+  }
+  alias = state.input.slice(_position, state.position);
+  if (!_hasOwnProperty$12.call(state.anchorMap, alias)) {
+    throwError2(state, 'unidentified alias "' + alias + '"');
+  }
+  state.result = state.anchorMap[alias];
+  skipSeparationSpace2(state, true, -1);
+  return true;
+}
+function composeNode2(state, parentIndent, nodeContext, allowToSeek, allowCompact) {
+  var allowBlockStyles, allowBlockScalars, allowBlockCollections, indentStatus = 1, atNewLine = false, hasContent = false, typeIndex, typeQuantity, typeList, type3, flowIndent, blockIndent;
+  if (state.listener !== null) {
+    state.listener("open", state);
+  }
+  state.tag = null;
+  state.anchor = null;
+  state.kind = null;
+  state.result = null;
+  allowBlockStyles = allowBlockScalars = allowBlockCollections = CONTEXT_BLOCK_OUT2 === nodeContext || CONTEXT_BLOCK_IN2 === nodeContext;
+  if (allowToSeek) {
+    if (skipSeparationSpace2(state, true, -1)) {
+      atNewLine = true;
+      if (state.lineIndent > parentIndent) {
+        indentStatus = 1;
+      } else if (state.lineIndent === parentIndent) {
+        indentStatus = 0;
+      } else if (state.lineIndent < parentIndent) {
+        indentStatus = -1;
+      }
+    }
+  }
+  if (indentStatus === 1) {
+    while (readTagProperty2(state) || readAnchorProperty2(state)) {
+      if (skipSeparationSpace2(state, true, -1)) {
+        atNewLine = true;
+        allowBlockCollections = allowBlockStyles;
+        if (state.lineIndent > parentIndent) {
+          indentStatus = 1;
+        } else if (state.lineIndent === parentIndent) {
+          indentStatus = 0;
+        } else if (state.lineIndent < parentIndent) {
+          indentStatus = -1;
+        }
+      } else {
+        allowBlockCollections = false;
+      }
+    }
+  }
+  if (allowBlockCollections) {
+    allowBlockCollections = atNewLine || allowCompact;
+  }
+  if (indentStatus === 1 || CONTEXT_BLOCK_OUT2 === nodeContext) {
+    if (CONTEXT_FLOW_IN2 === nodeContext || CONTEXT_FLOW_OUT2 === nodeContext) {
+      flowIndent = parentIndent;
+    } else {
+      flowIndent = parentIndent + 1;
+    }
+    blockIndent = state.position - state.lineStart;
+    if (indentStatus === 1) {
+      if (allowBlockCollections && (readBlockSequence2(state, blockIndent) || readBlockMapping2(state, blockIndent, flowIndent)) || readFlowCollection2(state, flowIndent)) {
+        hasContent = true;
+      } else {
+        if (allowBlockScalars && readBlockScalar2(state, flowIndent) || readSingleQuotedScalar2(state, flowIndent) || readDoubleQuotedScalar2(state, flowIndent)) {
+          hasContent = true;
+        } else if (readAlias2(state)) {
+          hasContent = true;
+          if (state.tag !== null || state.anchor !== null) {
+            throwError2(state, "alias node should not have any properties");
+          }
+        } else if (readPlainScalar2(state, flowIndent, CONTEXT_FLOW_IN2 === nodeContext)) {
+          hasContent = true;
+          if (state.tag === null) {
+            state.tag = "?";
+          }
+        }
+        if (state.anchor !== null) {
+          state.anchorMap[state.anchor] = state.result;
+        }
+      }
+    } else if (indentStatus === 0) {
+      hasContent = allowBlockCollections && readBlockSequence2(state, blockIndent);
+    }
+  }
+  if (state.tag === null) {
+    if (state.anchor !== null) {
+      state.anchorMap[state.anchor] = state.result;
+    }
+  } else if (state.tag === "?") {
+    if (state.result !== null && state.kind !== "scalar") {
+      throwError2(state, 'unacceptable node kind for !<?> tag; it should be "scalar", not "' + state.kind + '"');
+    }
+    for (typeIndex = 0, typeQuantity = state.implicitTypes.length;typeIndex < typeQuantity; typeIndex += 1) {
+      type3 = state.implicitTypes[typeIndex];
+      if (type3.resolve(state.result)) {
+        state.result = type3.construct(state.result);
+        state.tag = type3.tag;
+        if (state.anchor !== null) {
+          state.anchorMap[state.anchor] = state.result;
+        }
+        break;
+      }
+    }
+  } else if (state.tag !== "!") {
+    if (_hasOwnProperty$12.call(state.typeMap[state.kind || "fallback"], state.tag)) {
+      type3 = state.typeMap[state.kind || "fallback"][state.tag];
+    } else {
+      type3 = null;
+      typeList = state.typeMap.multi[state.kind || "fallback"];
+      for (typeIndex = 0, typeQuantity = typeList.length;typeIndex < typeQuantity; typeIndex += 1) {
+        if (state.tag.slice(0, typeList[typeIndex].tag.length) === typeList[typeIndex].tag) {
+          type3 = typeList[typeIndex];
+          break;
+        }
+      }
+    }
+    if (!type3) {
+      throwError2(state, "unknown tag !<" + state.tag + ">");
+    }
+    if (state.result !== null && type3.kind !== state.kind) {
+      throwError2(state, "unacceptable node kind for !<" + state.tag + '> tag; it should be "' + type3.kind + '", not "' + state.kind + '"');
+    }
+    if (!type3.resolve(state.result, state.tag)) {
+      throwError2(state, "cannot resolve a node with !<" + state.tag + "> explicit tag");
+    } else {
+      state.result = type3.construct(state.result, state.tag);
+      if (state.anchor !== null) {
+        state.anchorMap[state.anchor] = state.result;
+      }
+    }
+  }
+  if (state.listener !== null) {
+    state.listener("close", state);
+  }
+  return state.tag !== null || state.anchor !== null || hasContent;
+}
+function readDocument2(state) {
+  var documentStart = state.position, _position, directiveName, directiveArgs, hasDirectives = false, ch;
+  state.version = null;
+  state.checkLineBreaks = state.legacy;
+  state.tagMap = Object.create(null);
+  state.anchorMap = Object.create(null);
+  while ((ch = state.input.charCodeAt(state.position)) !== 0) {
+    skipSeparationSpace2(state, true, -1);
+    ch = state.input.charCodeAt(state.position);
+    if (state.lineIndent > 0 || ch !== 37) {
+      break;
+    }
+    hasDirectives = true;
+    ch = state.input.charCodeAt(++state.position);
+    _position = state.position;
+    while (ch !== 0 && !is_WS_OR_EOL2(ch)) {
+      ch = state.input.charCodeAt(++state.position);
+    }
+    directiveName = state.input.slice(_position, state.position);
+    directiveArgs = [];
+    if (directiveName.length < 1) {
+      throwError2(state, "directive name must not be less than one character in length");
+    }
+    while (ch !== 0) {
+      while (is_WHITE_SPACE2(ch)) {
+        ch = state.input.charCodeAt(++state.position);
+      }
+      if (ch === 35) {
+        do {
+          ch = state.input.charCodeAt(++state.position);
+        } while (ch !== 0 && !is_EOL2(ch));
+        break;
+      }
+      if (is_EOL2(ch))
+        break;
+      _position = state.position;
+      while (ch !== 0 && !is_WS_OR_EOL2(ch)) {
+        ch = state.input.charCodeAt(++state.position);
+      }
+      directiveArgs.push(state.input.slice(_position, state.position));
+    }
+    if (ch !== 0)
+      readLineBreak2(state);
+    if (_hasOwnProperty$12.call(directiveHandlers2, directiveName)) {
+      directiveHandlers2[directiveName](state, directiveName, directiveArgs);
+    } else {
+      throwWarning2(state, 'unknown document directive "' + directiveName + '"');
+    }
+  }
+  skipSeparationSpace2(state, true, -1);
+  if (state.lineIndent === 0 && state.input.charCodeAt(state.position) === 45 && state.input.charCodeAt(state.position + 1) === 45 && state.input.charCodeAt(state.position + 2) === 45) {
+    state.position += 3;
+    skipSeparationSpace2(state, true, -1);
+  } else if (hasDirectives) {
+    throwError2(state, "directives end mark is expected");
+  }
+  composeNode2(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT2, false, true);
+  skipSeparationSpace2(state, true, -1);
+  if (state.checkLineBreaks && PATTERN_NON_ASCII_LINE_BREAKS2.test(state.input.slice(documentStart, state.position))) {
+    throwWarning2(state, "non-ASCII line breaks are interpreted as content");
+  }
+  state.documents.push(state.result);
+  if (state.position === state.lineStart && testDocumentSeparator2(state)) {
+    if (state.input.charCodeAt(state.position) === 46) {
+      state.position += 3;
+      skipSeparationSpace2(state, true, -1);
+    }
+    return;
+  }
+  if (state.position < state.length - 1) {
+    throwError2(state, "end of the stream or a document separator is expected");
+  } else {
+    return;
+  }
+}
+function loadDocuments2(input, options) {
+  input = String(input);
+  options = options || {};
+  if (input.length !== 0) {
+    if (input.charCodeAt(input.length - 1) !== 10 && input.charCodeAt(input.length - 1) !== 13) {
+      input += `
+`;
+    }
+    if (input.charCodeAt(0) === 65279) {
+      input = input.slice(1);
+    }
+  }
+  var state = new State$12(input, options);
+  var nullpos = input.indexOf("\x00");
+  if (nullpos !== -1) {
+    state.position = nullpos;
+    throwError2(state, "null byte is not allowed in input");
+  }
+  state.input += "\x00";
+  while (state.input.charCodeAt(state.position) === 32) {
+    state.lineIndent += 1;
+    state.position += 1;
+  }
+  while (state.position < state.length - 1) {
+    readDocument2(state);
+  }
+  return state.documents;
+}
+function loadAll$12(input, iterator, options) {
+  if (iterator !== null && typeof iterator === "object" && typeof options === "undefined") {
+    options = iterator;
+    iterator = null;
+  }
+  var documents = loadDocuments2(input, options);
+  if (typeof iterator !== "function") {
+    return documents;
+  }
+  for (var index = 0, length = documents.length;index < length; index += 1) {
+    iterator(documents[index]);
+  }
+}
+function load$12(input, options) {
+  var documents = loadDocuments2(input, options);
+  if (documents.length === 0) {
+    return;
+  } else if (documents.length === 1) {
+    return documents[0];
+  }
+  throw new exception2("expected a single document in the stream, but found more");
+}
+var loadAll_12 = loadAll$12;
+var load_12 = load$12;
+var loader2 = {
+  loadAll: loadAll_12,
+  load: load_12
+};
+var _toString2 = Object.prototype.toString;
+var _hasOwnProperty2 = Object.prototype.hasOwnProperty;
+var CHAR_BOM2 = 65279;
+var CHAR_TAB2 = 9;
+var CHAR_LINE_FEED2 = 10;
+var CHAR_CARRIAGE_RETURN2 = 13;
+var CHAR_SPACE2 = 32;
+var CHAR_EXCLAMATION2 = 33;
+var CHAR_DOUBLE_QUOTE2 = 34;
+var CHAR_SHARP2 = 35;
+var CHAR_PERCENT2 = 37;
+var CHAR_AMPERSAND2 = 38;
+var CHAR_SINGLE_QUOTE2 = 39;
+var CHAR_ASTERISK2 = 42;
+var CHAR_COMMA2 = 44;
+var CHAR_MINUS2 = 45;
+var CHAR_COLON2 = 58;
+var CHAR_EQUALS2 = 61;
+var CHAR_GREATER_THAN2 = 62;
+var CHAR_QUESTION2 = 63;
+var CHAR_COMMERCIAL_AT2 = 64;
+var CHAR_LEFT_SQUARE_BRACKET2 = 91;
+var CHAR_RIGHT_SQUARE_BRACKET2 = 93;
+var CHAR_GRAVE_ACCENT2 = 96;
+var CHAR_LEFT_CURLY_BRACKET2 = 123;
+var CHAR_VERTICAL_LINE2 = 124;
+var CHAR_RIGHT_CURLY_BRACKET2 = 125;
+var ESCAPE_SEQUENCES2 = {};
+ESCAPE_SEQUENCES2[0] = "\\0";
+ESCAPE_SEQUENCES2[7] = "\\a";
+ESCAPE_SEQUENCES2[8] = "\\b";
+ESCAPE_SEQUENCES2[9] = "\\t";
+ESCAPE_SEQUENCES2[10] = "\\n";
+ESCAPE_SEQUENCES2[11] = "\\v";
+ESCAPE_SEQUENCES2[12] = "\\f";
+ESCAPE_SEQUENCES2[13] = "\\r";
+ESCAPE_SEQUENCES2[27] = "\\e";
+ESCAPE_SEQUENCES2[34] = "\\\"";
+ESCAPE_SEQUENCES2[92] = "\\\\";
+ESCAPE_SEQUENCES2[133] = "\\N";
+ESCAPE_SEQUENCES2[160] = "\\_";
+ESCAPE_SEQUENCES2[8232] = "\\L";
+ESCAPE_SEQUENCES2[8233] = "\\P";
+var DEPRECATED_BOOLEANS_SYNTAX2 = [
+  "y",
+  "Y",
+  "yes",
+  "Yes",
+  "YES",
+  "on",
+  "On",
+  "ON",
+  "n",
+  "N",
+  "no",
+  "No",
+  "NO",
+  "off",
+  "Off",
+  "OFF"
+];
+var DEPRECATED_BASE60_SYNTAX2 = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/;
+function compileStyleMap2(schema3, map4) {
+  var result, keys, index, length, tag, style, type3;
+  if (map4 === null)
+    return {};
+  result = {};
+  keys = Object.keys(map4);
+  for (index = 0, length = keys.length;index < length; index += 1) {
+    tag = keys[index];
+    style = String(map4[tag]);
+    if (tag.slice(0, 2) === "!!") {
+      tag = "tag:yaml.org,2002:" + tag.slice(2);
+    }
+    type3 = schema3.compiledTypeMap["fallback"][tag];
+    if (type3 && _hasOwnProperty2.call(type3.styleAliases, style)) {
+      style = type3.styleAliases[style];
+    }
+    result[tag] = style;
+  }
+  return result;
+}
+function encodeHex2(character) {
+  var string4, handle, length;
+  string4 = character.toString(16).toUpperCase();
+  if (character <= 255) {
+    handle = "x";
+    length = 2;
+  } else if (character <= 65535) {
+    handle = "u";
+    length = 4;
+  } else if (character <= 4294967295) {
+    handle = "U";
+    length = 8;
+  } else {
+    throw new exception2("code point within a string may not be greater than 0xFFFFFFFF");
+  }
+  return "\\" + handle + common2.repeat("0", length - string4.length) + string4;
+}
+var QUOTING_TYPE_SINGLE2 = 1;
+var QUOTING_TYPE_DOUBLE2 = 2;
+function State2(options) {
+  this.schema = options["schema"] || _default3;
+  this.indent = Math.max(1, options["indent"] || 2);
+  this.noArrayIndent = options["noArrayIndent"] || false;
+  this.skipInvalid = options["skipInvalid"] || false;
+  this.flowLevel = common2.isNothing(options["flowLevel"]) ? -1 : options["flowLevel"];
+  this.styleMap = compileStyleMap2(this.schema, options["styles"] || null);
+  this.sortKeys = options["sortKeys"] || false;
+  this.lineWidth = options["lineWidth"] || 80;
+  this.noRefs = options["noRefs"] || false;
+  this.noCompatMode = options["noCompatMode"] || false;
+  this.condenseFlow = options["condenseFlow"] || false;
+  this.quotingType = options["quotingType"] === '"' ? QUOTING_TYPE_DOUBLE2 : QUOTING_TYPE_SINGLE2;
+  this.forceQuotes = options["forceQuotes"] || false;
+  this.replacer = typeof options["replacer"] === "function" ? options["replacer"] : null;
+  this.implicitTypes = this.schema.compiledImplicit;
+  this.explicitTypes = this.schema.compiledExplicit;
+  this.tag = null;
+  this.result = "";
+  this.duplicates = [];
+  this.usedDuplicates = null;
+}
+function indentString2(string4, spaces) {
+  var ind = common2.repeat(" ", spaces), position = 0, next = -1, result = "", line, length = string4.length;
+  while (position < length) {
+    next = string4.indexOf(`
+`, position);
+    if (next === -1) {
+      line = string4.slice(position);
+      position = length;
+    } else {
+      line = string4.slice(position, next + 1);
+      position = next + 1;
+    }
+    if (line.length && line !== `
+`)
+      result += ind;
+    result += line;
+  }
+  return result;
+}
+function generateNextLine2(state, level) {
+  return `
+` + common2.repeat(" ", state.indent * level);
+}
+function testImplicitResolving2(state, str3) {
+  var index, length, type3;
+  for (index = 0, length = state.implicitTypes.length;index < length; index += 1) {
+    type3 = state.implicitTypes[index];
+    if (type3.resolve(str3)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isWhitespace2(c) {
+  return c === CHAR_SPACE2 || c === CHAR_TAB2;
+}
+function isPrintable2(c) {
+  return 32 <= c && c <= 126 || 161 <= c && c <= 55295 && c !== 8232 && c !== 8233 || 57344 <= c && c <= 65533 && c !== CHAR_BOM2 || 65536 <= c && c <= 1114111;
+}
+function isNsCharOrWhitespace2(c) {
+  return isPrintable2(c) && c !== CHAR_BOM2 && c !== CHAR_CARRIAGE_RETURN2 && c !== CHAR_LINE_FEED2;
+}
+function isPlainSafe2(c, prev, inblock) {
+  var cIsNsCharOrWhitespace = isNsCharOrWhitespace2(c);
+  var cIsNsChar = cIsNsCharOrWhitespace && !isWhitespace2(c);
+  return (inblock ? cIsNsCharOrWhitespace : cIsNsCharOrWhitespace && c !== CHAR_COMMA2 && c !== CHAR_LEFT_SQUARE_BRACKET2 && c !== CHAR_RIGHT_SQUARE_BRACKET2 && c !== CHAR_LEFT_CURLY_BRACKET2 && c !== CHAR_RIGHT_CURLY_BRACKET2) && c !== CHAR_SHARP2 && !(prev === CHAR_COLON2 && !cIsNsChar) || isNsCharOrWhitespace2(prev) && !isWhitespace2(prev) && c === CHAR_SHARP2 || prev === CHAR_COLON2 && cIsNsChar;
+}
+function isPlainSafeFirst2(c) {
+  return isPrintable2(c) && c !== CHAR_BOM2 && !isWhitespace2(c) && c !== CHAR_MINUS2 && c !== CHAR_QUESTION2 && c !== CHAR_COLON2 && c !== CHAR_COMMA2 && c !== CHAR_LEFT_SQUARE_BRACKET2 && c !== CHAR_RIGHT_SQUARE_BRACKET2 && c !== CHAR_LEFT_CURLY_BRACKET2 && c !== CHAR_RIGHT_CURLY_BRACKET2 && c !== CHAR_SHARP2 && c !== CHAR_AMPERSAND2 && c !== CHAR_ASTERISK2 && c !== CHAR_EXCLAMATION2 && c !== CHAR_VERTICAL_LINE2 && c !== CHAR_EQUALS2 && c !== CHAR_GREATER_THAN2 && c !== CHAR_SINGLE_QUOTE2 && c !== CHAR_DOUBLE_QUOTE2 && c !== CHAR_PERCENT2 && c !== CHAR_COMMERCIAL_AT2 && c !== CHAR_GRAVE_ACCENT2;
+}
+function isPlainSafeLast2(c) {
+  return !isWhitespace2(c) && c !== CHAR_COLON2;
+}
+function codePointAt2(string4, pos) {
+  var first = string4.charCodeAt(pos), second;
+  if (first >= 55296 && first <= 56319 && pos + 1 < string4.length) {
+    second = string4.charCodeAt(pos + 1);
+    if (second >= 56320 && second <= 57343) {
+      return (first - 55296) * 1024 + second - 56320 + 65536;
+    }
+  }
+  return first;
+}
+function needIndentIndicator2(string4) {
+  var leadingSpaceRe = /^\n* /;
+  return leadingSpaceRe.test(string4);
+}
+var STYLE_PLAIN2 = 1;
+var STYLE_SINGLE2 = 2;
+var STYLE_LITERAL2 = 3;
+var STYLE_FOLDED2 = 4;
+var STYLE_DOUBLE2 = 5;
+function chooseScalarStyle2(string4, singleLineOnly, indentPerLevel, lineWidth, testAmbiguousType, quotingType, forceQuotes, inblock) {
+  var i3;
+  var char = 0;
+  var prevChar = null;
+  var hasLineBreak = false;
+  var hasFoldableLine = false;
+  var shouldTrackWidth = lineWidth !== -1;
+  var previousLineBreak = -1;
+  var plain = isPlainSafeFirst2(codePointAt2(string4, 0)) && isPlainSafeLast2(codePointAt2(string4, string4.length - 1));
+  if (singleLineOnly || forceQuotes) {
+    for (i3 = 0;i3 < string4.length; char >= 65536 ? i3 += 2 : i3++) {
+      char = codePointAt2(string4, i3);
+      if (!isPrintable2(char)) {
+        return STYLE_DOUBLE2;
+      }
+      plain = plain && isPlainSafe2(char, prevChar, inblock);
+      prevChar = char;
+    }
+  } else {
+    for (i3 = 0;i3 < string4.length; char >= 65536 ? i3 += 2 : i3++) {
+      char = codePointAt2(string4, i3);
+      if (char === CHAR_LINE_FEED2) {
+        hasLineBreak = true;
+        if (shouldTrackWidth) {
+          hasFoldableLine = hasFoldableLine || i3 - previousLineBreak - 1 > lineWidth && string4[previousLineBreak + 1] !== " ";
+          previousLineBreak = i3;
+        }
+      } else if (!isPrintable2(char)) {
+        return STYLE_DOUBLE2;
+      }
+      plain = plain && isPlainSafe2(char, prevChar, inblock);
+      prevChar = char;
+    }
+    hasFoldableLine = hasFoldableLine || shouldTrackWidth && (i3 - previousLineBreak - 1 > lineWidth && string4[previousLineBreak + 1] !== " ");
+  }
+  if (!hasLineBreak && !hasFoldableLine) {
+    if (plain && !forceQuotes && !testAmbiguousType(string4)) {
+      return STYLE_PLAIN2;
+    }
+    return quotingType === QUOTING_TYPE_DOUBLE2 ? STYLE_DOUBLE2 : STYLE_SINGLE2;
+  }
+  if (indentPerLevel > 9 && needIndentIndicator2(string4)) {
+    return STYLE_DOUBLE2;
+  }
+  if (!forceQuotes) {
+    return hasFoldableLine ? STYLE_FOLDED2 : STYLE_LITERAL2;
+  }
+  return quotingType === QUOTING_TYPE_DOUBLE2 ? STYLE_DOUBLE2 : STYLE_SINGLE2;
+}
+function writeScalar2(state, string4, level, iskey, inblock) {
+  state.dump = function() {
+    if (string4.length === 0) {
+      return state.quotingType === QUOTING_TYPE_DOUBLE2 ? '""' : "''";
+    }
+    if (!state.noCompatMode) {
+      if (DEPRECATED_BOOLEANS_SYNTAX2.indexOf(string4) !== -1 || DEPRECATED_BASE60_SYNTAX2.test(string4)) {
+        return state.quotingType === QUOTING_TYPE_DOUBLE2 ? '"' + string4 + '"' : "'" + string4 + "'";
+      }
+    }
+    var indent = state.indent * Math.max(1, level);
+    var lineWidth = state.lineWidth === -1 ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent);
+    var singleLineOnly = iskey || state.flowLevel > -1 && level >= state.flowLevel;
+    function testAmbiguity(string5) {
+      return testImplicitResolving2(state, string5);
+    }
+    switch (chooseScalarStyle2(string4, singleLineOnly, state.indent, lineWidth, testAmbiguity, state.quotingType, state.forceQuotes && !iskey, inblock)) {
+      case STYLE_PLAIN2:
+        return string4;
+      case STYLE_SINGLE2:
+        return "'" + string4.replace(/'/g, "''") + "'";
+      case STYLE_LITERAL2:
+        return "|" + blockHeader2(string4, state.indent) + dropEndingNewline2(indentString2(string4, indent));
+      case STYLE_FOLDED2:
+        return ">" + blockHeader2(string4, state.indent) + dropEndingNewline2(indentString2(foldString2(string4, lineWidth), indent));
+      case STYLE_DOUBLE2:
+        return '"' + escapeString2(string4) + '"';
+      default:
+        throw new exception2("impossible error: invalid scalar style");
+    }
+  }();
+}
+function blockHeader2(string4, indentPerLevel) {
+  var indentIndicator = needIndentIndicator2(string4) ? String(indentPerLevel) : "";
+  var clip = string4[string4.length - 1] === `
+`;
+  var keep = clip && (string4[string4.length - 2] === `
+` || string4 === `
+`);
+  var chomp = keep ? "+" : clip ? "" : "-";
+  return indentIndicator + chomp + `
+`;
+}
+function dropEndingNewline2(string4) {
+  return string4[string4.length - 1] === `
+` ? string4.slice(0, -1) : string4;
+}
+function foldString2(string4, width) {
+  var lineRe = /(\n+)([^\n]*)/g;
+  var result = function() {
+    var nextLF = string4.indexOf(`
+`);
+    nextLF = nextLF !== -1 ? nextLF : string4.length;
+    lineRe.lastIndex = nextLF;
+    return foldLine2(string4.slice(0, nextLF), width);
+  }();
+  var prevMoreIndented = string4[0] === `
+` || string4[0] === " ";
+  var moreIndented;
+  var match;
+  while (match = lineRe.exec(string4)) {
+    var prefix = match[1], line = match[2];
+    moreIndented = line[0] === " ";
+    result += prefix + (!prevMoreIndented && !moreIndented && line !== "" ? `
+` : "") + foldLine2(line, width);
+    prevMoreIndented = moreIndented;
+  }
+  return result;
+}
+function foldLine2(line, width) {
+  if (line === "" || line[0] === " ")
+    return line;
+  var breakRe = / [^ ]/g;
+  var match;
+  var start = 0, end, curr = 0, next = 0;
+  var result = "";
+  while (match = breakRe.exec(line)) {
+    next = match.index;
+    if (next - start > width) {
+      end = curr > start ? curr : next;
+      result += `
+` + line.slice(start, end);
+      start = end + 1;
+    }
+    curr = next;
+  }
+  result += `
+`;
+  if (line.length - start > width && curr > start) {
+    result += line.slice(start, curr) + `
+` + line.slice(curr + 1);
+  } else {
+    result += line.slice(start);
+  }
+  return result.slice(1);
+}
+function escapeString2(string4) {
+  var result = "";
+  var char = 0;
+  var escapeSeq;
+  for (var i3 = 0;i3 < string4.length; char >= 65536 ? i3 += 2 : i3++) {
+    char = codePointAt2(string4, i3);
+    escapeSeq = ESCAPE_SEQUENCES2[char];
+    if (!escapeSeq && isPrintable2(char)) {
+      result += string4[i3];
+      if (char >= 65536)
+        result += string4[i3 + 1];
+    } else {
+      result += escapeSeq || encodeHex2(char);
+    }
+  }
+  return result;
+}
+function writeFlowSequence2(state, level, object4) {
+  var _result = "", _tag = state.tag, index, length, value;
+  for (index = 0, length = object4.length;index < length; index += 1) {
+    value = object4[index];
+    if (state.replacer) {
+      value = state.replacer.call(object4, String(index), value);
+    }
+    if (writeNode2(state, level, value, false, false) || typeof value === "undefined" && writeNode2(state, level, null, false, false)) {
+      if (_result !== "")
+        _result += "," + (!state.condenseFlow ? " " : "");
+      _result += state.dump;
+    }
+  }
+  state.tag = _tag;
+  state.dump = "[" + _result + "]";
+}
+function writeBlockSequence2(state, level, object4, compact) {
+  var _result = "", _tag = state.tag, index, length, value;
+  for (index = 0, length = object4.length;index < length; index += 1) {
+    value = object4[index];
+    if (state.replacer) {
+      value = state.replacer.call(object4, String(index), value);
+    }
+    if (writeNode2(state, level + 1, value, true, true, false, true) || typeof value === "undefined" && writeNode2(state, level + 1, null, true, true, false, true)) {
+      if (!compact || _result !== "") {
+        _result += generateNextLine2(state, level);
+      }
+      if (state.dump && CHAR_LINE_FEED2 === state.dump.charCodeAt(0)) {
+        _result += "-";
+      } else {
+        _result += "- ";
+      }
+      _result += state.dump;
+    }
+  }
+  state.tag = _tag;
+  state.dump = _result || "[]";
+}
+function writeFlowMapping2(state, level, object4) {
+  var _result = "", _tag = state.tag, objectKeyList = Object.keys(object4), index, length, objectKey, objectValue, pairBuffer;
+  for (index = 0, length = objectKeyList.length;index < length; index += 1) {
+    pairBuffer = "";
+    if (_result !== "")
+      pairBuffer += ", ";
+    if (state.condenseFlow)
+      pairBuffer += '"';
+    objectKey = objectKeyList[index];
+    objectValue = object4[objectKey];
+    if (state.replacer) {
+      objectValue = state.replacer.call(object4, objectKey, objectValue);
+    }
+    if (!writeNode2(state, level, objectKey, false, false)) {
+      continue;
+    }
+    if (state.dump.length > 1024)
+      pairBuffer += "? ";
+    pairBuffer += state.dump + (state.condenseFlow ? '"' : "") + ":" + (state.condenseFlow ? "" : " ");
+    if (!writeNode2(state, level, objectValue, false, false)) {
+      continue;
+    }
+    pairBuffer += state.dump;
+    _result += pairBuffer;
+  }
+  state.tag = _tag;
+  state.dump = "{" + _result + "}";
+}
+function writeBlockMapping2(state, level, object4, compact) {
+  var _result = "", _tag = state.tag, objectKeyList = Object.keys(object4), index, length, objectKey, objectValue, explicitPair, pairBuffer;
+  if (state.sortKeys === true) {
+    objectKeyList.sort();
+  } else if (typeof state.sortKeys === "function") {
+    objectKeyList.sort(state.sortKeys);
+  } else if (state.sortKeys) {
+    throw new exception2("sortKeys must be a boolean or a function");
+  }
+  for (index = 0, length = objectKeyList.length;index < length; index += 1) {
+    pairBuffer = "";
+    if (!compact || _result !== "") {
+      pairBuffer += generateNextLine2(state, level);
+    }
+    objectKey = objectKeyList[index];
+    objectValue = object4[objectKey];
+    if (state.replacer) {
+      objectValue = state.replacer.call(object4, objectKey, objectValue);
+    }
+    if (!writeNode2(state, level + 1, objectKey, true, true, true)) {
+      continue;
+    }
+    explicitPair = state.tag !== null && state.tag !== "?" || state.dump && state.dump.length > 1024;
+    if (explicitPair) {
+      if (state.dump && CHAR_LINE_FEED2 === state.dump.charCodeAt(0)) {
+        pairBuffer += "?";
+      } else {
+        pairBuffer += "? ";
+      }
+    }
+    pairBuffer += state.dump;
+    if (explicitPair) {
+      pairBuffer += generateNextLine2(state, level);
+    }
+    if (!writeNode2(state, level + 1, objectValue, true, explicitPair)) {
+      continue;
+    }
+    if (state.dump && CHAR_LINE_FEED2 === state.dump.charCodeAt(0)) {
+      pairBuffer += ":";
+    } else {
+      pairBuffer += ": ";
+    }
+    pairBuffer += state.dump;
+    _result += pairBuffer;
+  }
+  state.tag = _tag;
+  state.dump = _result || "{}";
+}
+function detectType2(state, object4, explicit) {
+  var _result, typeList, index, length, type3, style;
+  typeList = explicit ? state.explicitTypes : state.implicitTypes;
+  for (index = 0, length = typeList.length;index < length; index += 1) {
+    type3 = typeList[index];
+    if ((type3.instanceOf || type3.predicate) && (!type3.instanceOf || typeof object4 === "object" && object4 instanceof type3.instanceOf) && (!type3.predicate || type3.predicate(object4))) {
+      if (explicit) {
+        if (type3.multi && type3.representName) {
+          state.tag = type3.representName(object4);
+        } else {
+          state.tag = type3.tag;
+        }
+      } else {
+        state.tag = "?";
+      }
+      if (type3.represent) {
+        style = state.styleMap[type3.tag] || type3.defaultStyle;
+        if (_toString2.call(type3.represent) === "[object Function]") {
+          _result = type3.represent(object4, style);
+        } else if (_hasOwnProperty2.call(type3.represent, style)) {
+          _result = type3.represent[style](object4, style);
+        } else {
+          throw new exception2("!<" + type3.tag + '> tag resolver accepts not "' + style + '" style');
+        }
+        state.dump = _result;
+      }
+      return true;
+    }
+  }
+  return false;
+}
+function writeNode2(state, level, object4, block, compact, iskey, isblockseq) {
+  state.tag = null;
+  state.dump = object4;
+  if (!detectType2(state, object4, false)) {
+    detectType2(state, object4, true);
+  }
+  var type3 = _toString2.call(state.dump);
+  var inblock = block;
+  var tagStr;
+  if (block) {
+    block = state.flowLevel < 0 || state.flowLevel > level;
+  }
+  var objectOrArray = type3 === "[object Object]" || type3 === "[object Array]", duplicateIndex, duplicate;
+  if (objectOrArray) {
+    duplicateIndex = state.duplicates.indexOf(object4);
+    duplicate = duplicateIndex !== -1;
+  }
+  if (state.tag !== null && state.tag !== "?" || duplicate || state.indent !== 2 && level > 0) {
+    compact = false;
+  }
+  if (duplicate && state.usedDuplicates[duplicateIndex]) {
+    state.dump = "*ref_" + duplicateIndex;
+  } else {
+    if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) {
+      state.usedDuplicates[duplicateIndex] = true;
+    }
+    if (type3 === "[object Object]") {
+      if (block && Object.keys(state.dump).length !== 0) {
+        writeBlockMapping2(state, level, state.dump, compact);
+        if (duplicate) {
+          state.dump = "&ref_" + duplicateIndex + state.dump;
+        }
+      } else {
+        writeFlowMapping2(state, level, state.dump);
+        if (duplicate) {
+          state.dump = "&ref_" + duplicateIndex + " " + state.dump;
+        }
+      }
+    } else if (type3 === "[object Array]") {
+      if (block && state.dump.length !== 0) {
+        if (state.noArrayIndent && !isblockseq && level > 0) {
+          writeBlockSequence2(state, level - 1, state.dump, compact);
+        } else {
+          writeBlockSequence2(state, level, state.dump, compact);
+        }
+        if (duplicate) {
+          state.dump = "&ref_" + duplicateIndex + state.dump;
+        }
+      } else {
+        writeFlowSequence2(state, level, state.dump);
+        if (duplicate) {
+          state.dump = "&ref_" + duplicateIndex + " " + state.dump;
+        }
+      }
+    } else if (type3 === "[object String]") {
+      if (state.tag !== "?") {
+        writeScalar2(state, state.dump, level, iskey, inblock);
+      }
+    } else if (type3 === "[object Undefined]") {
+      return false;
+    } else {
+      if (state.skipInvalid)
+        return false;
+      throw new exception2("unacceptable kind of an object to dump " + type3);
+    }
+    if (state.tag !== null && state.tag !== "?") {
+      tagStr = encodeURI(state.tag[0] === "!" ? state.tag.slice(1) : state.tag).replace(/!/g, "%21");
+      if (state.tag[0] === "!") {
+        tagStr = "!" + tagStr;
+      } else if (tagStr.slice(0, 18) === "tag:yaml.org,2002:") {
+        tagStr = "!!" + tagStr.slice(18);
+      } else {
+        tagStr = "!<" + tagStr + ">";
+      }
+      state.dump = tagStr + " " + state.dump;
+    }
+  }
+  return true;
+}
+function getDuplicateReferences2(object4, state) {
+  var objects = [], duplicatesIndexes = [], index, length;
+  inspectNode2(object4, objects, duplicatesIndexes);
+  for (index = 0, length = duplicatesIndexes.length;index < length; index += 1) {
+    state.duplicates.push(objects[duplicatesIndexes[index]]);
+  }
+  state.usedDuplicates = new Array(length);
+}
+function inspectNode2(object4, objects, duplicatesIndexes) {
+  var objectKeyList, index, length;
+  if (object4 !== null && typeof object4 === "object") {
+    index = objects.indexOf(object4);
+    if (index !== -1) {
+      if (duplicatesIndexes.indexOf(index) === -1) {
+        duplicatesIndexes.push(index);
+      }
+    } else {
+      objects.push(object4);
+      if (Array.isArray(object4)) {
+        for (index = 0, length = object4.length;index < length; index += 1) {
+          inspectNode2(object4[index], objects, duplicatesIndexes);
+        }
+      } else {
+        objectKeyList = Object.keys(object4);
+        for (index = 0, length = objectKeyList.length;index < length; index += 1) {
+          inspectNode2(object4[objectKeyList[index]], objects, duplicatesIndexes);
+        }
+      }
+    }
+  }
+}
+function dump$12(input, options) {
+  options = options || {};
+  var state = new State2(options);
+  if (!state.noRefs)
+    getDuplicateReferences2(input, state);
+  var value = input;
+  if (state.replacer) {
+    value = state.replacer.call({ "": value }, "", value);
+  }
+  if (writeNode2(state, 0, value, true, true))
+    return state.dump + `
+`;
+  return "";
+}
+var dump_12 = dump$12;
+var dumper2 = {
+  dump: dump_12
+};
+function renamed2(from, to) {
+  return function() {
+    throw new Error("Function yaml." + from + " is removed in js-yaml 4. " + "Use yaml." + to + " instead, which is now safe by default.");
+  };
+}
+var load2 = loader2.load;
+var loadAll2 = loader2.loadAll;
+var dump2 = dumper2.dump;
+var safeLoad2 = renamed2("safeLoad", "load");
+var safeLoadAll2 = renamed2("safeLoadAll", "loadAll");
+var safeDump2 = renamed2("safeDump", "dump");
+
+// node_modules/pg-connection-string/esm/index.mjs
+var import___ = __toESM(require_pg_connection_string(), 1);
+var esm_default = import___.default.parse;
+var parse5 = import___.default.parse;
+var toClientConfig = import___.default.toClientConfig;
+var parseIntoClientConfig = import___.default.parseIntoClientConfig;
+
+// lib/instances.ts
+class InstancesParseError extends Error {
+  constructor(file, cause) {
+    const causeMsg = cause instanceof Error ? cause.message : String(cause);
+    super(`Failed to parse ${file}: ${causeMsg}`);
+    this.name = "InstancesParseError";
+  }
+}
+function loadInstances(file) {
+  if (!fs7.existsSync(file))
+    return [];
+  if (fs7.lstatSync(file).isDirectory())
+    return [];
+  const text = fs7.readFileSync(file, "utf8");
+  if (text.trim() === "")
+    return [];
+  let parsed;
+  try {
+    parsed = load2(text);
+  } catch (err) {
+    throw new InstancesParseError(file, err);
+  }
+  if (parsed === null || parsed === undefined)
+    return [];
+  if (!Array.isArray(parsed)) {
+    throw new InstancesParseError(file, "expected a YAML list at the document root");
+  }
+  return parsed;
+}
+function buildInstance(name, connStr) {
+  return {
+    name,
+    conn_str: connStr,
+    preset_metrics: "full",
+    custom_metrics: null,
+    is_enabled: true,
+    group: "default",
+    custom_tags: {
+      env: "production",
+      cluster: "default",
+      node_name: name,
+      sink_type: "~sink_type~"
+    }
+  };
+}
+function addInstanceToFile(file, instance) {
+  if (fs7.existsSync(file) && fs7.lstatSync(file).isDirectory()) {
+    fs7.rmSync(file, { recursive: true, force: true });
+  }
+  const existing = loadInstances(file);
+  if (existing.some((i3) => i3.name === instance.name)) {
+    throw new Error(`Monitoring target '${instance.name}' already exists`);
+  }
+  existing.push(instance);
+  fs7.writeFileSync(file, dump2(existing), "utf8");
+}
+function removeInstanceFromFile(file, name) {
+  const instances = loadInstances(file);
+  const filtered = instances.filter((i3) => i3.name !== name);
+  if (filtered.length === instances.length)
+    return false;
+  fs7.writeFileSync(file, dump2(filtered), "utf8");
+  return true;
+}
+function extractSslmode(connStr) {
+  try {
+    return (new URL(connStr).searchParams.get("sslmode") || "").toLowerCase();
+  } catch {
+    return "";
+  }
+}
+function sslOptionFromSslmode(sslmode) {
+  switch (sslmode) {
+    case "disable":
+      return false;
+    case "verify-ca":
+      return { rejectUnauthorized: true, checkServerIdentity: () => {
+        return;
+      } };
+    case "verify-full":
+      return { rejectUnauthorized: true };
+    case "allow":
+    case "prefer":
+    case "require":
+    case "no-verify":
+    case "":
+    default:
+      return { rejectUnauthorized: false };
+  }
+}
+var LAX_SSLMODES = new Set(["", "allow", "prefer", "require"]);
+function isLaxSslmode(sslmode) {
+  return LAX_SSLMODES.has(sslmode);
+}
+function warnIfLaxSslmode(connStr) {
+  const sslmode = extractSslmode(connStr);
+  if (!isLaxSslmode(sslmode))
+    return;
+  const shown = sslmode || "(unset)";
+  console.error(`⚠ sslmode=${shown}: TLS chain is NOT verified (matches libpq/psql semantics). ` + `Use sslmode=verify-full for full chain+hostname verification.`);
+}
+function buildClientConfig(connStr, extra = {}) {
+  const sslmode = extractSslmode(connStr);
+  const parsed = parse5(withoutSslmode(connStr));
+  return {
+    host: parsed.host || undefined,
+    port: parsed.port ? Number(parsed.port) : undefined,
+    user: parsed.user,
+    password: parsed.password,
+    database: parsed.database || undefined,
+    ssl: sslOptionFromSslmode(sslmode),
+    ...extra
+  };
+}
+function withoutSslmode(connStr) {
+  try {
+    const u = new URL(connStr);
+    u.searchParams.delete("sslmode");
+    return u.toString();
+  } catch {
+    return connStr;
+  }
+}
+
+// bin/postgres-ai.ts
+var nodeVersion = parseInt(process.versions.node.split(".")[0], 10);
+if (nodeVersion < 18) {
+  console.error(`\x1B[31mError: postgresai requires Node 18 or higher.\x1B[0m`);
+  console.error(`You are running Node.js ${process.versions.node}.`);
+  console.error(`Please upgrade to Node.js 20 LTS or Node.js 22 for security updates.`);
+  console.error(`
+Download: https://nodejs.org/`);
+  process.exit(1);
+}
+var rl = null;
+function getReadline() {
+  if (!rl) {
+    rl = createInterface({ input: process.stdin, output: process.stdout });
+  }
+  return rl;
+}
+function closeReadline() {
+  if (rl) {
+    rl.close();
+    rl = null;
+  }
+}
+function stripMatchingQuotes(value) {
+  const trimmed = value.trim();
+  const quote = trimmed[0];
+  if (trimmed.length >= 2 && (quote === '"' || quote === "'") && trimmed.endsWith(quote)) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+async function execFilePromise(file, args) {
+  return new Promise((resolve8, reject) => {
+    childProcess.execFile(file, args, (error2, stdout, stderr) => {
+      if (error2) {
+        const err = error2;
+        err.code = typeof error2.code === "number" ? error2.code : 1;
+        reject(err);
+      } else {
+        resolve8({ stdout, stderr });
+      }
+    });
+  });
+}
+function spawnSync2(cmd, args, options) {
+  const result = childProcess.spawnSync(cmd, args, {
+    stdio: options?.stdio === "inherit" ? "inherit" : "pipe",
+    env: options?.env,
+    cwd: options?.cwd,
+    encoding: "utf8"
+  });
+  return {
+    status: result.status,
+    stdout: typeof result.stdout === "string" ? result.stdout : "",
+    stderr: typeof result.stderr === "string" ? result.stderr : ""
+  };
+}
+function spawn2(cmd, args, options) {
+  const proc = childProcess.spawn(cmd, args, {
+    stdio: options?.stdio ?? "pipe",
+    env: options?.env,
+    cwd: options?.cwd,
+    detached: options?.detached
+  });
+  return {
+    on(event, cb) {
+      if (event === "close" || event === "exit") {
+        proc.on(event, (code, signal) => cb(code, signal ?? undefined));
+      } else if (event === "error") {
+        proc.on("error", (err) => cb(null, String(err)));
+      }
+      return this;
+    },
+    unref() {
+      proc.unref();
+    },
+    pid: proc.pid
+  };
+}
+async function question(prompt) {
+  return new Promise((resolve8) => {
+    getReadline().question(prompt, (answer) => {
+      resolve8(answer);
+    });
+  });
+}
+function expandHomePath(p) {
+  const s = (p || "").trim();
+  if (!s)
+    return s;
+  if (s === "~")
+    return os3.homedir();
+  if (s.startsWith("~/") || s.startsWith("~\\")) {
+    return path7.join(os3.homedir(), s.slice(2));
+  }
+  return s;
+}
+function createTtySpinner(enabled, initialText) {
+  if (!enabled) {
+    return {
+      update: () => {},
+      stop: () => {}
+    };
+  }
+  const frames = ["|", "/", "-", "\\"];
+  const startTs = Date.now();
+  let text = initialText;
+  let frameIdx = 0;
+  let stopped = false;
+  const render = () => {
+    if (stopped)
+      return;
+    const elapsedSec = ((Date.now() - startTs) / 1000).toFixed(1);
+    const frame = frames[frameIdx % frames.length] ?? frames[0] ?? "\u283F";
+    frameIdx += 1;
+    process.stdout.write(`\r\x1B[2K${frame} ${text} (${elapsedSec}s)`);
+  };
+  const timer = setInterval(render, 120);
+  render();
+  return {
+    update: (t) => {
+      text = t;
+      render();
+    },
+    stop: (finalText) => {
+      if (stopped)
+        return;
+      stopped = true;
+      clearInterval(timer);
+      process.stdout.write("\r\x1B[2K");
+      if (finalText && finalText.trim()) {
+        process.stdout.write(finalText);
+      }
+      process.stdout.write(`
+`);
+    }
+  };
+}
+function prepareOutputDirectory(outputOpt) {
+  if (!outputOpt)
+    return;
+  const outputDir = expandHomePath(outputOpt);
+  const outputPath = path7.isAbsolute(outputDir) ? outputDir : path7.resolve(process.cwd(), outputDir);
+  if (!fs8.existsSync(outputPath)) {
+    try {
+      fs8.mkdirSync(outputPath, { recursive: true });
+    } catch (e) {
+      const errAny = e;
+      const code = typeof errAny?.code === "string" ? errAny.code : "";
+      const msg = errAny instanceof Error ? errAny.message : String(errAny);
+      if (code === "EACCES" || code === "EPERM" || code === "ENOENT") {
+        console.error(`Error: Failed to create output directory: ${outputPath}`);
+        console.error(`Reason: ${msg}`);
+        console.error("Tip: choose a writable path, e.g. --output ./reports or --output ~/reports");
+        return null;
+      }
+      throw e;
+    }
+  }
+  return outputPath;
+}
+function prepareUploadConfig(opts, rootOpts, shouldUpload, uploadExplicitlyRequested) {
+  if (!shouldUpload)
+    return;
+  const { apiKey } = getConfig(rootOpts);
+  if (!apiKey) {
+    if (uploadExplicitlyRequested) {
+      console.error("Error: API key is required for upload");
+      console.error("Tip: run 'postgresai auth' or pass --api-key / set PGAI_API_KEY");
+      return null;
+    }
+    return;
+  }
+  const cfg = readConfig();
+  const { apiBaseUrl } = resolveBaseUrls2(rootOpts, cfg);
+  let project = (opts.project || cfg.defaultProject || "").trim();
+  let projectWasGenerated = false;
+  if (!project) {
+    project = `project_${crypto2.randomBytes(6).toString("hex")}`;
+    projectWasGenerated = true;
+    try {
+      writeConfig({ defaultProject: project });
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      console.error(`Warning: Failed to save generated default project: ${message}`);
+    }
+  }
+  return {
+    config: { apiKey, apiBaseUrl, project },
+    projectWasGenerated
+  };
+}
+async function uploadCheckupReports(uploadCfg, reports, spinner, logUpload) {
+  spinner.update("Creating remote checkup report");
+  const created = await withRetry(() => createCheckupReport({
+    apiKey: uploadCfg.apiKey,
+    apiBaseUrl: uploadCfg.apiBaseUrl,
+    project: uploadCfg.project
+  }), { maxAttempts: 3 }, (attempt, err, delayMs) => {
+    const errMsg = err instanceof Error ? err.message : String(err);
+    logUpload(`[Retry ${attempt}/3] createCheckupReport failed: ${errMsg}, retrying in ${delayMs}ms...`);
+  });
+  const reportId = created.reportId;
+  const uploaded = [];
+  for (const [checkId, report] of Object.entries(reports)) {
+    spinner.update(`Uploading ${checkId}.json`);
+    const jsonText = JSON.stringify(report, null, 2);
+    const r = await withRetry(() => uploadCheckupReportJson({
+      apiKey: uploadCfg.apiKey,
+      apiBaseUrl: uploadCfg.apiBaseUrl,
+      reportId,
+      filename: `${checkId}.json`,
+      checkId,
+      jsonText
+    }), { maxAttempts: 3 }, (attempt, err, delayMs) => {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      logUpload(`[Retry ${attempt}/3] Upload ${checkId}.json failed: ${errMsg}, retrying in ${delayMs}ms...`);
+    });
+    uploaded.push({ checkId, filename: `${checkId}.json`, chunkId: r.reportChunkId });
+  }
+  return { project: uploadCfg.project, reportId, uploaded };
+}
+function writeReportFiles(reports, outputPath) {
+  for (const [checkId, report] of Object.entries(reports)) {
+    const filePath = path7.join(outputPath, `${checkId}.json`);
+    fs8.writeFileSync(filePath, JSON.stringify(report, null, 2), "utf8");
+    const title = report.checkTitle || checkId;
+    console.log(`\u2713 ${checkId} ${title}: ${filePath}`);
+  }
+}
+function printUploadSummary(summary, projectWasGenerated, useStderr, reports) {
+  const out = useStderr ? console.error : console.log;
+  out(`
+Checkup report uploaded`);
+  out(`======================
+`);
+  if (projectWasGenerated) {
+    out(`Project: ${summary.project} (generated and saved as default)`);
+  } else {
+    out(`Project: ${summary.project}`);
+  }
+  out(`Report ID: ${summary.reportId}`);
+  out("View in Console: console.postgres.ai \u2192 Checkup \u2192 checkup reports");
+  out("");
+  const summaries = [];
+  let skippedCount = 0;
+  for (const item of summary.uploaded) {
+    const report = reports[item.checkId];
+    if (report) {
+      const { status, message } = generateCheckSummary(item.checkId, report);
+      const title = report.checkTitle || item.checkId;
+      const isSignificant = status !== "info" || /\d/.test(message) || message.includes("PostgreSQL") || message.includes("Version");
+      if (isSignificant) {
+        summaries.push({ checkId: item.checkId, title, status, message });
+      } else {
+        skippedCount++;
+      }
+    }
+  }
+  for (const { checkId, title, message } of summaries) {
+    out(`  ${checkId} (${title}): ${message}`);
+  }
+  if (skippedCount > 0) {
+    out(`  ${skippedCount} other check${skippedCount > 1 ? "s" : ""} completed`);
+  }
+}
+function getDefaultMonitoringProjectDir() {
+  const override = process.env.PGAI_PROJECT_DIR;
+  if (override && override.trim())
+    return override.trim();
+  return path7.join(getConfigDir(), "monitoring");
+}
+async function downloadText(url) {
+  const controller = new AbortController;
+  const timeout = setTimeout(() => controller.abort(), 15000);
+  try {
+    const response = await fetch(url, { signal: controller.signal });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status} for ${url}`);
+    }
+    return await response.text();
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function ensureDefaultMonitoringProject() {
+  const projectDir = getDefaultMonitoringProjectDir();
+  const composeFile = path7.resolve(projectDir, "docker-compose.yml");
+  const instancesFile = path7.resolve(projectDir, "instances.yml");
+  if (!fs8.existsSync(projectDir)) {
+    fs8.mkdirSync(projectDir, { recursive: true, mode: 448 });
+  }
+  if (!fs8.existsSync(composeFile)) {
+    const refs = [
+      process.env.PGAI_PROJECT_REF,
+      package_default.version,
+      `v${package_default.version}`,
+      "main"
+    ].filter((v) => Boolean(v && v.trim()));
+    let lastErr;
+    for (const ref of refs) {
+      const url = `https://gitlab.com/postgres-ai/postgres_ai/-/raw/${encodeURIComponent(ref)}/docker-compose.yml`;
+      try {
+        const text = await downloadText(url);
+        fs8.writeFileSync(composeFile, text, { encoding: "utf8", mode: 384 });
+        break;
+      } catch (err) {
+        lastErr = err;
+      }
+    }
+    if (!fs8.existsSync(composeFile)) {
+      const msg = lastErr instanceof Error ? lastErr.message : String(lastErr);
+      throw new Error(`Failed to bootstrap docker-compose.yml: ${msg}`);
+    }
+  }
+  if (fs8.existsSync(instancesFile) && fs8.lstatSync(instancesFile).isDirectory()) {
+    fs8.rmSync(instancesFile, { recursive: true, force: true });
+  }
+  if (!fs8.existsSync(instancesFile)) {
+    const header = `# PostgreSQL instances to monitor
+` + `# Add your instances using: pgai mon targets add <connection-string> <name>
+
+`;
+    fs8.writeFileSync(instancesFile, header, { encoding: "utf8", mode: 384 });
+  }
+  const pgwatchConfig = path7.resolve(projectDir, ".pgwatch-config");
+  if (!fs8.existsSync(pgwatchConfig)) {
+    fs8.writeFileSync(pgwatchConfig, "", { encoding: "utf8", mode: 384 });
+  }
+  const envFile = path7.resolve(projectDir, ".env");
+  if (!fs8.existsSync(envFile)) {
+    const envText = `PGAI_TAG=${package_default.version}
+# PGAI_REGISTRY=registry.gitlab.com/postgres-ai/postgres_ai
+`;
+    fs8.writeFileSync(envFile, envText, { encoding: "utf8", mode: 384 });
+  }
+  return { fs: fs8, path: path7, projectDir, composeFile, instancesFile };
+}
+function getConfig(opts) {
+  let apiKey = opts.apiKey || process.env.PGAI_API_KEY || "";
+  if (!apiKey) {
+    const fileConfig = readConfig();
+    if (!apiKey)
+      apiKey = fileConfig.apiKey || "";
+  }
+  return { apiKey };
+}
+function printResult(result, json3) {
+  if (typeof result === "string") {
+    process.stdout.write(result);
+    if (!/\n$/.test(result))
+      console.log();
+    return;
+  }
+  if (json3 || !process.stdout.isTTY) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    let text = dump(result);
+    if (Array.isArray(result)) {
+      text = text.replace(/\n- /g, `
+
+- `);
+    }
+    console.log(text);
+  }
+}
+var program2 = new Command;
+program2.name("postgres-ai").description("PostgresAI CLI").version(package_default.version).option("--api-key <key>", "API key (overrides PGAI_API_KEY)").option("--api-base-url <url>", "API base URL for backend RPC (overrides PGAI_API_BASE_URL)").option("--ui-base-url <url>", "UI base URL for browser routes (overrides PGAI_UI_BASE_URL)").option("--storage-base-url <url>", "Storage base URL for file uploads (overrides PGAI_STORAGE_BASE_URL)");
+program2.command("set-default-project <project>").description("store default project for checkup uploads").action(async (project) => {
+  const value = (project || "").trim();
+  if (!value) {
+    console.error("Error: project is required");
+    process.exitCode = 1;
+    return;
+  }
+  writeConfig({ defaultProject: value });
+  console.log(`Default project saved: ${value}`);
+});
+program2.command("set-storage-url <url>").description("store storage base URL for file uploads").action(async (url) => {
+  const value = (url || "").trim();
+  if (!value) {
+    console.error("Error: url is required");
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    const { normalizeBaseUrl: normalizeBaseUrl3 } = await Promise.resolve().then(() => (init_util(), exports_util2));
+    const normalized = normalizeBaseUrl3(value);
+    writeConfig({ storageBaseUrl: normalized });
     console.log(`Storage URL saved: ${normalized}`);
   } catch {
     console.error(`Error: invalid URL: ${value}`);
@@ -32093,9 +34874,9 @@ function resolvePaths() {
   let currentDir = startDir;
   while (true) {
     const composeFile = path7.resolve(currentDir, "docker-compose.yml");
-    if (fs7.existsSync(composeFile)) {
+    if (fs8.existsSync(composeFile)) {
       const instancesFile = path7.resolve(currentDir, "instances.yml");
-      return { fs: fs7, path: path7, projectDir: currentDir, composeFile, instancesFile };
+      return { fs: fs8, path: path7, projectDir: currentDir, composeFile, instancesFile };
     }
     const parentDir = path7.dirname(currentDir);
     if (parentDir === currentDir)
@@ -32179,10 +34960,10 @@ Debug: Registering monitoring instance...`);
 }
 function updatePgwatchConfig(configPath, updates) {
   let lines = [];
-  if (fs7.existsSync(configPath)) {
-    const stats = fs7.statSync(configPath);
+  if (fs8.existsSync(configPath)) {
+    const stats = fs8.statSync(configPath);
     if (!stats.isDirectory()) {
-      const content = fs7.readFileSync(configPath, "utf8");
+      const content = fs8.readFileSync(configPath, "utf8");
       lines = content.split(/\r?\n/).filter((l) => l.trim() !== "");
     }
   }
@@ -32194,7 +34975,7 @@ function updatePgwatchConfig(configPath, updates) {
       lines.push(`${key}=${value}`);
     }
   }
-  fs7.writeFileSync(configPath, lines.join(`
+  fs8.writeFileSync(configPath, lines.join(`
 `) + `
 `, { encoding: "utf8", mode: 384 });
 }
@@ -32225,11 +35006,11 @@ async function runCompose(args, grafanaPassword) {
     env.GF_SECURITY_ADMIN_PASSWORD = grafanaPassword;
   } else {
     const cfgPath = path7.resolve(projectDir, ".pgwatch-config");
-    if (fs7.existsSync(cfgPath)) {
+    if (fs8.existsSync(cfgPath)) {
       try {
-        const stats = fs7.statSync(cfgPath);
+        const stats = fs8.statSync(cfgPath);
         if (!stats.isDirectory()) {
-          const content = fs7.readFileSync(cfgPath, "utf8");
+          const content = fs8.readFileSync(cfgPath, "utf8");
           const match = content.match(/^grafana_password=([^\r\n]+)/m);
           if (match) {
             env.GF_SECURITY_ADMIN_PASSWORD = match[1].trim();
@@ -32243,9 +35024,9 @@ async function runCompose(args, grafanaPassword) {
     }
   }
   const envFilePath = path7.resolve(projectDir, ".env");
-  if (fs7.existsSync(envFilePath)) {
+  if (fs8.existsSync(envFilePath)) {
     try {
-      const envContent = fs7.readFileSync(envFilePath, "utf8");
+      const envContent = fs8.readFileSync(envFilePath, "utf8");
       if (!env.VM_AUTH_USERNAME) {
         const m = envContent.match(/^VM_AUTH_USERNAME=([^\r\n]+)/m);
         if (m)
@@ -32279,7 +35060,16 @@ program2.command("help", { isDefault: true }).description("show help").action(()
   program2.outputHelp();
 });
 var mon = program2.command("mon").description("monitoring services management");
-mon.command("local-install").description("install local monitoring stack (generate config, start services)").option("--demo", "demo mode with sample database", false).option("--api-key <key>", "Postgres AI API key for automated report uploads").option("--db-url <url>", "PostgreSQL connection URL to monitor").option("--tag <tag>", "Docker image tag to use (e.g., 0.14.0, 0.14.0-dev.33)").option("--project <name>", "Docker Compose project name (default: postgres_ai)").option("-y, --yes", "accept all defaults and skip interactive prompts", false).action(async (opts) => {
+mon.command("local-install").description("install local monitoring stack (generate config, start services)").addHelpText("after", [
+  "",
+  "Networking:",
+  "  Compose enables IPv6 on the project's default network so containers can",
+  "  reach IPv6-only databases (e.g. Supabase free-tier db.<ref>.supabase.co).",
+  "  Override on hosts whose Docker daemon cannot create an IPv6 network:",
+  "      PGAI_ENABLE_IPV6=false   (accepted: true|false|yes|no, lowercase)",
+  ""
+].join(`
+`)).option("--demo", "demo mode with sample database", false).option("--api-key <key>", "Postgres AI API key for automated report uploads").option("--db-url <url>", "PostgreSQL connection URL to monitor").option("--tag <tag>", "Docker image tag to use (e.g., 0.14.0, 0.14.0-dev.33)").option("--project <name>", "Docker Compose project name (default: postgres_ai)").option("-y, --yes", "accept all defaults and skip interactive prompts", false).action(async (opts) => {
   const globalOpts = program2.opts();
   let apiKey = opts.apiKey || globalOpts.apiKey;
   console.log(`
@@ -32304,8 +35094,8 @@ mon.command("local-install").description("install local monitoring stack (genera
   let existingReplicatorPassword = null;
   let existingVmAuthUsername = null;
   let existingVmAuthPassword = null;
-  if (fs7.existsSync(envFile)) {
-    const existingEnv = fs7.readFileSync(envFile, "utf8");
+  if (fs8.existsSync(envFile)) {
+    const existingEnv = fs8.readFileSync(envFile, "utf8");
     const registryMatch = existingEnv.match(/^PGAI_REGISTRY=(.+)$/m);
     if (registryMatch)
       existingRegistry = registryMatch[1].trim();
@@ -32333,7 +35123,7 @@ mon.command("local-install").description("install local monitoring stack (genera
   envLines.push(`REPLICATOR_PASSWORD=${existingReplicatorPassword || crypto2.randomBytes(32).toString("hex")}`);
   envLines.push(`VM_AUTH_USERNAME=${existingVmAuthUsername || "vmauth"}`);
   envLines.push(`VM_AUTH_PASSWORD=${existingVmAuthPassword || crypto2.randomBytes(18).toString("base64")}`);
-  fs7.writeFileSync(envFile, envLines.join(`
+  fs8.writeFileSync(envFile, envLines.join(`
 `) + `
 `, { encoding: "utf8", mode: 384 });
   if (opts.tag) {
@@ -32420,7 +35210,7 @@ Use demo mode without API key: postgres-ai mon local-install --demo`);
 # Add your instances using: postgres-ai mon targets add
 
 `;
-    fs7.writeFileSync(instancesPath2, emptyInstancesContent, "utf8");
+    fs8.writeFileSync(instancesPath2, emptyInstancesContent, "utf8");
     console.log(`Instances file: ${instancesPath2}`);
     console.log(`Project directory: ${projectDir2}
 `);
@@ -32440,26 +35230,15 @@ Use demo mode without API key: postgres-ai mon local-install --demo`);
       const host = m[3];
       const db = m[5];
       const instanceName = `${host}-${db}`.replace(/[^a-zA-Z0-9-]/g, "-");
-      const body = `- name: ${instanceName}
-  conn_str: ${connStr}
-  preset_metrics: full
-  custom_metrics:
-  is_enabled: true
-  group: default
-  custom_tags:
-    env: production
-    cluster: default
-    node_name: ${instanceName}
-    sink_type: ~sink_type~
-`;
-      fs7.appendFileSync(instancesPath2, body, "utf8");
+      addInstanceToFile(instancesPath2, buildInstance(instanceName, connStr));
       console.log(`\u2713 Monitoring target '${instanceName}' added
 `);
       console.log("Testing connection to the added instance...");
       {
         let testClient = null;
         try {
-          testClient = new Client({ connectionString: connStr, connectionTimeoutMillis: 1e4 });
+          warnIfLaxSslmode(connStr);
+          testClient = new Client(buildClientConfig(connStr, { connectionTimeoutMillis: 1e4 }));
           await testClient.connect();
           const result = await testClient.query("select version();");
           console.log("\u2713 Connection successful");
@@ -32500,26 +35279,15 @@ You can provide either:`);
             const host = m[3];
             const db = m[5];
             const instanceName = `${host}-${db}`.replace(/[^a-zA-Z0-9-]/g, "-");
-            const body = `- name: ${instanceName}
-  conn_str: ${connStr}
-  preset_metrics: full
-  custom_metrics:
-  is_enabled: true
-  group: default
-  custom_tags:
-    env: production
-    cluster: default
-    node_name: ${instanceName}
-    sink_type: ~sink_type~
-`;
-            fs7.appendFileSync(instancesPath2, body, "utf8");
+            addInstanceToFile(instancesPath2, buildInstance(instanceName, connStr));
             console.log(`\u2713 Monitoring target '${instanceName}' added
 `);
             console.log("Testing connection to the added instance...");
             {
               let testClient = null;
               try {
-                testClient = new Client({ connectionString: connStr, connectionTimeoutMillis: 1e4 });
+                warnIfLaxSslmode(connStr);
+                testClient = new Client(buildClientConfig(connStr, { connectionTimeoutMillis: 1e4 }));
                 await testClient.connect();
                 const result = await testClient.query("select version();");
                 console.log("\u2713 Connection successful");
@@ -32551,12 +35319,12 @@ You can provide either:`);
       path7.resolve(currentDir, "..", "..", "instances.demo.yml"),
       path7.resolve(currentDir, "..", "..", "..", "instances.demo.yml")
     ];
-    const demoSrc = demoCandidates.find((p) => fs7.existsSync(p));
+    const demoSrc = demoCandidates.find((p) => fs8.existsSync(p));
     if (demoSrc) {
-      if (fs7.existsSync(instancesPath) && fs7.lstatSync(instancesPath).isDirectory()) {
-        fs7.rmSync(instancesPath, { recursive: true, force: true });
+      if (fs8.existsSync(instancesPath) && fs8.lstatSync(instancesPath).isDirectory()) {
+        fs8.rmSync(instancesPath, { recursive: true, force: true });
       }
-      fs7.copyFileSync(demoSrc, instancesPath);
+      fs8.copyFileSync(demoSrc, instancesPath);
       console.log(`\u2713 Demo monitoring target configured
 `);
     } else {
@@ -32580,10 +35348,10 @@ Searched: ${demoCandidates.join(", ")}
   let vmAuthUsername = "";
   let vmAuthPassword = "";
   try {
-    if (fs7.existsSync(cfgPath)) {
-      const stats = fs7.statSync(cfgPath);
+    if (fs8.existsSync(cfgPath)) {
+      const stats = fs8.statSync(cfgPath);
       if (!stats.isDirectory()) {
-        const content = fs7.readFileSync(cfgPath, "utf8");
+        const content = fs8.readFileSync(cfgPath, "utf8");
         const match = content.match(/^grafana_password=([^\r\n]+)/m);
         if (match) {
           grafanaPassword = match[1].trim();
@@ -32595,15 +35363,15 @@ Searched: ${demoCandidates.join(", ")}
       const { stdout: password } = await execFilePromise("openssl", ["rand", "-base64", "12"]);
       grafanaPassword = password.trim().replace(/\n/g, "");
       let configContent = "";
-      if (fs7.existsSync(cfgPath)) {
-        const stats = fs7.statSync(cfgPath);
+      if (fs8.existsSync(cfgPath)) {
+        const stats = fs8.statSync(cfgPath);
         if (!stats.isDirectory()) {
-          configContent = fs7.readFileSync(cfgPath, "utf8");
+          configContent = fs8.readFileSync(cfgPath, "utf8");
         }
       }
       const lines = configContent.split(/\r?\n/).filter((l) => !/^grafana_password=/.test(l));
       lines.push(`grafana_password=${grafanaPassword}`);
-      fs7.writeFileSync(cfgPath, lines.filter(Boolean).join(`
+      fs8.writeFileSync(cfgPath, lines.filter(Boolean).join(`
 `) + `
 `, "utf8");
     }
@@ -32617,8 +35385,8 @@ Searched: ${demoCandidates.join(", ")}
   }
   try {
     const envFile2 = path7.resolve(projectDir, ".env");
-    if (fs7.existsSync(envFile2)) {
-      const envContent = fs7.readFileSync(envFile2, "utf8");
+    if (fs8.existsSync(envFile2)) {
+      const envContent = fs8.readFileSync(envFile2, "utf8");
       const userMatch = envContent.match(/^VM_AUTH_USERNAME=([^\r\n]+)/m);
       const passMatch = envContent.match(/^VM_AUTH_PASSWORD=([^\r\n]+)/m);
       if (userMatch)
@@ -32634,13 +35402,13 @@ Searched: ${demoCandidates.join(", ")}
         vmAuthPassword = vmPass.trim().replace(/\n/g, "");
       }
       let envContent = "";
-      if (fs7.existsSync(envFile2)) {
-        envContent = fs7.readFileSync(envFile2, "utf8");
+      if (fs8.existsSync(envFile2)) {
+        envContent = fs8.readFileSync(envFile2, "utf8");
       }
-      const envLines2 = envContent.split(/\r?\n/).filter((l) => !/^VM_AUTH_USERNAME=/.test(l) && !/^VM_AUTH_PASSWORD=/.test(l)).filter((l, i2, arr) => !(i2 === arr.length - 1 && l === ""));
+      const envLines2 = envContent.split(/\r?\n/).filter((l) => !/^VM_AUTH_USERNAME=/.test(l) && !/^VM_AUTH_PASSWORD=/.test(l)).filter((l, i3, arr) => !(i3 === arr.length - 1 && l === ""));
       envLines2.push(`VM_AUTH_USERNAME=${vmAuthUsername}`);
       envLines2.push(`VM_AUTH_PASSWORD=${vmAuthPassword}`);
-      fs7.writeFileSync(envFile2, envLines2.join(`
+      fs8.writeFileSync(envFile2, envLines2.join(`
 `) + `
 `, { encoding: "utf8", mode: 384 });
     }
@@ -32849,11 +35617,11 @@ mon.command("config").description("show monitoring services configuration").acti
   console.log(`Project Directory: ${projectDir}`);
   console.log(`Docker Compose File: ${composeFile}`);
   console.log(`Instances File: ${instancesFile}`);
-  if (fs7.existsSync(instancesFile) && !fs7.lstatSync(instancesFile).isDirectory()) {
+  if (fs8.existsSync(instancesFile) && !fs8.lstatSync(instancesFile).isDirectory()) {
     console.log(`
 Instances configuration:
 `);
-    const text = fs7.readFileSync(instancesFile, "utf8");
+    const text = fs8.readFileSync(instancesFile, "utf8");
     process.stdout.write(text);
     if (!/\n$/.test(text))
       console.log();
@@ -32869,7 +35637,7 @@ mon.command("update").description("update monitoring stack").action(async () =>
 `);
   try {
     const gitDir = path7.resolve(process.cwd(), ".git");
-    if (!fs7.existsSync(gitDir)) {
+    if (!fs8.existsSync(gitDir)) {
       console.error("Not a git repository. Cannot update.");
       process.exitCode = 1;
       return;
@@ -33024,42 +35792,33 @@ mon.command("check").description("monitoring services system readiness check").a
 var targets = mon.command("targets").description("manage databases to monitor");
 targets.command("list").description("list monitoring target databases").action(async () => {
   const { instancesFile: instancesPath, projectDir } = await resolveOrInitPaths();
-  if (!fs7.existsSync(instancesPath) || fs7.lstatSync(instancesPath).isDirectory()) {
+  if (!fs8.existsSync(instancesPath) || fs8.lstatSync(instancesPath).isDirectory()) {
     console.error(`instances.yml not found in ${projectDir}`);
     process.exitCode = 1;
     return;
   }
+  let instances;
   try {
-    const content = fs7.readFileSync(instancesPath, "utf8");
-    const instances = load(content);
-    if (!instances || !Array.isArray(instances) || instances.length === 0) {
-      console.log("No monitoring targets configured");
-      console.log("");
-      console.log("To add a monitoring target:");
-      console.log("  postgres-ai mon targets add <connection-string> <name>");
-      console.log("");
-      console.log("Example:");
-      console.log("  postgres-ai mon targets add 'postgresql://user:pass@host:5432/db' my-db");
-      return;
-    }
-    const filtered = instances.filter((inst) => inst.name && inst.is_enabled !== false);
-    if (filtered.length === 0) {
-      console.log("No monitoring targets configured");
-      console.log("");
-      console.log("To add a monitoring target:");
-      console.log("  postgres-ai mon targets add <connection-string> <name>");
-      console.log("");
-      console.log("Example:");
-      console.log("  postgres-ai mon targets add 'postgresql://user:pass@host:5432/db' my-db");
-      return;
-    }
-    for (const inst of filtered) {
-      console.log(`Target: ${inst.name}`);
-    }
+    instances = loadInstances(instancesPath);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     console.error(`Error parsing instances.yml: ${message}`);
     process.exitCode = 1;
+    return;
+  }
+  const filtered = instances.filter((inst) => inst.name && inst.is_enabled !== false);
+  if (filtered.length === 0) {
+    console.log("No monitoring targets configured");
+    console.log("");
+    console.log("To add a monitoring target:");
+    console.log("  postgres-ai mon targets add <connection-string> <name>");
+    console.log("");
+    console.log("Example:");
+    console.log("  postgres-ai mon targets add 'postgresql://user:pass@host:5432/db' my-db");
+    return;
+  }
+  for (const inst of filtered) {
+    console.log(`Target: ${inst.name}`);
   }
 });
 targets.command("add [connStr] [name]").description("add monitoring target database").action(async (connStr, name) => {
@@ -33079,70 +35838,28 @@ targets.command("add [connStr] [name]").description("add monitoring target datab
   const db = m[5];
   const instanceName = name && name.trim() ? name.trim() : `${host}-${db}`.replace(/[^a-zA-Z0-9-]/g, "-");
   try {
-    if (fs7.existsSync(file) && !fs7.lstatSync(file).isDirectory()) {
-      const content2 = fs7.readFileSync(file, "utf8");
-      const instances = load(content2) || [];
-      if (Array.isArray(instances)) {
-        const exists = instances.some((inst) => inst.name === instanceName);
-        if (exists) {
-          console.error(`Monitoring target '${instanceName}' already exists`);
-          process.exitCode = 1;
-          return;
-        }
-      }
-    }
+    addInstanceToFile(file, buildInstance(instanceName, connStr));
+    console.log(`Monitoring target '${instanceName}' added`);
   } catch (err) {
-    const isFile = fs7.existsSync(file) && !fs7.lstatSync(file).isDirectory();
-    const content2 = isFile ? fs7.readFileSync(file, "utf8") : "";
-    const escapedName = instanceName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    if (new RegExp(`^- name: ${escapedName}$`, "m").test(content2)) {
-      console.error(`Monitoring target '${instanceName}' already exists`);
-      process.exitCode = 1;
-      return;
-    }
-  }
-  if (fs7.existsSync(file) && fs7.lstatSync(file).isDirectory()) {
-    fs7.rmSync(file, { recursive: true, force: true });
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(message);
+    process.exitCode = 1;
   }
-  const body = `- name: ${instanceName}
-  conn_str: ${connStr}
-  preset_metrics: full
-  custom_metrics:
-  is_enabled: true
-  group: default
-  custom_tags:
-    env: production
-    cluster: default
-    node_name: ${instanceName}
-    sink_type: ~sink_type~
-`;
-  const content = fs7.existsSync(file) ? fs7.readFileSync(file, "utf8") : "";
-  fs7.appendFileSync(file, (content && !/\n$/.test(content) ? `
-` : "") + body, "utf8");
-  console.log(`Monitoring target '${instanceName}' added`);
 });
 targets.command("remove <name>").description("remove monitoring target database").action(async (name) => {
   const { instancesFile: file } = await resolveOrInitPaths();
-  if (!fs7.existsSync(file) || fs7.lstatSync(file).isDirectory()) {
+  if (!fs8.existsSync(file) || fs8.lstatSync(file).isDirectory()) {
     console.error("instances.yml not found");
     process.exitCode = 1;
     return;
   }
   try {
-    const content = fs7.readFileSync(file, "utf8");
-    const instances = load(content);
-    if (!instances || !Array.isArray(instances)) {
-      console.error("Invalid instances.yml format");
-      process.exitCode = 1;
-      return;
-    }
-    const filtered = instances.filter((inst) => inst.name !== name);
-    if (filtered.length === instances.length) {
+    const removed = removeInstanceFromFile(file, name);
+    if (!removed) {
       console.error(`Monitoring target '${name}' not found`);
       process.exitCode = 1;
       return;
     }
-    fs7.writeFileSync(file, dump(filtered), "utf8");
     console.log(`Monitoring target '${name}' removed`);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -33152,32 +35869,35 @@ targets.command("remove <name>").description("remove monitoring target database"
 });
 targets.command("test <name>").description("test monitoring target database connectivity").action(async (name) => {
   const { instancesFile: instancesPath } = await resolveOrInitPaths();
-  if (!fs7.existsSync(instancesPath) || fs7.lstatSync(instancesPath).isDirectory()) {
+  if (!fs8.existsSync(instancesPath) || fs8.lstatSync(instancesPath).isDirectory()) {
     console.error("instances.yml not found");
     process.exitCode = 1;
     return;
   }
+  let instances;
+  try {
+    instances = loadInstances(instancesPath);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`Error parsing instances.yml: ${message}`);
+    process.exitCode = 1;
+    return;
+  }
+  const instance = instances.find((inst) => inst.name === name);
+  if (!instance) {
+    console.error(`Monitoring target '${name}' not found`);
+    process.exitCode = 1;
+    return;
+  }
+  if (!instance.conn_str) {
+    console.error(`Connection string not found for monitoring target '${name}'`);
+    process.exitCode = 1;
+    return;
+  }
+  console.log(`Testing connection to monitoring target '${name}'...`);
+  warnIfLaxSslmode(instance.conn_str);
+  const client = new Client(buildClientConfig(instance.conn_str, { connectionTimeoutMillis: 1e4 }));
   try {
-    const content = fs7.readFileSync(instancesPath, "utf8");
-    const instances = load(content);
-    if (!instances || !Array.isArray(instances)) {
-      console.error("Invalid instances.yml format");
-      process.exitCode = 1;
-      return;
-    }
-    const instance = instances.find((inst) => inst.name === name);
-    if (!instance) {
-      console.error(`Monitoring target '${name}' not found`);
-      process.exitCode = 1;
-      return;
-    }
-    if (!instance.conn_str) {
-      console.error(`Connection string not found for monitoring target '${name}'`);
-      process.exitCode = 1;
-      return;
-    }
-    console.log(`Testing connection to monitoring target '${name}'...`);
-    const client = new Client({ connectionString: instance.conn_str, connectionTimeoutMillis: 1e4 });
     try {
       await client.connect();
       const result = await client.query("select version();");
@@ -33411,7 +36131,7 @@ To authenticate, run: pgai auth`);
 });
 auth.command("remove-key").description("remove API key").action(async () => {
   const newConfigPath = getConfigPath();
-  const hasNewConfig = fs7.existsSync(newConfigPath);
+  const hasNewConfig = fs8.existsSync(newConfigPath);
   let legacyPath;
   try {
     const { projectDir } = await resolveOrInitPaths();
@@ -33419,7 +36139,7 @@ auth.command("remove-key").description("remove API key").action(async () => {
   } catch {
     legacyPath = path7.resolve(process.cwd(), ".pgwatch-config");
   }
-  const hasLegacyConfig = fs7.existsSync(legacyPath) && fs7.statSync(legacyPath).isFile();
+  const hasLegacyConfig = fs8.existsSync(legacyPath) && fs8.statSync(legacyPath).isFile();
   if (!hasNewConfig && !hasLegacyConfig) {
     console.log("No API key configured");
     return;
@@ -33429,11 +36149,11 @@ auth.command("remove-key").description("remove API key").action(async () => {
   }
   if (hasLegacyConfig) {
     try {
-      const content = fs7.readFileSync(legacyPath, "utf8");
+      const content = fs8.readFileSync(legacyPath, "utf8");
       const filtered = content.split(/\r?\n/).filter((l) => !/^api_key=/.test(l)).join(`
 `).replace(/\n+$/g, `
 `);
-      fs7.writeFileSync(legacyPath, filtered, "utf8");
+      fs8.writeFileSync(legacyPath, filtered, "utf8");
     } catch (err) {
       console.warn(`Warning: Could not update legacy config: ${err instanceof Error ? err.message : String(err)}`);
     }
@@ -33454,17 +36174,17 @@ mon.command("generate-grafana-password").description("generate Grafana password
       return;
     }
     let configContent = "";
-    if (fs7.existsSync(cfgPath)) {
-      const stats = fs7.statSync(cfgPath);
+    if (fs8.existsSync(cfgPath)) {
+      const stats = fs8.statSync(cfgPath);
       if (stats.isDirectory()) {
         console.error(".pgwatch-config is a directory, expected a file. Skipping read.");
       } else {
-        configContent = fs7.readFileSync(cfgPath, "utf8");
+        configContent = fs8.readFileSync(cfgPath, "utf8");
       }
     }
     const lines = configContent.split(/\r?\n/).filter((l) => !/^grafana_password=/.test(l));
     lines.push(`grafana_password=${newPassword}`);
-    fs7.writeFileSync(cfgPath, lines.filter(Boolean).join(`
+    fs8.writeFileSync(cfgPath, lines.filter(Boolean).join(`
 `) + `
 `, "utf8");
     console.log("\u2713 New Grafana password generated and saved");
@@ -33487,18 +36207,18 @@ Note: This command requires 'openssl' to be installed`);
 mon.command("show-grafana-credentials").description("show Grafana credentials for monitoring services").action(async () => {
   const { projectDir } = await resolveOrInitPaths();
   const cfgPath = path7.resolve(projectDir, ".pgwatch-config");
-  if (!fs7.existsSync(cfgPath)) {
+  if (!fs8.existsSync(cfgPath)) {
     console.error("Configuration file not found. Run 'postgres-ai mon local-install' first.");
     process.exitCode = 1;
     return;
   }
-  const stats = fs7.statSync(cfgPath);
+  const stats = fs8.statSync(cfgPath);
   if (stats.isDirectory()) {
     console.error(".pgwatch-config is a directory, expected a file. Cannot read credentials.");
     process.exitCode = 1;
     return;
   }
-  const content = fs7.readFileSync(cfgPath, "utf8");
+  const content = fs8.readFileSync(cfgPath, "utf8");
   const lines = content.split(/\r?\n/);
   let password = "";
   for (const line of lines) {
@@ -33519,8 +36239,8 @@ Grafana credentials:`);
   console.log("  Username: monitor");
   console.log(`  Password: ${password}`);
   const envFile = path7.resolve(projectDir, ".env");
-  if (fs7.existsSync(envFile)) {
-    const envContent = fs7.readFileSync(envFile, "utf8");
+  if (fs8.existsSync(envFile)) {
+    const envContent = fs8.readFileSync(envFile, "utf8");
     const vmUser = envContent.match(/^VM_AUTH_USERNAME=([^\r\n]+)/m);
     const vmPass = envContent.match(/^VM_AUTH_PASSWORD=([^\r\n]+)/m);
     if (vmUser && vmPass) {
@@ -33532,8 +36252,8 @@ VictoriaMetrics credentials:`);
   }
   console.log("");
 });
-function interpretEscapes2(str2) {
-  return str2.replace(/\\\\/g, "\x00").replace(/\\n/g, `
+function interpretEscapes2(str3) {
+  return str3.replace(/\\\\/g, "\x00").replace(/\\n/g, `
 `).replace(/\\t/g, "\t").replace(/\\r/g, "\r").replace(/\\"/g, '"').replace(/\\'/g, "'").replace(/\x00/g, "\\");
 }
 var issues = program2.command("issues").description("issues management");
@@ -34247,12 +36967,12 @@ reports.command("data [reportId]").description("get checkup report file data (in
     spinner.stop();
     if (opts.output) {
       const dir = path7.resolve(opts.output);
-      fs7.mkdirSync(dir, { recursive: true });
+      fs8.mkdirSync(dir, { recursive: true });
       for (const f of result) {
         const safeName = path7.basename(f.filename);
         const filePath = path7.join(dir, safeName);
         const content = f.type === "json" ? JSON.stringify(tryParseJson(f.data), null, 2) : f.data;
-        fs7.writeFileSync(filePath, content, "utf-8");
+        fs8.writeFileSync(filePath, content, "utf-8");
         console.log(filePath);
       }
     } else if (opts.json) {
@@ -34386,13 +37106,13 @@ mcp.command("install [client]").description("install MCP server configuration fo
         process.exitCode = 1;
         return;
     }
-    if (!fs7.existsSync(configDir)) {
-      fs7.mkdirSync(configDir, { recursive: true });
+    if (!fs8.existsSync(configDir)) {
+      fs8.mkdirSync(configDir, { recursive: true });
     }
     let config2 = { mcpServers: {} };
-    if (fs7.existsSync(configPath)) {
+    if (fs8.existsSync(configPath)) {
       try {
-        const content = fs7.readFileSync(configPath, "utf8");
+        const content = fs8.readFileSync(configPath, "utf8");
         config2 = JSON.parse(content);
         if (!config2.mcpServers) {
           config2.mcpServers = {};
@@ -34405,7 +37125,7 @@ mcp.command("install [client]").description("install MCP server configuration fo
       command: pgaiPath,
       args: ["mcp", "start"]
     };
-    fs7.writeFileSync(configPath, JSON.stringify(config2, null, 2), "utf8");
+    fs8.writeFileSync(configPath, JSON.stringify(config2, null, 2), "utf8");
     console.log(`\u2713 PostgresAI MCP server configured for ${client}`);
     console.log(`  Config file: ${configPath}`);
     console.log("");