@tinacms/cli 1.3.2 → 1.4.0

package/dist/index.js

@@ -4,9 +4,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
 var __export = (target, all) => {
   for (var name2 in all)
     __defProp(target, name2, { get: all[name2], enumerable: true });
@@ -25,282 +22,43 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/utils/index.ts
-var parseMediaFolder;
-var init_utils = __esm({
-  "src/utils/index.ts"() {
-    parseMediaFolder = (str) => {
-      let returnString = str;
-      if (returnString.startsWith("/"))
-        returnString = returnString.substr(1);
-      if (returnString.endsWith("/"))
-        returnString = returnString.substr(0, returnString.length - 1);
-      return returnString;
-    };
-  }
-});
-
-// src/server/models/media.ts
-var import_fs_extra6, import_path6, MediaModel;
-var init_media = __esm({
-  "src/server/models/media.ts"() {
-    import_fs_extra6 = __toESM(require("fs-extra"));
-    import_path6 = require("path");
-    init_utils();
-    MediaModel = class {
-      constructor({ rootPath: rootPath2, publicFolder, mediaRoot }) {
-        this.rootPath = rootPath2;
-        this.mediaRoot = mediaRoot;
-        this.publicFolder = publicFolder;
-      }
-      async listMedia(args) {
-        try {
-          const folderPath = (0, import_path6.join)(
-            this.rootPath,
-            this.publicFolder,
-            this.mediaRoot,
-            args.searchPath
-          );
-          const searchPath = parseMediaFolder(args.searchPath);
-          const filesStr = await import_fs_extra6.default.readdir(folderPath);
-          const filesProm = filesStr.map(async (file) => {
-            const filePath = (0, import_path6.join)(folderPath, file);
-            const stat = await import_fs_extra6.default.stat(filePath);
-            let src = `/${file}`;
-            const isFile = stat.isFile();
-            if (!isFile) {
-              return {
-                isFile,
-                size: stat.size,
-                src,
-                filename: file
-              };
-            }
-            if (searchPath) {
-              src = `/${searchPath}${src}`;
-            }
-            if (this.mediaRoot) {
-              src = `/${this.mediaRoot}${src}`;
-            }
-            return {
-              isFile,
-              size: stat.size,
-              src,
-              filename: file
-            };
-          });
-          const offset = Number(args.cursor) || 0;
-          const limit = Number(args.limit) || 20;
-          const rawItems = await Promise.all(filesProm);
-          const sortedItems = rawItems.sort((a, b) => {
-            if (a.isFile && !b.isFile) {
-              return 1;
-            }
-            if (!a.isFile && b.isFile) {
-              return -1;
-            }
-            return 0;
-          });
-          const limitItems = sortedItems.slice(offset, offset + limit);
-          const files = limitItems.filter((x) => x.isFile);
-          const directories = limitItems.filter((x) => !x.isFile).map((x) => x.src);
-          const cursor = rawItems.length > offset + limit ? String(offset + limit) : null;
-          return {
-            files,
-            directories,
-            cursor
-          };
-        } catch (error) {
-          console.error(error);
-          return {
-            files: [],
-            directories: [],
-            error: error == null ? void 0 : error.toString()
-          };
-        }
-      }
-      async deleteMedia(args) {
-        try {
-          const file = (0, import_path6.join)(
-            this.rootPath,
-            this.publicFolder,
-            this.mediaRoot,
-            args.searchPath
-          );
-          await import_fs_extra6.default.stat(file);
-          await import_fs_extra6.default.remove(file);
-          return { ok: true };
-        } catch (error) {
-          console.error(error);
-          return { ok: false, message: error == null ? void 0 : error.toString() };
-        }
-      }
-    };
-  }
-});
-
-// src/server/routes/index.ts
-var import_express, import_path7, import_multer, createMediaRouter;
-var init_routes = __esm({
-  "src/server/routes/index.ts"() {
-    import_express = require("express");
-    import_path7 = require("path");
-    import_multer = __toESM(require("multer"));
-    init_media();
-    createMediaRouter = (config2) => {
-      const mediaFolder = (0, import_path7.join)(
-        config2.rootPath,
-        config2.publicFolder,
-        config2.mediaRoot
-      );
-      const storage = import_multer.default.diskStorage({
-        destination: function(req, file, cb) {
-          cb(null, mediaFolder);
-        },
-        filename: function(req, _file, cb) {
-          const file = req.params[0];
-          cb(null, file);
-        }
-      });
-      const upload = (0, import_multer.default)({ storage });
-      const uploadRoute = upload.single("file");
-      const mediaModel = new MediaModel(config2);
-      const mediaRouter = (0, import_express.Router)();
-      mediaRouter.get("/list/*", async (req, res) => {
-        const folder = req.params[0];
-        const cursor = req.query.cursor;
-        const limit = req.query.limit;
-        const media = await mediaModel.listMedia({
-          searchPath: folder,
-          cursor,
-          limit
-        });
-        res.json(media);
-      });
-      mediaRouter.delete("/*", async (req, res) => {
-        const file = req.params[0];
-        const didDelete = await mediaModel.deleteMedia({ searchPath: file });
-        res.json(didDelete);
-      });
-      mediaRouter.post("/upload/*", async function(req, res) {
-        await uploadRoute(req, res, (err) => {
-          if (err instanceof import_multer.default.MulterError) {
-            res.status(500).json({ message: err.message });
-          } else if (err) {
-            res.status(500).json({ message: err.message });
-          } else {
-            res.json({ success: true });
-          }
-        });
-      });
-      return mediaRouter;
-    };
-  }
-});
-
-// src/server/server.ts
-var import_cors, import_http, import_express2, import_altair_express_middleware, import_body_parser, gqlServer;
-var init_server = __esm({
-  "src/server/server.ts"() {
-    import_cors = __toESM(require("cors"));
-    import_http = __toESM(require("http"));
-    import_express2 = __toESM(require("express"));
-    import_altair_express_middleware = require("altair-express-middleware");
-    import_body_parser = __toESM(require("body-parser"));
-    init_routes();
-    init_utils();
-    gqlServer = async (database, verbose) => {
-      var _a, _b, _c;
-      const gqlPackage = require("@tinacms/graphql");
-      const app = (0, import_express2.default)();
-      const server = import_http.default.createServer(app);
-      app.use((0, import_cors.default)());
-      app.use(import_body_parser.default.json());
-      app.use(
-        "/altair",
-        (0, import_altair_express_middleware.altairExpress)({
-          endpointURL: "/graphql",
-          initialQuery: `# Welcome to Tina!
-      # We've got a simple query set up for you to get started
-      # but there's plenty more for you to explore on your own!
-      query MyQuery {
-        collections {
-          documents {
-            id
-            sys {
-              filename
-              extension
-            }
-          }
-        }
-      }`
-        })
-      );
-      app.post("/graphql", async (req, res) => {
-        const { query, variables } = req.body;
-        const config2 = {
-          useRelativeMedia: true
-        };
-        const result = await gqlPackage.resolve({
-          config: config2,
-          database,
-          query,
-          variables,
-          verbose
-        });
-        return res.json(result);
-      });
-      const db = database;
-      const schema = await db.getSchema();
-      const mediaPaths = (_c = (_b = (_a = schema == null ? void 0 : schema.schema) == null ? void 0 : _a.config) == null ? void 0 : _b.media) == null ? void 0 : _c.tina;
-      app.use(
-        "/media",
-        createMediaRouter({
-          rootPath: db.bridge.rootPath,
-          publicFolder: parseMediaFolder((mediaPaths == null ? void 0 : mediaPaths.publicFolder) || ""),
-          mediaRoot: parseMediaFolder((mediaPaths == null ? void 0 : mediaPaths.mediaRoot) || "")
-        })
-      );
-      return server;
-    };
-  }
-});
-
-// src/server/index.ts
-var init_server2 = __esm({
-  "src/server/index.ts"() {
-    init_server();
-  }
-});
-
-// src/cmds/start-server/server.ts
-var server_exports = {};
-__export(server_exports, {
-  default: () => server_default
-});
-var server_default;
-var init_server3 = __esm({
-  "src/cmds/start-server/server.ts"() {
-    init_server2();
-    server_default = gqlServer;
-  }
-});
-
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  defineSchema: () => defineSchema,
-  init: () => init
+  default: () => src_default
 });
 module.exports = __toCommonJS(src_exports);
-var commander = __toESM(require("commander"));
+var import_clipanion5 = require("clipanion");
 
 // package.json
-var name = "@tinacms/cli";
-var version = "1.3.2";
+var version = "1.4.0";
 
-// src/cmds/audit/audit.ts
-var import_graphql = require("@tinacms/graphql");
+// src/next/commands/dev-command/index.ts
+var import_clipanion = require("clipanion");
+var import_fs_extra4 = __toESM(require("fs-extra"));
+var import_path6 = __toESM(require("path"));
+var import_chokidar = __toESM(require("chokidar"));
+var import_graphql8 = require("@tinacms/graphql");
+
+// src/next/config-manager.ts
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_path = __toESM(require("path"));
+var import_os = __toESM(require("os"));
+var esbuild = __toESM(require("esbuild"));
+var url = __toESM(require("url"));
+var dotenv = __toESM(require("dotenv"));
+var import_normalize_path = __toESM(require("normalize-path"));
+
+// src/logger/index.ts
+var import_chalk = __toESM(require("chalk"));
+
+// src/logger/is-unicode-supported.ts
+function isUnicodeSupported() {
+  if (process.platform !== "win32") {
+    return process.env.TERM !== "linux";
+  }
+  return Boolean(process.env.CI) || Boolean(process.env.WT_SESSION) || Boolean(process.env.TERMINUS_SUBLIME) || process.env.ConEmuTask === "{cmd::Cmder}" || process.env.TERM_PROGRAM === "Terminus-Sublime" || process.env.TERM_PROGRAM === "vscode" || process.env.TERM === "xterm-256color" || process.env.TERM === "alacritty" || process.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
 
 // src/logger/index.ts
 var import_log4js = __toESM(require("log4js"));
@@ -312,658 +70,947 @@ import_log4js.default.configure({
   categories: { default: { appenders: ["out"], level: "info" } }
 });
 logger.level = "info";
-
-// src/cmds/audit/audit.ts
-var import_graphql2 = require("@tinacms/graphql");
-var import_chalk = __toESM(require("chalk"));
-var auditDocuments = async (args) => {
-  const { collection, database, useDefaultValues, documents } = args;
-  let error = false;
-  for (let i = 0; i < documents.length; i++) {
-    const node = documents[i].node;
-    const relativePath = node.path.replace(`${collection.path}/`, "");
-    const documentQuery = `query {
-        document(collection: "${collection.name}", relativePath: "${relativePath}") {
-          __typename
-          ...on Document {
-            _values
-          }
-        }
-      }`;
-    const docResult = await (0, import_graphql.resolve)({
-      database,
-      query: documentQuery,
-      variables: {},
-      silenceErrors: true,
-      verbose: args.verbose || false,
-      isAudit: true
+function ansiRegex() {
+  const pattern = [
+    "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
+    "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))"
+  ].join("|");
+  return new RegExp(pattern, "g");
+}
+var bar = "\u2502";
+var strip = (str) => str.replace(ansiRegex(), "");
+var note = (message = "", title = "") => {
+  const lines = `
+${message}
+`.split("\n");
+  const len = lines.reduce((sum, ln) => {
+    ln = strip(ln);
+    return ln.length > sum ? ln.length : sum;
+  }, 0) + 2;
+  const msg = lines.map(
+    (ln) => `${import_chalk.default.gray(bar)}  ${import_chalk.default.white(ln)}${" ".repeat(
+      len - strip(ln).length
+    )}${import_chalk.default.gray(bar)}`
+  ).join("\n");
+  process.stdout.write(
+    `${import_chalk.default.gray(bar)}
+${import_chalk.default.green("\u25CB")}  ${import_chalk.default.reset(
+      title
+    )} ${import_chalk.default.gray(
+      "\u2500".repeat(len - title.length - 1) + "\u256E"
+    )}
+${msg}
+${import_chalk.default.gray("\u251C" + "\u2500".repeat(len + 2) + "\u256F")}
+`
+  );
+};
+var summary = (content2) => {
+  const outString = [];
+  let longestKey = 0;
+  content2.items.forEach((item) => {
+    item.subItems.forEach((subItem) => {
+      if (subItem.key.length > longestKey) {
+        longestKey = subItem.key.length;
+      }
     });
-    if (docResult.errors) {
-      error = true;
-      docResult.errors.forEach((err) => {
-        logger.error(import_chalk.default.red(err.message));
-        if (err.originalError.originalError) {
-          logger.error(
-            import_chalk.default.red(`    ${err.originalError.originalError.message}`)
-          );
-        }
-      });
+  });
+  content2.items.forEach((item) => {
+    outString.push(`${item.emoji} ${import_chalk.default.cyan(item.heading)}`);
+    item.subItems.forEach((subItem) => {
+      const spaces = longestKey - subItem.key.length + 4;
+      outString.push(
+        `   ${subItem.key}:${[...Array(spaces)].join(" ")}${import_chalk.default.cyan(
+          subItem.value
+        )}`
+      );
+    });
+    outString.push(``);
+  });
+  if (process.env.CI) {
+    logger.info(JSON.stringify(content2, null, 2));
+  } else {
+    note(outString.join("\n"), content2.heading);
+  }
+};
+var unicode = isUnicodeSupported();
+var s = (c, fallback) => unicode ? c : fallback;
+var S_STEP_ACTIVE = s("\u25C6", "*");
+var S_STEP_CANCEL = s("\u25A0", "x");
+var S_STEP_ERROR = s("\u25B2", "x");
+var S_STEP_SUBMIT = s("\u25C7", "o");
+var S_BAR_START = s("\u250C", "T");
+var S_BAR = s("\u2502", "|");
+var S_BAR_END = s("\u2514", "\u2014");
+var S_RADIO_ACTIVE = s("\u25CF", ">");
+var S_RADIO_INACTIVE = s("\u25CB", " ");
+var S_CHECKBOX_ACTIVE = s("\u25FB", "[\u2022]");
+var S_CHECKBOX_SELECTED = s("\u25FC", "[+]");
+var S_CHECKBOX_INACTIVE = s("\u25FB", "[ ]");
+var S_PASSWORD_MASK = s("\u25AA", "\u2022");
+var S_BAR_H = s("\u2500", "-");
+var S_CORNER_TOP_RIGHT = s("\u256E", "+");
+var S_CONNECT_LEFT = s("\u251C", "+");
+var S_CORNER_BOTTOM_RIGHT = s("\u256F", "+");
+var S_INFO = s("\u25CF", "\u2022");
+var S_SUCCESS = s("\u25C6", "*");
+var S_WARN = s("\u25B2", "!");
+var S_ERROR = s("\u25A0", "x");
+
+// src/next/config-manager.ts
+var TINA_FOLDER = "tina";
+var LEGACY_TINA_FOLDER = ".tina";
+var GENERATED_FOLDER = "__generated__";
+var GRAPHQL_JSON_FILE = "_graphql.json";
+var GRAPHQL_GQL_FILE = "schema.gql";
+var SCHEMA_JSON_FILE = "_schema.json";
+var LOOKUP_JSON_FILE = "_lookup.json";
+var ConfigManager = class {
+  constructor(rootPath = process.cwd(), tinaGraphQLVersion) {
+    this.rootPath = (0, import_normalize_path.default)(rootPath);
+    this.tinaGraphQLVersionFromCLI = tinaGraphQLVersion;
+  }
+  isUsingTs() {
+    return [".ts", ".tsx"].includes(import_path.default.extname(this.tinaConfigFilePath));
+  }
+  hasSelfHostedConfig() {
+    return !!this.selfHostedDatabaseFilePath;
+  }
+  hasSeparateContentRoot() {
+    return this.rootPath !== this.contentRootPath;
+  }
+  async processConfig() {
+    this.tinaFolderPath = await this.getTinaFolderPath(this.rootPath);
+    this.envFilePath = import_path.default.resolve(
+      import_path.default.join(this.tinaFolderPath, "..", ".env")
+    );
+    dotenv.config({ path: this.envFilePath });
+    this.tinaConfigFilePath = await this.getPathWithExtension(
+      import_path.default.join(this.tinaFolderPath, "config")
+    );
+    if (!this.tinaConfigFilePath) {
+      throw new Error(
+        `Unable to find confg file in ${this.tinaFolderPath}. Looking for a file named "config.{ts,tsx,js,jsx}"`
+      );
+    }
+    this.selfHostedDatabaseFilePath = await this.getPathWithExtension(
+      import_path.default.join(this.tinaFolderPath, "database")
+    );
+    this.generatedFolderPath = import_path.default.join(this.tinaFolderPath, GENERATED_FOLDER);
+    this.config = await this.loadConfigFile(
+      this.generatedFolderPath,
+      this.tinaConfigFilePath
+    );
+    this.generatedGraphQLGQLPath = import_path.default.join(
+      this.generatedFolderPath,
+      GRAPHQL_GQL_FILE
+    );
+    this.generatedGraphQLJSONPath = import_path.default.join(
+      this.generatedFolderPath,
+      GRAPHQL_JSON_FILE
+    );
+    this.generatedSchemaJSONPath = import_path.default.join(
+      this.generatedFolderPath,
+      SCHEMA_JSON_FILE
+    );
+    this.generatedLookupJSONPath = import_path.default.join(
+      this.generatedFolderPath,
+      LOOKUP_JSON_FILE
+    );
+    this.generatedQueriesFilePath = import_path.default.join(
+      this.generatedFolderPath,
+      "queries.gql"
+    );
+    this.generatedFragmentsFilePath = import_path.default.join(
+      this.generatedFolderPath,
+      "frags.gql"
+    );
+    const fullLocalContentPath = import_path.default.join(
+      this.tinaFolderPath,
+      this.config.localContentPath || ""
+    );
+    if (this.config.localContentPath && await import_fs_extra.default.existsSync(fullLocalContentPath)) {
+      logger.info(`Using separate content repo at ${fullLocalContentPath}`);
+      this.contentRootPath = fullLocalContentPath;
     } else {
-      const topLevelDefaults = {};
-      if (useDefaultValues && typeof collection.fields !== "string") {
-        collection.fields.filter((x) => !x.list).forEach((x) => {
-          const value = x.ui;
-          if (typeof value !== "undefined") {
-            topLevelDefaults[x.name] = value.defaultValue;
-          }
-        });
-      }
-      const params = transformDocumentIntoMutationRequestPayload(
-        docResult.data.document._values,
-        {
-          includeCollection: true,
-          includeTemplate: typeof collection.templates !== "undefined"
-        },
-        topLevelDefaults
+      this.contentRootPath = this.rootPath;
+    }
+    this.generatedTypesTSFilePath = import_path.default.join(
+      this.generatedFolderPath,
+      "types.ts"
+    );
+    this.generatedTypesJSFilePath = import_path.default.join(
+      this.generatedFolderPath,
+      "types.js"
+    );
+    this.generatedTypesDFilePath = import_path.default.join(
+      this.generatedFolderPath,
+      "types.d.ts"
+    );
+    this.userQueriesAndFragmentsGlob = import_path.default.join(
+      this.tinaFolderPath,
+      "queries/**/*.{graphql,gql}"
+    );
+    this.generatedQueriesAndFragmentsGlob = import_path.default.join(
+      this.generatedFolderPath,
+      "*.{graphql,gql}"
+    );
+    this.generatedClientTSFilePath = import_path.default.join(
+      this.generatedFolderPath,
+      "client.ts"
+    );
+    this.generatedClientJSFilePath = import_path.default.join(
+      this.generatedFolderPath,
+      "client.js"
+    );
+    this.publicFolderPath = import_path.default.join(
+      this.rootPath,
+      this.config.build.publicFolder
+    );
+    this.outputFolderPath = import_path.default.join(
+      this.publicFolderPath,
+      this.config.build.outputFolder
+    );
+    this.outputHTMLFilePath = import_path.default.join(this.outputFolderPath, "index.html");
+    this.outputGitignorePath = import_path.default.join(this.outputFolderPath, ".gitignore");
+    this.spaHTMLPath = url.pathToFileURL(
+      require.resolve("@tinacms/app")
+    ).pathname;
+    this.spaRootPath = this.spaHTMLPath.replace("/index.html", "");
+    this.spaMainPath = import_path.default.join(this.spaRootPath, "src", "main.tsx");
+  }
+  async getTinaFolderPath(rootPath) {
+    const tinaFolderPath = import_path.default.join(rootPath, TINA_FOLDER);
+    const tinaFolderExists = await import_fs_extra.default.pathExists(tinaFolderPath);
+    if (tinaFolderExists) {
+      this.isUsingLegacyFolder = false;
+      return tinaFolderPath;
+    }
+    const legacyFolderPath = import_path.default.join(rootPath, LEGACY_TINA_FOLDER);
+    const legacyFolderExists = await import_fs_extra.default.pathExists(legacyFolderPath);
+    if (legacyFolderExists) {
+      this.isUsingLegacyFolder = true;
+      return legacyFolderPath;
+    }
+    throw new Error(
+      `Unable to find Tina folder, if you're working in folder outside of the Tina config be sure to specify --rootPath`
+    );
+  }
+  getTinaGraphQLVersion() {
+    var _a, _b;
+    if (this.tinaGraphQLVersionFromCLI) {
+      return this.tinaGraphQLVersionFromCLI;
+    }
+    const generatedSchema = import_fs_extra.default.readJSONSync(this.generatedSchemaJSONPath);
+    if (!generatedSchema || !(typeof (generatedSchema == null ? void 0 : generatedSchema.version) !== "undefined") || !(typeof ((_a = generatedSchema == null ? void 0 : generatedSchema.version) == null ? void 0 : _a.major) === "string") || !(typeof ((_b = generatedSchema == null ? void 0 : generatedSchema.version) == null ? void 0 : _b.minor) === "string")) {
+      throw new Error(
+        `Can not find Tina GraphQL version in ${this.generatedSchemaJSONPath}`
       );
-      const mutation = `mutation($collection: String!, $relativePath: String!, $params: DocumentUpdateMutation!) {
-        updateDocument(
-          collection: $collection,
-          relativePath: $relativePath,
-          params: $params
-        ){__typename}
-      }`;
-      const mutationRes = await (0, import_graphql.resolve)({
-        database,
-        query: mutation,
-        variables: {
-          params,
-          collection: collection.name,
-          relativePath
-        },
-        isAudit: true,
-        silenceErrors: true,
-        verbose: args.verbose || false
-      });
-      if (mutationRes.errors) {
-        mutationRes.errors.forEach((err) => {
-          error = true;
-          logger.error(import_chalk.default.red(err.message));
-        });
-      }
     }
+    return `${generatedSchema.version.major}.${generatedSchema.version.minor}`;
   }
-  return error;
-};
-var transformDocumentIntoMutationRequestPayload = (document, instructions, defaults) => {
-  const { _collection, __typename, _template, ...rest } = document;
-  const params = transformParams(rest);
-  const paramsWithTemplate = instructions.includeTemplate ? { [_template]: params } : params;
-  return instructions.includeCollection ? { [_collection]: { ...defaults, ...filterObject(paramsWithTemplate) } } : { ...defaults, ...filterObject(paramsWithTemplate) };
-};
-var transformParams = (data) => {
-  if (["string", "number", "boolean"].includes(typeof data)) {
-    return data;
+  printGeneratedClientFilePath() {
+    if (this.isUsingTs()) {
+      return this.generatedClientTSFilePath.replace(`${this.rootPath}/`, "");
+    }
+    return this.generatedClientJSFilePath.replace(`${this.rootPath}/`, "");
   }
-  if (Array.isArray(data)) {
-    return data.map((item) => transformParams(item));
+  printGeneratedTypesFilePath() {
+    return this.generatedTypesTSFilePath.replace(`${this.rootPath}/`, "");
   }
-  try {
-    (0, import_graphql2.assertShape)(
-      data,
-      (yup) => yup.object({ _template: yup.string().required() })
-    );
-    const { _template, __typename, ...rest } = data;
-    const nested = transformParams(rest);
-    return { [_template]: nested };
-  } catch (e) {
-    if (e.message === "Failed to assertShape - _template is a required field") {
-      if (!data) {
-        return void 0;
-        return [];
-      }
-      const accum = {};
-      Object.entries(data).map(([keyName, value]) => {
-        accum[keyName] = transformParams(value);
-      });
-      return accum;
-    } else {
-      if (!data) {
-        return void 0;
-        return [];
-      }
-      throw e;
+  printoutputHTMLFilePath() {
+    return this.outputHTMLFilePath.replace(`${this.publicFolderPath}/`, "");
+  }
+  printRelativePath(filename) {
+    if (filename) {
+      return filename.replace(`${this.rootPath}/`, "");
     }
+    throw `No path provided to print`;
   }
-};
-function filterObject(obj) {
-  const ret = {};
-  Object.keys(obj).filter((key) => obj[key] !== void 0).forEach((key) => ret[key] = obj[key]);
-  return ret;
-}
-
-// src/cmds/audit/index.ts
-var import_chalk3 = __toESM(require("chalk"));
-var import_prompts = __toESM(require("prompts"));
-var import_metrics = require("@tinacms/metrics");
+  printContentRelativePath(filename) {
+    if (filename) {
+      return filename.replace(`${this.contentRootPath}/`, "");
+    }
+    throw `No path provided to print`;
+  }
+  async getPathWithExtension(filepath) {
+    const extensions = ["tsx", "ts", "jsx", "js"];
+    let result;
+    await Promise.all(
+      extensions.map(async (ext) => {
+        if (result) {
+          return;
+        }
+        const filepathWithExtension = `${filepath}.${ext}`;
+        const exists = await import_fs_extra.default.existsSync(filepathWithExtension);
+        if (exists) {
+          result = filepathWithExtension;
+        }
+      })
+    );
+    return result;
+  }
+  async loadDatabaseFile() {
+    const tmpdir = import_path.default.join(import_os.default.tmpdir(), Date.now().toString());
+    const outfile = import_path.default.join(tmpdir, "database.build.js");
+    await esbuild.build({
+      entryPoints: [this.selfHostedDatabaseFilePath],
+      bundle: true,
+      platform: "node",
+      outfile
+    });
+    const result = require(outfile);
+    await import_fs_extra.default.removeSync(outfile);
+    return result.default;
+  }
+  async loadConfigFile(generatedFolderPath, configFilePath) {
+    const tmpdir = import_path.default.join(import_os.default.tmpdir(), Date.now().toString());
+    const outfile = import_path.default.join(tmpdir, "config.build.jsx");
+    const outfile2 = import_path.default.join(tmpdir, "config.build.js");
+    const tempTSConfigFile = import_path.default.join(tmpdir, "tsconfig.json");
+    await import_fs_extra.default.outputFileSync(tempTSConfigFile, "{}");
+    await esbuild.build({
+      entryPoints: [configFilePath],
+      bundle: true,
+      target: ["es2020"],
+      platform: "node",
+      outfile
+    });
+    await esbuild.build({
+      entryPoints: [outfile],
+      bundle: true,
+      platform: "node",
+      outfile: outfile2
+    });
+    const result = require(outfile2);
+    await import_fs_extra.default.removeSync(outfile);
+    await import_fs_extra.default.removeSync(outfile2);
+    return result.default;
+  }
+};
+
+// src/next/commands/dev-command/html.ts
+var devHTML = (port) => `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>TinaCMS</title>
+  </head>
+
+  <!-- if development -->
+  <script type="module">
+    import RefreshRuntime from 'http://localhost:${port}/@react-refresh'
+    RefreshRuntime.injectIntoGlobalHook(window)
+    window.$RefreshReg$ = () => {}
+    window.$RefreshSig$ = () => (type) => type
+    window.__vite_plugin_react_preamble_installed__ = true
+  <\/script>
+  <script type="module" src="http://localhost:${port}/@vite/client"><\/script>
+  <script
+    type="module"
+    src="http://localhost:${port}/src/main.tsx"
+  ><\/script>
+  <body class="tina-tailwind">
+    <div id="root"></div>
+  </body>
+</html>`;
+
+// src/next/commands/dev-command/server/index.ts
+var import_body_parser = __toESM(require("body-parser"));
+var import_path5 = __toESM(require("path"));
+var import_cors = __toESM(require("cors"));
+var import_vite2 = require("vite");
+var import_graphql = require("@tinacms/graphql");
 
-// src/utils/theme.ts
-var import_chalk2 = __toESM(require("chalk"));
-var successText = import_chalk2.default.bold.green;
-var focusText = import_chalk2.default.bold;
-var dangerText = import_chalk2.default.bold.red;
-var neutralText = import_chalk2.default.bold.cyan;
-var linkText = import_chalk2.default.bold.cyan;
-var labelText = import_chalk2.default.bold;
-var cmdText = import_chalk2.default.inverse;
-var indentedCmd = (str) => {
-  return `  \u2503 ` + str;
-};
-var logText = import_chalk2.default.italic.gray;
-var warnText = import_chalk2.default.yellowBright.bgBlack;
-var titleText = import_chalk2.default.bgHex("d2f1f8").hex("ec4816");
-var CONFIRMATION_TEXT = import_chalk2.default.dim("enter to confirm");
-
-// src/cmds/audit/index.ts
-var rootPath = process.cwd();
-var audit = async (ctx, next, options) => {
-  const telemetry = new import_metrics.Telemetry({ disabled: options.noTelemetry });
-  await telemetry.submitRecord({
-    event: {
-      name: "tinacms:cli:audit:invoke",
-      clean: Boolean(options.clean),
-      useDefaults: Boolean(options.useDefaultValues)
-    }
-  });
-  if (options.clean) {
-    logger.info(
-      `You are using the \`--clean\` option. This will modify your content as if a user is submitting a form. Before running this you should have a ${import_chalk3.default.bold(
-        "clean git tree"
-      )} so unwanted changes can be undone.
-
-`
-    );
-    const res = await (0, import_prompts.default)({
-      name: "useClean",
-      type: "confirm",
-      message: `Do you want to continue?`
+// src/next/commands/dev-command/server/media.ts
+var import_fs_extra2 = __toESM(require("fs-extra"));
+var import_path2 = __toESM(require("path"));
+var import_busboy = __toESM(require("busboy"));
+var createMediaRouter = (config3) => {
+  const mediaFolder = import_path2.default.join(
+    config3.rootPath,
+    config3.publicFolder,
+    config3.mediaRoot
+  );
+  const mediaModel = new MediaModel(config3);
+  const handleList = async (req, res) => {
+    const requestURL = new URL(req.url, config3.apiURL);
+    const folder = requestURL.pathname.replace("/media/list/", "");
+    const limit = requestURL.searchParams.get("limit");
+    const cursor = requestURL.searchParams.get("cursor");
+    const media = await mediaModel.listMedia({
+      searchPath: folder,
+      cursor,
+      limit
     });
-    if (!res.useClean) {
-      logger.warn(import_chalk3.default.yellowBright("\u26A0\uFE0F Audit not complete"));
-      process.exit(0);
-    }
-  }
-  if (options.useDefaultValues && !options.clean) {
-    logger.warn(
-      import_chalk3.default.yellowBright(
-        "WARNING: using the `--useDefaultValues` without the `--clean` flag has no effect. Please re-run audit and add the `--clean` flag"
-      )
-    );
-  }
-  const database = ctx.database;
-  const schema = await database.getSchema();
-  const collections = schema.getCollections();
-  let error = false;
-  for (let i = 0; i < collections.length; i++) {
-    const collection = collections[i];
-    const docs = await database.query(
-      { collection: collection.name, first: -1, filterChain: [] },
-      (item) => ({ path: item })
-    );
-    logger.info(
-      `Checking ${neutralText(collection.name)} collection. ${docs.edges.length} Documents`
-    );
-    const returnError = await auditDocuments({
-      collection,
-      database,
-      rootPath,
-      useDefaultValues: options.useDefaultValues,
-      documents: docs.edges,
-      verbose: ctx.verbose
+    res.end(JSON.stringify(media));
+  };
+  const handleDelete = async (req, res) => {
+    const file = decodeURIComponent(req.url.slice("/media/".length));
+    const didDelete = await mediaModel.deleteMedia({ searchPath: file });
+    res.end(JSON.stringify(didDelete));
+  };
+  const handlePost = async function(req, res) {
+    const bb = (0, import_busboy.default)({ headers: req.headers });
+    bb.on("file", (name2, file, info) => {
+      const saveTo = import_path2.default.join(mediaFolder, info.filename);
+      file.pipe(import_fs_extra2.default.createWriteStream(saveTo));
     });
-    error = error || returnError;
-  }
-  ctx.error = error;
-  next();
-};
-var printFinalMessage = async (ctx, next, _options) => {
-  if (ctx.error) {
-    logger.error(
-      import_chalk3.default.redBright(`\u203C\uFE0F Audit ${import_chalk3.default.bold("failed")} with errors`)
-    );
-  } else if (ctx.warning) {
-    logger.warn(import_chalk3.default.yellowBright("\u26A0\uFE0F Audit passed with warnings"));
-  } else {
-    logger.info(import_chalk3.default.greenBright("\u2705 Audit passed"));
-  }
-  next();
-};
-
-// src/cmds/baseCmds.ts
-var import_config2 = require("dotenv/config");
-
-// src/middleware.ts
-var chain = async (cmds, options) => {
-  const ctx = {};
-  const next = async (middlewareIndex) => {
-    if (middlewareIndex >= cmds.length) {
-      process.exit(0);
-    }
+    bb.on("error", (error) => {
+      res.statusCode = 500;
+      if (error instanceof Error) {
+        res.end(JSON.stringify({ message: error }));
+      } else {
+        res.end(JSON.stringify({ message: "Unknown error while uploading" }));
+      }
+    });
+    bb.on("close", () => {
+      res.statusCode = 200;
+      res.end(JSON.stringify({ success: true }));
+    });
+    req.pipe(bb);
+  };
+  return { handleList, handleDelete, handlePost };
+};
+var parseMediaFolder = (str) => {
+  let returnString = str;
+  if (returnString.startsWith("/"))
+    returnString = returnString.substr(1);
+  if (returnString.endsWith("/"))
+    returnString = returnString.substr(0, returnString.length - 1);
+  return returnString;
+};
+var MediaModel = class {
+  constructor({ rootPath, publicFolder, mediaRoot }) {
+    this.rootPath = rootPath;
+    this.mediaRoot = mediaRoot;
+    this.publicFolder = publicFolder;
+  }
+  async listMedia(args) {
     try {
-      await cmds[middlewareIndex](
-        ctx,
-        () => next(middlewareIndex + 1),
-        options || {}
+      const folderPath = (0, import_path2.join)(
+        this.rootPath,
+        this.publicFolder,
+        this.mediaRoot,
+        args.searchPath
       );
-    } catch (err) {
-      console.error(`  ${dangerText(err)}`);
-      if (err.stack) {
-        console.log(err.stack);
-      }
-      process.exit(1);
+      const searchPath = parseMediaFolder(args.searchPath);
+      const filesStr = await import_fs_extra2.default.readdir(folderPath);
+      const filesProm = filesStr.map(async (file) => {
+        const filePath = (0, import_path2.join)(folderPath, file);
+        const stat = await import_fs_extra2.default.stat(filePath);
+        let src = `/${file}`;
+        const isFile = stat.isFile();
+        if (!isFile) {
+          return {
+            isFile,
+            size: stat.size,
+            src,
+            filename: file
+          };
+        }
+        if (searchPath) {
+          src = `/${searchPath}${src}`;
+        }
+        if (this.mediaRoot) {
+          src = `/${this.mediaRoot}${src}`;
+        }
+        return {
+          isFile,
+          size: stat.size,
+          src,
+          filename: file
+        };
+      });
+      const offset = Number(args.cursor) || 0;
+      const limit = Number(args.limit) || 20;
+      const rawItems = await Promise.all(filesProm);
+      const sortedItems = rawItems.sort((a, b) => {
+        if (a.isFile && !b.isFile) {
+          return 1;
+        }
+        if (!a.isFile && b.isFile) {
+          return -1;
+        }
+        return 0;
+      });
+      const limitItems = sortedItems.slice(offset, offset + limit);
+      const files = limitItems.filter((x) => x.isFile);
+      const directories = limitItems.filter((x) => !x.isFile).map((x) => x.src);
+      const cursor = rawItems.length > offset + limit ? String(offset + limit) : null;
+      return {
+        files,
+        directories,
+        cursor
+      };
+    } catch (error) {
+      console.error(error);
+      return {
+        files: [],
+        directories: [],
+        error: error == null ? void 0 : error.toString()
+      };
     }
-  };
-  if (cmds.length > 0) {
-    await next(0);
-  }
-};
-
-// src/cmds/baseCmds.ts
-var import_chalk4 = __toESM(require("chalk"));
-
-// src/cmds/start-server/index.ts
-var import_path8 = __toESM(require("path"));
-var import_chokidar = __toESM(require("chokidar"));
-var import_metrics2 = require("@tinacms/metrics");
-
-// src/cmds/start-server/lock.ts
-var AsyncLock = class {
-  constructor() {
-    this.disable = () => {
-    };
-    this.promise = Promise.resolve();
-  }
-  enable() {
-    this.promise = new Promise((resolve2) => this.disable = resolve2);
-  }
-};
-
-// src/cmds/start-server/errors/index.ts
-var import_graphql3 = require("@tinacms/graphql");
-var BuildSchemaError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "BuildSchemaError";
-  }
-};
-var ExecuteSchemaError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "ExecuteSchemaError";
   }
-};
-var handleServerErrors = (e) => {
-  if (e.name === "BuildSchemaError") {
-    logger.error(`${dangerText(
-      "ERROR: your schema was not successfully built: see https://tina.io/docs/errors/esbuild-error/ for more details"
-    )}
-  Error Message Below
-  ${e}`);
-  } else if (e.name === "ExecuteSchemaError") {
-    logger.error(`${dangerText(
-      "ERROR: your schema was not successfully executed: see https://tina.io/docs/errors/esbuild-error/ for more details"
-    )}
-  Error Message Below
-  ${e}`);
-  } else if (e.name === "TinaSchemaValidationError") {
-    logger.error(`${dangerText(
-      "ERROR: your schema was not successfully validated: see https://tina.io/docs/schema/ for instructions on how to setup a schema"
-    )}
-  Error Message Below
-  ${e}`);
-  } else if (e instanceof import_graphql3.TinaFetchError) {
-    (0, import_graphql3.handleFetchErrorError)(e, true);
-  } else {
-    logger.info(
-      dangerText(
-        "Compilation failed with errors. Server has not been restarted."
-      ) + ` see error below 
- ${e.message}`
-    );
+  async deleteMedia(args) {
+    try {
+      const file = (0, import_path2.join)(
+        this.rootPath,
+        this.publicFolder,
+        this.mediaRoot,
+        args.searchPath
+      );
+      await import_fs_extra2.default.stat(file);
+      await import_fs_extra2.default.remove(file);
+      return { ok: true };
+    } catch (error) {
+      console.error(error);
+      return { ok: false, message: error == null ? void 0 : error.toString() };
+    }
   }
 };
 
-// src/buildTina/index.ts
-var import_fs_extra5 = __toESM(require("fs-extra"));
-var import_graphql9 = require("@tinacms/graphql");
-var import_datalayer = require("@tinacms/datalayer");
-var import_memory_level = require("memory-level");
-var import_path5 = __toESM(require("path"));
-
-// src/cmds/compile/index.ts
-var _ = __toESM(require("lodash"));
-var import_fs_extra2 = __toESM(require("fs-extra"));
-var import_path2 = __toESM(require("path"));
+// src/next/commands/dev-command/server/index.ts
 var import_esbuild = require("esbuild");
 
-// src/lib/getPath.ts
-var import_path = __toESM(require("path"));
-var import_fs_extra = __toESM(require("fs-extra"));
-var fileExists = ({
-  projectDir,
-  filename,
-  allowedTypes
-}) => {
-  if (!import_fs_extra.default.existsSync(projectDir)) {
-    return false;
-  }
-  const filePaths = allowedTypes.map(
-    (ext) => import_path.default.join(projectDir, `${filename}.${ext}`)
-  );
-  let inputFile = void 0;
-  filePaths.every((path11) => {
-    if (import_fs_extra.default.existsSync(path11)) {
-      inputFile = path11;
-      return false;
+// src/next/vite/index.ts
+var import_path4 = __toESM(require("path"));
+var import_vite = require("vite");
+
+// src/next/vite/tailwind.ts
+var import_tailwindcss = __toESM(require("tailwindcss"));
+var import_postcss_nested = __toESM(require("postcss-nested/index.js"));
+var import_nesting = __toESM(require("tailwindcss/nesting/index.js"));
+var import_defaultTheme = __toESM(require("tailwindcss/defaultTheme.js"));
+var import_typography = __toESM(require("@tailwindcss/typography"));
+var import_line_clamp = __toESM(require("@tailwindcss/line-clamp"));
+var import_aspect_ratio = __toESM(require("@tailwindcss/aspect-ratio"));
+var import_path3 = __toESM(require("path"));
+var tinaTailwind = (spaPath, configFilePath) => {
+  return {
+    name: "vite-plugin-tina",
+    config: (viteConfig) => {
+      const plugins = [];
+      const content2 = [
+        import_path3.default.join(spaPath, "src/**/*.{vue,js,ts,jsx,tsx,svelte}"),
+        import_path3.default.join(configFilePath)
+      ];
+      const tw = (0, import_tailwindcss.default)({
+        important: ".tina-tailwind",
+        theme: {
+          columns: {
+            auto: "auto",
+            1: "1",
+            2: "2",
+            3: "3",
+            4: "4",
+            5: "5",
+            6: "6",
+            7: "7",
+            8: "8",
+            9: "9",
+            10: "10",
+            11: "11",
+            12: "12",
+            "3xs": "256px",
+            "2xs": "288px",
+            xs: "320px",
+            sm: "384px",
+            md: "448px",
+            lg: "512px",
+            xl: "576px",
+            "2xl": "672px",
+            "3xl": "768px",
+            "4xl": "896px",
+            "5xl": "1024px",
+            "6xl": "1152px",
+            "7xl": "1280px"
+          },
+          spacing: {
+            px: "1px",
+            0: "0px",
+            0.5: "2px",
+            1: "4px",
+            1.5: "6px",
+            2: "8px",
+            2.5: "10px",
+            3: "12px",
+            3.5: "14px",
+            4: "16px",
+            5: "20px",
+            6: "24px",
+            7: "28px",
+            8: "32px",
+            9: "36px",
+            10: "40px",
+            11: "44px",
+            12: "48px",
+            14: "56px",
+            16: "64px",
+            18: "72px",
+            20: "80px",
+            24: "96px",
+            28: "114px",
+            32: "128px",
+            36: "144px",
+            40: "160px",
+            44: "176px",
+            48: "192px",
+            52: "208px",
+            56: "224px",
+            60: "240px",
+            64: "256px",
+            72: "288px",
+            80: "320px",
+            96: "384px"
+          },
+          borderRadius: {
+            none: "0px",
+            sm: "2px",
+            DEFAULT: "4px",
+            md: "6px",
+            lg: "8px",
+            xl: "12px",
+            "2xl": "16px",
+            "3xl": "24px",
+            full: "9999px"
+          },
+          borderWidth: {
+            DEFAULT: "1px",
+            0: "0",
+            2: "2px",
+            3: "3px",
+            4: "4px",
+            6: "6px",
+            8: "8px"
+          },
+          fontSize: {
+            xs: ["13px", { lineHeight: "1.33" }],
+            sm: ["14px", { lineHeight: "1.43" }],
+            base: ["16px", { lineHeight: "1.5" }],
+            md: ["16px", { lineHeight: "1.5" }],
+            lg: ["18px", { lineHeight: "1.55" }],
+            xl: ["20px", { lineHeight: "1.4" }],
+            "2xl": ["24px", { lineHeight: "1.33" }],
+            "3xl": ["30px", { lineHeight: "1.2" }],
+            "4xl": ["36px", { lineHeight: "1.1" }],
+            "5xl": ["48px", { lineHeight: "1" }],
+            "6xl": ["60px", { lineHeight: "1" }],
+            "7xl": ["72px", { lineHeight: "1" }],
+            "8xl": ["96px", { lineHeight: "1" }],
+            "9xl": ["128px", { lineHeight: "1" }]
+          },
+          opacity: {
+            0: "0",
+            5: ".05",
+            7: ".07",
+            10: ".1",
+            15: ".15",
+            20: ".2",
+            25: ".25",
+            30: ".3",
+            40: ".4",
+            50: ".5",
+            60: ".6",
+            70: ".7",
+            75: ".75",
+            80: ".8",
+            90: ".9",
+            100: "1"
+          },
+          zIndex: {
+            "-1": "-1",
+            base: "9000",
+            panel: "9400",
+            menu: "9800",
+            chrome: "10200",
+            overlay: "10600",
+            modal: "10800",
+            0: "0",
+            10: "10",
+            20: "20",
+            30: "30",
+            40: "40",
+            25: "25",
+            50: "50",
+            75: "75",
+            100: "100",
+            auto: "auto"
+          },
+          extend: {
+            scale: {
+              97: ".97",
+              103: "1.03"
+            },
+            transitionDuration: {
+              0: "0ms",
+              2e3: "2000ms"
+            },
+            boxShadow: {
+              xs: "0 0 0 1px rgba(0, 0, 0, 0.05)",
+              outline: "0 0 0 3px rgba(66, 153, 225, 0.5)"
+            },
+            colors: {
+              blue: {
+                50: "#DCEEFF",
+                100: "#B4DBFF",
+                200: "#85C5FE",
+                300: "#4EABFE",
+                400: "#2296fe",
+                500: "#0084FF",
+                600: "#0574e4",
+                700: "#0D5DBD",
+                800: "#144696",
+                900: "#1D2C6C",
+                1e3: "#241748"
+              },
+              gray: {
+                50: "#F6F6F9",
+                100: "#EDECF3",
+                150: "#E6E3EF",
+                200: "#E1DDEC",
+                250: "#C9C5D5",
+                300: "#b2adbe",
+                400: "#918c9e",
+                500: "#716c7f",
+                600: "#565165",
+                700: "#433e52",
+                800: "#363145",
+                900: "#252336",
+                1e3: "#1c1b2e"
+              },
+              orange: {
+                400: "#EB6337",
+                500: "#EC4815",
+                600: "#DC4419"
+              }
+            },
+            fontFamily: {
+              sans: ["Inter", ...import_defaultTheme.default.fontFamily.sans]
+            },
+            lineHeight: {
+              3: "12px",
+              4: "16px",
+              5: "20px",
+              6: "24px",
+              7: "28px",
+              8: "32px",
+              9: "36px",
+              10: "40px"
+            },
+            maxWidth: {
+              form: "900px"
+            },
+            screens: {
+              xs: "320px",
+              sm: "560px",
+              md: "720px",
+              lg: "1030px"
+            }
+          }
+        },
+        content: content2,
+        plugins: [
+          (0, import_typography.default)({ className: "tina-prose" }),
+          import_line_clamp.default,
+          import_aspect_ratio.default
+        ]
+      });
+      plugins.push(import_nesting.default);
+      plugins.push(import_postcss_nested.default);
+      plugins.push(tw);
+      return {
+        css: {
+          postcss: {
+            plugins
+          }
+        }
+      };
     }
-    return true;
-  });
-  return Boolean(inputFile);
+  };
 };
-var getPath = ({
-  projectDir,
-  filename,
-  allowedTypes,
-  errorMessage
-}) => {
-  if (!import_fs_extra.default.existsSync(projectDir)) {
-    if (errorMessage) {
-      throw new Error(errorMessage);
-    } else {
-      throw new Error(`Could not find ${projectDir}`);
-    }
-  }
-  const filePaths = allowedTypes.map(
-    (ext) => import_path.default.join(projectDir, `${filename}.${ext}`)
-  );
-  let inputFile = void 0;
-  filePaths.every((path11) => {
-    if (import_fs_extra.default.existsSync(path11)) {
-      inputFile = path11;
-      return false;
-    }
-    return true;
-  });
-  if (!inputFile && errorMessage) {
-    throw new Error(errorMessage);
-  }
-  return inputFile;
-};
-
-// src/cmds/compile/index.ts
-var generatedFilesToRemove = [
-  "_graphql.json",
-  "__lookup.json",
-  "__schema.json",
-  "frags.gql",
-  "queries.gql",
-  "schema.gql",
-  "db"
-];
-var resetGeneratedFolder = async ({
-  tinaGeneratedPath,
-  usingTs,
-  isBuild
+
+// src/next/vite/index.ts
+var import_normalize_path2 = __toESM(require("normalize-path"));
+var createConfig = async ({
+  configManager,
+  database,
+  apiURL,
+  plugins = [],
+  noSDK,
+  noWatch,
+  rollupOptions
 }) => {
-  try {
-    if (isBuild) {
-      await import_fs_extra2.default.emptyDir(tinaGeneratedPath);
-    } else {
-      for (let index = 0; index < generatedFilesToRemove.length; index++) {
-        const file = generatedFilesToRemove[index];
-        if (file === "db") {
-          try {
-            await import_fs_extra2.default.remove(import_path2.default.join(tinaGeneratedPath, file));
-          } catch (_e) {
-          }
+  const publicEnv = {};
+  Object.keys(process.env).forEach((key) => {
+    if (key.startsWith("TINA_PUBLIC_") || key.startsWith("NEXT_PUBLIC_") || key === "NODE_ENV" || key === "HEAD") {
+      try {
+        if (typeof process.env[key] === "string") {
+          publicEnv[key] = process.env[key];
         } else {
-          await import_fs_extra2.default.remove(import_path2.default.join(tinaGeneratedPath, file));
+          publicEnv[key] = JSON.stringify(process.env[key]);
         }
+      } catch (error) {
+        console.warn(
+          `Could not stringify public env process.env.${key} env variable`
+        );
+        console.warn(error);
       }
     }
-  } catch (e) {
-    console.log(e);
-  }
-  await import_fs_extra2.default.mkdirp(tinaGeneratedPath);
-  const ext = usingTs ? "ts" : "js";
-  if (!await import_fs_extra2.default.pathExists(import_path2.default.join(tinaGeneratedPath, `types.${ext}`))) {
-    await import_fs_extra2.default.writeFile(
-      import_path2.default.join(tinaGeneratedPath, `types.${ext}`),
-      `
-      export const queries = (client)=>({})
-      `
-    );
-  }
-  if (!await import_fs_extra2.default.pathExists(import_path2.default.join(tinaGeneratedPath, `client.${ext}`))) {
-    await import_fs_extra2.default.writeFile(
-      import_path2.default.join(tinaGeneratedPath, `client.${ext}`),
-      `
-export const client = ()=>{}
-export default client
-`
-    );
-  }
-  await import_fs_extra2.default.outputFile(
-    import_path2.default.join(tinaGeneratedPath, ".gitignore"),
-    `app
-db
-prebuild
-client.ts
-client.js
-types.ts
-types.js
-types.d.ts
-frags.gql
-queries.gql
-schema.gql
-out.jsx
-`
-  );
-};
-var cleanup = async ({ tinaTempPath }) => {
-  await import_fs_extra2.default.remove(tinaTempPath);
-};
-var compileFile = async (options, fileName) => {
-  const root = options.rootPath;
-  if (!root) {
-    throw new Error("ctx.rootPath has not been attached");
-  }
-  const tinaPath = import_path2.default.join(root, ".tina");
-  const tsConfigPath = import_path2.default.join(root, "tsconfig.json");
-  const tinaGeneratedPath = import_path2.default.join(tinaPath, "__generated__");
-  const tinaTempPath = import_path2.default.join(tinaGeneratedPath, `temp_${fileName}`);
-  const packageJSONFilePath = import_path2.default.join(root, "package.json");
-  if (!options.schemaFileType) {
-    const usingTs = await import_fs_extra2.default.pathExists(tsConfigPath);
-    options = { ...options, schemaFileType: usingTs ? "ts" : "js" };
-  }
-  if (options.verbose) {
-    logger.info(logText(`Compiling ${fileName}...`));
-  }
-  const { schemaFileType: requestedSchemaFileType = "ts" } = options;
-  const schemaFileType2 = (requestedSchemaFileType === "ts" || requestedSchemaFileType === "tsx") && "ts" || (requestedSchemaFileType === "js" || requestedSchemaFileType === "jsx") && "js";
-  if (!schemaFileType2) {
-    throw new Error(
-      `Requested schema file type '${requestedSchemaFileType}' is not valid. Supported schema file types: 'ts, js, tsx, jsx'`
-    );
-  }
-  try {
-    const define = {};
-    if (!process.env.NODE_ENV) {
-      define["process.env.NODE_ENV"] = options.dev ? '"development"' : '"production"';
-    }
-    const inputFile = getPath({
-      projectDir: tinaPath,
-      filename: fileName,
-      allowedTypes: ["js", "jsx", "tsx", "ts"],
-      errorMessage: `Must provide a ${fileName}.{js,jsx,tsx,ts}`
-    });
-    await transpile(
-      inputFile,
-      `${fileName}.cjs`,
-      tinaTempPath,
-      options.verbose,
-      define,
-      packageJSONFilePath
-    );
-  } catch (e) {
-    await cleanup({ tinaTempPath });
-    throw new BuildSchemaError(e);
-  }
-  Object.keys(require.cache).map((key) => {
-    if (key.startsWith(tinaTempPath)) {
-      delete require.cache[require.resolve(key)];
-    }
-  });
-  let returnObject = {};
-  try {
-    const schemaFunc = require(import_path2.default.join(tinaTempPath, `${fileName}.cjs`));
-    returnObject = schemaFunc.default;
-    await cleanup({ tinaTempPath });
-  } catch (e) {
-    await cleanup({ tinaTempPath });
-    if (e instanceof Error) {
-      if (e.name === "TinaSchemaValidationError") {
-        throw e;
-      }
-    }
-    throw new ExecuteSchemaError(e);
-  }
-  return returnObject;
-};
-var compileSchema = async (options) => {
-  const root = options.rootPath;
-  const tinaPath = import_path2.default.join(root, ".tina");
-  const tinaGeneratedPath = import_path2.default.join(tinaPath, "__generated__");
-  const tinaConfigPath = import_path2.default.join(tinaGeneratedPath, "config");
-  const schemaExists = fileExists({
-    projectDir: tinaPath,
-    filename: "schema",
-    allowedTypes: ["js", "jsx", "tsx", "ts"]
   });
-  const configExists = fileExists({
-    projectDir: tinaPath,
-    filename: "config",
-    allowedTypes: ["js", "jsx", "tsx", "ts"]
-  });
-  if (!schemaExists && !configExists) {
-    throw new Error(
-      "No schema or config file found in .tina folder. Please run `npx @tinacms/cli@latest init` to generate a schema file."
-    );
-  }
-  let schema;
-  if (schemaExists && !configExists) {
-    console.warn(
-      `schema.{ts,tsx,js,jsx} will soon be deprecated, in favor of the new config.{ts,tsx,js,jsx}
-See here for migration steps, see here: https://tina.io/blog/upgrading-to-iframe`
+  const alias = {
+    TINA_IMPORT: configManager.tinaConfigFilePath,
+    SCHEMA_IMPORT: configManager.generatedGraphQLJSONPath
+  };
+  if (noSDK) {
+    alias["CLIENT_IMPORT"] = import_path4.default.join(
+      configManager.spaRootPath,
+      "src",
+      "dummy-client.ts"
     );
-    schema = await compileFile(options, "schema");
-  }
-  if (configExists) {
-    const config2 = await compileFile(options, "config");
-    const configCopy = _.cloneDeep(config2);
-    delete configCopy.schema;
-    if (config2 == null ? void 0 : config2.schema) {
-      schema = { ...config2.schema, config: configCopy };
+  } else {
+    alias["CLIENT_IMPORT"] = configManager.isUsingTs() ? configManager.generatedTypesTSFilePath : configManager.generatedTypesJSFilePath;
+  }
+  const config3 = {
+    root: configManager.spaRootPath,
+    base: `/${(0, import_normalize_path2.default)(configManager.config.build.outputFolder)}/`,
+    appType: "spa",
+    resolve: {
+      alias,
+      dedupe: ["graphql", "tinacms", "@tinacms/toolkit", "react", "react-dom"]
+    },
+    define: {
+      "process.env": `new Object(${JSON.stringify(publicEnv)})`,
+      "process.platform": `"${process.platform}"`,
+      __API_URL__: `"${apiURL}"`,
+      __TOKEN__: `"${configManager.config.token}"`,
+      __TINA_GRAPHQL_VERSION__: `"${configManager.getTinaGraphQLVersion()}"`
+    },
+    optimizeDeps: {
+      force: true,
+      include: ["react/jsx-runtime", "react/jsx-dev-runtime"]
+    },
+    server: {
+      watch: noWatch ? {
+        ignored: ["**/*"]
+      } : void 0,
+      fs: {
+        strict: false
+      }
+    },
+    build: {
+      sourcemap: true,
+      outDir: configManager.outputFolderPath,
+      emptyOutDir: true,
+      rollupOptions
+    },
+    plugins: [
+      (0, import_vite.splitVendorChunkPlugin)(),
+      tinaTailwind(configManager.spaRootPath, configManager.tinaConfigFilePath),
+      ...plugins
+    ]
+  };
+  return config3;
+};
+
+// src/next/commands/dev-command/server/index.ts
+var createDevServer = async (configManager, database, apiURL, noSDK, noWatch) => {
+  const plugins = [
+    {
+      name: "transform-tsx",
+      async transform(code, id) {
+        if (id.startsWith(configManager.rootPath)) {
+          const extName = import_path5.default.extname(id);
+          if (extName.startsWith(".tsx") || extName.startsWith(".ts")) {
+            const result = await (0, import_esbuild.transform)(code, { loader: "tsx" });
+            return {
+              code: result.code
+            };
+          }
+        }
+      }
+    },
+    {
+      name: "graphql-endpoints",
+      configureServer(server) {
+        server.middlewares.use((0, import_cors.default)());
+        server.middlewares.use(import_body_parser.default.json());
+        server.middlewares.use(async (req, res, next) => {
+          var _a;
+          const mediaPaths = (_a = configManager.config.media) == null ? void 0 : _a.tina;
+          const mediaRouter = createMediaRouter({
+            rootPath: configManager.rootPath,
+            apiURL,
+            publicFolder: parseMediaFolder((mediaPaths == null ? void 0 : mediaPaths.publicFolder) || ""),
+            mediaRoot: parseMediaFolder((mediaPaths == null ? void 0 : mediaPaths.mediaRoot) || "")
+          });
+          if (req.url.startsWith("/media/upload")) {
+            await mediaRouter.handlePost(req, res);
+            return;
+          }
+          if (req.url.startsWith("/media")) {
+            if (req.method === "DELETE") {
+              await mediaRouter.handleDelete(req, res);
+              return;
+            }
+          }
+          if (req.url.startsWith("/media/list")) {
+            await mediaRouter.handleList(req, res);
+            return;
+          }
+          if (req.url === "/altair") {
+            res.end(
+              JSON.stringify({
+                status: "The GraphQL playground has moved to <your-dev-url>/index.html#/graphql"
+              })
+            );
+            return;
+          }
+          if (req.url === "/graphql") {
+            const { query, variables } = req.body;
+            const result = await (0, import_graphql.resolve)({
+              config: {
+                useRelativeMedia: true
+              },
+              database,
+              query,
+              variables,
+              verbose: false
+            });
+            res.end(JSON.stringify(result));
+            return;
+          }
+          next();
+        });
+      }
     }
-  }
-  await import_fs_extra2.default.outputFile(
-    import_path2.default.join(tinaConfigPath, `schema.json`),
-    JSON.stringify(schema, null, 2)
+  ];
+  return (0, import_vite2.createServer)(
+    await createConfig({
+      configManager,
+      database,
+      apiURL,
+      plugins,
+      noSDK,
+      noWatch,
+      rollupOptions: {
+        input: configManager.spaMainPath
+      }
+    })
   );
-  return schema;
 };
-var transpile = async (inputFile, outputFile, tempDir, verbose, define, packageJSONFilePath, platform = "neutral") => {
-  if (verbose)
-    logger.info(logText("Building javascript..."));
-  const packageJSON = JSON.parse(
-    import_fs_extra2.default.readFileSync(packageJSONFilePath).toString() || "{}"
-  );
-  const deps = (packageJSON == null ? void 0 : packageJSON.dependencies) || [];
-  const peerDeps = (packageJSON == null ? void 0 : packageJSON.peerDependencies) || [];
-  const devDeps = (packageJSON == null ? void 0 : packageJSON.devDependencies) || [];
-  const external = Object.keys({ ...deps, ...peerDeps, ...devDeps });
-  const prebuiltInputPath = import_path2.default.join(tempDir, "temp-output.jsx");
-  await (0, import_esbuild.build)({
-    bundle: true,
-    platform,
-    target: ["es2020"],
-    entryPoints: [inputFile],
-    treeShaking: true,
-    external: [...external, "./node_modules/*"],
-    loader: loaders,
-    outfile: prebuiltInputPath,
-    define
-  });
-  const tempTsConfigPath = import_path2.default.join(tempDir, "temp-tsconfig.json");
-  await import_fs_extra2.default.outputFileSync(tempTsConfigPath, "{}");
-  const outputPath = import_path2.default.join(tempDir, outputFile);
-  await (0, import_esbuild.build)({
-    bundle: true,
-    platform,
-    target: ["node10.4"],
-    entryPoints: [prebuiltInputPath],
-    format: "cjs",
-    treeShaking: true,
-    external: [...external, "./node_modules/*"],
-    tsconfig: tempTsConfigPath,
-    loader: loaders,
-    outfile: outputPath,
-    define
-  });
-  if (verbose)
-    logger.info(logText(`Javascript built`));
-};
-var defineSchema = (config2) => {
-  return config2;
-};
-var loaders = {
-  ".aac": "file",
-  ".css": "file",
-  ".eot": "file",
-  ".flac": "file",
-  ".gif": "file",
-  ".jpeg": "file",
-  ".jpg": "file",
-  ".json": "json",
-  ".mp3": "file",
-  ".mp4": "file",
-  ".ogg": "file",
-  ".otf": "file",
-  ".png": "file",
-  ".svg": "file",
-  ".ttf": "file",
-  ".wav": "file",
-  ".webm": "file",
-  ".webp": "file",
-  ".woff": "file",
-  ".woff2": "file",
-  ".js": "jsx",
-  ".jsx": "jsx",
-  ".tsx": "tsx"
-};
-
-// src/cmds/query-gen/genTypes.ts
-var import_graphql8 = require("graphql");
+
+// src/next/codegen/index.ts
 var import_fs_extra3 = __toESM(require("fs-extra"));
-var import_path3 = __toESM(require("path"));
+var import_graphql6 = require("graphql");
 
-// src/codegen/index.ts
-var import_graphql7 = require("graphql");
+// src/next/codegen/codegen/index.ts
+var import_graphql5 = require("graphql");
 
-// src/codegen/plugin.ts
-var AddGeneratedClientFunc = (_schema, _documents, _config, _info) => {
-  return `
+// src/next/codegen/codegen/plugin.ts
+var AddGeneratedClientFunc = (apiURL) => {
+  return (_schema, _documents, _config, _info) => {
+    return `
 // TinaSDK generated code
 import { createClient, TinaClient } from "tinacms/dist/client";
 
@@ -990,7 +1037,7 @@ const generateRequester = (client: TinaClient) => {
  **/
 export const ExperimentalGetTinaClient = () =>
   getSdk(
-    generateRequester(createClient({ url: "http://localhost:4001/graphql", queries }))
+    generateRequester(createClient({ url: "${apiURL}", queries }))
   );
 
 export const queries = (client: TinaClient) => {
@@ -998,26 +1045,27 @@ export const queries = (client: TinaClient) => {
   return getSdk(requester);
 };
 `;
+  };
 };
-var AddGeneratedClient = {
-  plugin: AddGeneratedClientFunc
-};
+var AddGeneratedClient = (apiURL) => ({
+  plugin: AddGeneratedClientFunc(apiURL)
+});
 
-// src/codegen/index.ts
+// src/next/codegen/codegen/index.ts
 var import_graphql_file_loader = require("@graphql-tools/graphql-file-loader");
 var import_core = require("@graphql-codegen/core");
 var import_load = require("@graphql-tools/load");
 var import_typescript_operations = require("@graphql-codegen/typescript-operations");
 var import_typescript = require("@graphql-codegen/typescript");
 
-// src/codegen/sdkPlugin/index.ts
-var import_graphql5 = require("graphql");
-var import_graphql6 = require("graphql");
+// src/next/codegen/codegen/sdkPlugin/index.ts
+var import_graphql3 = require("graphql");
+var import_graphql4 = require("graphql");
 
-// src/codegen/sdkPlugin/visitor.ts
+// src/next/codegen/codegen/sdkPlugin/visitor.ts
 var import_visitor_plugin_common = require("@graphql-codegen/visitor-plugin-common");
 var import_auto_bind = __toESM(require("auto-bind"));
-var import_graphql4 = require("graphql");
+var import_graphql2 = require("graphql");
 var GenericSdkVisitor = class extends import_visitor_plugin_common.ClientSideBaseVisitor {
   constructor(schema, fragments, rawConfig) {
     super(schema, fragments, rawConfig, {
@@ -1034,7 +1082,7 @@ var GenericSdkVisitor = class extends import_visitor_plugin_common.ClientSideBas
   buildOperation(node, documentVariableName, operationType, operationResultType, operationVariablesTypes) {
     if (node.name == null) {
       throw new Error(
-        "Plugin 'generic-sdk' cannot generate SDK for unnamed operation.\n\n" + (0, import_graphql4.print)(node)
+        "Plugin 'generic-sdk' cannot generate SDK for unnamed operation.\n\n" + (0, import_graphql2.print)(node)
       );
     } else {
       this._operationsToInclude.push({
@@ -1051,13 +1099,13 @@ var GenericSdkVisitor = class extends import_visitor_plugin_common.ClientSideBas
     const usingObservable = !!this.config.usingObservableFrom;
     const allPossibleActions = this._operationsToInclude.map((o) => {
       const optionalVariables = !o.node.variableDefinitions || o.node.variableDefinitions.length === 0 || o.node.variableDefinitions.every(
-        (v) => v.type.kind !== import_graphql4.Kind.NON_NULL_TYPE || v.defaultValue
+        (v) => v.type.kind !== import_graphql2.Kind.NON_NULL_TYPE || v.defaultValue
       );
       const returnType = usingObservable && o.operationType === "Subscription" ? "Observable" : "Promise";
       return `${o.node.name.value}(variables${optionalVariables ? "?" : ""}: ${o.operationVariablesTypes}, options?: C): ${returnType}<${o.operationResultType}> {
     return requester<${o.operationResultType}, ${o.operationVariablesTypes}>(${o.documentVariableName}, variables, options);
   }`;
-    }).map((s) => (0, import_visitor_plugin_common.indentMultiline)(s, 2));
+    }).map((s2) => (0, import_visitor_plugin_common.indentMultiline)(s2, 2));
     return `export type Requester<C= {}> = <R, V>(doc: ${this.config.documentMode === import_visitor_plugin_common.DocumentMode.string ? "string" : "DocumentNode"}, vars?: V, options?: C) => ${usingObservable ? "Promise<R> & Observable<R>" : "Promise<R>"}
   export function getSdk<C>(requester: Requester<C>) {
     return {
@@ -1068,26 +1116,26 @@ var GenericSdkVisitor = class extends import_visitor_plugin_common.ClientSideBas
   }
 };
 
-// src/codegen/sdkPlugin/index.ts
-var plugin = (schema, documents, config2) => {
-  const allAst = (0, import_graphql6.concatAST)(
+// src/next/codegen/codegen/sdkPlugin/index.ts
+var plugin = (schema, documents, config3) => {
+  const allAst = (0, import_graphql4.concatAST)(
     documents.reduce((prev, v) => {
       return [...prev, v.document];
     }, [])
   );
   const allFragments = [
     ...allAst.definitions.filter(
-      (d) => d.kind === import_graphql6.Kind.FRAGMENT_DEFINITION
+      (d) => d.kind === import_graphql4.Kind.FRAGMENT_DEFINITION
     ).map((fragmentDef) => ({
       node: fragmentDef,
       name: fragmentDef.name.value,
       onType: fragmentDef.typeCondition.name.value,
       isExternal: false
     })),
-    ...config2.externalFragments || []
+    ...config3.externalFragments || []
   ];
-  const visitor = new GenericSdkVisitor(schema, allFragments, config2);
-  const visitorResult = (0, import_graphql5.visit)(allAst, { leave: visitor });
+  const visitor = new GenericSdkVisitor(schema, allFragments, config3);
+  const visitorResult = (0, import_graphql3.visit)(allAst, { leave: visitor });
   return {
     content: [
       visitor.fragments,
@@ -1097,22 +1145,15 @@ var plugin = (schema, documents, config2) => {
   };
 };
 
-// src/codegen/index.ts
-var generateTypes = async (schema, queryPathGlob = process.cwd(), fragDocPath = process.cwd(), options = {
-  noSDK: false,
-  verbose: false
-}) => {
-  if (options.verbose)
-    logger.info("Generating types...");
+// src/next/codegen/codegen/index.ts
+var generateTypes = async (schema, queryPathGlob = process.cwd(), fragDocPath = process.cwd(), apiURL) => {
   let docs = [];
   let fragDocs = [];
-  if (!options.noSDK) {
-    docs = await loadGraphQLDocuments(queryPathGlob);
-    fragDocs = await loadGraphQLDocuments(fragDocPath);
-  }
+  docs = await loadGraphQLDocuments(queryPathGlob);
+  fragDocs = await loadGraphQLDocuments(fragDocPath);
   const res = await (0, import_core.codegen)({
     filename: process.cwd(),
-    schema: (0, import_graphql7.parse)((0, import_graphql7.printSchema)(schema)),
+    schema: (0, import_graphql5.parse)((0, import_graphql5.printSchema)(schema)),
     documents: [...docs, ...fragDocs],
     config: {},
     plugins: [
@@ -1133,7 +1174,7 @@ var generateTypes = async (schema, queryPathGlob = process.cwd(), fragDocPath =
       typescriptSdk: {
         plugin
       },
-      AddGeneratedClient
+      AddGeneratedClient: AddGeneratedClient(apiURL)
     }
   });
   return res;
@@ -1155,66 +1196,132 @@ var loadGraphQLDocuments = async (globPath) => {
   return result;
 };
 
-// src/cmds/query-gen/genTypes.ts
+// src/next/codegen/index.ts
 var import_esbuild2 = require("esbuild");
 var TINA_HOST = "content.tinajs.io";
-async function genClient({
-  tinaSchema,
-  usingTs,
-  rootPath: rootPath2
-}, options) {
-  var _a, _b, _c, _d, _e, _f, _g;
-  const generatedPath = import_path3.default.join(rootPath2, ".tina", "__generated__");
-  const branch = (_a = tinaSchema == null ? void 0 : tinaSchema.config) == null ? void 0 : _a.branch;
-  const clientId = (_b = tinaSchema == null ? void 0 : tinaSchema.config) == null ? void 0 : _b.clientId;
-  const token = (_c = tinaSchema.config) == null ? void 0 : _c.token;
-  const baseUrl = ((_e = (_d = tinaSchema == null ? void 0 : tinaSchema.config) == null ? void 0 : _d.tinaioConfig) == null ? void 0 : _e.contentApiUrlOverride) || `https://${TINA_HOST}`;
-  if ((!branch || !clientId || !token) && !(options == null ? void 0 : options.local) && !((_f = tinaSchema == null ? void 0 : tinaSchema.config) == null ? void 0 : _f.contentApiUrlOverride)) {
-    const missing = [];
-    if (!branch)
-      missing.push("branch");
-    if (!clientId)
-      missing.push("clientId");
-    if (!token)
-      missing.push("token");
-    throw new Error(
-      `Client not configured properly. Missing ${missing.join(
-        ", "
-      )}. Please visit https://tina.io/docs/tina-cloud/connecting-site/ for more information`
+var Codegen = class {
+  constructor({
+    configManager,
+    port,
+    schema,
+    noSDK,
+    queryDoc,
+    fragDoc
+  }) {
+    this.configManager = configManager;
+    this.port = port;
+    this.schema = schema;
+    this.noSDK = noSDK;
+    this.queryDoc = queryDoc;
+    this.fragDoc = fragDoc;
+  }
+  async removeGeneratedFilesIfExists() {
+    await unlinkIfExists(this.configManager.generatedClientJSFilePath);
+    await unlinkIfExists(this.configManager.generatedTypesDFilePath);
+    await unlinkIfExists(this.configManager.generatedTypesJSFilePath);
+    await unlinkIfExists(this.configManager.generatedTypesTSFilePath);
+    await unlinkIfExists(this.configManager.generatedClientTSFilePath);
+    await unlinkIfExists(this.configManager.generatedQueriesFilePath);
+    await unlinkIfExists(this.configManager.generatedFragmentsFilePath);
+  }
+  async execute() {
+    const apiURL = this.getApiURL();
+    if (this.noSDK) {
+      await this.removeGeneratedFilesIfExists();
+      return apiURL;
+    }
+    await import_fs_extra3.default.outputFile(
+      this.configManager.generatedQueriesFilePath,
+      this.queryDoc
     );
+    await import_fs_extra3.default.outputFile(
+      this.configManager.generatedFragmentsFilePath,
+      this.fragDoc
+    );
+    await maybeWarnFragmentSize(this.configManager.generatedFragmentsFilePath);
+    const { clientString } = await this.genClient();
+    const { codeString, schemaString } = await this.genTypes();
+    await import_fs_extra3.default.outputFile(
+      this.configManager.generatedGraphQLGQLPath,
+      schemaString
+    );
+    if (this.configManager.isUsingTs()) {
+      await import_fs_extra3.default.outputFile(
+        this.configManager.generatedTypesTSFilePath,
+        codeString
+      );
+      await import_fs_extra3.default.outputFile(
+        this.configManager.generatedClientTSFilePath,
+        clientString
+      );
+      await unlinkIfExists(this.configManager.generatedClientJSFilePath);
+      await unlinkIfExists(this.configManager.generatedTypesDFilePath);
+      await unlinkIfExists(this.configManager.generatedTypesJSFilePath);
+    } else {
+      await import_fs_extra3.default.outputFile(
+        this.configManager.generatedTypesDFilePath,
+        codeString
+      );
+      const jsCode = await (0, import_esbuild2.transform)(codeString, { loader: "ts" });
+      await import_fs_extra3.default.outputFile(
+        this.configManager.generatedTypesJSFilePath,
+        jsCode.code
+      );
+      await import_fs_extra3.default.outputFile(
+        this.configManager.generatedClientJSFilePath,
+        clientString
+      );
+      await unlinkIfExists(this.configManager.generatedTypesTSFilePath);
+      await unlinkIfExists(this.configManager.generatedClientTSFilePath);
+    }
+    return apiURL;
   }
-  let apiURL = options.local ? `http://localhost:${options.port || 4001}/graphql` : `${baseUrl}/content/${clientId}/github/${branch}`;
-  if ((_g = tinaSchema.config) == null ? void 0 : _g.contentApiUrlOverride) {
-    apiURL = tinaSchema.config.contentApiUrlOverride;
+  getApiURL() {
+    var _a, _b, _c, _d;
+    const branch = (_a = this.configManager.config) == null ? void 0 : _a.branch;
+    const clientId = (_b = this.configManager.config) == null ? void 0 : _b.clientId;
+    const token = (_c = this.configManager.config) == null ? void 0 : _c.token;
+    const version2 = this.configManager.getTinaGraphQLVersion();
+    const baseUrl = ((_d = this.configManager.config.tinaioConfig) == null ? void 0 : _d.contentApiUrlOverride) || `https://${TINA_HOST}`;
+    if ((!branch || !clientId || !token) && !this.port && !this.configManager.config.contentApiUrlOverride) {
+      const missing = [];
+      if (!branch)
+        missing.push("branch");
+      if (!clientId)
+        missing.push("clientId");
+      if (!token)
+        missing.push("token");
+      throw new Error(
+        `Client not configured properly. Missing ${missing.join(
+          ", "
+        )}. Please visit https://tina.io/docs/tina-cloud/connecting-site/ for more information`
+      );
+    }
+    let apiURL = this.port ? `http://localhost:${this.port}/graphql` : `${baseUrl}/${version2}/content/${clientId}/github/${branch}`;
+    if (this.configManager.config.contentApiUrlOverride) {
+      apiURL = this.configManager.config.contentApiUrlOverride;
+    }
+    return apiURL;
   }
-  const clientPath = import_path3.default.join(generatedPath, `client.${usingTs ? "ts" : "js"}`);
-  import_fs_extra3.default.writeFileSync(
-    clientPath,
-    `import { createClient } from "tinacms/dist/client";
+  async genClient() {
+    var _a;
+    const token = (_a = this.configManager.config) == null ? void 0 : _a.token;
+    const apiURL = this.getApiURL();
+    const clientString = `import { createClient } from "tinacms/dist/client";
 import { queries } from "./types";
 export const client = createClient({ url: '${apiURL}', token: '${token}', queries });
 export default client;
-  `
-  );
-  return apiURL;
-}
-async function genTypes({
-  schema,
-  usingTs,
-  rootPath: rootPath2
-}, next, options) {
-  const typesPath = rootPath2 + "/.tina/__generated__/types.ts";
-  const typesJSPath = rootPath2 + "/.tina/__generated__/types.js";
-  const typesDPath = rootPath2 + "/.tina/__generated__/types.d.ts";
-  const fragPath = rootPath2 + "/.tina/__generated__/*.{graphql,gql}";
-  const queryPathGlob = rootPath2 + "/.tina/queries/**/*.{graphql,gql}";
-  const typescriptTypes = await generateTypes(
-    schema,
-    queryPathGlob,
-    fragPath,
-    options
-  );
-  const code = `//@ts-nocheck
+  `;
+    return { apiURL, clientString };
+  }
+  async genTypes() {
+    const typescriptTypes = await generateTypes(
+      this.schema,
+      this.configManager.userQueriesAndFragmentsGlob,
+      this.configManager.generatedQueriesAndFragmentsGlob,
+      this.getApiURL()
+    );
+    const codeString = `//@ts-nocheck
   // DO NOT MODIFY THIS FILE. This file is automatically generated by Tina
   export function gql(strings: TemplateStringsArray, ...args: string[]): string {
     let str = ''
@@ -1225,31 +1332,139 @@ async function genTypes({
   }
   ${typescriptTypes}
   `;
-  if (usingTs) {
-    await import_fs_extra3.default.outputFile(typesPath, code);
-  } else {
-    await import_fs_extra3.default.outputFile(typesDPath, code);
-    const jsCode = await (0, import_esbuild2.transform)(code, { loader: "ts" });
-    await import_fs_extra3.default.outputFile(typesJSPath, jsCode.code);
-  }
-  const schemaString = await (0, import_graphql8.printSchema)(schema);
-  const schemaPath = rootPath2 + "/.tina/__generated__/schema.gql";
-  await import_fs_extra3.default.outputFile(
-    schemaPath,
-    `# DO NOT MODIFY THIS FILE. This file is automatically generated by Tina
-${schemaString}
+    const schemaString = `# DO NOT MODIFY THIS FILE. This file is automatically generated by Tina
+${await (0, import_graphql6.printSchema)(this.schema)}
 schema {
   query: Query
   mutation: Mutation
 }
-  `
+`;
+    return { codeString, schemaString };
+  }
+};
+var maybeWarnFragmentSize = async (filepath) => {
+  if (await (await import_fs_extra3.default.stat(filepath)).size > 100 * 1024) {
+    console.warn(
+      "Warning: frags.gql is very large (>100kb). Consider setting the reference depth to 1 or 0. See code snippet below."
+    );
+    console.log(
+      `const schema = defineSchema({
+        config: {
+            client: {
+                referenceDepth: 1,
+            },
+        }
+        // ...
+    })`
+    );
+  }
+};
+var unlinkIfExists = async (filepath) => {
+  if (await import_fs_extra3.default.existsSync(filepath)) {
+    await import_fs_extra3.default.unlinkSync(filepath);
+  }
+};
+
+// src/next/commands/dev-command/index.ts
+var import_chalk3 = __toESM(require("chalk"));
+
+// src/utils/start-subprocess.ts
+var import_child_process = __toESM(require("child_process"));
+
+// src/utils/theme.ts
+var import_chalk2 = __toESM(require("chalk"));
+var successText = import_chalk2.default.bold.green;
+var focusText = import_chalk2.default.bold;
+var dangerText = import_chalk2.default.bold.red;
+var neutralText = import_chalk2.default.bold.cyan;
+var linkText = import_chalk2.default.bold.cyan;
+var labelText = import_chalk2.default.bold;
+var cmdText = import_chalk2.default.inverse;
+var indentedCmd = (str) => {
+  return `  \u2503 ` + str;
+};
+var logText = import_chalk2.default.italic.gray;
+var warnText = import_chalk2.default.yellowBright.bgBlack;
+var titleText = import_chalk2.default.bgHex("d2f1f8").hex("ec4816");
+var CONFIRMATION_TEXT = import_chalk2.default.dim("enter to confirm");
+
+// src/utils/start-subprocess.ts
+var startSubprocess2 = async ({ command }) => {
+  if (typeof command === "string") {
+    const commands = command.split(" ");
+    const firstCommand = commands[0];
+    const args = commands.slice(1) || [];
+    const ps = import_child_process.default.spawn(firstCommand, args, {
+      stdio: "inherit",
+      shell: true
+    });
+    ps.on("error", (code) => {
+      logger.error(
+        dangerText(
+          `An error has occurred in the Next.js child process. Error message below`
+        )
+      );
+      logger.error(`name: ${code.name}
+message: ${code.message}
+
+stack: ${code.stack || "No stack was provided"}`);
+    });
+    ps.on("close", (code) => {
+      logger.info(`child process exited with code ${code}`);
+      process.exit(code);
+    });
+    return ps;
+  }
+};
+
+// src/next/database.ts
+var import_graphql7 = require("@tinacms/graphql");
+var import_readable_stream = require("readable-stream");
+var import_net = require("net");
+var import_many_level = require("many-level");
+var import_memory_level = require("memory-level");
+var createDBServer = () => {
+  const levelHost = new import_many_level.ManyLevelHost(
+    new import_memory_level.MemoryLevel({
+      valueEncoding: "json"
+    })
   );
-  next();
+  const dbServer = (0, import_net.createServer)(function(socket) {
+    return (0, import_readable_stream.pipeline)(socket, levelHost.createRpcStream(), socket, () => {
+    });
+  });
+  dbServer.once("error", (err) => {
+    if ((err == null ? void 0 : err.code) === "EADDRINUSE") {
+      throw new Error(`Tina Dev server is already in use`);
+    }
+  });
+  dbServer.listen(9e3);
+};
+async function createAndInitializeDatabase(configManager, bridgeOverride) {
+  let database;
+  const bridge = bridgeOverride || new import_graphql7.FilesystemBridge(configManager.rootPath, configManager.contentRootPath);
+  if (configManager.hasSelfHostedConfig() && configManager.config.contentApiUrlOverride) {
+    database = await configManager.loadDatabaseFile();
+    database.bridge = bridge;
+  } else {
+    if (configManager.hasSelfHostedConfig() && !configManager.config.contentApiUrlOverride) {
+      logger.warn(
+        `Found a database config file at ${configManager.printRelativePath(
+          configManager.selfHostedDatabaseFilePath
+        )} but there was no "contentApiUrlOverride" set. Falling back to built-in datalayer`
+      );
+    }
+    const level = new import_graphql7.TinaLevelClient();
+    level.openConnection();
+    database = (0, import_graphql7.createDatabase)({
+      bridge,
+      level,
+      tinaDirectory: configManager.isUsingLegacyFolder ? LEGACY_TINA_FOLDER : TINA_FOLDER
+    });
+  }
+  return database;
 }
 
-// src/buildTina/index.ts
-var import_app = require("@tinacms/app");
-
 // src/utils/spinner.ts
 var import_cli_spinner = require("cli-spinner");
 async function localSpin({
@@ -1286,423 +1501,343 @@ function spin({
   }
 }
 
-// src/buildTina/attachPath.ts
-var import_fs_extra4 = require("fs-extra");
-var import_path4 = __toESM(require("path"));
-var attachPath = async (ctx, next, options) => {
-  ctx.rootPath = options.rootPath || process.cwd();
-  ctx.usingTs = await isProjectTs(ctx.rootPath);
-  next();
-};
-var isProjectTs = async (rootPath2) => {
-  const tinaPath = import_path4.default.join(rootPath2, ".tina");
-  return await (0, import_fs_extra4.pathExists)(import_path4.default.join(tinaPath, "schema.ts")) || await (0, import_fs_extra4.pathExists)(import_path4.default.join(tinaPath, "schema.tsx")) || await (0, import_fs_extra4.pathExists)(import_path4.default.join(tinaPath, "config.ts")) || await (0, import_fs_extra4.pathExists)(import_path4.default.join(tinaPath, "config.tsx"));
-};
-
-// src/buildTina/index.ts
-var buildSetupCmdBuild = async (ctx, next, opts) => {
-  const rootPath2 = ctx.rootPath;
-  await buildSetup({
-    ...opts,
-    rootPath: rootPath2
-  });
-  ctx.builder = new ConfigBuilder(ctx.database);
-  next();
-};
-var buildSetupCmdServerStart = async (ctx, next, opts) => {
-  const rootPath2 = ctx.rootPath;
-  await buildSetup({
-    ...opts,
-    rootPath: rootPath2
-  });
-  ctx.builder = new ConfigBuilder(ctx.database);
-  next();
-};
-var buildSetupCmdAudit = async (ctx, next, options) => {
-  const rootPath2 = ctx.rootPath;
-  const bridge = options.clean ? new import_datalayer.FilesystemBridge(rootPath2) : new import_datalayer.AuditFileSystemBridge(rootPath2);
-  await import_fs_extra5.default.ensureDirSync(import_path5.default.join(rootPath2, ".tina", "__generated__"));
-  const database = await (0, import_graphql9.createDatabase)({
-    level: new import_memory_level.MemoryLevel({
-      valueEncoding: "json"
-    }),
-    bridge
-  });
-  ctx.bridge = bridge;
-  ctx.database = database;
-  ctx.builder = new ConfigBuilder(ctx.database);
-  next();
-};
-var buildSetup = async ({ rootPath: rootPath2 }) => {
-  await import_fs_extra5.default.ensureDirSync(import_path5.default.join(rootPath2, ".tina", "__generated__"));
-};
-var buildCmdBuild = async (ctx, next, options) => {
-  const { schema, graphQLSchema, tinaSchema } = await ctx.builder.build({
-    rootPath: ctx.rootPath,
-    ...options
-  });
-  ctx.schema = schema;
-  ctx.graphQLSchema = graphQLSchema;
-  ctx.tinaSchema = tinaSchema;
-  const apiUrl = await ctx.builder.genTypedClient({
-    compiledSchema: schema,
-    local: options.local,
-    noSDK: options.noSDK,
-    verbose: options.verbose,
-    usingTs: ctx.usingTs,
-    rootPath: ctx.rootPath,
-    port: options.port
-  });
-  ctx.apiUrl = apiUrl;
-  await buildAdmin({
-    local: options.local,
-    rootPath: ctx.rootPath,
-    schema,
-    apiUrl
-  });
-  next();
-};
-var auditCmdBuild = async (ctx, next, options) => {
-  const { graphQLSchema, tinaSchema } = await ctx.builder.build({
-    rootPath: ctx.rootPath,
-    ...options,
-    verbose: true
-  });
-  await spin({
-    waitFor: async () => {
-      await ctx.database.indexContent({ graphQLSchema, tinaSchema });
-    },
-    text: "Indexing local files"
-  });
-  next();
-};
-var indexIntoSelfHostedDatabase = async (ctx, next) => {
-  if (!ctx.isSelfHostedDatabase) {
-    return next();
-  }
-  const { graphQLSchema, tinaSchema } = ctx;
-  await spin({
-    waitFor: async () => {
-      await ctx.database.indexContent({ graphQLSchema, tinaSchema });
-    },
-    text: "Indexing to self-hosted database"
-  });
-  next();
-};
-var ConfigBuilder = class {
-  constructor(database) {
-    this.database = database;
-  }
-  async build({ dev, verbose, rootPath: rootPath2, local }) {
-    var _a, _b, _c;
-    const usingTs = await isProjectTs(rootPath2);
-    if (!rootPath2) {
-      throw new Error("Root path has not been attached");
-    }
-    const tinaGeneratedPath = import_path5.default.join(rootPath2, ".tina", "__generated__");
-    this.database.clearCache();
-    await import_fs_extra5.default.mkdirp(tinaGeneratedPath);
-    await resetGeneratedFolder({
-      tinaGeneratedPath,
-      usingTs,
-      isBuild: !local
-    });
-    const compiledSchema = await compileSchema({
-      verbose,
-      dev,
-      rootPath: rootPath2
-    });
-    if (this.database.bridge.addOutputPath && ((_a = compiledSchema.config) == null ? void 0 : _a.localContentPath)) {
-      if ((_c = (_b = compiledSchema == null ? void 0 : compiledSchema.config) == null ? void 0 : _b.media) == null ? void 0 : _c.tina) {
-        throw new Error(
-          `"media.tina" is not supported when the "localContentPath" property is present.`
-        );
-      }
-      let localContentPath = compiledSchema.config.localContentPath;
-      if (!localContentPath.startsWith("/")) {
-        localContentPath = import_path5.default.join(process.cwd(), ".tina", localContentPath);
-      }
-      if (await import_fs_extra5.default.pathExists(localContentPath)) {
-        logger.info(logText(`Using separate content path ${localContentPath}`));
-      } else {
-        logger.warn(
-          warnText(
-            `Using separate content path ${localContentPath}
-  but no directory was found at that location, creating one...`
-          )
-        );
-        await import_fs_extra5.default.mkdir(localContentPath);
-      }
-      this.database.bridge.addOutputPath(localContentPath);
-    }
-    const { graphQLSchema, tinaSchema } = await (0, import_graphql9.buildSchema)(
-      rootPath2,
-      this.database,
-      ["experimentalData", "isomorphicGitBridge"]
-    );
-    return { schema: compiledSchema, graphQLSchema, tinaSchema };
-  }
-  async genTypedClient({
-    usingTs,
-    compiledSchema,
-    noSDK,
-    verbose,
-    local,
-    port,
-    rootPath: rootPath2
-  }) {
-    const astSchema = await (0, import_graphql9.getASTSchema)(this.database);
-    await genTypes({ schema: astSchema, usingTs, rootPath: rootPath2 }, () => {
-    }, {
-      noSDK,
-      verbose
+// src/next/commands/dev-command/index.ts
+var DevCommand = class extends import_clipanion.Command {
+  constructor() {
+    super(...arguments);
+    this.port = import_clipanion.Option.String("-p,--port", "4001", {
+      description: "Specify a port to run the server on. (default 4001)"
+    });
+    this.subCommand = import_clipanion.Option.String("-c,--command", {
+      description: "The sub-command to run"
+    });
+    this.rootPath = import_clipanion.Option.String("--rootPath", {
+      description: "Specify the root directory to run the CLI from (defaults to current working directory)"
+    });
+    this.watchFolders = import_clipanion.Option.String("-w,--watchFolders", {
+      description: "DEPRECATED - a list of folders (relative to where this is being run) that the cli will watch for changes"
+    });
+    this.isomorphicGitBridge = import_clipanion.Option.Boolean("--isomorphicGitBridge", {
+      description: "DEPRECATED - Enable Isomorphic Git Bridge Implementation"
+    });
+    this.experimentalDataLayer = import_clipanion.Option.Boolean("--experimentalData", {
+      description: "DEPRECATED - Build the server with additional data querying capabilities"
+    });
+    this.verbose = import_clipanion.Option.Boolean("-v,--verbose", false, {
+      description: "increase verbosity of logged output"
+    });
+    this.noWatch = import_clipanion.Option.Boolean("--noWatch", false, {
+      description: "Don't regenerate config on file changes"
+    });
+    this.noSDK = import_clipanion.Option.Boolean("--noSDK", false, {
+      description: "Don't generate the generated client SDK"
+    });
+    this.noTelemetry = import_clipanion.Option.Boolean("--noTelemetry", false, {
+      description: "Disable anonymous telemetry that is collected"
     });
-    return genClient(
-      { tinaSchema: compiledSchema, usingTs, rootPath: rootPath2 },
-      {
-        local,
-        port
-      }
-    );
   }
-};
-var buildAdmin = async ({
-  schema,
-  local,
-  rootPath: rootPath2,
-  apiUrl
-}) => {
-  var _a;
-  if ((_a = schema == null ? void 0 : schema.config) == null ? void 0 : _a.build) {
-    const buildVite = async () => {
-      var _a2, _b, _c, _d, _e, _f, _g;
-      await (0, import_app.viteBuild)({
-        local,
-        rootPath: rootPath2,
-        outputFolder: (_b = (_a2 = schema == null ? void 0 : schema.config) == null ? void 0 : _a2.build) == null ? void 0 : _b.outputFolder,
-        publicFolder: (_d = (_c = schema == null ? void 0 : schema.config) == null ? void 0 : _c.build) == null ? void 0 : _d.publicFolder,
-        apiUrl,
-        host: (_g = (_f = (_e = schema == null ? void 0 : schema.config) == null ? void 0 : _e.build) == null ? void 0 : _f.host) != null ? _g : false
-      });
-    };
-    if (local) {
-      logger.info(logText("Starting Tina asset server"));
-      await buildVite();
-    } else {
-      await spin({
-        text: logText("Building static site"),
-        waitFor: buildVite
-      });
-      logger.info(logText("\nDone building static site"));
-    }
+  async catch(error) {
+    logger.error("Error occured during tinacms dev");
+    console.error(error);
+    process.exit(1);
   }
-};
-
-// src/cmds/start-server/index.ts
-var buildLock = new AsyncLock();
-var reBuildLock = new AsyncLock();
-var gqlPackageFile = require.resolve("@tinacms/graphql");
-async function startServer(ctx, next, {
-  port = 4001,
-  noWatch,
-  noSDK,
-  noTelemetry,
-  watchFolders,
-  verbose,
-  dev
-}) {
-  buildLock.disable();
-  reBuildLock.disable();
-  const rootPath2 = ctx.rootPath;
-  const t = new import_metrics2.Telemetry({ disabled: Boolean(noTelemetry) });
-  t.submitRecord({
-    event: {
-      name: "tinacms:cli:server:start:invoke"
+  async execute() {
+    if (this.watchFolders) {
+      logger.warn(
+        "--watchFolders has been deprecated, imports from your Tina config file will be watched automatically. If you still need it please open a ticket at https://github.com/tinacms/tinacms/issues"
+      );
     }
-  });
-  const bridge = ctx.bridge;
-  const database = ctx.database;
-  const shouldBuild = bridge.supportsBuilding();
-  let ready = false;
-  const state = {
-    server: null,
-    sockets: []
-  };
-  let isReady = false;
-  const beforeBuild = async () => {
-    await buildLock.promise;
-    buildLock.enable();
-  };
-  const afterBuild = async () => {
-    buildLock.disable();
-  };
-  const start = async () => {
-    await buildLock.promise;
-    buildLock.enable();
-    try {
-      const s = (init_server3(), __toCommonJS(server_exports));
-      state.server = await s.default(database);
-      await new Promise((resolve2, reject) => {
-        state.server.listen(port, () => {
-          var _a, _b;
-          const altairUrl = `http://localhost:${port}/altair/`;
-          const cmsUrl = ((_b = (_a = ctx.schema) == null ? void 0 : _a.config) == null ? void 0 : _b.build) ? `[your-development-url]/${ctx.schema.config.build.outputFolder}/index.html` : `[your-development-url]/admin`;
-          if (verbose)
-            logger.info(`Started Filesystem GraphQL server on port: ${port}`);
-          console.log("");
-          logger.info(indentedCmd(`GraphQL playground: ${linkText(altairUrl)}`));
-          logger.info(indentedCmd(`CMS: ${linkText(cmsUrl)} 
-`));
-          resolve2();
-        });
-        state.server.on("error", function(e) {
-          if (e.code === "EADDRINUSE") {
-            logger.error(dangerText(`Port ${port} already in use`));
-          }
-          reject(e);
-        });
-        state.server.on("connection", (socket) => {
-          state.sockets.push(socket);
-        });
-      });
-    } catch (error) {
-      throw error;
-    } finally {
-      buildLock.disable();
+    if (this.isomorphicGitBridge) {
+      logger.warn("--isomorphicGitBridge has been deprecated");
     }
-  };
-  const restart = async () => {
-    return new Promise((resolve2, reject) => {
-      logger.info("restarting local server...");
-      delete require.cache[gqlPackageFile];
-      state.sockets.forEach((socket) => {
-        if (socket.destroyed === false) {
-          socket.destroy();
+    if (this.experimentalDataLayer) {
+      logger.warn(
+        "--experimentalDataLayer has been deprecated, the data layer is now built-in automatically"
+      );
+    }
+    const configManager = new ConfigManager(this.rootPath);
+    logger.info("Starting Tina Dev Server");
+    createDBServer();
+    let database = null;
+    const setup = async ({ firstTime }) => {
+      try {
+        await configManager.processConfig();
+      } catch (e) {
+        logger.error(e.message);
+        if (this.verbose) {
+          console.error(e);
         }
-      });
-      state.sockets = [];
-      state.server.close(async () => {
-        logger.info("Server closed");
-        start().then((x) => resolve2(x)).catch((err) => reject(err));
-      });
-    });
-  };
-  const build2 = async () => {
-    var _a, _b;
-    logger.info(titleText(" TinaCMS ") + focusText(" - Build Started\n"));
-    try {
-      await beforeBuild();
-      const { schema, graphQLSchema, tinaSchema } = await ctx.builder.build({
-        rootPath: ctx.rootPath,
-        verbose,
-        local: true
-      });
-      ctx.schema = schema;
-      const missingFormat = (_b = (_a = tinaSchema == null ? void 0 : tinaSchema.schema) == null ? void 0 : _a.collections) == null ? void 0 : _b.filter((x) => !x.format).map((x) => x.name).join(", ");
-      if (missingFormat) {
-        logger.warn(
-          warnText(
-            `No format provided for collection(s) "${missingFormat}", defaulting to .md`
-          )
+        if (firstTime) {
+          logger.error(
+            "Unable to start dev server, please fix your Tina config and try again"
+          );
+          process.exit(1);
+        }
+      }
+      if (firstTime) {
+        database = await createAndInitializeDatabase(configManager);
+      } else {
+        database.clearCache();
+      }
+      const { tinaSchema, graphQLSchema, queryDoc, fragDoc } = await (0, import_graphql8.buildSchema)(database, configManager.config);
+      if (!configManager.isUsingLegacyFolder) {
+        delete require.cache[configManager.generatedSchemaJSONPath];
+        delete require.cache[configManager.generatedLookupJSONPath];
+        delete require.cache[configManager.generatedGraphQLJSONPath];
+        const schemaObject = require(configManager.generatedSchemaJSONPath);
+        const lookupObject = require(configManager.generatedLookupJSONPath);
+        const graphqlSchemaObject = require(configManager.generatedGraphQLJSONPath);
+        await import_fs_extra4.default.writeFileSync(
+          import_path6.default.join(configManager.tinaFolderPath, "tina-lock.json"),
+          JSON.stringify({
+            schema: schemaObject,
+            lookup: lookupObject,
+            graphql: graphqlSchemaObject
+          })
         );
       }
-      const apiUrl = await ctx.builder.genTypedClient({
-        compiledSchema: schema,
-        local: true,
-        noSDK,
-        verbose,
-        usingTs: ctx.usingTs,
-        port,
-        rootPath: ctx.rootPath
+      const codegen2 = new Codegen({
+        schema: await (0, import_graphql8.getASTSchema)(database),
+        configManager,
+        port: Number(this.port),
+        noSDK: this.noSDK,
+        queryDoc,
+        fragDoc
       });
+      const apiURL2 = await codegen2.execute();
+      if (!this.noWatch) {
+        this.watchQueries(configManager, async () => await codegen2.execute());
+      }
+      const warnings = [];
       await spin({
         waitFor: async () => {
-          await ctx.database.indexContent({ graphQLSchema, tinaSchema });
+          const res = await database.indexContent({
+            graphQLSchema,
+            tinaSchema
+          });
+          warnings.push(...res.warnings);
         },
-        text: logText("Indexing local files")
-      });
-      await buildAdmin({
-        local: true,
-        rootPath: ctx.rootPath,
-        schema,
-        apiUrl
+        text: "Indexing local files"
       });
-    } catch (error) {
-      throw error;
-    } finally {
-      await afterBuild();
+      if (warnings.length > 0) {
+        logger.warn(`Indexing completed with ${warnings.length} warning(s)`);
+        warnings.forEach((warning) => {
+          logger.warn(warnText(`${warning}`));
+        });
+      }
+      return { apiURL: apiURL2, database };
+    };
+    const { apiURL } = await setup({ firstTime: true });
+    await import_fs_extra4.default.outputFile(configManager.outputHTMLFilePath, devHTML(this.port));
+    await import_fs_extra4.default.outputFile(
+      configManager.outputGitignorePath,
+      "index.html\nassets/"
+    );
+    const server = await createDevServer(
+      configManager,
+      database,
+      apiURL,
+      this.noSDK,
+      this.noWatch
+    );
+    await server.listen(Number(this.port));
+    if (!this.noWatch) {
+      this.watchContentFiles(configManager, database);
     }
-  };
-  const foldersToWatch = (watchFolders || []).map((x) => import_path8.default.join(rootPath2, x));
-  if (!noWatch && !process.env.CI) {
-    import_chokidar.default.watch(
-      [
-        ...foldersToWatch,
-        `${rootPath2}/.tina/**/*.{ts,gql,graphql,js,tsx,jsx}`,
-        gqlPackageFile
-      ],
-      {
-        ignored: [
-          "**/node_modules/**/*",
-          "**/.next/**/*",
-          `${import_path8.default.resolve(rootPath2)}/.tina/__generated__/**/*`
-        ]
+    server.watcher.on("change", async (changedPath) => {
+      if (changedPath.includes("__generated__")) {
+        return;
+      }
+      if (changedPath.includes("@tinacms/app")) {
+        return;
+      }
+      if (changedPath.includes("tinacms/dist")) {
+        return;
       }
-    ).on("ready", async () => {
-      if (verbose)
-        console.log("Generating Tina config");
       try {
-        if (shouldBuild) {
-          await build2();
-        }
-        ready = true;
-        isReady = true;
-        await start();
-        next();
+        logger.info("Tina config updated");
+        await setup({ firstTime: false });
       } catch (e) {
-        handleServerErrors(e);
-        throw e;
+        logger.error(e.message);
       }
-    }).on("all", async () => {
-      if (ready) {
-        await reBuildLock.promise;
-        reBuildLock.enable();
-        logger.info("Tina change detected, regenerating config");
-        try {
-          if (shouldBuild) {
-            await build2();
-          }
-          if (isReady) {
-            await restart();
-          }
-        } catch (e) {
-          handleServerErrors(e);
-          t.submitRecord({
-            event: {
-              name: "tinacms:cli:server:error",
-              errorMessage: e.message
-            }
-          });
-        } finally {
-          reBuildLock.disable();
-        }
+    });
+    const subItems = [];
+    if (configManager.hasSeparateContentRoot()) {
+      subItems.push({
+        key: "Content repo",
+        value: configManager.contentRootPath
+      });
+    }
+    const summaryItems = [
+      {
+        emoji: "\u{1F999}",
+        heading: "Tina Config",
+        subItems: [
+          {
+            key: "CMS",
+            value: `<your-dev-server-url>/${configManager.printoutputHTMLFilePath()}`
+          },
+          {
+            key: "API playground",
+            value: `<your-dev-server-url>/${configManager.printoutputHTMLFilePath()}#/graphql`
+          },
+          {
+            key: "API url",
+            value: apiURL
+          },
+          ...subItems
+        ]
       }
+    ];
+    if (!this.noSDK) {
+      summaryItems.push({
+        emoji: "\u{1F916}",
+        heading: "Auto-generated files",
+        subItems: [
+          {
+            key: "GraphQL Client",
+            value: configManager.printGeneratedClientFilePath()
+          },
+          {
+            key: "Typescript Types",
+            value: configManager.printGeneratedTypesFilePath()
+          }
+        ]
+      });
+    }
+    summary({
+      heading: "Tina Dev Server is running...",
+      items: [
+        ...summaryItems
+      ]
     });
-  } else {
-    if (process.env.CI) {
-      logger.info("Detected CI environment, omitting watch commands...");
+    let subProc;
+    if (this.subCommand) {
+      subProc = await startSubprocess2({ command: this.subCommand });
+      logger.info(`Starting subprocess: ${import_chalk3.default.cyan(this.subCommand)}`);
     }
-    if (shouldBuild) {
-      await build2();
+    function exitHandler(options, exitCode) {
+      if (subProc) {
+        subProc.kill();
+      }
+      process.exit();
     }
-    await start();
-    next();
+    process.on("exit", exitHandler);
+    process.on("SIGINT", exitHandler);
+    process.on("SIGUSR1", exitHandler);
+    process.on("SIGUSR2", exitHandler);
+    process.on("uncaughtException", exitHandler);
+  }
+  watchContentFiles(configManager, database) {
+    const collectionContentFiles = [];
+    configManager.config.schema.collections.forEach((collection) => {
+      const collectionGlob = `${import_path6.default.join(
+        configManager.contentRootPath,
+        collection.path
+      )}/**/*.${collection.format || "md"}`;
+      collectionContentFiles.push(collectionGlob);
+    });
+    let ready = false;
+    import_chokidar.default.watch(collectionContentFiles).on("ready", () => {
+      ready = true;
+    }).on("add", async (addedFile) => {
+      if (!ready) {
+        return;
+      }
+      const pathFromRoot = configManager.printContentRelativePath(addedFile);
+      database.indexContentByPaths([pathFromRoot]);
+    }).on("change", async (changedFile) => {
+      const pathFromRoot = configManager.printContentRelativePath(changedFile);
+      database.indexContentByPaths([pathFromRoot]);
+    }).on("unlink", async (removedFile) => {
+      const pathFromRoot = configManager.printContentRelativePath(removedFile);
+      database.deleteContentByPaths([pathFromRoot]);
+    });
   }
-}
-
-// src/cmds/statusChecks/waitForIndexing.ts
-var import_progress = __toESM(require("progress"));
-var import_schema_tools = require("@tinacms/schema-tools");
+  watchQueries(configManager, callback) {
+    let ready = false;
+    import_chokidar.default.watch(configManager.userQueriesAndFragmentsGlob).on("ready", () => {
+      ready = true;
+    }).on("add", async (addedFile) => {
+      await callback();
+    }).on("change", async (changedFile) => {
+      await callback();
+    }).on("unlink", async (removedFile) => {
+      await callback();
+    });
+  }
+};
+DevCommand.paths = [["dev"], ["server:start"]];
+DevCommand.usage = import_clipanion.Command.Usage({
+  category: `Commands`,
+  description: `Builds Tina and starts the dev server`,
+  examples: [
+    [`A basic example`, `$0 dev`],
+    [`A second example`, `$0 dev --rootPath`]
+  ]
+});
+
+// src/next/commands/build-command/index.ts
+var import_node_fetch2 = __toESM(require("node-fetch"));
+var import_clipanion2 = require("clipanion");
+var import_progress2 = __toESM(require("progress"));
+var import_fs_extra5 = __toESM(require("fs-extra"));
+var import_graphql9 = require("@tinacms/graphql");
+
+// src/next/commands/build-command/server.ts
+var import_vite4 = require("vite");
+var buildProductionSpa = async (configManager, database, apiURL, noSDK) => {
+  const publicEnv = {};
+  Object.keys(process.env).forEach((key) => {
+    if (key.startsWith("TINA_PUBLIC_") || key.startsWith("NEXT_PUBLIC_") || key === "NODE_ENV" || key === "HEAD") {
+      try {
+        if (typeof process.env[key] === "string") {
+          publicEnv[key] = process.env[key];
+        } else {
+          publicEnv[key] = JSON.stringify(process.env[key]);
+        }
+      } catch (error) {
+        console.warn(
+          `Could not stringify public env process.env.${key} env variable`
+        );
+        console.warn(error);
+      }
+    }
+  });
+  const config3 = await createConfig({
+    configManager,
+    database,
+    apiURL,
+    noSDK,
+    noWatch: true
+  });
+  return (0, import_vite4.build)(config3);
+};
+
+// src/next/commands/build-command/index.ts
+var import_schema_tools2 = require("@tinacms/schema-tools");
+var import_graphql10 = require("graphql");
+var import_core2 = require("@graphql-inspector/core");
+
+// src/next/commands/build-command/waitForDB.ts
+var import_progress = __toESM(require("progress"));
+var import_schema_tools = require("@tinacms/schema-tools");
+var import_node_fetch = __toESM(require("node-fetch"));
+
+// src/utils/sleep.ts
+function timeout(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function sleepAndCallFunc({
+  fn,
+  ms
+}) {
+  await timeout(ms);
+  const res = await fn();
+  return res;
+}
+
+// src/next/commands/build-command/waitForDB.ts
 var POLLING_INTERVAL = 5e3;
 var STATUS_INPROGRESS = "inprogress";
 var STATUS_COMPLETE = "complete";
@@ -1713,30 +1848,30 @@ var IndexFailedError = class extends Error {
     this.name = "IndexFailedError";
   }
 };
-var waitForDB = async (ctx, next, options) => {
-  const token = ctx.schema.config.token;
-  if (ctx.isSelfHostedDatabase) {
-    return next();
-  }
-  const { clientId, branch, isLocalClient, host } = (0, import_schema_tools.parseURL)(ctx.apiUrl);
-  if (isLocalClient) {
-    return next();
+var waitForDB = async (config3, apiUrl, verbose) => {
+  const token = config3.token;
+  const { clientId, branch, isLocalClient, host } = (0, import_schema_tools.parseURL)(apiUrl);
+  if (isLocalClient || !host || !clientId || !branch) {
+    if (verbose) {
+      logger.info(logText("Not using Tina Cloud, skipping DB check"));
+    }
+    return;
   }
-  const bar = new import_progress.default(
+  const bar2 = new import_progress.default(
     "Checking indexing process in Tina Cloud... :prog",
     1
   );
   const pollForStatus = async () => {
     try {
-      if (options.verbose) {
+      if (verbose) {
         logger.info(logText("Polling for status..."));
       }
-      const headers = new Headers();
+      const headers = new import_node_fetch.Headers();
       headers.append("Content-Type", "application/json");
       if (token) {
         headers.append("X-API-KEY", token);
       }
-      const response = await fetch(
+      const response = await (0, import_node_fetch.default)(
         `https://${host}/db/${clientId}/status/${branch}`,
         {
           method: "GET",
@@ -1747,15 +1882,14 @@ var waitForDB = async (ctx, next, options) => {
       const { status, error } = await response.json();
       const statusMessage = `Indexing status: '${status}'`;
       if (status === STATUS_COMPLETE) {
-        bar.tick({
+        bar2.tick({
           prog: "\u2705"
         });
-        return next();
       } else if (status === STATUS_INPROGRESS) {
-        if (options.verbose) {
+        if (verbose) {
           logger.info(logText(`${statusMessage}, trying again in 5 seconds`));
         }
-        setTimeout(pollForStatus, POLLING_INTERVAL);
+        await sleepAndCallFunc({ fn: pollForStatus, ms: POLLING_INTERVAL });
       } else if (status === STATUS_FAILED) {
         throw new IndexFailedError(
           `Attempting to index but responded with status 'failed', To retry the indexing process, click \u201CReset Repository Cache\u201D in tina cloud advance settings.  ${error}`
@@ -1767,7 +1901,7 @@ var waitForDB = async (ctx, next, options) => {
       }
     } catch (e) {
       if (e instanceof IndexFailedError) {
-        bar.tick({
+        bar2.tick({
           prog: "\u274C"
         });
         throw e;
@@ -1777,48 +1911,598 @@ var waitForDB = async (ctx, next, options) => {
         );
       }
     }
-  };
-  spin({
-    text: "Checking indexing process in Tina Cloud...",
-    waitFor: pollForStatus
-  });
+  };
+  await spin({
+    text: "Checking indexing process in Tina Cloud...",
+    waitFor: pollForStatus
+  });
+};
+
+// src/next/commands/build-command/index.ts
+var BuildCommand = class extends import_clipanion2.Command {
+  constructor() {
+    super(...arguments);
+    this.rootPath = import_clipanion2.Option.String("--rootPath", {
+      description: "Specify the root directory to run the CLI from (defaults to current working directory)"
+    });
+    this.verbose = import_clipanion2.Option.Boolean("-v,--verbose", false, {
+      description: "increase verbosity of logged output"
+    });
+    this.noSDK = import_clipanion2.Option.Boolean("--noSDK", false, {
+      description: "Don't generate the generated client SDK"
+    });
+    this.isomorphicGitBridge = import_clipanion2.Option.Boolean("--isomorphicGitBridge", {
+      description: "DEPRECATED - Enable Isomorphic Git Bridge Implementation"
+    });
+    this.localOption = import_clipanion2.Option.Boolean("--local", {
+      description: "DEPRECATED: Uses the local file system graphql server"
+    });
+    this.experimentalDataLayer = import_clipanion2.Option.Boolean("--experimentalData", {
+      description: "DEPRECATED - Build the server with additional data querying capabilities"
+    });
+    this.noTelemetry = import_clipanion2.Option.Boolean("--noTelemetry", false, {
+      description: "Disable anonymous telemetry that is collected"
+    });
+    this.tinaGraphQLVersion = import_clipanion2.Option.String("--tina-graphql-version", {
+      description: "Specify the version of @tinacms/graphql to use (defaults to latest)"
+    });
+  }
+  async catch(error) {
+    console.error(error);
+    process.exit(1);
+  }
+  async execute() {
+    const configManager = new ConfigManager(
+      this.rootPath,
+      this.tinaGraphQLVersion
+    );
+    logger.info("Starting Tina build");
+    if (this.isomorphicGitBridge) {
+      logger.warn("--isomorphicGitBridge has been deprecated");
+    }
+    if (this.experimentalDataLayer) {
+      logger.warn(
+        "--experimentalDataLayer has been deprecated, the data layer is now built-in automatically"
+      );
+    }
+    if (this.localOption) {
+      logger.warn("--local has been deprecated");
+    }
+    try {
+      await configManager.processConfig();
+    } catch (e) {
+      logger.error(e.message);
+      logger.error("Unable to build, please fix your Tina config and try again");
+      process.exit(1);
+    }
+    createDBServer();
+    const database = await createAndInitializeDatabase(configManager);
+    const { queryDoc, fragDoc } = await (0, import_graphql9.buildSchema)(
+      database,
+      configManager.config
+    );
+    const codegen2 = new Codegen({
+      schema: await (0, import_graphql9.getASTSchema)(database),
+      configManager,
+      noSDK: this.noSDK,
+      queryDoc,
+      fragDoc
+    });
+    const apiURL = await codegen2.execute();
+    await this.checkClientInfo(configManager, apiURL);
+    await waitForDB(configManager.config, apiURL, false);
+    await this.checkGraphqlSchema(configManager, database, apiURL);
+    await buildProductionSpa(configManager, database, apiURL, this.noSDK);
+    await import_fs_extra5.default.outputFile(
+      configManager.outputGitignorePath,
+      "index.html\nassets/"
+    );
+    const summaryItems = [];
+    if (!this.noSDK) {
+      summaryItems.push({
+        emoji: "\u{1F916}",
+        heading: "Auto-generated files",
+        subItems: [
+          {
+            key: "GraphQL Client",
+            value: configManager.printGeneratedClientFilePath()
+          },
+          {
+            key: "Typescript Types",
+            value: configManager.printGeneratedTypesFilePath()
+          }
+        ]
+      });
+    }
+    summary({
+      heading: "Tina build complete",
+      items: [
+        {
+          emoji: "\u{1F999}",
+          heading: "Tina Config",
+          subItems: [
+            {
+              key: "API url",
+              value: apiURL
+            }
+          ]
+        },
+        ...summaryItems
+      ]
+    });
+    process.exit();
+  }
+  async checkClientInfo(configManager, apiURL) {
+    const { config: config3 } = configManager;
+    const token = config3.token;
+    const { clientId, branch, host } = (0, import_schema_tools2.parseURL)(apiURL);
+    const url2 = `https://${host}/db/${clientId}/status/${branch}`;
+    const bar2 = new import_progress2.default("Checking clientId and token. :prog", 1);
+    let branchKnown = false;
+    try {
+      const res = await request({
+        token,
+        url: url2
+      });
+      bar2.tick({
+        prog: "\u2705"
+      });
+      if (!(res.status === "unknown")) {
+        branchKnown = true;
+      }
+    } catch (e) {
+      summary({
+        heading: "Error when checking client information",
+        items: [
+          {
+            emoji: "\u274C",
+            heading: "You provided",
+            subItems: [
+              {
+                key: "clientId",
+                value: config3.clientId
+              },
+              {
+                key: "token",
+                value: config3.token
+              }
+            ]
+          }
+        ]
+      });
+      throw e;
+    }
+    const branchBar = new import_progress2.default("Checking branch is on Tina Cloud. :prog", 1);
+    if (branchKnown) {
+      branchBar.tick({
+        prog: "\u2705"
+      });
+      return;
+    }
+    for (let i = 0; i <= 5; i++) {
+      await sleepAndCallFunc({
+        fn: async () => {
+          const res = await request({
+            token,
+            url: url2
+          });
+          if (this.verbose) {
+            logger.info(
+              `Branch status: ${res.status}. Attempt: ${i + 1}. Trying again in 5 seconds.`
+            );
+          }
+          if (!(res.status === "unknown")) {
+            branchBar.tick({
+              prog: "\u2705"
+            });
+            return;
+          }
+        },
+        ms: 5e3
+      });
+    }
+    branchBar.tick({
+      prog: "\u274C"
+    });
+    logger.error(
+      `${dangerText(
+        `ERROR: Branch '${branch}' is not on Tina Cloud.`
+      )} Please make sure that branch '${branch}' exists in your repository and that you have pushed your all changes to the remote. View all all branches and there current status here: ${linkText(
+        `https://app.tina.io/projects/${clientId}/configuration`
+      )}`
+    );
+    throw new Error("Branch is not on Tina Cloud");
+  }
+  async checkGraphqlSchema(configManager, database, apiURL) {
+    const bar2 = new import_progress2.default(
+      "Checking local GraphQL Schema matches server. :prog",
+      1
+    );
+    const { config: config3 } = configManager;
+    const token = config3.token;
+    const remoteSchema = await fetchRemoteGraphqlSchema({
+      url: apiURL,
+      token
+    });
+    const remoteGqlSchema = (0, import_graphql10.buildClientSchema)(remoteSchema);
+    const localSchemaDocument = await database.getGraphQLSchemaFromBridge();
+    const localGraphqlSchema = (0, import_graphql10.buildASTSchema)(localSchemaDocument);
+    const diffResult = await (0, import_core2.diff)(localGraphqlSchema, remoteGqlSchema);
+    if (diffResult.length === 0) {
+      bar2.tick({
+        prog: "\u2705"
+      });
+    } else {
+      bar2.tick({
+        prog: "\u274C"
+      });
+      let errorMessage = `The local GraphQL schema doesn't match the remote GraphQL schema. Please push up your changes to Github to update your remote GraphQL schema.`;
+      if (config3 == null ? void 0 : config3.branch) {
+        errorMessage += `
+
+Additional info: Branch: ${config3.branch}, Client ID: ${config3.clientId} `;
+      }
+      throw new Error(errorMessage);
+    }
+  }
+};
+BuildCommand.paths = [["build"]];
+BuildCommand.usage = import_clipanion2.Command.Usage({
+  category: `Commands`,
+  description: `Build the CMS and autogenerated modules for usage with Tina Cloud`
+});
+async function request(args) {
+  const headers = new import_node_fetch2.Headers();
+  if (args.token) {
+    headers.append("X-API-KEY", args.token);
+  }
+  headers.append("Content-Type", "application/json");
+  const url2 = args == null ? void 0 : args.url;
+  const res = await (0, import_node_fetch2.default)(url2, {
+    method: "GET",
+    headers,
+    redirect: "follow"
+  });
+  const json = await res.json();
+  if (!res.ok) {
+    let additionalInfo = "";
+    if (res.status === 401 || res.status === 403) {
+      additionalInfo = "Please check that your client ID, URL and read only token are configured properly.";
+    }
+    if (json) {
+      additionalInfo += `
+
+Message from server: ${json.message}`;
+    }
+    throw new Error(
+      `Server responded with status code ${res.status}, ${res.statusText}. ${additionalInfo ? additionalInfo : ""} Please see our FAQ for more information: https://tina.io/docs/errors/faq/`
+    );
+  }
+  if (json.errors) {
+    throw new Error(
+      `Unable to fetch, please see our FAQ for more information: https://tina.io/docs/errors/faq/
+
+      Errors: 
+	${json.errors.map((error) => error.message).join("\n")}`
+    );
+  }
+  return {
+    status: json == null ? void 0 : json.status,
+    timestamp: json == null ? void 0 : json.timestamp
+  };
+}
+var fetchRemoteGraphqlSchema = async ({
+  url: url2,
+  token
+}) => {
+  const headers = new import_node_fetch2.Headers();
+  if (token) {
+    headers.append("X-API-KEY", token);
+  }
+  const body = JSON.stringify({ query: (0, import_graphql10.getIntrospectionQuery)(), variables: {} });
+  headers.append("Content-Type", "application/json");
+  const res = await (0, import_node_fetch2.default)(url2, {
+    method: "POST",
+    headers,
+    body
+  });
+  const data = await res.json();
+  return data == null ? void 0 : data.data;
+};
+
+// src/next/commands/audit-command/index.ts
+var import_clipanion3 = require("clipanion");
+var import_graphql13 = require("@tinacms/graphql");
+
+// src/next/commands/audit-command/audit.ts
+var import_prompts = __toESM(require("prompts"));
+var import_metrics = require("@tinacms/metrics");
+var import_graphql11 = require("@tinacms/graphql");
+var import_graphql12 = require("@tinacms/graphql");
+var import_chalk4 = __toESM(require("chalk"));
+var audit = async ({
+  database,
+  clean,
+  useDefaultValues,
+  noTelemetry,
+  verbose
+}) => {
+  const telemetry = new import_metrics.Telemetry({ disabled: noTelemetry });
+  await telemetry.submitRecord({
+    event: {
+      name: "tinacms:cli:audit:invoke",
+      clean: Boolean(clean),
+      useDefaults: Boolean(useDefaultValues)
+    }
+  });
+  if (clean) {
+    logger.info(
+      `You are using the \`--clean\` option. This will modify your content as if a user is submitting a form. Before running this you should have a ${import_chalk4.default.bold(
+        "clean git tree"
+      )} so unwanted changes can be undone.
+
+`
+    );
+    const res = await (0, import_prompts.default)({
+      name: "useClean",
+      type: "confirm",
+      message: `Do you want to continue?`
+    });
+    if (!res.useClean) {
+      logger.warn(import_chalk4.default.yellowBright("\u26A0\uFE0F Audit not complete"));
+      process.exit(0);
+    }
+  }
+  if (useDefaultValues && !clean) {
+    logger.warn(
+      import_chalk4.default.yellowBright(
+        "WARNING: using the `--useDefaultValues` without the `--clean` flag has no effect. Please re-run audit and add the `--clean` flag"
+      )
+    );
+  }
+  const schema = await database.getSchema();
+  const collections = schema.getCollections();
+  let error = false;
+  for (let i = 0; i < collections.length; i++) {
+    const collection = collections[i];
+    const docs = await database.query(
+      { collection: collection.name, first: -1, filterChain: [] },
+      (item) => ({ path: item })
+    );
+    logger.info(
+      `Checking ${neutralText(collection.name)} collection. ${docs.edges.length} Documents`
+    );
+    const returnError = await auditDocuments({
+      collection,
+      database,
+      useDefaultValues,
+      documents: docs.edges,
+      verbose
+    });
+    error = error || returnError;
+  }
+  if (error) {
+    logger.error(
+      import_chalk4.default.redBright(`\u203C\uFE0F Audit ${import_chalk4.default.bold("failed")} with errors`)
+    );
+  } else {
+    logger.info(import_chalk4.default.greenBright("\u2705 Audit passed"));
+  }
+};
+var auditDocuments = async (args) => {
+  const { collection, database, useDefaultValues, documents } = args;
+  let error = false;
+  for (let i = 0; i < documents.length; i++) {
+    const node = documents[i].node;
+    const relativePath = node.path.replace(`${collection.path}/`, "");
+    const documentQuery = `query {
+        document(collection: "${collection.name}", relativePath: "${relativePath}") {
+          __typename
+          ...on Document {
+            _values
+          }
+        }
+      }`;
+    const docResult = await (0, import_graphql11.resolve)({
+      database,
+      query: documentQuery,
+      variables: {},
+      silenceErrors: true,
+      verbose: args.verbose || false,
+      isAudit: true
+    });
+    if (docResult.errors) {
+      error = true;
+      docResult.errors.forEach((err) => {
+        logger.error(import_chalk4.default.red(err.message));
+        if (err.originalError.originalError) {
+          logger.error(
+            import_chalk4.default.red(`    ${err.originalError.originalError.message}`)
+          );
+        }
+      });
+    } else {
+      const topLevelDefaults = {};
+      if (useDefaultValues && typeof collection.fields !== "string") {
+        collection.fields.filter((x) => !x.list).forEach((x) => {
+          const value = x.ui;
+          if (typeof value !== "undefined") {
+            topLevelDefaults[x.name] = value.defaultValue;
+          }
+        });
+      }
+      const params = transformDocumentIntoMutationRequestPayload(
+        docResult.data.document._values,
+        {
+          includeCollection: true,
+          includeTemplate: typeof collection.templates !== "undefined"
+        },
+        topLevelDefaults
+      );
+      const mutation = `mutation($collection: String!, $relativePath: String!, $params: DocumentUpdateMutation!) {
+        updateDocument(
+          collection: $collection,
+          relativePath: $relativePath,
+          params: $params
+        ){__typename}
+      }`;
+      const mutationRes = await (0, import_graphql11.resolve)({
+        database,
+        query: mutation,
+        variables: {
+          params,
+          collection: collection.name,
+          relativePath
+        },
+        isAudit: true,
+        silenceErrors: true,
+        verbose: args.verbose || false
+      });
+      if (mutationRes.errors) {
+        mutationRes.errors.forEach((err) => {
+          error = true;
+          logger.error(import_chalk4.default.red(err.message));
+        });
+      }
+    }
+  }
+  return error;
+};
+var transformDocumentIntoMutationRequestPayload = (document, instructions, defaults) => {
+  const { _collection, __typename, _template, ...rest } = document;
+  const params = transformParams(rest);
+  const paramsWithTemplate = instructions.includeTemplate ? { [_template]: params } : params;
+  return instructions.includeCollection ? { [_collection]: { ...defaults, ...filterObject(paramsWithTemplate) } } : { ...defaults, ...filterObject(paramsWithTemplate) };
+};
+var transformParams = (data) => {
+  if (["string", "number", "boolean"].includes(typeof data)) {
+    return data;
+  }
+  if (Array.isArray(data)) {
+    return data.map((item) => transformParams(item));
+  }
+  try {
+    (0, import_graphql12.assertShape)(
+      data,
+      (yup) => yup.object({ _template: yup.string().required() })
+    );
+    const { _template, __typename, ...rest } = data;
+    const nested = transformParams(rest);
+    return { [_template]: nested };
+  } catch (e) {
+    if (e.message === "Failed to assertShape - _template is a required field") {
+      if (!data) {
+        return void 0;
+        return [];
+      }
+      const accum = {};
+      Object.entries(data).map(([keyName, value]) => {
+        accum[keyName] = transformParams(value);
+      });
+      return accum;
+    } else {
+      if (!data) {
+        return void 0;
+        return [];
+      }
+      throw e;
+    }
+  }
 };
+function filterObject(obj) {
+  const ret = {};
+  Object.keys(obj).filter((key) => obj[key] !== void 0).forEach((key) => ret[key] = obj[key]);
+  return ret;
+}
 
-// src/cmds/startSubprocess/index.ts
-var import_child_process = __toESM(require("child_process"));
-var startSubprocess = async (_ctx, next, { command }) => {
-  if (typeof command === "string") {
-    const commands = command.split(" ");
-    const firstCommand = commands[0];
-    const args = commands.slice(1) || [];
-    const ps = import_child_process.default.spawn(firstCommand, args, {
-      stdio: "inherit",
-      shell: true
+// src/next/commands/audit-command/index.ts
+var import_graphql14 = require("@tinacms/graphql");
+var AuditCommand = class extends import_clipanion3.Command {
+  constructor() {
+    super(...arguments);
+    this.rootPath = import_clipanion3.Option.String("--rootPath", {
+      description: "Specify the root directory to run the CLI from"
     });
-    ps.on("error", (code) => {
-      logger.error(
-        dangerText(
-          `An error has occurred in the Next.js child process. Error message below`
-        )
-      );
-      logger.error(`name: ${code.name}
-message: ${code.message}
-
-stack: ${code.stack || "No stack was provided"}`);
+    this.verbose = import_clipanion3.Option.Boolean("-v,--verbose", false, {
+      description: "increase verbosity of logged output"
     });
-    ps.on("close", (code) => {
-      logger.info(`child process exited with code ${code}`);
-      process.exit(code);
+    this.clean = import_clipanion3.Option.Boolean("--clean", false, {
+      description: "Clean the output"
     });
+    this.useDefaultValues = import_clipanion3.Option.Boolean("--useDefaultValues", false, {
+      description: "When cleaning the output, use defaults on the config"
+    });
+    this.noTelemetry = import_clipanion3.Option.Boolean("--noTelemetry", false, {
+      description: "Disable anonymous telemetry that is collected"
+    });
+  }
+  async catch(error) {
+    logger.error("Error occured during tinacms audit");
+    if (this.verbose) {
+      console.error(error);
+    }
+    process.exit(1);
+  }
+  async execute() {
+    const configManager = new ConfigManager(this.rootPath);
+    logger.info("Starting Tina Audit");
+    try {
+      await configManager.processConfig();
+    } catch (e) {
+      logger.error(e.message);
+      process.exit(1);
+    }
+    createDBServer();
+    const database = await createAndInitializeDatabase(
+      configManager,
+      this.clean ? void 0 : new import_graphql14.AuditFileSystemBridge(configManager.rootPath)
+    );
+    const { tinaSchema, graphQLSchema } = await (0, import_graphql13.buildSchema)(
+      database,
+      configManager.config
+    );
+    const warnings = [];
+    await spin({
+      waitFor: async () => {
+        const res = await database.indexContent({
+          graphQLSchema,
+          tinaSchema
+        });
+        warnings.push(...res.warnings);
+      },
+      text: "Indexing local files"
+    });
+    if (warnings.length > 0) {
+      logger.warn(`Indexing completed with ${warnings.length} warning(s)`);
+      warnings.forEach((warning) => {
+        logger.warn(warnText(`${warning}`));
+      });
+    }
+    await audit({
+      database,
+      clean: this.clean,
+      noTelemetry: this.noTelemetry,
+      useDefaultValues: this.useDefaultValues,
+      verbose: this.verbose
+    });
+    process.exit();
   }
 };
+AuditCommand.paths = [["audit"]];
+AuditCommand.usage = import_clipanion3.Command.Usage({
+  category: `Commands`,
+  description: `Audit config and content files`
+});
+
+// src/next/commands/init-command/index.ts
+var import_clipanion4 = require("clipanion");
 
 // src/cmds/init/index.ts
-var import_path11 = __toESM(require("path"));
+var import_path9 = __toESM(require("path"));
 var import_prettier = require("prettier");
-var import_fs_extra9 = __toESM(require("fs-extra"));
+var import_fs_extra8 = __toESM(require("fs-extra"));
 var import_prompts2 = __toESM(require("prompts"));
-var import_metrics3 = require("@tinacms/metrics");
+var import_metrics2 = require("@tinacms/metrics");
 
 // src/cmds/init/setup-files/index.ts
 var nextPostPage = ({
@@ -2159,8 +2843,8 @@ var configExamples = {
 };
 
 // src/cmds/forestry-migrate/util/index.ts
-var import_fs_extra7 = __toESM(require("fs-extra"));
-var import_path9 = __toESM(require("path"));
+var import_fs_extra6 = __toESM(require("fs-extra"));
+var import_path7 = __toESM(require("path"));
 var import_js_yaml = __toESM(require("js-yaml"));
 var import_zod = __toESM(require("zod"));
 
@@ -2298,7 +2982,7 @@ var FrontmatterTemplateSchema = import_zod.default.object({
 });
 var transformForestryFieldsToTinaFields = ({
   fields,
-  rootPath: rootPath2,
+  rootPath,
   template,
   skipBlocks = false
 }) => {
@@ -2415,7 +3099,7 @@ var transformForestryFieldsToTinaFields = ({
           label: forestryField2.label,
           fields: transformForestryFieldsToTinaFields({
             fields: forestryField2.fields,
-            rootPath: rootPath2,
+            rootPath,
             template,
             skipBlocks
           })
@@ -2430,7 +3114,7 @@ var transformForestryFieldsToTinaFields = ({
           fields: transformForestryFieldsToTinaFields({
             fields: forestryField2.fields,
             template,
-            rootPath: rootPath2,
+            rootPath,
             skipBlocks
           })
         };
@@ -2484,9 +3168,9 @@ var transformForestryFieldsToTinaFields = ({
   });
   return tinaFields;
 };
-var getFieldsFromTemplates = ({ tem, rootPath: rootPath2, skipBlocks = false }) => {
-  const templatePath = import_path9.default.join(
-    rootPath2,
+var getFieldsFromTemplates = ({ tem, rootPath, skipBlocks = false }) => {
+  const templatePath = import_path7.default.join(
+    rootPath,
     ".forestry",
     "front_matter",
     "templates",
@@ -2494,7 +3178,7 @@ var getFieldsFromTemplates = ({ tem, rootPath: rootPath2, skipBlocks = false })
   );
   let templateString = "";
   try {
-    templateString = import_fs_extra7.default.readFileSync(templatePath).toString();
+    templateString = import_fs_extra6.default.readFileSync(templatePath).toString();
   } catch {
     throw new Error(
       `Could not find template ${tem} at ${templatePath}
@@ -2506,7 +3190,7 @@ var getFieldsFromTemplates = ({ tem, rootPath: rootPath2, skipBlocks = false })
   const template = parseTemplates({ val: templateObj });
   const fields = transformForestryFieldsToTinaFields({
     fields: template.fields,
-    rootPath: rootPath2,
+    rootPath,
     template: tem,
     skipBlocks
   });
@@ -2516,9 +3200,9 @@ var parseTemplates = ({ val }) => {
   const template = FrontmatterTemplateSchema.parse(val);
   return template;
 };
-var hasForestryConfig = async ({ rootPath: rootPath2 }) => {
-  const forestryPath = import_path9.default.join(rootPath2, ".forestry", "settings.yml");
-  const exists = await import_fs_extra7.default.pathExists(forestryPath);
+var hasForestryConfig = async ({ rootPath }) => {
+  const forestryPath = import_path7.default.join(rootPath, ".forestry", "settings.yml");
+  const exists = await import_fs_extra6.default.pathExists(forestryPath);
   return {
     path: forestryPath,
     exists
@@ -2530,11 +3214,11 @@ var parseSections = ({ val }) => {
 };
 
 // src/cmds/forestry-migrate/index.ts
-var import_fs_extra8 = __toESM(require("fs-extra"));
-var import_path10 = __toESM(require("path"));
+var import_fs_extra7 = __toESM(require("fs-extra"));
+var import_path8 = __toESM(require("path"));
 var import_js_yaml2 = __toESM(require("js-yaml"));
 var import_minimatch = __toESM(require("minimatch"));
-var import_graphql10 = require("@tinacms/graphql");
+var import_graphql15 = require("@tinacms/graphql");
 var BODY_FIELD = {
   type: "rich-text",
   name: "body",
@@ -2546,17 +3230,17 @@ var stringifyLabel = (label) => {
   return label.replace(/[^a-zA-Z0-9]/g, "_").toLowerCase();
 };
 var generateAllCollections = async ({
-  rootPath: rootPath2
+  rootPath
 }) => {
-  const allTemplates = (await import_fs_extra8.default.readdir(
-    import_path10.default.join(rootPath2, ".forestry", "front_matter", "templates")
-  )).map((tem) => import_path10.default.basename(tem, ".yml"));
+  const allTemplates = (await import_fs_extra7.default.readdir(
+    import_path8.default.join(rootPath, ".forestry", "front_matter", "templates")
+  )).map((tem) => import_path8.default.basename(tem, ".yml"));
   const templateMap = /* @__PURE__ */ new Map();
   const proms = allTemplates.map(async (tem) => {
     try {
       const { fields, templateObj } = getFieldsFromTemplates({
         tem,
-        rootPath: rootPath2
+        rootPath
       });
       templateMap.set(tem, { fields, templateObj });
     } catch (e) {
@@ -2570,10 +3254,10 @@ var generateAllCollections = async ({
 };
 var generateCollections = async ({
   forestryPath,
-  rootPath: rootPath2
+  rootPath
 }) => {
-  const templateMap = await generateAllCollections({ rootPath: rootPath2 });
-  const forestryConfig = await import_fs_extra8.default.readFile(forestryPath);
+  const templateMap = await generateAllCollections({ rootPath });
+  const forestryConfig = await import_fs_extra7.default.readFile(forestryPath);
   const forestryYaml = import_js_yaml2.default.load(forestryConfig.toString());
   const forestrySchema = parseSections({ val: forestryYaml });
   const collections = [];
@@ -2611,10 +3295,10 @@ var generateCollections = async ({
               });
               (_a = templateObj == null ? void 0 : templateObj.pages) == null ? void 0 : _a.forEach((page) => {
                 try {
-                  const filePath = import_path10.default.join(rootPath2, page);
-                  const extname = import_path10.default.extname(filePath);
-                  const fileContent = import_fs_extra8.default.readFileSync(filePath).toString();
-                  const content2 = (0, import_graphql10.parseFile)(
+                  const filePath = import_path8.default.join(rootPath, page);
+                  const extname = import_path8.default.extname(filePath);
+                  const fileContent = import_fs_extra7.default.readFileSync(filePath).toString();
+                  const content2 = (0, import_graphql15.parseFile)(
                     fileContent,
                     extname,
                     (yup) => yup.object({})
@@ -2623,9 +3307,9 @@ var generateCollections = async ({
                     _template: stringifyLabel(tem),
                     ...content2
                   };
-                  import_fs_extra8.default.writeFileSync(
+                  import_fs_extra7.default.writeFileSync(
                     filePath,
-                    (0, import_graphql10.stringifyFile)(newContent, extname, true)
+                    (0, import_graphql15.stringifyFile)(newContent, extname, true)
                   );
                 } catch (error) {
                   console.log("Error updating file", page);
@@ -2660,10 +3344,10 @@ var generateCollections = async ({
               fields.push(...additionalFields);
               (_a = templateObj == null ? void 0 : templateObj.pages) == null ? void 0 : _a.forEach((page) => {
                 try {
-                  const filePath = import_path10.default.join(rootPath2, page);
-                  const extname = import_path10.default.extname(filePath);
-                  const fileContent = import_fs_extra8.default.readFileSync(filePath).toString();
-                  const content2 = (0, import_graphql10.parseFile)(
+                  const filePath = import_path8.default.join(rootPath, page);
+                  const extname = import_path8.default.extname(filePath);
+                  const fileContent = import_fs_extra7.default.readFileSync(filePath).toString();
+                  const content2 = (0, import_graphql15.parseFile)(
                     fileContent,
                     extname,
                     (yup) => yup.object({})
@@ -2672,9 +3356,9 @@ var generateCollections = async ({
                     _template: stringifyLabel(tem),
                     ...content2
                   };
-                  import_fs_extra8.default.writeFileSync(
+                  import_fs_extra7.default.writeFileSync(
                     filePath,
-                    (0, import_graphql10.stringifyFile)(newContent, extname, true)
+                    (0, import_graphql15.stringifyFile)(newContent, extname, true)
                   );
                 } catch (error) {
                   logger.log("Error updating file", page);
@@ -2715,8 +3399,11 @@ var generateCollections = async ({
 };
 
 // src/cmds/init/index.ts
-async function initStaticTina(ctx, next, options) {
-  const baseDir = ctx.rootPath;
+async function initStaticTina({
+  rootPath,
+  noTelemetry
+}) {
+  const baseDir = rootPath;
   logger.level = "info";
   const clientId = await chooseClientId();
   let token = null;
@@ -2727,24 +3414,24 @@ async function initStaticTina(ctx, next, options) {
   const framework = await chooseFramework();
   const usingTypescript = await chooseTypescript();
   const publicFolder = await choosePublicFolder({ framework });
-  const forestryPath = await hasForestryConfig({ rootPath: ctx.rootPath });
+  const forestryPath = await hasForestryConfig({ rootPath });
   let collections;
   if (forestryPath.exists) {
     collections = await forestryMigrate({
       forestryPath: forestryPath.path,
-      rootPath: ctx.rootPath
+      rootPath
     });
   }
   await reportTelemetry({
     usingTypescript,
     hasForestryConfig: forestryPath.exists,
-    noTelemetry: options.noTelemetry
+    noTelemetry
   });
-  const hasPackageJSON = await import_fs_extra9.default.pathExistsSync("package.json");
+  const hasPackageJSON = await import_fs_extra8.default.pathExistsSync("package.json");
   if (!hasPackageJSON) {
     await createPackageJSON();
   }
-  const hasGitignore = await import_fs_extra9.default.pathExistsSync(".gitignore");
+  const hasGitignore = await import_fs_extra8.default.pathExistsSync(".gitignore");
   if (!hasGitignore) {
     await createGitignore({ baseDir });
   } else {
@@ -2863,7 +3550,7 @@ var chooseFramework = async () => {
 };
 var forestryMigrate = async ({
   forestryPath,
-  rootPath: rootPath2
+  rootPath
 }) => {
   logger.info(
     `It looks like you have a ${focusText(
@@ -2897,7 +3584,7 @@ ${logText(
   });
   const collections = await generateCollections({
     forestryPath,
-    rootPath: rootPath2
+    rootPath
   });
   ErrorSingleton.getInstance().printNameErrors();
   return JSON.stringify(collections, null, 2);
@@ -2910,12 +3597,12 @@ var reportTelemetry = async ({
   if (noTelemetry) {
     logger.info(logText("Telemetry disabled"));
   }
-  const telemetry = new import_metrics3.Telemetry({ disabled: noTelemetry });
-  const schemaFileType2 = usingTypescript ? "ts" : "js";
+  const telemetry = new import_metrics2.Telemetry({ disabled: noTelemetry });
+  const schemaFileType = usingTypescript ? "ts" : "js";
   await telemetry.submitRecord({
     event: {
       name: "tinacms:cli:init:invoke",
-      schemaFileType: schemaFileType2,
+      schemaFileType,
       hasForestryConfig: hasForestryConfig2
     }
   });
@@ -2926,22 +3613,22 @@ var createPackageJSON = async () => {
 };
 var createGitignore = async ({ baseDir }) => {
   logger.info(logText("No .gitignore found, creating one"));
-  await import_fs_extra9.default.outputFileSync(import_path11.default.join(baseDir, ".gitignore"), "node_modules");
+  await import_fs_extra8.default.outputFileSync(import_path9.default.join(baseDir, ".gitignore"), "node_modules");
 };
 var checkGitignoreForNodeModules = async ({
   baseDir
 }) => {
-  const gitignoreContent = await import_fs_extra9.default.readFileSync(import_path11.default.join(baseDir, ".gitignore")).toString();
+  const gitignoreContent = await import_fs_extra8.default.readFileSync(import_path9.default.join(baseDir, ".gitignore")).toString();
   return gitignoreContent.split("\n").some((item) => item === "node_modules");
 };
 var addNodeModulesToGitignore = async ({ baseDir }) => {
   logger.info(logText("Adding node_modules to .gitignore"));
-  const gitignoreContent = await import_fs_extra9.default.readFileSync(import_path11.default.join(baseDir, ".gitignore")).toString();
+  const gitignoreContent = await import_fs_extra8.default.readFileSync(import_path9.default.join(baseDir, ".gitignore")).toString();
   const newGitignoreContent = [
     ...gitignoreContent.split("\n"),
     "node_modules"
   ].join("\n");
-  await import_fs_extra9.default.writeFileSync(import_path11.default.join(baseDir, ".gitignore"), newGitignoreContent);
+  await import_fs_extra8.default.writeFileSync(import_path9.default.join(baseDir, ".gitignore"), newGitignoreContent);
 };
 var addDependencies = async (packageManager) => {
   logger.info(logText("Adding dependencies, this might take a moment..."));
@@ -2956,12 +3643,12 @@ var addDependencies = async (packageManager) => {
 };
 var addConfigFile = async (args) => {
   const { baseDir, usingTypescript } = args;
-  const configPath = import_path11.default.join(
+  const configPath = import_path9.default.join(
     ".tina",
     `config.${usingTypescript ? "ts" : "js"}`
   );
-  const fullConfigPath = import_path11.default.join(baseDir, configPath);
-  if (import_fs_extra9.default.pathExistsSync(fullConfigPath)) {
+  const fullConfigPath = import_path9.default.join(baseDir, configPath);
+  if (import_fs_extra8.default.pathExistsSync(fullConfigPath)) {
     const override = await (0, import_prompts2.default)({
       name: "selection",
       type: "confirm",
@@ -2969,7 +3656,7 @@ var addConfigFile = async (args) => {
     });
     if (override["selection"]) {
       logger.info(logText(`Overriding file at ${configPath}.`));
-      await import_fs_extra9.default.outputFileSync(fullConfigPath, config(args));
+      await import_fs_extra8.default.outputFileSync(fullConfigPath, config2(args));
     } else {
       logger.info(logText(`Not overriding file at ${configPath}.`));
     }
@@ -2979,13 +3666,13 @@ var addConfigFile = async (args) => {
         `Adding config file at .tina/config.${usingTypescript ? "ts" : "js"}`
       )
     );
-    await import_fs_extra9.default.outputFileSync(fullConfigPath, config(args));
+    await import_fs_extra8.default.outputFileSync(fullConfigPath, config2(args));
   }
 };
 var addContentFile = async ({ baseDir }) => {
-  const contentPath = import_path11.default.join("content", "posts", "hello-world.md");
-  const fullContentPath = import_path11.default.join(baseDir, contentPath);
-  if (import_fs_extra9.default.pathExistsSync(fullContentPath)) {
+  const contentPath = import_path9.default.join("content", "posts", "hello-world.md");
+  const fullContentPath = import_path9.default.join(baseDir, contentPath);
+  if (import_fs_extra8.default.pathExistsSync(fullContentPath)) {
     const override = await (0, import_prompts2.default)({
       name: "selection",
       type: "confirm",
@@ -2993,13 +3680,13 @@ var addContentFile = async ({ baseDir }) => {
     });
     if (override["selection"]) {
       logger.info(logText(`Overriding file at ${contentPath}.`));
-      await import_fs_extra9.default.outputFileSync(fullContentPath, content);
+      await import_fs_extra8.default.outputFileSync(fullContentPath, content);
     } else {
       logger.info(logText(`Not overriding file at ${contentPath}.`));
     }
   } else {
     logger.info(logText(`Adding content file at ${contentPath}`));
-    await import_fs_extra9.default.outputFileSync(fullContentPath, content);
+    await import_fs_extra8.default.outputFileSync(fullContentPath, content);
   }
 };
 var logNextSteps = ({
@@ -3041,8 +3728,8 @@ var frameworkDevCmds = {
     return installText;
   }
 };
-var config = (args) => {
-  return (0, import_prettier.format)(configExamples[args.framework.name](args));
+var config2 = (args) => {
+  return (0, import_prettier.format)(configExamples[args.framework.name](args), { parser: "babel" });
 };
 var content = `---
 title: Hello, World!
@@ -3059,20 +3746,20 @@ var addReactiveFile = {
     baseDir,
     usingTypescript
   }) => {
-    const usingSrc = !import_fs_extra9.default.pathExistsSync(import_path11.default.join(baseDir, "pages"));
-    const pagesPath = import_path11.default.join(baseDir, usingSrc ? "src" : "", "pages");
-    const packageJSONPath = import_path11.default.join(baseDir, "package.json");
-    const tinaBlogPagePath = import_path11.default.join(pagesPath, "demo", "blog");
-    const tinaBlogPagePathFile = import_path11.default.join(
+    const usingSrc = !import_fs_extra8.default.pathExistsSync(import_path9.default.join(baseDir, "pages"));
+    const pagesPath = import_path9.default.join(baseDir, usingSrc ? "src" : "", "pages");
+    const packageJSONPath = import_path9.default.join(baseDir, "package.json");
+    const tinaBlogPagePath = import_path9.default.join(pagesPath, "demo", "blog");
+    const tinaBlogPagePathFile = import_path9.default.join(
       tinaBlogPagePath,
       `[filename].${usingTypescript ? "tsx" : "js"}`
     );
-    if (!import_fs_extra9.default.pathExistsSync(tinaBlogPagePathFile)) {
-      import_fs_extra9.default.mkdirpSync(tinaBlogPagePath);
-      import_fs_extra9.default.writeFileSync(tinaBlogPagePathFile, nextPostPage({ usingSrc }));
+    if (!import_fs_extra8.default.pathExistsSync(tinaBlogPagePathFile)) {
+      import_fs_extra8.default.mkdirpSync(tinaBlogPagePath);
+      import_fs_extra8.default.writeFileSync(tinaBlogPagePathFile, nextPostPage({ usingSrc }));
     }
     logger.info("Adding a nextjs example... \u2705");
-    const pack = JSON.parse(import_fs_extra9.default.readFileSync(packageJSONPath).toString());
+    const pack = JSON.parse(import_fs_extra8.default.readFileSync(packageJSONPath).toString());
     const oldScripts = pack.scripts || {};
     const newPack = JSON.stringify(
       {
@@ -3082,7 +3769,7 @@ var addReactiveFile = {
       null,
       2
     );
-    import_fs_extra9.default.writeFileSync(packageJSONPath, newPack);
+    import_fs_extra8.default.writeFileSync(packageJSONPath, newPack);
   }
 };
 function execShellCommand(cmd) {
@@ -3097,577 +3784,49 @@ function execShellCommand(cmd) {
   });
 }
 
-// src/buildTina/attachDatabase.ts
-var path10 = __toESM(require("path"));
-var import_datalayer2 = require("@tinacms/datalayer");
-var import_graphql11 = require("@tinacms/graphql");
-var import_fs_extra11 = __toESM(require("fs-extra"));
-
-// src/buildTina/git.ts
-var import_fs_extra10 = __toESM(require("fs-extra"));
-var import_ini = __toESM(require("ini"));
-var import_os = __toESM(require("os"));
-var import_path12 = __toESM(require("path"));
-var resolveGitRoot = async () => {
-  const pathParts = process.cwd().split(import_path12.default.sep);
-  while (true) {
-    const pathToGit = pathParts.join(import_path12.default.sep);
-    if (await import_fs_extra10.default.pathExists(import_path12.default.join(pathToGit, ".git"))) {
-      return pathToGit;
-    }
-    if (!pathParts.length) {
-      throw new Error(
-        "Unable to locate your .git folder (required for isomorphicGitBridge)"
-      );
-    }
-    pathParts.pop();
-  }
-};
-async function makeIsomorphicOptions(fsBridge) {
-  var _a, _b, _c, _d;
-  const gitRoot = await resolveGitRoot();
-  const options = {
-    gitRoot,
-    author: {
-      name: "",
-      email: ""
-    },
-    onPut: async (filepath, data) => {
-      await fsBridge.put(filepath, data);
-    },
-    onDelete: async (filepath) => {
-      await fsBridge.delete(filepath);
-    }
-  };
-  const userGitConfig = `${import_os.default.homedir()}${import_path12.default.sep}.gitconfig`;
-  if (await import_fs_extra10.default.pathExists(userGitConfig)) {
-    const config2 = import_ini.default.parse(await import_fs_extra10.default.readFile(userGitConfig, "utf-8"));
-    if ((_a = config2["user"]) == null ? void 0 : _a["name"]) {
-      options.author.name = config2["user"]["name"];
-    }
-    if ((_b = config2["user"]) == null ? void 0 : _b["email"]) {
-      options.author.email = config2["user"]["email"];
-    }
-  }
-  let repoGitConfig = void 0;
-  if (!options.author.name) {
-    repoGitConfig = import_ini.default.parse(
-      await import_fs_extra10.default.readFile(`${gitRoot}/.git/config`, "utf-8")
-    );
-    if ((_c = repoGitConfig["user"]) == null ? void 0 : _c["name"]) {
-      options.author.name = repoGitConfig["user"]["name"];
-    }
-    if (!options.author.name) {
-      throw new Error(
-        'Unable to determine user.name from git config. Hint: `git config --global user.name "John Doe"`'
-      );
-    }
-  }
-  if (!options.author.email) {
-    repoGitConfig = repoGitConfig || import_ini.default.parse(await import_fs_extra10.default.readFile(`${gitRoot}/.git/config`, "utf-8"));
-    if ((_d = repoGitConfig["user"]) == null ? void 0 : _d["email"]) {
-      options.author.email = repoGitConfig["user"]["email"];
-    }
-    if (!options.author.email) {
-      throw new Error(
-        "Unable to determine user.email from git config. Hint: `git config --global user.email johndoe@example.com`"
-      );
-    }
-  }
-  return options;
-}
-
-// src/buildTina/attachDatabase.ts
-var import_memory_level2 = require("memory-level");
-var import_many_level = require("many-level");
-var import_readable_stream = require("readable-stream");
-var import_net = require("net");
-var attachDatabase = async (ctx, next, _options) => {
-  const tinaPath = path10.join(ctx.rootPath, ".tina");
-  const tinaGeneratedPath = path10.join(tinaPath, "__generated__");
-  const tinaTempPath = path10.join(tinaGeneratedPath, `temp_database`);
-  const define = {};
-  if (!process.env.NODE_ENV) {
-    define["process.env.NODE_ENV"] = _options.dev ? '"development"' : '"production"';
-  }
-  const inputFile = getPath({
-    projectDir: path10.join(ctx.rootPath, ".tina"),
-    filename: "database",
-    allowedTypes: ["js", "jsx", "tsx", "ts"]
-  });
-  const fsBridge = new import_datalayer2.FilesystemBridge(ctx.rootPath);
-  const levelHost = new import_many_level.ManyLevelHost(
-    new import_memory_level2.MemoryLevel({
-      valueEncoding: "json"
-    })
-  );
-  const server = (0, import_net.createServer)(function(socket) {
-    (0, import_readable_stream.pipeline)(socket, levelHost.createRpcStream(), socket, () => {
-    });
-  });
-  server.listen(9e3);
-  ctx.dbServer = server;
-  if (inputFile) {
-    try {
-      await transpile(
-        inputFile,
-        "database.cjs",
-        tinaTempPath,
-        _options.verbose,
-        define,
-        path10.join(ctx.rootPath, "package.json"),
-        "node"
-      );
-    } catch (e) {
-      await import_fs_extra11.default.remove(tinaTempPath);
-      throw new BuildSchemaError(e);
-    }
-    Object.keys(require.cache).map((key) => {
-      if (key.startsWith(tinaTempPath)) {
-        delete require.cache[require.resolve(key)];
-      }
-    });
-    try {
-      const databaseFunc = require(path10.join(tinaTempPath, `database.cjs`));
-      ctx.database = databaseFunc.default;
-      ctx.database.bridge = fsBridge;
-      ctx.bridge = ctx.database.bridge;
-      ctx.isSelfHostedDatabase = true;
-      await import_fs_extra11.default.remove(tinaTempPath);
-    } catch (e) {
-      await import_fs_extra11.default.remove(tinaTempPath);
-      throw e;
-    }
-  } else {
-    const bridge = _options.isomorphicGitBridge ? new import_datalayer2.IsomorphicBridge(
-      ctx.rootPath,
-      _options.isomorphicGitBridge && await makeIsomorphicOptions(fsBridge)
-    ) : fsBridge;
-    const level = new import_graphql11.TinaLevelClient();
-    level.openConnection();
-    ctx.database = await (0, import_graphql11.createDatabase)({ level, bridge });
-    ctx.bridge = bridge;
-  }
-  next();
-};
-
-// src/cmds/statusChecks/checkClientInformation.ts
-var import_progress2 = __toESM(require("progress"));
-var import_graphql12 = require("graphql");
-var import_core2 = require("@graphql-inspector/core");
-var import_schema_tools2 = require("@tinacms/schema-tools");
-async function request(args) {
-  const headers = new Headers();
-  if (args.token) {
-    headers.append("X-API-KEY", args.token);
-  }
-  headers.append("Content-Type", "application/json");
-  const url = args == null ? void 0 : args.url;
-  const res = await fetch(url, {
-    method: "GET",
-    headers,
-    redirect: "follow"
-  });
-  const json = await res.json();
-  if (!res.ok) {
-    let additionalInfo = "";
-    if (res.status === 401 || res.status === 403) {
-      additionalInfo = "Please check that your client ID, URL and read only token are configured properly.";
-    }
-    if (json) {
-      additionalInfo += `
-
-Message from server: ${json.message}`;
-    }
-    throw new Error(
-      `Server responded with status code ${res.status}, ${res.statusText}. ${additionalInfo ? additionalInfo : ""} Please see our FAQ for more information: https://tina.io/docs/errors/faq/`
-    );
-  }
-  if (json.errors) {
-    throw new Error(
-      `Unable to fetch, please see our FAQ for more information: https://tina.io/docs/errors/faq/
-
-      Errors: 
-	${json.errors.map((error) => error.message).join("\n")}`
-    );
-  }
-  return {
-    status: json == null ? void 0 : json.status,
-    timestamp: json == null ? void 0 : json.timestamp
-  };
-}
-var checkClientInfo = async (ctx, next, _options) => {
-  var _a;
-  if (ctx.isSelfHostedDatabase) {
-    return next();
-  }
-  const config2 = (_a = ctx.schema) == null ? void 0 : _a.config;
-  const token = config2.token;
-  const { clientId, branch, host } = (0, import_schema_tools2.parseURL)(ctx.apiUrl);
-  const url = `https://${host}/db/${clientId}/status/${branch}`;
-  const bar = new import_progress2.default("Checking clientId, token and branch. :prog", 1);
-  try {
-    await request({
-      token,
-      url
-    });
-    bar.tick({
-      prog: "\u2705"
+// src/next/commands/init-command/index.ts
+var InitCommand = class extends import_clipanion4.Command {
+  constructor() {
+    super(...arguments);
+    this.rootPath = import_clipanion4.Option.String("--rootPath", {
+      description: "Specify the root directory to run the CLI from"
     });
-  } catch (e) {
-    bar.tick({
-      prog: "\u274C"
+    this.noTelemetry = import_clipanion4.Option.Boolean("--noTelemetry", false, {
+      description: "Disable anonymous telemetry that is collected"
     });
-    console.warn(
-      `Error when checking client information. You provided 
-
- ${JSON.stringify(
-        {
-          branch: config2 == null ? void 0 : config2.branch,
-          clientId: config2 == null ? void 0 : config2.clientId,
-          token: config2 == null ? void 0 : config2.token
-        },
-        null,
-        2
-      )}
-
- Please check you have the correct "clientId", "branch" and "token" configured. For more information see https://tina.io/docs/tina-cloud/connecting-site/`
-    );
-    throw e;
   }
-  next();
-};
-var fetchRemoteGraphqlSchema = async ({
-  url,
-  token
-}) => {
-  const headers = new Headers();
-  if (token) {
-    headers.append("X-API-KEY", token);
+  async catch(error) {
+    logger.error("Error occured during tinacms init");
+    console.error(error);
+    process.exit(1);
   }
-  const body = JSON.stringify({ query: (0, import_graphql12.getIntrospectionQuery)(), variables: {} });
-  headers.append("Content-Type", "application/json");
-  const res = await fetch(url, {
-    method: "POST",
-    headers,
-    body
-  });
-  const data = await res.json();
-  return data == null ? void 0 : data.data;
-};
-var checkGraphqlSchema = async (ctx, next, _options) => {
-  var _a;
-  const bar = new import_progress2.default(
-    "Checking local GraphQL Schema matches server. :prog",
-    1
-  );
-  const config2 = (_a = ctx.schema) == null ? void 0 : _a.config;
-  const token = config2.token;
-  const url = ctx.apiUrl;
-  const remoteSchema = await fetchRemoteGraphqlSchema({
-    url,
-    token
-  });
-  const remoteGqlSchema = (0, import_graphql12.buildClientSchema)(remoteSchema);
-  const localSchemaDocument = await ctx.database.getGraphQLSchemaFromBridge();
-  const localGraphqlSchema = (0, import_graphql12.buildSchema)((0, import_graphql12.print)(localSchemaDocument));
-  const diffResult = await (0, import_core2.diff)(localGraphqlSchema, remoteGqlSchema);
-  if (diffResult.length === 0) {
-    bar.tick({
-      prog: "\u2705"
-    });
-  } else {
-    bar.tick({
-      prog: "\u274C"
+  async execute() {
+    await initStaticTina({
+      rootPath: this.rootPath || process.cwd(),
+      noTelemetry: this.noTelemetry
     });
-    let errorMessage = `The local GraphQL schema doesn't match the remote GraphQL schema. Please push up your changes to Github to update your remote GraphQL schema.`;
-    if (config2 == null ? void 0 : config2.branch) {
-      errorMessage += `
-
-Additional info: Branch: ${config2.branch}, Client ID: ${config2.clientId} `;
-    }
-    throw new Error(errorMessage);
+    process.exit();
   }
-  next();
-};
-
-// src/cmds/baseCmds.ts
-var CMD_START_SERVER = "server:start";
-var CMD_DEV = "dev";
-var INIT = "init";
-var AUDIT = "audit";
-var CMD_BUILD = "build";
-var startServerPortOption = {
-  name: "--port <port>",
-  description: "Specify a port to run the server on. (default 4001)"
 };
-var rootPathOption = {
-  name: "--rootPath <rootPath>",
-  description: "Specify the root directory to run the CLI from (defaults to current working directory)"
-};
-var experimentalDatalayer = {
-  name: "--experimentalData",
-  description: "Build the server with additional data querying capabilities"
-};
-var isomorphicGitBridge = {
-  name: "--isomorphicGitBridge",
-  description: "Enable Isomorphic Git Bridge Implementation"
-};
-var schemaFileType = {
-  name: "--schemaFileType [fileType]",
-  description: "The file type to use for the Tina schema"
-};
-var subCommand = {
-  name: "-c, --command <command>",
-  description: "The sub-command to run"
-};
-var noWatchOption = {
-  name: "--noWatch",
-  description: "Don't regenerate config on file changes"
-};
-var noSDKCodegenOption = {
-  name: "--noSDK",
-  description: "Don't generate the generated client SDK"
-};
-var cleanOption = {
-  name: "--clean",
-  description: "Updates all content files to remove any data not explicitly permitted by the current schema definition"
-};
-var useDefaultValuesOption = {
-  name: "--useDefaultValues",
-  description: "Adds default values to the graphQL mutation so that default values can be filled into existing documents (useful for adding a field with `required: true`)"
-};
-var noTelemetryOption = {
-  name: "--noTelemetry",
-  description: "Disable anonymous telemetry that is collected"
-};
-var watchFileOption = {
-  name: "-w, --watchFolders [folders...]",
-  description: "a list of folders (relative to where this is being run) that the cli will watch for changes"
-};
-var verboseOption = {
-  name: "-v, --verbose",
-  description: "increase verbosity of logged output",
-  defaultValue: false
-};
-var developmentOption = {
-  name: "--dev",
-  description: "Uses NODE_ENV=development when compiling client and schema"
-};
-var localOption = {
-  name: "--local",
-  description: "Uses the local file system graphql server",
-  defaultValue: false
-};
-var checkOptions = async (_ctx, next, options) => {
-  if (options == null ? void 0 : options.experimentalData) {
-    logger.warn(
-      warnText(
-        "Warning: you are using the `--experimentalData`flag. This flag is not needed and can safely be removed. It will be deprecated in a future version"
-      )
-    );
-  }
-  next();
-};
-var baseCmds = [
-  {
-    command: CMD_START_SERVER,
-    description: "Start Filesystem Graphql Server",
-    options: [
-      startServerPortOption,
-      subCommand,
-      experimentalDatalayer,
-      isomorphicGitBridge,
-      noWatchOption,
-      noSDKCodegenOption,
-      noTelemetryOption,
-      watchFileOption,
-      verboseOption,
-      developmentOption,
-      localOption
-    ],
-    action: (options) => chain(
-      [
-        attachPath,
-        attachDatabase,
-        async (ctx, next, _2) => {
-          logger.warn(
-            warnText(
-              "server:start will be deprecated in the future, please use `tinacms dev` instead"
-            )
-          );
-          next();
-        },
-        checkOptions,
-        buildSetupCmdServerStart,
-        startServer,
-        startSubprocess
-      ],
-      options
-    )
-  },
-  {
-    command: CMD_DEV,
-    description: "Builds tina and starts the dev server.",
-    options: [
-      startServerPortOption,
-      subCommand,
-      isomorphicGitBridge,
-      noWatchOption,
-      noSDKCodegenOption,
-      noTelemetryOption,
-      watchFileOption,
-      verboseOption,
-      rootPathOption
-    ],
-    action: (options) => chain(
-      [
-        attachPath,
-        attachDatabase,
-        checkOptions,
-        buildSetupCmdServerStart,
-        startServer,
-        startSubprocess
-      ],
-      options
-    )
-  },
-  {
-    command: CMD_BUILD,
-    description: "Build Tina",
-    options: [
-      experimentalDatalayer,
-      isomorphicGitBridge,
-      noSDKCodegenOption,
-      noTelemetryOption,
-      verboseOption,
-      developmentOption,
-      localOption,
-      rootPathOption
-    ],
-    action: (options) => chain(
-      [
-        attachPath,
-        attachDatabase,
-        checkOptions,
-        buildSetupCmdBuild,
-        buildCmdBuild,
-        checkClientInfo,
-        waitForDB,
-        checkGraphqlSchema,
-        indexIntoSelfHostedDatabase
-      ],
-      options
-    )
-  },
-  {
-    command: INIT,
-    options: [
-      rootPathOption,
-      experimentalDatalayer,
-      isomorphicGitBridge,
-      noTelemetryOption,
-      schemaFileType
-    ],
-    description: "Add Tina Cloud to an existing project",
-    action: (options) => {
-      chain([attachPath, checkOptions, initStaticTina], options);
-    }
-  },
-  {
-    options: [
-      rootPathOption,
-      cleanOption,
-      useDefaultValuesOption,
-      noTelemetryOption,
-      verboseOption
-    ],
-    command: AUDIT,
-    description: "Audit your schema and the files to check for errors",
-    action: (options) => chain(
-      [
-        attachPath,
-        buildSetupCmdAudit,
-        auditCmdBuild,
-        async (_ctx, next) => {
-          logger.level = "info";
-          logger.info(
-            import_chalk4.default.hex("#eb6337").bgWhite("Welcome to tina audit \u{1F999}")
-          );
-          next();
-        },
-        audit,
-        printFinalMessage
-      ],
-      options
-    )
-  }
-];
+InitCommand.paths = [["init"]];
+InitCommand.usage = import_clipanion4.Command.Usage({
+  category: `Commands`,
+  description: `Add Tina to an existing project`
+});
 
 // src/index.ts
-var program = new commander.Command(name);
-var registerCommands = (commands, noHelp = false) => {
-  commands.forEach((command, i) => {
-    let newCmd = program.command(command.command, { noHelp }).description(command.description).action((...args) => {
-      command.action(...args);
-    });
-    if (command.alias) {
-      newCmd = newCmd.alias(command.alias);
-    }
-    newCmd.on("--help", function() {
-      if (command.examples) {
-        logger.info(`
-Examples:
-  ${command.examples}`);
-      }
-      if (command.subCommands) {
-        logger.info("\nCommands:");
-        const optionTag = " [options]";
-        command.subCommands.forEach((subcommand, i2) => {
-          const commandStr = `${subcommand.command}${(subcommand.options || []).length ? optionTag : ""}`;
-          const padLength = Math.max(...command.subCommands.map((sub) => sub.command.length)) + optionTag.length;
-          logger.info(
-            `${commandStr.padEnd(padLength)} ${subcommand.description}`
-          );
-        });
-      }
-      logger.info("");
-    });
-    (command.options || []).forEach((option) => {
-      newCmd.option(option.name, option.description, option == null ? void 0 : option.defaultValue);
-    });
-    if (command.subCommands) {
-      registerCommands(command.subCommands, true);
-    }
-  });
-};
-async function init(args) {
-  program.version(version);
-  const commands = [...baseCmds];
-  registerCommands(commands);
-  program.usage("command [options]");
-  program.on("command:*", function() {
-    logger.error(
-      "Invalid command: %s\nSee --help for a list of available commands.",
-      args.join(" ")
-    );
-    process.exit(1);
-  });
-  program.on("--help", function() {
-    logger.info(
-      logText(`
-You can get help on any command with "-h" or "--help".
-e.g: "tinacms server:start --help"
-    `)
-    );
-  });
-  if (!process.argv.slice(2).length) {
-    program.help();
-  }
-  program.parse(args);
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  defineSchema,
-  init
+var cli = new import_clipanion5.Cli({
+  binaryName: `tinacms`,
+  binaryLabel: `TinaCMS`,
+  binaryVersion: version
 });
+cli.register(DevCommand);
+cli.register(BuildCommand);
+cli.register(AuditCommand);
+cli.register(InitCommand);
+cli.register(import_clipanion5.Builtins.DefinitionsCommand);
+cli.register(import_clipanion5.Builtins.HelpCommand);
+cli.register(import_clipanion5.Builtins.VersionCommand);
+var src_default = cli;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});