visigraph 0.0.4 → 0.0.7

package/dist/main.js

@@ -2856,10 +2856,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} flag
        * @private
        */
-      unknownOption(flag) {
+      unknownOption(flag2) {
         if (this._allowUnknownOption) return;
         let suggestion = "";
-        if (flag.startsWith("--") && this._showSuggestionAfterError) {
+        if (flag2.startsWith("--") && this._showSuggestionAfterError) {
           let candidateFlags = [];
           let command = this;
           do {
@@ -2867,9 +2867,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
             candidateFlags = candidateFlags.concat(moreFlags);
             command = command.parent;
           } while (command && !command._enablePositionalOptions);
-          suggestion = suggestSimilar(flag, candidateFlags);
+          suggestion = suggestSimilar(flag2, candidateFlags);
         }
-        const message = `error: unknown option '${flag}'${suggestion}`;
+        const message = `error: unknown option '${flag2}'${suggestion}`;
         this.error(message, { code: "commander.unknownOption" });
       }
       /**
@@ -3662,13 +3662,13 @@ var require_directives = __commonJS({
             onError("Verbatim tags must end with a >");
           return verbatim;
         }
-        const [, handle, suffix] = source.match(/^(.*!)([^!]*)$/s);
-        if (!suffix)
+        const [, handle, suffix2] = source.match(/^(.*!)([^!]*)$/s);
+        if (!suffix2)
           onError(`The ${source} tag has no suffix`);
         const prefix = this.tags[handle];
         if (prefix) {
           try {
-            return prefix + decodeURIComponent(suffix);
+            return prefix + decodeURIComponent(suffix2);
           } catch (error) {
             onError(String(error));
             return null;
@@ -3956,36 +3956,38 @@ var require_Alias = __commonJS({
           if (node.anchor === this.source)
             found = node;
         }
+        if (found && ctx) {
+          const { anchors: anchors2, doc: doc2, maxAliasCount } = ctx;
+          let data = anchors2.get(found);
+          if (!data) {
+            toJS.toJS(found, null, ctx);
+            data = anchors2.get(found);
+          }
+          if (data?.res === void 0) {
+            const msg = "This should not happen: Alias anchor was not resolved?";
+            throw new ReferenceError(msg);
+          }
+          if (maxAliasCount >= 0) {
+            data.count += 1;
+            if (data.aliasCount === 0)
+              data.aliasCount = getAliasCount(doc2, found, anchors2);
+            if (data.count * data.aliasCount > maxAliasCount) {
+              const msg = "Excessive alias count indicates a resource exhaustion attack";
+              throw new ReferenceError(msg);
+            }
+          }
+        }
         return found;
       }
       toJSON(_arg, ctx) {
         if (!ctx)
           return { source: this.source };
-        const { anchors: anchors2, doc, maxAliasCount } = ctx;
-        const source = this.resolve(doc, ctx);
+        const source = this.resolve(ctx.doc, ctx);
         if (!source) {
           const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
           throw new ReferenceError(msg);
         }
-        let data = anchors2.get(source);
-        if (!data) {
-          toJS.toJS(source, null, ctx);
-          data = anchors2.get(source);
-        }
-        if (data?.res === void 0) {
-          const msg = "This should not happen: Alias anchor was not resolved?";
-          throw new ReferenceError(msg);
-        }
-        if (maxAliasCount >= 0) {
-          data.count += 1;
-          if (data.aliasCount === 0)
-            data.aliasCount = getAliasCount(doc, source, anchors2);
-          if (data.count * data.aliasCount > maxAliasCount) {
-            const msg = "Excessive alias count indicates a resource exhaustion attack";
-            throw new ReferenceError(msg);
-          }
-        }
-        return data.res;
+        return ctx.anchors.get(source).res;
       }
       toString(ctx, _onComment, _onChompKeep) {
         const src = `*${this.source}`;
@@ -7987,37 +7989,38 @@ var require_resolve_flow_scalar = __commonJS({
       }
       if (badChar)
         onError(0, "BAD_SCALAR_START", `Plain value cannot start with ${badChar}`);
-      return foldLines(source);
+      return unfoldLines(source);
     }
     function singleQuotedValue(source, onError) {
       if (source[source.length - 1] !== "'" || source.length === 1)
         onError(source.length, "MISSING_CHAR", "Missing closing 'quote");
-      return foldLines(source.slice(1, -1)).replace(/''/g, "'");
+      return unfoldLines(source.slice(1, -1)).replace(/''/g, "'");
     }
-    function foldLines(source) {
-      let first, line;
+    function unfoldLines(source) {
+      const line = /(.*?)\r?\n/sy;
+      let match = line.exec(source);
+      if (!match)
+        return source;
+      let trimEnd, trimBoth;
       try {
-        first = new RegExp("(.*?)(?<![ 	])[ 	]*\r?\n", "sy");
-        line = new RegExp("[ 	]*(.*?)(?:(?<![ 	])[ 	]*)?\r?\n", "sy");
+        trimEnd = new RegExp("(?<![ 	])[ 	]+$");
+        trimBoth = new RegExp("^[ 	]+|(?<![ 	])[ 	]+$", "g");
       } catch {
-        first = /(.*?)[ \t]*\r?\n/sy;
-        line = /[ \t]*(.*?)[ \t]*\r?\n/sy;
+        trimEnd = /[ \t]+$/;
+        trimBoth = /^[ \t]+|[ \t]+$/g;
       }
-      let match = first.exec(source);
-      if (!match)
-        return source;
-      let res = match[1];
+      let res = match[1].replace(trimEnd, "");
       let sep = " ";
-      let pos = first.lastIndex;
-      line.lastIndex = pos;
+      let pos = line.lastIndex;
       while (match = line.exec(source)) {
-        if (match[1] === "") {
+        const lm = match[1].replace(trimBoth, "");
+        if (lm === "") {
           if (sep === "\n")
             res += sep;
           else
             sep = "\n";
         } else {
-          res += sep + match[1];
+          res += sep + lm;
           sep = " ";
         }
         pos = line.lastIndex;
@@ -10804,16 +10807,86 @@ function lineOf(range, lines) {
   return `line ${line}, column ${col}`;
 }
 
+// ../core/dist/kinds.js
+var FAMILIES = ["container", "endpoint", "entity"];
+var KindRegistry = class _KindRegistry {
+  families = /* @__PURE__ */ new Map();
+  static of(...extensions) {
+    const r = new _KindRegistry();
+    for (const e of extensions)
+      r.register(e);
+    return r;
+  }
+  register(extension) {
+    for (const definition of extension.kinds) {
+      if (!FAMILIES.includes(definition.family)) {
+        throw new Error(`extension '${extension.name}': unknown family '${definition.family}'`);
+      }
+      const table = this.families.get(definition.family) ?? /* @__PURE__ */ new Map();
+      const existing = table.get(definition.kind);
+      if (existing) {
+        throw new Error(`extension '${extension.name}': ${definition.family} kind '${definition.kind}' is already registered by '${existing.extension}'`);
+      }
+      table.set(definition.kind, { definition, extension: extension.name });
+      this.families.set(definition.family, table);
+    }
+    return this;
+  }
+  /** True when at least one kind is registered for the family, so kinds in it are checked. */
+  governs(family) {
+    return (this.families.get(family)?.size ?? 0) > 0;
+  }
+  get(family, kind) {
+    return this.families.get(family)?.get(kind)?.definition;
+  }
+  kinds(family) {
+    return [...this.families.get(family)?.keys() ?? []].sort();
+  }
+};
+function checkKind(registry, family, element) {
+  if (!registry || !registry.governs(family))
+    return [];
+  const kind = element.kind;
+  if (kind === void 0)
+    return [];
+  if (typeof kind !== "string")
+    return [["kind", `${family} kind must be a string`]];
+  const def = registry.get(family, kind);
+  if (!def)
+    return [["kind", `unknown ${family} kind '${kind}'; registered: ${registry.kinds(family).join(", ")}`]];
+  const out = [];
+  for (const [name, decl] of Object.entries(def.properties)) {
+    const value = element[name];
+    if (value === void 0) {
+      if (decl.required)
+        out.push([name, `${family} kind '${kind}' requires '${name}'`]);
+      continue;
+    }
+    if (typeof value !== decl.type) {
+      out.push([name, `'${name}' on ${family} kind '${kind}' must be a ${decl.type}`]);
+      continue;
+    }
+    if (decl.enum && !decl.enum.includes(value)) {
+      out.push([name, `'${name}' on ${family} kind '${kind}' must be one of ${decl.enum.join(", ")}; got '${String(value)}'`]);
+    }
+  }
+  return out;
+}
+
 // ../core/dist/resolve.js
 function resolve(model, options = {}) {
-  const r = new Resolver();
+  const r = new Resolver(options.kinds);
   const root = r.declare(model, model.system, void 0, { file: options.file ?? "", prefix: "" });
   r.bind(root, void 0);
   r.check(root);
   return { root, diagnostics: r.diagnostics };
 }
 var Resolver = class {
+  kinds;
   diagnostics = [];
+  constructor(kinds2) {
+    this.kinds = kinds2;
+  }
   /** Scopes by interior identity, so a shared file is one scope. */
   scopes = /* @__PURE__ */ new Map();
   locs = /* @__PURE__ */ new Map();
@@ -10852,6 +10925,8 @@ var Resolver = class {
         return;
       }
       scope.entities.set(entity.id, entity);
+      for (const [suffix2, message] of checkKind(this.kinds, "entity", entity))
+        err(`${path}.${suffix2}`, message);
     });
     eachListed(node.journeys, "journeys", err, (journey, path) => {
       if (scope.journeys.has(journey.id)) {
@@ -10865,6 +10940,8 @@ var Resolver = class {
         err(`${path}.id`, `duplicate container id '${child.id}'`);
         return;
       }
+      for (const [suffix2, message] of checkKind(this.kinds, "container", child))
+        err(`${path}.${suffix2}`, message);
       const link = child[LINKED];
       const childLoc = link ? { file: link.file, prefix: "" } : { file: loc.file, prefix: `${loc.prefix}${path}.` };
       scope.children.set(child.id, this.declare(child, child.id, child, childLoc, scope.path));
@@ -10878,6 +10955,8 @@ var Resolver = class {
         err(`${path}.id`, `duplicate endpoint id '${endpoint.id}' in container '${container.id}'`);
       }
       endpointIds.add(endpoint.id);
+      for (const [suffix2, message] of checkKind(this.kinds, "endpoint", endpoint))
+        err(`${path}.${suffix2}`, message);
     });
     const stateIds = /* @__PURE__ */ new Set();
     eachListed(container.state, "state", err, (state, path) => {
@@ -10934,6 +11013,21 @@ var Resolver = class {
     const loc = this.locs.get(scope);
     const err = (path, message) => this.err(loc, path, message);
     const node = scope.container ?? this.rootNode(scope);
+    eachListed(node.containers, "containers", () => {
+    }, (container, cPath) => {
+      if (container[LINKED])
+        return;
+      eachListed(container.endpoints, `${cPath}.endpoints`, () => {
+      }, (endpoint, ePath) => {
+        for (const key of ["accepts", "returns"]) {
+          if (endpoint[key] === void 0)
+            continue;
+          const entity = ref(endpoint[key], `${ePath}.${key}`, err);
+          if (entity)
+            this.lookupMember(scope, entity, "entity", `${ePath}.${key}`, err);
+        }
+      });
+    });
     eachListed(node.journeys, "journeys", err, (journey, path) => {
       const hasSteps = journey.steps !== void 0;
       const hasScenarios = journey.scenarios !== void 0;
@@ -10982,20 +11076,30 @@ var Resolver = class {
         this.lookupContainer(scope, from, `${p}.from`, err);
       const to = ref(step.to, `${p}.to`, err);
       const target = to ? this.lookupContainer(scope, to, `${p}.to`, err) : void 0;
+      let endpointDecl;
       if (step.endpoint !== void 0) {
         const endpoint = ref(step.endpoint, `${p}.endpoint`, err);
         if (endpoint && target) {
           if (endpoint.includes(".")) {
             err(`${p}.endpoint`, `endpoint '${endpoint}' must be a bare id on the 'to' container, not a path`);
-          } else if (!(target.container?.endpoints ?? []).some((e) => e.id === endpoint)) {
-            err(`${p}.endpoint`, `container '${to}' has no endpoint '${endpoint}'`);
+          } else {
+            endpointDecl = (target.container?.endpoints ?? []).find((e) => e.id === endpoint);
+            if (!endpointDecl)
+              err(`${p}.endpoint`, `container '${to}' has no endpoint '${endpoint}'`);
           }
         }
       }
       if (step.payload !== void 0) {
-        const entity = isRecord(step.payload) ? ref(step.payload.entity, `${p}.payload.entity`, err) : ref(step.payload, `${p}.payload`, err);
-        if (entity)
-          this.lookupMember(scope, entity, "entity", `${p}.payload`, err);
+        const entityRef = isRecord(step.payload) ? ref(step.payload.entity, `${p}.payload.entity`, err) : ref(step.payload, `${p}.payload`, err);
+        const payload = entityRef ? this.lookupMember(scope, entityRef, "entity", `${p}.payload`, err) : void 0;
+        if (payload && endpointDecl?.accepts !== void 0 && target) {
+          const owner = this.ownerScope(target);
+          const accepted = owner ? this.lookupMember(owner, endpointDecl.accepts, "entity", `${p}.payload`, () => {
+          }) : void 0;
+          if (accepted && accepted !== payload) {
+            err(`${p}.payload`, `endpoint '${step.endpoint}' on '${to}' accepts '${endpointDecl.accepts}', not '${entityRef}'`);
+          }
+        }
       }
       if (!STEP_KINDS.includes(step.kind)) {
         err(`${p}.kind`, `kind must be one of ${STEP_KINDS.join(", ")}; got '${String(step.kind)}'`);
@@ -11026,19 +11130,27 @@ var Resolver = class {
     }
     return cur;
   }
-  /** Resolve `a.b.name` as container path `a.b` plus a member id. */
   lookupMember(scope, pathStr, kind, at, err) {
     const segments = pathStr.split(".");
     const name = segments.pop();
     const owner = segments.length === 0 ? scope : this.lookupContainer(scope, segments.join("."), at, err);
     if (!owner)
-      return false;
-    const table = kind === "entity" ? owner.entities : owner.journeys;
-    if (!table.has(name)) {
+      return void 0;
+    const found = kind === "entity" ? owner.entities.get(name) : owner.journeys.get(name);
+    if (!found) {
       err(at, segments.length === 0 ? `unknown ${kind} '${name}'` : `unknown ${kind} '${name}' in '${segments.join(".")}'`);
-      return false;
+      return void 0;
     }
-    return true;
+    return found;
+  }
+  /** The scope a container is declared in: where its endpoint contracts resolve from. */
+  ownerScope(target) {
+    for (const s of this.scopes.values()) {
+      for (const child of s.children.values())
+        if (child === target)
+          return s;
+    }
+    return void 0;
   }
 };
 function loadedFile(req, loc) {
@@ -11095,6 +11207,36 @@ var EXIT = {
   usage: 2
 };
 
+// ../ext-http/dist/index.js
+var http = {
+  name: "@visigraph/ext-http",
+  kinds: [
+    {
+      family: "endpoint",
+      kind: "http",
+      description: "An HTTP endpoint: a method and a path on a container.",
+      properties: {
+        method: {
+          type: "string",
+          tier: "advanced",
+          required: true,
+          enum: ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"],
+          category: "transport"
+        },
+        path: {
+          type: "string",
+          tier: "advanced",
+          required: true,
+          category: "transport"
+        }
+      }
+    }
+  ]
+};
+
+// src/kinds.ts
+var kinds = KindRegistry.of(http);
+
 // src/commands/validate.ts
 function registerValidate(program3) {
   program3.command("validate").argument("<model>", "path to a model file (YAML)").description("check a model and every model it links or requires; every identifier must resolve").addHelpText(
@@ -11112,7 +11254,7 @@ async function validate(file) {
   const parsed = await loadModel(file);
   let diagnostics = parsed.diagnostics;
   if (parsed.model) {
-    diagnostics = diagnostics.concat(resolve(parsed.model, { file }).diagnostics);
+    diagnostics = diagnostics.concat(resolve(parsed.model, { file, kinds }).diagnostics);
   }
   for (const d of diagnostics) {
     const where = d.path ? `${d.file ?? file}:${d.path}` : d.file ?? file;
@@ -11126,6 +11268,101 @@ async function validate(file) {
   return EXIT.ok;
 }
 
+// src/update.ts
+var import_yaml2 = __toESM(require_dist(), 1);
+import { spawn } from "child_process";
+import { mkdir, readFile as readFile2, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { join as join2 } from "path";
+import readline from "readline";
+
+// src/progress.ts
+var CELLS = 6;
+var GLYPHS = {
+  unicode: { filled: "\u25B0", empty: "\u25B1" },
+  // ▰ ▱  black / white parallelogram
+  ascii: { filled: "#", empty: ".", open: "[", close: "]" }
+};
+function renderProgress(done, total, opts = {}) {
+  const cells = opts.cells ?? CELLS;
+  const safeTotal = Math.max(total, 0);
+  const safeDone = Math.min(Math.max(done, 0), safeTotal);
+  const filled = safeTotal === 0 ? 0 : Math.round(safeDone / safeTotal * cells);
+  return `${bar(filled, cells, opts.unicode ?? true)} ${safeDone}/${safeTotal}${suffix(opts.label)}`;
+}
+function renderSweep(tick, opts = {}) {
+  const cells = opts.cells ?? CELLS;
+  const unicode = opts.unicode ?? true;
+  const g = unicode ? GLYPHS.unicode : GLYPHS.ascii;
+  const pos = (tick % cells + cells) % cells;
+  const body = Array.from({ length: cells }, (_, i) => i === pos ? g.filled : g.empty).join("");
+  return `${unicode ? body : `${GLYPHS.ascii.open}${body}${GLYPHS.ascii.close}`}${suffix(opts.label)}`;
+}
+function bar(filled, cells, unicode) {
+  const g = unicode ? GLYPHS.unicode : GLYPHS.ascii;
+  const body = g.filled.repeat(filled) + g.empty.repeat(cells - filled);
+  return unicode ? body : `${GLYPHS.ascii.open}${body}${GLYPHS.ascii.close}`;
+}
+function suffix(label) {
+  return label ? ` ${label}` : "";
+}
+function supportsUnicode(env = process.env, platform = process.platform) {
+  if (platform === "win32") {
+    return Boolean(env.WT_SESSION || env.TERM_PROGRAM === "vscode" || env.ConEmuANSI === "ON");
+  }
+  if (env.TERM === "dumb") return false;
+  const locale = env.LC_ALL || env.LC_CTYPE || env.LANG || "";
+  return /utf-?8/i.test(locale) || locale === "";
+}
+var ProgressLine = class {
+  constructor(out = process.stderr) {
+    this.out = out;
+    this.enabled = Boolean(out.isTTY);
+    this.unicode = supportsUnicode();
+  }
+  out;
+  timer;
+  tick = 0;
+  enabled;
+  unicode;
+  /** Animate a sweep with a label until `stop` or `finish` is called. */
+  sweep(label, intervalMs = 120) {
+    if (!this.enabled) return;
+    this.clearTimer();
+    this.draw(renderSweep(this.tick, { unicode: this.unicode, label }));
+    this.timer = setInterval(() => {
+      this.tick += 1;
+      this.draw(renderSweep(this.tick, { unicode: this.unicode, label }));
+    }, intervalMs);
+  }
+  /** Show `done` of `total` with a label. */
+  update(done, total, label) {
+    if (!this.enabled) return;
+    this.clearTimer();
+    this.draw(renderProgress(done, total, label === void 0 ? { unicode: this.unicode } : { unicode: this.unicode, label }));
+  }
+  /** Fill the bar, print the final label, and move to a new line. */
+  finish(label) {
+    if (!this.enabled) return;
+    this.clearTimer();
+    this.draw(renderProgress(CELLS, CELLS, { unicode: this.unicode, label }));
+    this.out.write("\n");
+  }
+  /** Erase the line without a final message. */
+  stop() {
+    if (!this.enabled) return;
+    this.clearTimer();
+    this.out.write("\r\x1B[2K");
+  }
+  draw(text) {
+    this.out.write(`\r\x1B[2K${text}`);
+  }
+  clearTimer() {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = void 0;
+  }
+};
+
 // src/version.ts
 import { createRequire } from "module";
 var load = createRequire(import.meta.url);
@@ -11133,15 +11370,184 @@ var pkg = load("../package.json");
 var VERSION = pkg.version;
 var DESCRIPTION = pkg.description;
 
+// src/update.ts
+var PKG_NAME = "visigraph";
+var DEFAULT_REGISTRY = "https://registry.npmjs.org";
+var FETCH_TIMEOUT_MS = 2e3;
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var NO_UPDATE_ENV = "VISIGRAPH_NO_UPDATE_CHECK";
+var configDir = () => process.env.VISIGRAPH_HOME ?? join2(homedir(), ".visigraph");
+async function maybeUpdate() {
+  const gate = shouldCheck({
+    noUpdateEnv: process.env[NO_UPDATE_ENV] === "1",
+    stdinTTY: Boolean(process.stdin.isTTY),
+    stdoutTTY: Boolean(process.stdout.isTTY),
+    configCheckDisabled: await configDisablesCheck()
+  });
+  if (!gate) return;
+  const latest = await latestVersion();
+  if (!latest || !isNewerVersion(latest, VERSION)) return;
+  const viaNpx = invokedViaNpx({ npmCommand: process.env.npm_command, script: process.argv[1] ?? "" });
+  console.log(`visigraph ${latest} is available; you have ${VERSION}.`);
+  if (viaNpx) {
+    console.log(`Run it with: npx ${PKG_NAME}@latest`);
+    return;
+  }
+  if (!await confirm("Update now?")) return;
+  const progress = new ProgressLine();
+  progress.sweep(`installing visigraph ${latest}`);
+  const result = await runInstall();
+  if (!result.ok) {
+    progress.stop();
+    console.error("Update failed. Continuing with the current version.");
+    if (result.output.trim()) console.error(result.output.trim());
+    return;
+  }
+  progress.finish(`updated to ${latest}, relaunching`);
+  await relaunch();
+}
+function shouldCheck(input) {
+  if (input.noUpdateEnv) return false;
+  if (input.configCheckDisabled) return false;
+  if (!input.stdinTTY || !input.stdoutTTY) return false;
+  return true;
+}
+function compareVersions(a, b) {
+  const pa = a.split("-")[0].split(".").map(Number);
+  const pb = b.split("-")[0].split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (d !== 0) return d;
+  }
+  return 0;
+}
+function isNewerVersion(latest, current) {
+  return compareVersions(latest, current) > 0;
+}
+function invokedViaNpx(input) {
+  return input.npmCommand === "exec" || /[\\/]_npx[\\/]/.test(input.script);
+}
+function registryFrom(input) {
+  const fromEnv = input.env?.trim();
+  if (fromEnv) return fromEnv.replace(/\/+$/, "");
+  const line = input.npmrc?.split(/\r?\n/).find((l) => /^\s*registry\s*=/.test(l));
+  const fromRc = line?.split("=").slice(1).join("=").trim();
+  if (fromRc) return fromRc.replace(/\/+$/, "");
+  return DEFAULT_REGISTRY;
+}
+function cacheIsFresh(entry, now, ttl = CACHE_TTL_MS) {
+  return entry !== void 0 && typeof entry.latest === "string" && now - entry.checkedAt < ttl;
+}
+async function fetchLatestVersion(registry, fetchImpl = fetch) {
+  try {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), FETCH_TIMEOUT_MS);
+    const res = await fetchImpl(`${registry}/${PKG_NAME}/latest`, {
+      signal: ctrl.signal,
+      headers: { "User-Agent": `${PKG_NAME}/${VERSION}`, accept: "application/json" }
+    });
+    clearTimeout(timer);
+    if (!res.ok) return null;
+    const data = await res.json();
+    return typeof data.version === "string" ? data.version : null;
+  } catch {
+    return null;
+  }
+}
+async function configDisablesCheck() {
+  try {
+    const text = await readFile2(join2(configDir(), "config.yaml"), "utf8");
+    const cfg = (0, import_yaml2.parse)(text);
+    return cfg?.update?.check === false;
+  } catch {
+    return false;
+  }
+}
+async function latestVersion() {
+  const cachePath = join2(configDir(), "update-check.json");
+  const now = Date.now();
+  try {
+    const cached = JSON.parse(await readFile2(cachePath, "utf8"));
+    if (cacheIsFresh(cached, now)) return cached.latest;
+  } catch {
+  }
+  let npmrc;
+  try {
+    npmrc = await readFile2(join2(homedir(), ".npmrc"), "utf8");
+  } catch {
+    npmrc = void 0;
+  }
+  const registry = registryFrom({ env: process.env.npm_config_registry, npmrc });
+  const latest = await fetchLatestVersion(registry);
+  if (latest) {
+    try {
+      await mkdir(configDir(), { recursive: true });
+      await writeFile(cachePath, JSON.stringify({ checkedAt: now, latest }));
+    } catch {
+    }
+  }
+  return latest;
+}
+function confirm(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve2) => {
+    rl.on("close", () => resolve2(false));
+    rl.question(`${question} (y/N) `, (answer) => {
+      resolve2(/^y(es)?$/i.test(answer.trim()));
+      rl.close();
+    });
+  });
+}
+function runInstall() {
+  const npm = process.platform === "win32" ? "npm.cmd" : "npm";
+  return new Promise((resolve2) => {
+    const chunks = [];
+    const child = spawn(npm, ["install", "-g", `${PKG_NAME}@latest`, "--no-fund", "--no-audit"], {
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: false
+    });
+    child.stdout.on("data", (d) => chunks.push(d.toString()));
+    child.stderr.on("data", (d) => chunks.push(d.toString()));
+    child.on("exit", (code) => resolve2({ ok: code === 0, output: chunks.join("") }));
+    child.on("error", (e) => resolve2({ ok: false, output: e.message }));
+  });
+}
+function relaunch() {
+  const script = process.argv[1];
+  const args = process.argv.slice(2);
+  return new Promise((_, reject) => {
+    const child = spawn(process.execPath, [script, ...args], {
+      stdio: "inherit",
+      shell: false,
+      env: { ...process.env, [NO_UPDATE_ENV]: "1" }
+    });
+    child.on("exit", (code) => process.exit(code ?? 0));
+    child.on("error", reject);
+  });
+}
+
 // src/main.ts
+for (const stream of [process.stdout, process.stderr]) {
+  stream.on("error", (e) => {
+    if (e.code === "EPIPE") process.exit(process.exitCode ?? 0);
+    throw e;
+  });
+}
 var program2 = new Command();
-program2.name("visigraph").description(DESCRIPTION).version(VERSION, "-v, --version", "print the version and exit").helpOption("-h, --help", "print help and exit").helpCommand("help [command]", "print help for a command").showHelpAfterError("(run with --help for usage)").exitOverride();
+program2.name("visigraph").addHelpText("before", `${DESCRIPTION}
+`).version(VERSION, "-v, --version", "print the version and exit").helpOption("-h, --help", "print help and exit").helpCommand("help [command]", "print help for a command").showHelpAfterError("(run with --help for usage)").exitOverride();
 registerValidate(program2);
+var INSTANT = /* @__PURE__ */ new Set(["-v", "--version", "-h", "--help", "help"]);
+var [flag, maybeCommand] = process.argv.slice(2);
+if ((flag === "-h" || flag === "--help") && maybeCommand && program2.commands.some((c) => c.name() === maybeCommand)) {
+  process.argv.splice(2, 2, "help", maybeCommand);
+}
 try {
   if (process.argv.length <= 2) {
     program2.outputHelp();
     process.exitCode = EXIT.usage;
   } else {
+    if (!process.argv.slice(2).some((a) => INSTANT.has(a))) await maybeUpdate();
     await program2.parseAsync(process.argv);
   }
 } catch (e) {