arri 0.0.6 → 0.0.9

package/dist/cli.cjs

@@ -5,7 +5,7 @@ const tty = require('node:tty');
 const fs$f = require('node:fs');
 const path$e = require('node:path');
 const require$$0 = require('stream');
-const index = require('./shared/arri.d77f4d0e.cjs');
+const index = require('./shared/arri.8e602d87.cjs');
 const require$$0$1 = require('os');
 const require$$0$2 = require('path');
 const require$$0$3 = require('util');
@@ -29,7 +29,7 @@ const node_module = require('node:module');
 const assert = require('node:assert');
 const v8$1 = require('node:v8');
 const node_util = require('node:util');
-const index$1 = require('./shared/arri.38ad6cd0.cjs');
+const dart = require('./shared/arri.835c5c3c.cjs');
 const node_http = require('node:http');
 const https = require('node:https');
 const node_net = require('node:net');
@@ -37,6 +37,7 @@ const require$$0$5 = require('http');
 const require$$1 = require('https');
 const childProcess = require('node:child_process');
 require('fs/promises');
+require('child_process');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
@@ -22841,85 +22842,165 @@ async function resolveConfig(source, options, sourceOptions = {}) {
 
 const unsafePorts = /* @__PURE__ */ new Set([
   1,
+  // tcpmux
   7,
+  // echo
   9,
+  // discard
   11,
+  // systat
   13,
+  // daytime
   15,
+  // netstat
   17,
+  // qotd
   19,
+  // chargen
   20,
+  // ftp data
   21,
+  // ftp access
   22,
+  // ssh
   23,
+  // telnet
   25,
+  // smtp
   37,
+  // time
   42,
+  // name
   43,
+  // nicname
   53,
+  // domain
   69,
+  // tftp
   77,
+  // priv-rjs
   79,
+  // finger
   87,
+  // ttylink
   95,
+  // supdup
   101,
+  // hostriame
   102,
+  // iso-tsap
   103,
+  // gppitnp
   104,
+  // acr-nema
   109,
+  // pop2
   110,
+  // pop3
   111,
+  // sunrpc
   113,
+  // auth
   115,
+  // sftp
   117,
+  // uucp-path
   119,
+  // nntp
   123,
+  // NTP
   135,
+  // loc-srv /epmap
   137,
+  // netbios
   139,
+  // netbios
   143,
+  // imap2
   161,
+  // snmp
   179,
+  // BGP
   389,
+  // ldap
   427,
+  // SLP (Also used by Apple Filing Protocol)
   465,
+  // smtp+ssl
   512,
+  // print / exec
   513,
+  // login
   514,
+  // shell
   515,
+  // printer
   526,
+  // tempo
   530,
+  // courier
   531,
+  // chat
   532,
+  // netnews
   540,
+  // uucp
   548,
+  // AFP (Apple Filing Protocol)
   554,
+  // rtsp
   556,
+  // remotefs
   563,
+  // nntp+ssl
   587,
+  // smtp (rfc6409)
   601,
+  // syslog-conn (rfc3195)
   636,
+  // ldap+ssl
   989,
+  // ftps-data
   990,
+  // ftps
   993,
+  // ldap+ssl
   995,
+  // pop3+ssl
   1719,
+  // h323gatestat
   1720,
+  // h323hostcall
   1723,
+  // pptp
   2049,
+  // nfs
   3659,
+  // apple-sasl / PasswordServer
   4045,
+  // lockd
   5060,
+  // sip
   5061,
+  // sips
   6e3,
+  // X11
   6566,
+  // sane-port
   6665,
+  // Alternate IRC [Apple addition]
   6666,
+  // Alternate IRC [Apple addition]
   6667,
+  // Standard IRC [Apple addition]
   6668,
+  // Alternate IRC [Apple addition]
   6669,
+  // Alternate IRC [Apple addition]
   6697,
+  // IRC + TLS
   10080
+  // Amanda
 ]);
 function isUnsafePort(port) {
   return unsafePorts.has(port);
@@ -22935,16 +23016,17 @@ async function getPort(config = {}) {
   if (typeof config === "number" || typeof config === "string") {
     config = { port: Number.parseInt(config + "") || 0 };
   }
+  const _port = Number(config.port ?? process.env.PORT ?? 3e3);
   const options = {
     name: "default",
-    random: false,
+    random: _port === 0,
     ports: [],
     portRange: [],
     alternativePortRange: config.port ? [] : [3e3, 3100],
     host: void 0,
     verbose: false,
     ...config,
-    port: config.port || Number.parseInt(process.env.PORT || "") || 3e3
+    port: _port
   };
   if (options.random) {
     return getRandomPort(options.host);
@@ -52192,12 +52274,12 @@ function isDocker() {
   return isDockerCached;
 }
 
-function getNetworkInterfaces(v4Only = true) {
+function getNetworkInterfaces(includeIPV6) {
   const addrs = /* @__PURE__ */ new Set();
   for (const details of Object.values(os$2.networkInterfaces())) {
     if (details) {
       for (const d of details) {
-        if (!d.internal && !(d.mac === "00:00:00:00:00:00") && !d.address.startsWith("fe80::") && !(v4Only && (d.family === "IPv6" || +d.family === 6))) {
+        if (!d.internal && !(d.mac === "00:00:00:00:00:00") && !d.address.startsWith("fe80::") && !(!includeIPV6 && (d.family === "IPv6" || +d.family === 6))) {
           addrs.add(formatAddress(d));
         }
       }
@@ -52215,11 +52297,36 @@ function formatURL(url) {
     )
   );
 }
-function getPublicURL(urls, listhenOptions) {
+const _localHosts = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "::1"]);
+function isLocalhost(hostname) {
+  return hostname === void 0 ? false : _localHosts.has(hostname);
+}
+const _anyHosts = /* @__PURE__ */ new Set(["", "0.0.0.0", "::"]);
+function isAnyhost(hostname) {
+  return hostname === void 0 ? false : _anyHosts.has(hostname);
+}
+function generateURL(hostname, listhenOptions, baseURL) {
+  const proto = listhenOptions.https ? "https://" : "http://";
+  let port = listhenOptions.port || "";
+  if (port === 80 && proto === "http://" || port === 443 && proto === "https://") {
+    port = "";
+  }
+  if (hostname[0] !== "[" && hostname.includes(":")) {
+    hostname = `[${hostname}]`;
+  }
+  return proto + hostname + ":" + port + (baseURL || listhenOptions.baseURL || "");
+}
+function getPublicURL(listhenOptions, baseURL) {
   if (listhenOptions.publicURL) {
     return listhenOptions.publicURL;
   }
-  return detectStackblitzURL(listhenOptions._entry) || urls.find((url) => url.type === "network" && !url.url.startsWith("["))?.url || urls.find((url) => url.type === "network")?.url;
+  const stackblitzURL = detectStackblitzURL(listhenOptions._entry);
+  if (stackblitzURL) {
+    return stackblitzURL;
+  }
+  if (listhenOptions.hostname && !isLocalhost(listhenOptions.hostname) && !isAnyhost(listhenOptions.hostname)) {
+    return generateURL(listhenOptions.hostname, listhenOptions, baseURL);
+  }
 }
 function detectStackblitzURL(entry) {
   try {
@@ -52526,7 +52633,7 @@ async function listen(handle, _options = {}) {
   const _isProd = _options.isProd ?? process.env.NODE_ENV === "production";
   const _isTest = _options.isTest ?? process.env.NODE_ENV === "test";
   const _hostname = process.env.HOST ?? _options.hostname;
-  const _public = _options.public ?? (process.argv.includes("--host") ? true : void 0) ?? (_hostname === "localhost" ? false : _isProd);
+  const _public = _options.public ?? (isLocalhost(_hostname) ? false : void 0) ?? (isAnyhost(_hostname) ? true : void 0) ?? (process.argv.includes("--host") ? true : void 0) ?? _isProd;
   const listhenOptions = defu$1(_options, {
     name: "",
     https: false,
@@ -52541,6 +52648,24 @@ async function listen(handle, _options = {}) {
     public: _public,
     autoClose: true
   });
+  const _localhost = isLocalhost(listhenOptions.hostname);
+  const _anyhost = isAnyhost(listhenOptions.hostname);
+  if (listhenOptions.public && _localhost) {
+    consola.warn(
+      `[listhen] Trying to listhen on private host ${JSON.stringify(
+        listhenOptions.hostname
+      )} with public option disabled.`
+    );
+    listhenOptions.public = false;
+  } else if (!listhenOptions.public && _anyhost) {
+    consola.warn(
+      `[listhen] Trying to listhen on public host ${JSON.stringify(
+        listhenOptions.hostname
+      )} with public option disabled. Using "localhost".`
+    );
+    listhenOptions.public = false;
+    listhenOptions.hostname = "localhost";
+  }
   if (listhenOptions.isTest) {
     listhenOptions.showURL = false;
   }
@@ -52548,7 +52673,7 @@ async function listen(handle, _options = {}) {
     listhenOptions.open = false;
     listhenOptions.clipboard = false;
   }
-  const port = await getPort({
+  const port = listhenOptions.port = await getPort({
     port: Number(listhenOptions.port),
     verbose: !listhenOptions.isTest,
     host: listhenOptions.hostname,
@@ -52556,12 +52681,6 @@ async function listen(handle, _options = {}) {
     ...typeof listhenOptions.port === "object" && listhenOptions.port
   });
   let server;
-  let addr;
-  const getURL = (host, baseURL) => {
-    const anyV4 = addr?.addr === "0.0.0.0";
-    const anyV6 = addr?.addr === "[::]";
-    return `${addr.proto}://${host || listhenOptions.hostname || (anyV4 || anyV6 ? "localhost" : addr.addr)}:${addr.port}${baseURL || listhenOptions.baseURL}`;
-  };
   let https$1 = false;
   const httpsOptions = listhenOptions.https;
   if (httpsOptions) {
@@ -52570,14 +52689,15 @@ async function listen(handle, _options = {}) {
     addShutdown(server);
     await node_util.promisify(server.listen.bind(server))(port, listhenOptions.hostname);
     const _addr = server.address();
-    addr = { proto: "https", addr: formatAddress(_addr), port: _addr.port };
+    listhenOptions.port = _addr.port;
   } else {
     server = node_http.createServer(handle);
     addShutdown(server);
     await node_util.promisify(server.listen.bind(server))(port, listhenOptions.hostname);
     const _addr = server.address();
-    addr = { proto: "http", addr: formatAddress(_addr), port: _addr.port };
+    listhenOptions.port = _addr.port;
   }
+  const getURL = (host = listhenOptions.hostname, baseURL) => generateURL(host, listhenOptions, baseURL);
   let tunnel;
   if (listhenOptions.tunnel) {
     const { startTunnel } = await import('./chunks/index.cjs');
@@ -52604,32 +52724,34 @@ async function listen(handle, _options = {}) {
   }
   const getURLs = async (getURLOptions = {}) => {
     const urls = [];
-    const baseURL = getURLOptions?.baseURL || listhenOptions.baseURL || "";
-    urls.push({
-      url: getURL("localhost", baseURL),
-      type: "local"
-    });
-    const publicURL = getURLOptions.publicURL || getPublicURL(urls, listhenOptions);
+    const _addURL = (type, url) => {
+      if (!urls.some((u) => u.url === url)) {
+        urls.push({
+          url,
+          type
+        });
+      }
+    };
+    const publicURL = getURLOptions.publicURL || getPublicURL(listhenOptions, getURLOptions.baseURL);
     if (publicURL) {
-      urls.push({
-        url: publicURL,
-        type: "network"
-      });
+      _addURL("network", publicURL);
+    }
+    if (_localhost || _anyhost) {
+      _addURL(
+        "local",
+        getURL(listhenOptions.hostname || "localhost", getURLOptions.baseURL)
+      );
     }
     if (tunnel) {
-      urls.push({
-        url: await tunnel.getURL(),
-        type: "tunnel"
-      });
+      _addURL("tunnel", await tunnel.getURL());
     }
-    const anyV4 = addr?.addr === "0.0.0.0";
-    const anyV6 = addr?.addr === "[::]";
-    if (anyV4 || anyV6) {
-      for (const addr2 of getNetworkInterfaces(anyV4)) {
-        urls.push({
-          url: getURL(addr2, baseURL),
-          type: "network"
-        });
+    if (listhenOptions.public) {
+      const _ipv6Host = listhenOptions.hostname.includes(":");
+      for (const addr of getNetworkInterfaces(_ipv6Host)) {
+        if (addr === publicURL) {
+          continue;
+        }
+        _addURL("network", getURL(addr, getURLOptions.baseURL));
       }
     }
     return urls;
@@ -52641,10 +52763,18 @@ async function listen(handle, _options = {}) {
     const firstLocalUrl = urls.find((u) => u.type === "local");
     const firstPublicUrl = urls.find((u) => u.type !== "local");
     const showQR = (showURLOptions.qr ?? listhenOptions.qr) !== false;
+    if (firstPublicUrl && showQR) {
+      const space = " ".repeat(14);
+      lines.push(" ");
+      lines.push(
+        ...renderUnicodeCompact(firstPublicUrl.url).split("\n").map((line) => space + line)
+      );
+      lines.push(" ");
+    }
     const typeMap = {
       local: ["Local", "green"],
       tunnel: ["Tunnel", "yellow"],
-      network: ["Network", "gray"]
+      network: ["Network", "magenta"]
     };
     for (const url of urls) {
       const type = typeMap[url.type];
@@ -52656,7 +52786,7 @@ async function listen(handle, _options = {}) {
         suffix += colors.gray(" [copied to clipboard]");
       }
       if (url === firstPublicUrl && showQR) {
-        suffix += colors.gray(" [QR code \u2B07\uFE0F ]");
+        suffix += colors.gray(" [QR code]");
       }
       lines.push(`${label} ${formatURL(url.url)}${suffix}`);
     }
@@ -52665,13 +52795,6 @@ async function listen(handle, _options = {}) {
         colors.gray(`  \u279C Network:  use ${colors.white("--host")} to expose`)
       );
     }
-    if (firstPublicUrl && showQR) {
-      const space = " ".repeat(14);
-      lines.push(" ");
-      lines.push(
-        ...renderUnicodeCompact(firstPublicUrl.url).split("\n").map((line) => space + line)
-      );
-    }
     console.log("\n" + lines.join("\n") + "\n");
   };
   if (listhenOptions.showURL) {
@@ -52698,26 +52821,6 @@ async function listen(handle, _options = {}) {
   };
 }
 
-const dev = defineCommand({
-  meta: {
-    name: "dev",
-    description: "Start the arri dev server"
-  },
-  args: {
-    config: {
-      type: "string",
-      description: "Path to the arri config file",
-      alias: "c",
-      default: "./arri.config.ts"
-    }
-  },
-  run: async ({ args }) => {
-    const config = await loadConfig({
-      configFile: path$d.resolve(args.config)
-    });
-    await main$1(config.config);
-  }
-});
 const disallowedNameChars = "~`!@#$%^&*()-+=[]{}\\|:;\"'<>,./";
 const getRpcMetaFromPath = (config, filePath) => {
   if (!config.procedureDir) {
@@ -52864,7 +52967,7 @@ async function generateApplicationDefinition(config) {
   });
   await fs__default$2.writeFile(
     path$d.resolve(`${config.rootDir}`, ".arri/definition.ts"),
-    await index$1.format2(
+    await dart.format2(
       `${importParts.join("\n")}
 
             export interface ClientDefinition {
@@ -52936,10 +53039,391 @@ async function setupWorkingDir(config) {
   }
   await fs__default$2.mkdir(arriDir);
 }
+const dev = defineCommand({
+  meta: {
+    name: "dev",
+    description: "Start the arri dev server"
+  },
+  args: {
+    config: {
+      type: "string",
+      description: "Path to the arri config file",
+      alias: "c",
+      default: "./arri.config.ts"
+    }
+  },
+  async run({ args }) {
+    const config = await loadConfig({
+      configFile: path$d.resolve(args.config)
+    });
+    await main$1(config.config);
+  }
+});
+
+class FetchError extends Error {
+  constructor(message, opts) {
+    super(message, opts);
+    this.name = "FetchError";
+    if (opts?.cause && !this.cause) {
+      this.cause = opts.cause;
+    }
+  }
+}
+function createFetchError(ctx) {
+  const errorMessage = ctx.error?.message || ctx.error?.toString() || "";
+  const method = ctx.request?.method || ctx.options?.method || "GET";
+  const url = ctx.request?.url || String(ctx.request) || "/";
+  const requestStr = `[${method}] ${JSON.stringify(url)}`;
+  const statusStr = ctx.response ? `${ctx.response.status} ${ctx.response.statusText}` : "<no response>";
+  const message = `${requestStr}: ${statusStr}${errorMessage ? ` ${errorMessage}` : ""}`;
+  const fetchError = new FetchError(
+    message,
+    ctx.error ? { cause: ctx.error } : void 0
+  );
+  for (const key of ["request", "options", "response"]) {
+    Object.defineProperty(fetchError, key, {
+      get() {
+        return ctx[key];
+      }
+    });
+  }
+  for (const [key, refKey] of [
+    ["data", "_data"],
+    ["status", "status"],
+    ["statusCode", "status"],
+    ["statusText", "statusText"],
+    ["statusMessage", "statusText"]
+  ]) {
+    Object.defineProperty(fetchError, key, {
+      get() {
+        return ctx.response && ctx.response[refKey];
+      }
+    });
+  }
+  return fetchError;
+}
+
+const payloadMethods = new Set(
+  Object.freeze(["PATCH", "POST", "PUT", "DELETE"])
+);
+function isPayloadMethod(method = "GET") {
+  return payloadMethods.has(method.toUpperCase());
+}
+function isJSONSerializable(value) {
+  if (value === void 0) {
+    return false;
+  }
+  const t = typeof value;
+  if (t === "string" || t === "number" || t === "boolean" || t === null) {
+    return true;
+  }
+  if (t !== "object") {
+    return false;
+  }
+  if (Array.isArray(value)) {
+    return true;
+  }
+  if (value.buffer) {
+    return false;
+  }
+  return value.constructor && value.constructor.name === "Object" || typeof value.toJSON === "function";
+}
+const textTypes = /* @__PURE__ */ new Set([
+  "image/svg",
+  "application/xml",
+  "application/xhtml",
+  "application/html"
+]);
+const JSON_RE = /^application\/(?:[\w!#$%&*.^`~-]*\+)?json(;.+)?$/i;
+function detectResponseType(_contentType = "") {
+  if (!_contentType) {
+    return "json";
+  }
+  const contentType = _contentType.split(";").shift() || "";
+  if (JSON_RE.test(contentType)) {
+    return "json";
+  }
+  if (textTypes.has(contentType) || contentType.startsWith("text/")) {
+    return "text";
+  }
+  return "blob";
+}
+function mergeFetchOptions(input, defaults, Headers = globalThis.Headers) {
+  const merged = {
+    ...defaults,
+    ...input
+  };
+  if (defaults?.params && input?.params) {
+    merged.params = {
+      ...defaults?.params,
+      ...input?.params
+    };
+  }
+  if (defaults?.query && input?.query) {
+    merged.query = {
+      ...defaults?.query,
+      ...input?.query
+    };
+  }
+  if (defaults?.headers && input?.headers) {
+    merged.headers = new Headers(defaults?.headers || {});
+    for (const [key, value] of new Headers(input?.headers || {})) {
+      merged.headers.set(key, value);
+    }
+  }
+  return merged;
+}
+
+const retryStatusCodes = /* @__PURE__ */ new Set([
+  408,
+  // Request Timeout
+  409,
+  // Conflict
+  425,
+  // Too Early
+  429,
+  // Too Many Requests
+  500,
+  // Internal Server Error
+  502,
+  // Bad Gateway
+  503,
+  // Service Unavailable
+  504
+  //  Gateway Timeout
+]);
+const nullBodyResponses = /* @__PURE__ */ new Set([101, 204, 205, 304]);
+function createFetch(globalOptions = {}) {
+  const {
+    fetch = globalThis.fetch,
+    Headers = globalThis.Headers,
+    AbortController = globalThis.AbortController
+  } = globalOptions;
+  async function onError(context) {
+    const isAbort = context.error && context.error.name === "AbortError" && !context.options.timeout || false;
+    if (context.options.retry !== false && !isAbort) {
+      let retries;
+      if (typeof context.options.retry === "number") {
+        retries = context.options.retry;
+      } else {
+        retries = isPayloadMethod(context.options.method) ? 0 : 1;
+      }
+      const responseCode = context.response && context.response.status || 500;
+      if (retries > 0 && (Array.isArray(context.options.retryStatusCodes) ? context.options.retryStatusCodes.includes(responseCode) : retryStatusCodes.has(responseCode))) {
+        const retryDelay = context.options.retryDelay || 0;
+        if (retryDelay > 0) {
+          await new Promise((resolve) => setTimeout(resolve, retryDelay));
+        }
+        return $fetchRaw(context.request, {
+          ...context.options,
+          retry: retries - 1,
+          timeout: context.options.timeout
+        });
+      }
+    }
+    const error = createFetchError(context);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(error, $fetchRaw);
+    }
+    throw error;
+  }
+  const $fetchRaw = async function $fetchRaw2(_request, _options = {}) {
+    const context = {
+      request: _request,
+      options: mergeFetchOptions(_options, globalOptions.defaults, Headers),
+      response: void 0,
+      error: void 0
+    };
+    context.options.method = context.options.method?.toUpperCase();
+    if (context.options.onRequest) {
+      await context.options.onRequest(context);
+    }
+    if (typeof context.request === "string") {
+      if (context.options.baseURL) {
+        context.request = index.withBase(context.request, context.options.baseURL);
+      }
+      if (context.options.query || context.options.params) {
+        context.request = index.withQuery(context.request, {
+          ...context.options.params,
+          ...context.options.query
+        });
+      }
+    }
+    if (context.options.body && isPayloadMethod(context.options.method)) {
+      if (isJSONSerializable(context.options.body)) {
+        context.options.body = typeof context.options.body === "string" ? context.options.body : JSON.stringify(context.options.body);
+        context.options.headers = new Headers(context.options.headers || {});
+        if (!context.options.headers.has("content-type")) {
+          context.options.headers.set("content-type", "application/json");
+        }
+        if (!context.options.headers.has("accept")) {
+          context.options.headers.set("accept", "application/json");
+        }
+      } else if (
+        // ReadableStream Body
+        "pipeTo" in context.options.body && typeof context.options.body.pipeTo === "function" || // Node.js Stream Body
+        typeof context.options.body.pipe === "function"
+      ) {
+        if (!("duplex" in context.options)) {
+          context.options.duplex = "half";
+        }
+      }
+    }
+    if (!context.options.signal && context.options.timeout) {
+      const controller = new AbortController();
+      setTimeout(() => controller.abort(), context.options.timeout);
+      context.options.signal = controller.signal;
+    }
+    try {
+      context.response = await fetch(
+        context.request,
+        context.options
+      );
+    } catch (error) {
+      context.error = error;
+      if (context.options.onRequestError) {
+        await context.options.onRequestError(context);
+      }
+      return await onError(context);
+    }
+    const hasBody = context.response.body && !nullBodyResponses.has(context.response.status) && context.options.method !== "HEAD";
+    if (hasBody) {
+      const responseType = (context.options.parseResponse ? "json" : context.options.responseType) || detectResponseType(context.response.headers.get("content-type") || "");
+      switch (responseType) {
+        case "json": {
+          const data = await context.response.text();
+          const parseFunction = context.options.parseResponse || index.destr;
+          context.response._data = parseFunction(data);
+          break;
+        }
+        case "stream": {
+          context.response._data = context.response.body;
+          break;
+        }
+        default: {
+          context.response._data = await context.response[responseType]();
+        }
+      }
+    }
+    if (context.options.onResponse) {
+      await context.options.onResponse(context);
+    }
+    if (!context.options.ignoreResponseError && context.response.status >= 400 && context.response.status < 600) {
+      if (context.options.onResponseError) {
+        await context.options.onResponseError(context);
+      }
+      return await onError(context);
+    }
+    return context.response;
+  };
+  const $fetch = async function $fetch2(request, options) {
+    const r = await $fetchRaw(request, options);
+    return r._data;
+  };
+  $fetch.raw = $fetchRaw;
+  $fetch.native = (...args) => fetch(...args);
+  $fetch.create = (defaultOptions = {}) => createFetch({
+    ...globalOptions,
+    defaults: {
+      ...globalOptions.defaults,
+      ...defaultOptions
+    }
+  });
+  return $fetch;
+}
+
+const _globalThis = function() {
+  if (typeof globalThis !== "undefined") {
+    return globalThis;
+  }
+  if (typeof self !== "undefined") {
+    return self;
+  }
+  if (typeof window !== "undefined") {
+    return window;
+  }
+  if (typeof global !== "undefined") {
+    return global;
+  }
+  throw new Error("unable to locate global object");
+}();
+const fetch = _globalThis.fetch || (() => Promise.reject(new Error("[ofetch] global.fetch is not supported!")));
+const Headers = _globalThis.Headers;
+const AbortController = _globalThis.AbortController;
+const ofetch = createFetch({ fetch, Headers, AbortController });
+
+const codegenDart = defineCommand({
+  args: {
+    location: {
+      type: "positional",
+      required: true,
+      description: "The path to an Arri definition file or a url that returns an Arri definition file."
+    },
+    clientName: {
+      type: "string",
+      alias: ["name"],
+      required: true
+    },
+    outFile: {
+      type: "string",
+      alias: ["out", "o"],
+      required: true
+    }
+  },
+  async run({ args }) {
+    const isUrl = args.location.startsWith("http://") || args.location.startsWith("https://");
+    let def;
+    if (isUrl) {
+      const result = await ofetch(args.location);
+      def = result;
+    } else {
+      if (!fs$f.existsSync(args.location)) {
+        throw new Error(`Unable to find ${args.location}`);
+      }
+      const jsonString = JSON.parse(
+        fs$f.readFileSync(args.location, { encoding: "utf-8" })
+      );
+      def = jsonString;
+    }
+    if (!def) {
+      throw new Error("Unable to load ApplicationDefinition json file");
+    }
+    await dart.dartClientGenerator({
+      clientName: args.clientName,
+      outputFile: args.outFile
+    }).generator(def);
+  }
+});
+const codegenTypescript = defineCommand({
+  args: {
+    location: {
+      type: "positional",
+      required: true,
+      description: "The path to an Arri definition file or a url that returns an Arri definition file."
+    },
+    clientName: {
+      type: "string",
+      alias: ["name"],
+      required: true
+    },
+    outFile: {
+      type: "string",
+      alias: ["out", "o"],
+      required: true
+    }
+  }
+});
+const codegen = defineCommand({
+  subCommands: {
+    dart: codegenDart,
+    typescript: codegenTypescript
+  }
+});
 
 const main = defineCommand({
   subCommands: {
-    dev
+    dev,
+    codegen
   }
 });
 void runMain(main);