@tinacms/cli 0.0.0-a63a1f5-20251124043708 → 0.0.0-a6b1b39-20251217041730

package/dist/index.js

@@ -1,53 +1,20 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name2 in all)
-    __defProp(target, name2, { get: all[name2], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
 // src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  default: () => index_default
-});
-module.exports = __toCommonJS(index_exports);
-var import_clipanion8 = require("clipanion");
+import { Cli, Builtins } from "clipanion";
 
 // package.json
-var version = "1.12.4";
+var version = "2.0.3";
 
 // src/next/commands/dev-command/index.ts
-var import_path7 = __toESM(require("path"));
-var import_graphql10 = require("@tinacms/graphql");
-var import_search = require("@tinacms/search");
-var import_async_lock = __toESM(require("async-lock"));
-var import_chokidar = __toESM(require("chokidar"));
-var import_clipanion2 = require("clipanion");
-var import_fs_extra6 = __toESM(require("fs-extra"));
+import path8 from "path";
+import { FilesystemBridge as FilesystemBridge2, buildSchema } from "@tinacms/graphql";
+import { LocalSearchIndexClient, SearchIndexer } from "@tinacms/search";
+import AsyncLock from "async-lock";
+import chokidar from "chokidar";
+import { Command as Command2, Option as Option2 } from "clipanion";
+import fs7 from "fs-extra";
 
 // src/logger/index.ts
-var import_chalk = __toESM(require("chalk"));
+import chalk from "chalk";
 
 // src/logger/is-unicode-supported.ts
 function isUnicodeSupported() {
@@ -61,15 +28,15 @@ function isUnicodeSupported() {
 }
 
 // src/logger/index.ts
-var import_log4js = __toESM(require("log4js"));
-var logger = import_log4js.default.getLogger();
-import_log4js.default.configure({
-  appenders: {
-    out: { type: "stdout", layout: { type: "messagePassThrough" } }
-  },
-  categories: { default: { appenders: ["out"], level: "info" } }
-});
-logger.level = "info";
+var logger = {
+  level: "info",
+  info: (msg) => process.stdout.write(msg + "\n"),
+  warn: (msg) => process.stdout.write(msg + "\n"),
+  error: (msg) => process.stderr.write(msg + "\n"),
+  debug: (msg) => {
+    if (logger.level === "debug") process.stdout.write(msg + "\n");
+  }
+};
 function ansiRegex() {
   const pattern = [
     "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
@@ -88,18 +55,18 @@ ${message}
     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(
+    (ln) => `${chalk.gray(bar)}  ${chalk.white(ln)}${" ".repeat(
       len - strip(ln).length
-    )}${import_chalk.default.gray(bar)}`
+    )}${chalk.gray(bar)}`
   ).join("\n");
   const underscoreLen = len - title.length - 1 > 0 ? len - title.length - 1 : 0;
   process.stdout.write(
-    `${import_chalk.default.gray(bar)}
-${import_chalk.default.green("\u25CB")}  ${import_chalk.default.reset(
+    `${chalk.gray(bar)}
+${chalk.green("\u25CB")}  ${chalk.reset(
       title
-    )} ${import_chalk.default.gray("\u2500".repeat(underscoreLen) + "\u256E")}
+    )} ${chalk.gray("\u2500".repeat(underscoreLen) + "\u256E")}
 ${msg}
-${import_chalk.default.gray(
+${chalk.gray(
       "\u251C" + "\u2500".repeat(len + 2) + "\u256F"
     )}
 `
@@ -116,11 +83,11 @@ var summary = (content) => {
     });
   });
   content.items.forEach((item) => {
-    outString.push(`${item.emoji} ${import_chalk.default.cyan(item.heading)}`);
+    outString.push(`${item.emoji} ${chalk.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.key}:${[...Array(spaces)].join(" ")}${chalk.cyan(
           subItem.value
         )}`
       );
@@ -158,12 +125,12 @@ var S_WARN = s("\u25B2", "!");
 var S_ERROR = s("\u25A0", "x");
 
 // src/utils/spinner.ts
-var import_cli_spinner = require("cli-spinner");
+import { Spinner } from "cli-spinner";
 async function localSpin({
   waitFor,
   text
 }) {
-  const spinner = new import_cli_spinner.Spinner({
+  const spinner = new Spinner({
     text: `${text} %s`,
     stream: process.stderr,
     onTick: function(msg) {
@@ -194,32 +161,32 @@ function spin({
 }
 
 // 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;
+import chalk2 from "chalk";
+var successText = chalk2.bold.green;
+var focusText = chalk2.bold;
+var dangerText = chalk2.bold.red;
+var neutralText = chalk2.bold.cyan;
+var linkText = chalk2.bold.cyan;
+var labelText = chalk2.bold;
+var cmdText = chalk2.inverse;
 var indentedCmd = (str) => {
   return `  \u2503 ` + str;
 };
 var indentText = (str) => {
   return String(str).split("\n").map((line) => `   ${line}`).join("\n");
 };
-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");
+var logText = chalk2.italic.gray;
+var warnText = chalk2.yellowBright.bgBlack;
+var titleText = chalk2.bgHex("d2f1f8").hex("ec4816");
+var CONFIRMATION_TEXT = chalk2.dim("enter to confirm");
 
 // src/next/codegen/index.ts
-var import_fs_extra = __toESM(require("fs-extra"));
-var import_path = __toESM(require("path"));
-var import_graphql5 = require("graphql");
+import fs from "fs-extra";
+import path from "path";
+import { buildASTSchema, printSchema as printSchema2 } from "graphql";
 
 // src/next/codegen/codegen/index.ts
-var import_graphql4 = require("graphql");
+import { parse, printSchema } from "graphql";
 
 // src/next/codegen/codegen/plugin.ts
 var AddGeneratedClientFunc = (apiURL) => {
@@ -288,37 +255,44 @@ var AddGeneratedClient = (apiURL) => ({
 });
 
 // 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");
+import { GraphQLFileLoader } from "@graphql-tools/graphql-file-loader";
+import { codegen } from "@graphql-codegen/core";
+import { loadDocuments } from "@graphql-tools/load";
+import { plugin as typescriptOperationsPlugin } from "@graphql-codegen/typescript-operations";
+import { plugin as typescriptPlugin } from "@graphql-codegen/typescript";
 
 // src/next/codegen/codegen/sdkPlugin/index.ts
-var import_graphql2 = require("graphql");
-var import_graphql3 = require("graphql");
+import { visit } from "graphql";
+import {
+  concatAST,
+  Kind as Kind2
+} from "graphql";
 
 // 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_graphql = require("graphql");
-var GenericSdkVisitor = class extends import_visitor_plugin_common.ClientSideBaseVisitor {
+import {
+  ClientSideBaseVisitor,
+  DocumentMode,
+  indentMultiline
+} from "@graphql-codegen/visitor-plugin-common";
+import autoBind from "auto-bind";
+import { Kind, print } from "graphql";
+var GenericSdkVisitor = class extends ClientSideBaseVisitor {
+  _operationsToInclude = [];
   constructor(schema, fragments, rawConfig) {
     super(schema, fragments, rawConfig, {
       usingObservableFrom: rawConfig.usingObservableFrom
     });
-    this._operationsToInclude = [];
-    (0, import_auto_bind.default)(this);
+    autoBind(this);
     if (this.config.usingObservableFrom) {
       this._additionalImports.push(this.config.usingObservableFrom);
     }
-    if (this.config.documentMode !== import_visitor_plugin_common.DocumentMode.string) {
+    if (this.config.documentMode !== DocumentMode.string) {
     }
   }
   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_graphql.print)(node)
+        "Plugin 'generic-sdk' cannot generate SDK for unnamed operation.\n\n" + print(node)
       );
     } else {
       this._operationsToInclude.push({
@@ -336,14 +310,14 @@ 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_graphql.Kind.NON_NULL_TYPE || v.defaultValue
+        (v) => v.type.kind !== 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((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>"}
+    }).map((s2) => indentMultiline(s2, 2));
+    return `export type Requester<C= {}> = <R, V>(doc: ${this.config.documentMode === DocumentMode.string ? "string" : "DocumentNode"}, vars?: V, options?: C) => ${usingObservable ? "Promise<R> & Observable<R>" : "Promise<R>"}
   export function getSdk<C>(requester: Requester<C>) {
     return {
   ${allPossibleActions.join(",\n")}
@@ -355,14 +329,14 @@ var GenericSdkVisitor = class extends import_visitor_plugin_common.ClientSideBas
 
 // src/next/codegen/codegen/sdkPlugin/index.ts
 var plugin = (schema, documents, config2) => {
-  const allAst = (0, import_graphql3.concatAST)(
+  const allAst = concatAST(
     documents.reduce((prev, v) => {
       return [...prev, v.document];
     }, [])
   );
   const allFragments = [
     ...allAst.definitions.filter(
-      (d) => d.kind === import_graphql3.Kind.FRAGMENT_DEFINITION
+      (d) => d.kind === Kind2.FRAGMENT_DEFINITION
     ).map((fragmentDef) => ({
       node: fragmentDef,
       name: fragmentDef.name.value,
@@ -372,7 +346,7 @@ var plugin = (schema, documents, config2) => {
     ...config2.externalFragments || []
   ];
   const visitor = new GenericSdkVisitor(schema, allFragments, config2);
-  const visitorResult = (0, import_graphql2.visit)(allAst, { leave: visitor });
+  const visitorResult = visit(allAst, { leave: visitor });
   return {
     // We will take care of imports
     // prepend: visitor.getImports(),
@@ -390,10 +364,10 @@ var generateTypes = async (schema, queryPathGlob = process.cwd(), fragDocPath =
   let fragDocs = [];
   docs = await loadGraphQLDocuments(queryPathGlob);
   fragDocs = await loadGraphQLDocuments(fragDocPath);
-  const res = await (0, import_core.codegen)({
+  const res = await codegen({
     // Filename is not used. This is because the typescript plugin returns a string instead of writing to a file.
     filename: process.cwd(),
-    schema: (0, import_graphql4.parse)((0, import_graphql4.printSchema)(schema)),
+    schema: parse(printSchema(schema)),
     documents: [...docs, ...fragDocs],
     config: {},
     plugins: [
@@ -406,10 +380,10 @@ var generateTypes = async (schema, queryPathGlob = process.cwd(), fragDocPath =
     ],
     pluginMap: {
       typescript: {
-        plugin: import_typescript.plugin
+        plugin: typescriptPlugin
       },
       typescriptOperations: {
-        plugin: import_typescript_operations.plugin
+        plugin: typescriptOperationsPlugin
       },
       typescriptSdk: {
         plugin
@@ -422,8 +396,8 @@ var generateTypes = async (schema, queryPathGlob = process.cwd(), fragDocPath =
 var loadGraphQLDocuments = async (globPath) => {
   let result = [];
   try {
-    result = await (0, import_load.loadDocuments)(globPath, {
-      loaders: [new import_graphql_file_loader.GraphQLFileLoader()]
+    result = await loadDocuments(globPath, {
+      loaders: [new GraphQLFileLoader()]
     });
   } catch (e) {
     if (
@@ -440,11 +414,27 @@ var loadGraphQLDocuments = async (globPath) => {
 };
 
 // src/next/codegen/index.ts
-var import_esbuild = require("esbuild");
-var import_graphql6 = require("@tinacms/graphql");
-var import_normalize_path = __toESM(require("normalize-path"));
+import { transform } from "esbuild";
+import { mapUserFields } from "@tinacms/graphql";
+import normalizePath from "normalize-path";
 var TINA_HOST = "content.tinajs.io";
 var Codegen = class {
+  configManager;
+  port;
+  schema;
+  queryDoc;
+  fragDoc;
+  isLocal;
+  // The API url used in the client
+  apiURL;
+  // This is always the local URL.
+  localUrl;
+  // production url
+  productionUrl;
+  graphqlSchemaDoc;
+  tinaSchema;
+  lookup;
+  noClientBuildCache;
   constructor({
     configManager,
     port,
@@ -460,7 +450,7 @@ var Codegen = class {
     this.graphqlSchemaDoc = graphqlSchemaDoc;
     this.configManager = configManager;
     this.port = port;
-    this.schema = (0, import_graphql5.buildASTSchema)(graphqlSchemaDoc);
+    this.schema = buildASTSchema(graphqlSchemaDoc);
     this.tinaSchema = tinaSchema;
     this.queryDoc = queryDoc;
     this.fragDoc = fragDoc;
@@ -468,19 +458,19 @@ var Codegen = class {
     this.noClientBuildCache = noClientBuildCache;
   }
   async writeConfigFile(fileName, data) {
-    const filePath = import_path.default.join(
+    const filePath = path.join(
       this.configManager.generatedFolderPath,
       fileName
     );
-    await import_fs_extra.default.ensureFile(filePath);
-    await import_fs_extra.default.outputFile(filePath, data);
+    await fs.ensureFile(filePath);
+    await fs.outputFile(filePath, data);
     if (this.configManager.hasSeparateContentRoot()) {
-      const filePath2 = import_path.default.join(
+      const filePath2 = path.join(
         this.configManager.generatedFolderPathContentRepo,
         fileName
       );
-      await import_fs_extra.default.ensureFile(filePath2);
-      await import_fs_extra.default.outputFile(filePath2, data);
+      await fs.ensureFile(filePath2);
+      await fs.outputFile(filePath2, data);
     }
   }
   async removeGeneratedFilesIfExists() {
@@ -512,11 +502,11 @@ var Codegen = class {
       await this.removeGeneratedFilesIfExists();
       return apiURL;
     }
-    await import_fs_extra.default.outputFile(
+    await fs.outputFile(
       this.configManager.generatedQueriesFilePath,
       this.queryDoc
     );
-    await import_fs_extra.default.outputFile(
+    await fs.outputFile(
       this.configManager.generatedFragmentsFilePath,
       this.fragDoc
     );
@@ -524,21 +514,21 @@ var Codegen = class {
     const { clientString } = await this.genClient();
     const databaseClientString = this.configManager.hasSelfHostedConfig() ? await this.genDatabaseClient() : "";
     const { codeString, schemaString } = await this.genTypes();
-    await import_fs_extra.default.outputFile(
+    await fs.outputFile(
       this.configManager.generatedGraphQLGQLPath,
       schemaString
     );
     if (this.configManager.isUsingTs()) {
-      await import_fs_extra.default.outputFile(
+      await fs.outputFile(
         this.configManager.generatedTypesTSFilePath,
         codeString
       );
-      await import_fs_extra.default.outputFile(
+      await fs.outputFile(
         this.configManager.generatedClientTSFilePath,
         clientString
       );
       if (this.configManager.hasSelfHostedConfig()) {
-        await import_fs_extra.default.outputFile(
+        await fs.outputFile(
           this.configManager.generatedDatabaseClientTSFilePath,
           databaseClientString
         );
@@ -547,35 +537,35 @@ var Codegen = class {
       await unlinkIfExists(this.configManager.generatedTypesDFilePath);
       await unlinkIfExists(this.configManager.generatedTypesJSFilePath);
     } else {
-      await import_fs_extra.default.outputFile(
+      await fs.outputFile(
         this.configManager.generatedTypesDFilePath,
         codeString
       );
-      const jsTypes = await (0, import_esbuild.transform)(codeString, { loader: "ts" });
-      await import_fs_extra.default.outputFile(
+      const jsTypes = await transform(codeString, { loader: "ts" });
+      await fs.outputFile(
         this.configManager.generatedTypesJSFilePath,
         jsTypes.code
       );
-      await import_fs_extra.default.outputFile(
+      await fs.outputFile(
         this.configManager.generatedClientDFilePath,
         clientString
       );
-      const jsClient = await (0, import_esbuild.transform)(clientString, { loader: "ts" });
-      await import_fs_extra.default.outputFile(
+      const jsClient = await transform(clientString, { loader: "ts" });
+      await fs.outputFile(
         this.configManager.generatedClientJSFilePath,
         jsClient.code
       );
       await unlinkIfExists(this.configManager.generatedTypesTSFilePath);
       await unlinkIfExists(this.configManager.generatedClientTSFilePath);
       if (this.configManager.hasSelfHostedConfig()) {
-        const jsDatabaseClient = await (0, import_esbuild.transform)(databaseClientString, {
+        const jsDatabaseClient = await transform(databaseClientString, {
           loader: "ts"
         });
-        await import_fs_extra.default.outputFile(
+        await fs.outputFile(
           this.configManager.generatedDatabaseClientJSFilePath,
           jsDatabaseClient.code
         );
-        await import_fs_extra.default.outputFile(
+        await fs.outputFile(
           this.configManager.generatedDatabaseClientDFilePath,
           databaseClientString
         );
@@ -623,7 +613,7 @@ var Codegen = class {
     const authCollection = this.tinaSchema.getCollections().find((c) => c.isAuthCollection);
     let authFields = [];
     if (authCollection) {
-      const usersFields = (0, import_graphql6.mapUserFields)(authCollection, []);
+      const usersFields = mapUserFields(authCollection, []);
       if (usersFields.length === 0) {
         throw new Error("No user field found");
       }
@@ -713,7 +703,7 @@ export default databaseClient;
     const apiURL = this.getApiURL();
     const clientString = `import { createClient } from "tinacms/dist/client";
 import { queries } from "./types";
-export const client = createClient({ ${this.noClientBuildCache === false ? `cacheDir: '${(0, import_normalize_path.default)(
+export const client = createClient({ ${this.noClientBuildCache === false ? `cacheDir: '${normalizePath(
       this.configManager.generatedCachePath
     )}', ` : ""}url: '${apiURL}', token: '${token}', queries, ${errorPolicy ? `errorPolicy: '${errorPolicy}'` : ""} });
 export default client;
@@ -739,7 +729,7 @@ export default client;
   ${typescriptTypes}
   `;
     const schemaString = `# DO NOT MODIFY THIS FILE. This file is automatically generated by Tina
-${(0, import_graphql5.printSchema)(this.schema)}
+${printSchema2(this.schema)}
 schema {
   query: Query
   mutation: Mutation
@@ -751,7 +741,7 @@ schema {
 var maybeWarnFragmentSize = async (filepath) => {
   if (
     // is the file bigger than 100kb?
-    (await import_fs_extra.default.stat(filepath)).size > // convert to 100 kb to bytes
+    (await fs.stat(filepath)).size > // convert to 100 kb to bytes
     100 * 1024
   ) {
     console.warn(
@@ -768,26 +758,28 @@ var maybeWarnFragmentSize = async (filepath) => {
   }
 };
 var unlinkIfExists = async (filepath) => {
-  if (import_fs_extra.default.existsSync(filepath)) {
-    import_fs_extra.default.unlinkSync(filepath);
+  if (fs.existsSync(filepath)) {
+    fs.unlinkSync(filepath);
   }
 };
 
 // src/next/config-manager.ts
-var import_fs_extra2 = __toESM(require("fs-extra"));
-var import_path3 = __toESM(require("path"));
-var import_os = __toESM(require("os"));
-var esbuild = __toESM(require("esbuild"));
-var dotenv = __toESM(require("dotenv"));
-var import_normalize_path2 = __toESM(require("normalize-path"));
-var import_chalk3 = __toESM(require("chalk"));
+import fs2 from "fs-extra";
+import path3 from "path";
+import os from "os";
+import { pathToFileURL } from "url";
+import * as esbuild from "esbuild";
+import * as dotenv from "dotenv";
+import normalizePath2 from "normalize-path";
+import chalk3 from "chalk";
+import { createRequire } from "module";
 
 // src/utils/path.ts
-var import_path2 = __toESM(require("path"));
+import path2 from "path";
 function stripNativeTrailingSlash(p) {
-  const { root } = import_path2.default.parse(p);
+  const { root } = path2.parse(p);
   let str = p;
-  while (str.length > root.length && str.endsWith(import_path2.default.sep)) {
+  while (str.length > root.length && str.endsWith(path2.sep)) {
     str = str.slice(0, -1);
   }
   return str;
@@ -802,17 +794,57 @@ var GRAPHQL_GQL_FILE = "schema.gql";
 var SCHEMA_JSON_FILE = "_schema.json";
 var LOOKUP_JSON_FILE = "_lookup.json";
 var ConfigManager = class {
+  config;
+  rootPath;
+  tinaFolderPath;
+  isUsingLegacyFolder;
+  tinaConfigFilePath;
+  tinaSpaPackagePath;
+  contentRootPath;
+  envFilePath;
+  generatedCachePath;
+  generatedFolderPath;
+  generatedFolderPathContentRepo;
+  generatedGraphQLGQLPath;
+  generatedGraphQLJSONPath;
+  generatedSchemaJSONPath;
+  generatedLookupJSONPath;
+  generatedTypesTSFilePath;
+  generatedTypesJSFilePath;
+  generatedTypesDFilePath;
+  generatedClientTSFilePath;
+  generatedClientJSFilePath;
+  generatedClientDFilePath;
+  generatedDatabaseClientJSFilePath;
+  generatedDatabaseClientTSFilePath;
+  generatedDatabaseClientDFilePath;
+  generatedQueriesFilePath;
+  generatedFragmentsFilePath;
+  generatedQueriesAndFragmentsGlob;
+  userQueriesAndFragmentsGlob;
+  publicFolderPath;
+  outputFolderPath;
+  outputHTMLFilePath;
+  outputGitignorePath;
+  selfHostedDatabaseFilePath;
+  prebuildFilePath;
+  spaRootPath;
+  spaMainPath;
+  spaHTMLPath;
+  tinaGraphQLVersionFromCLI;
+  legacyNoSDK;
+  watchList;
   constructor({
     rootPath = process.cwd(),
     tinaGraphQLVersion,
     legacyNoSDK
   }) {
-    this.rootPath = (0, import_normalize_path2.default)(rootPath);
+    this.rootPath = normalizePath2(rootPath);
     this.tinaGraphQLVersionFromCLI = tinaGraphQLVersion;
     this.legacyNoSDK = legacyNoSDK;
   }
   isUsingTs() {
-    return [".ts", ".tsx"].includes(import_path3.default.extname(this.tinaConfigFilePath));
+    return [".ts", ".tsx"].includes(path3.extname(this.tinaConfigFilePath));
   }
   hasSelfHostedConfig() {
     return !!this.selfHostedDatabaseFilePath;
@@ -827,13 +859,14 @@ var ConfigManager = class {
     return this.config.client?.skip || false;
   }
   async processConfig() {
+    const require2 = createRequire(import.meta.url);
     this.tinaFolderPath = await this.getTinaFolderPath(this.rootPath);
-    this.envFilePath = import_path3.default.resolve(
-      import_path3.default.join(this.tinaFolderPath, "..", ".env")
+    this.envFilePath = path3.resolve(
+      path3.join(this.tinaFolderPath, "..", ".env")
     );
     dotenv.config({ path: this.envFilePath });
     this.tinaConfigFilePath = await this.getPathWithExtension(
-      import_path3.default.join(this.tinaFolderPath, "config")
+      path3.join(this.tinaFolderPath, "config")
     );
     if (!this.tinaConfigFilePath) {
       throw new Error(
@@ -841,89 +874,89 @@ var ConfigManager = class {
       );
     }
     this.selfHostedDatabaseFilePath = await this.getPathWithExtension(
-      import_path3.default.join(this.tinaFolderPath, "database")
+      path3.join(this.tinaFolderPath, "database")
     );
-    this.generatedFolderPath = import_path3.default.join(this.tinaFolderPath, GENERATED_FOLDER);
-    this.generatedCachePath = import_path3.default.join(
+    this.generatedFolderPath = path3.join(this.tinaFolderPath, GENERATED_FOLDER);
+    this.generatedCachePath = path3.join(
       this.generatedFolderPath,
       ".cache",
       String((/* @__PURE__ */ new Date()).getTime())
     );
-    this.generatedGraphQLGQLPath = import_path3.default.join(
+    this.generatedGraphQLGQLPath = path3.join(
       this.generatedFolderPath,
       GRAPHQL_GQL_FILE
     );
-    this.generatedGraphQLJSONPath = import_path3.default.join(
+    this.generatedGraphQLJSONPath = path3.join(
       this.generatedFolderPath,
       GRAPHQL_JSON_FILE
     );
-    this.generatedSchemaJSONPath = import_path3.default.join(
+    this.generatedSchemaJSONPath = path3.join(
       this.generatedFolderPath,
       SCHEMA_JSON_FILE
     );
-    this.generatedLookupJSONPath = import_path3.default.join(
+    this.generatedLookupJSONPath = path3.join(
       this.generatedFolderPath,
       LOOKUP_JSON_FILE
     );
-    this.generatedQueriesFilePath = import_path3.default.join(
+    this.generatedQueriesFilePath = path3.join(
       this.generatedFolderPath,
       "queries.gql"
     );
-    this.generatedFragmentsFilePath = import_path3.default.join(
+    this.generatedFragmentsFilePath = path3.join(
       this.generatedFolderPath,
       "frags.gql"
     );
-    this.generatedTypesTSFilePath = import_path3.default.join(
+    this.generatedTypesTSFilePath = path3.join(
       this.generatedFolderPath,
       "types.ts"
     );
-    this.generatedTypesJSFilePath = import_path3.default.join(
+    this.generatedTypesJSFilePath = path3.join(
       this.generatedFolderPath,
       "types.js"
     );
-    this.generatedTypesDFilePath = import_path3.default.join(
+    this.generatedTypesDFilePath = path3.join(
       this.generatedFolderPath,
       "types.d.ts"
     );
-    this.userQueriesAndFragmentsGlob = import_path3.default.join(
+    this.userQueriesAndFragmentsGlob = path3.join(
       this.tinaFolderPath,
       "queries/**/*.{graphql,gql}"
     );
-    this.generatedQueriesAndFragmentsGlob = import_path3.default.join(
+    this.generatedQueriesAndFragmentsGlob = path3.join(
       this.generatedFolderPath,
       "*.{graphql,gql}"
     );
-    this.generatedClientTSFilePath = import_path3.default.join(
+    this.generatedClientTSFilePath = path3.join(
       this.generatedFolderPath,
       "client.ts"
     );
-    this.generatedClientJSFilePath = import_path3.default.join(
+    this.generatedClientJSFilePath = path3.join(
       this.generatedFolderPath,
       "client.js"
     );
-    this.generatedClientDFilePath = import_path3.default.join(
+    this.generatedClientDFilePath = path3.join(
       this.generatedFolderPath,
       "client.d.ts"
     );
-    this.generatedDatabaseClientDFilePath = import_path3.default.join(
+    this.generatedDatabaseClientDFilePath = path3.join(
       this.generatedFolderPath,
       "databaseClient.d.ts"
     );
-    this.generatedDatabaseClientTSFilePath = import_path3.default.join(
+    this.generatedDatabaseClientTSFilePath = path3.join(
       this.generatedFolderPath,
       "databaseClient.ts"
     );
-    this.generatedDatabaseClientJSFilePath = import_path3.default.join(
+    this.generatedDatabaseClientJSFilePath = path3.join(
       this.generatedFolderPath,
       "databaseClient.js"
     );
-    const clientExists = this.isUsingTs() ? await import_fs_extra2.default.pathExists(this.generatedClientTSFilePath) : await import_fs_extra2.default.pathExists(this.generatedClientJSFilePath);
+    const clientExists = this.isUsingTs() ? await fs2.pathExists(this.generatedClientTSFilePath) : await fs2.pathExists(this.generatedClientJSFilePath);
     if (!clientExists) {
       const file = "export default ()=>({})\nexport const client = ()=>({})";
       if (this.isUsingTs()) {
-        await import_fs_extra2.default.outputFile(this.generatedClientTSFilePath, file);
+        await fs2.outputFile(this.generatedClientTSFilePath, file);
       } else {
-        await import_fs_extra2.default.outputFile(this.generatedClientJSFilePath, file);
+        await fs2.outputFile(this.generatedClientJSFilePath, file);
       }
     }
     const { config: config2, prebuildPath, watchList } = await this.loadConfigFile(
@@ -933,29 +966,29 @@ var ConfigManager = class {
     this.watchList = watchList;
     this.config = config2;
     this.prebuildFilePath = prebuildPath;
-    this.publicFolderPath = import_path3.default.join(
+    this.publicFolderPath = path3.join(
       this.rootPath,
       this.config.build.publicFolder
     );
-    this.outputFolderPath = import_path3.default.join(
+    this.outputFolderPath = path3.join(
       this.publicFolderPath,
       this.config.build.outputFolder
     );
-    this.outputHTMLFilePath = import_path3.default.join(this.outputFolderPath, "index.html");
-    this.outputGitignorePath = import_path3.default.join(this.outputFolderPath, ".gitignore");
+    this.outputHTMLFilePath = path3.join(this.outputFolderPath, "index.html");
+    this.outputGitignorePath = path3.join(this.outputFolderPath, ".gitignore");
     const fullLocalContentPath = stripNativeTrailingSlash(
-      import_path3.default.join(this.tinaFolderPath, this.config.localContentPath || "")
+      path3.join(this.tinaFolderPath, this.config.localContentPath || "")
     );
     if (this.config.localContentPath) {
-      const localContentPathExists = await import_fs_extra2.default.pathExists(fullLocalContentPath);
+      const localContentPathExists = await fs2.pathExists(fullLocalContentPath);
       if (localContentPathExists) {
         logger.info(`Using separate content repo at ${fullLocalContentPath}`);
         this.contentRootPath = fullLocalContentPath;
       } else {
         logger.warn(
-          `${import_chalk3.default.yellow("Warning:")} The localContentPath ${import_chalk3.default.cyan(
+          `${chalk3.yellow("Warning:")} The localContentPath ${chalk3.cyan(
             fullLocalContentPath
-          )} does not exist. Please create it or remove the localContentPath from your config file at ${import_chalk3.default.cyan(
+          )} does not exist. Please create it or remove the localContentPath from your config file at ${chalk3.cyan(
             this.tinaConfigFilePath
           )}`
         );
@@ -964,22 +997,22 @@ var ConfigManager = class {
     if (!this.contentRootPath) {
       this.contentRootPath = this.rootPath;
     }
-    this.generatedFolderPathContentRepo = import_path3.default.join(
+    this.generatedFolderPathContentRepo = path3.join(
       await this.getTinaFolderPath(this.contentRootPath),
       GENERATED_FOLDER
     );
-    this.spaMainPath = require.resolve("@tinacms/app");
-    this.spaRootPath = import_path3.default.join(this.spaMainPath, "..", "..");
+    this.spaMainPath = require2.resolve("@tinacms/app");
+    this.spaRootPath = path3.join(this.spaMainPath, "..", "..");
   }
   async getTinaFolderPath(rootPath) {
-    const tinaFolderPath = import_path3.default.join(rootPath, TINA_FOLDER);
-    const tinaFolderExists = await import_fs_extra2.default.pathExists(tinaFolderPath);
+    const tinaFolderPath = path3.join(rootPath, TINA_FOLDER);
+    const tinaFolderExists = await fs2.pathExists(tinaFolderPath);
     if (tinaFolderExists) {
       this.isUsingLegacyFolder = false;
       return tinaFolderPath;
     }
-    const legacyFolderPath = import_path3.default.join(rootPath, LEGACY_TINA_FOLDER);
-    const legacyFolderExists = await import_fs_extra2.default.pathExists(legacyFolderPath);
+    const legacyFolderPath = path3.join(rootPath, LEGACY_TINA_FOLDER);
+    const legacyFolderExists = await fs2.pathExists(legacyFolderPath);
     if (legacyFolderExists) {
       this.isUsingLegacyFolder = true;
       return legacyFolderPath;
@@ -998,7 +1031,7 @@ var ConfigManager = class {
         patch: version2[2] || "x"
       };
     }
-    const generatedSchema = import_fs_extra2.default.readJSONSync(this.generatedSchemaJSONPath);
+    const generatedSchema = fs2.readJSONSync(this.generatedSchemaJSONPath);
     if (!generatedSchema || !(typeof generatedSchema?.version !== "undefined")) {
       throw new Error(
         `Can not find Tina GraphQL version in ${this.generatedSchemaJSONPath}`
@@ -1045,7 +1078,7 @@ var ConfigManager = class {
           return;
         }
         const filepathWithExtension = `${filepath}.${ext}`;
-        const exists = import_fs_extra2.default.existsSync(filepathWithExtension);
+        const exists = fs2.existsSync(filepathWithExtension);
         if (exists) {
           result = filepathWithExtension;
         }
@@ -1054,33 +1087,45 @@ var ConfigManager = class {
     return result;
   }
   async loadDatabaseFile() {
-    const tmpdir = import_path3.default.join(import_os.default.tmpdir(), Date.now().toString());
-    const outfile = import_path3.default.join(tmpdir, "database.build.js");
+    const tmpdir = path3.join(os.tmpdir(), Date.now().toString());
+    const outfile = path3.join(tmpdir, "database.build.mjs");
     await esbuild.build({
       entryPoints: [this.selfHostedDatabaseFilePath],
       bundle: true,
       platform: "node",
+      format: "esm",
       outfile,
-      loader: loaders
+      loader: loaders,
+      // Provide a require() polyfill for ESM bundles containing CommonJS packages.
+      // Some bundled packages (e.g., 'scmp' used by 'mongodb-level') use require('crypto').
+      // When esbuild inlines these CommonJS packages, it keeps the require() calls,
+      // but ESM doesn't have a global require. This banner creates one using Node.js's
+      // official createRequire API, allowing the bundled CommonJS code to work in ESM.
+      banner: {
+        js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`
+      }
     });
-    const result = require(outfile);
-    import_fs_extra2.default.removeSync(outfile);
+    const result = await import(pathToFileURL(outfile).href);
+    fs2.removeSync(outfile);
     return result.default;
   }
   async loadConfigFile(generatedFolderPath, configFilePath) {
-    const tmpdir = import_path3.default.join(import_os.default.tmpdir(), Date.now().toString());
-    const preBuildConfigPath = import_path3.default.join(
+    const tmpdir = path3.join(os.tmpdir(), Date.now().toString());
+    const preBuildConfigPath = path3.join(
       this.generatedFolderPath,
       "config.prebuild.jsx"
     );
-    const outfile = import_path3.default.join(tmpdir, "config.build.jsx");
-    const outfile2 = import_path3.default.join(tmpdir, "config.build.js");
-    const tempTSConfigFile = import_path3.default.join(tmpdir, "tsconfig.json");
-    import_fs_extra2.default.outputFileSync(tempTSConfigFile, "{}");
+    const outfile = path3.join(tmpdir, "config.build.jsx");
+    const outfile2 = path3.join(tmpdir, "config.build.mjs");
+    const tempTSConfigFile = path3.join(tmpdir, "tsconfig.json");
+    const esmRequireBanner = {
+      js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`
+    };
+    fs2.outputFileSync(tempTSConfigFile, "{}");
     const result2 = await esbuild.build({
       entryPoints: [configFilePath],
       bundle: true,
-      target: ["es2020"],
+      target: ["esnext"],
       platform: "browser",
       format: "esm",
       logLevel: "silent",
@@ -1100,31 +1145,34 @@ var ConfigManager = class {
     await esbuild.build({
       entryPoints: [configFilePath],
       bundle: true,
-      target: ["es2020"],
+      target: ["esnext"],
       logLevel: "silent",
       platform: "node",
+      format: "esm",
       outfile,
-      loader: loaders
+      loader: loaders,
+      banner: esmRequireBanner
     });
     await esbuild.build({
       entryPoints: [outfile],
       bundle: true,
-      // Suppress warning about comparison with -0 from client module
       logLevel: "silent",
       platform: "node",
+      target: ["esnext"],
+      format: "esm",
       outfile: outfile2,
       loader: loaders
     });
     let result;
     try {
-      result = require(outfile2);
+      result = await import(pathToFileURL(outfile2).href);
     } catch (e) {
       console.error("Unexpected error loading config");
       console.error(e);
       throw e;
     }
-    import_fs_extra2.default.removeSync(outfile);
-    import_fs_extra2.default.removeSync(outfile2);
+    fs2.removeSync(outfile);
+    fs2.removeSync(outfile2);
     return {
       config: result.default,
       prebuildPath: preBuildConfigPath,
@@ -1159,20 +1207,24 @@ var loaders = {
 };
 
 // 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");
+import {
+  createDatabaseInternal,
+  FilesystemBridge,
+  TinaLevelClient
+} from "@tinacms/graphql";
+import { pipeline } from "readable-stream";
+import { createServer } from "net";
+import { ManyLevelHost } from "many-level";
+import { MemoryLevel } from "memory-level";
 var createDBServer = (port) => {
-  const levelHost = new import_many_level.ManyLevelHost(
+  const levelHost = new ManyLevelHost(
     // @ts-ignore
-    new import_memory_level.MemoryLevel({
+    new MemoryLevel({
       valueEncoding: "json"
     })
   );
-  const dbServer = (0, import_net.createServer)(function(socket) {
-    return (0, import_readable_stream.pipeline)(socket, levelHost.createRpcStream(), socket, () => {
+  const dbServer = createServer(function(socket) {
+    return pipeline(socket, levelHost.createRpcStream(), socket, () => {
     });
   });
   dbServer.once("error", (err) => {
@@ -1186,7 +1238,7 @@ var createDBServer = (port) => {
 };
 async function createAndInitializeDatabase(configManager, datalayerPort, bridgeOverride) {
   let database;
-  const bridge = bridgeOverride || new import_graphql7.FilesystemBridge(configManager.rootPath, configManager.contentRootPath);
+  const bridge = bridgeOverride || new FilesystemBridge(configManager.rootPath, configManager.contentRootPath);
   if (configManager.hasSelfHostedConfig() && configManager.config.contentApiUrlOverride) {
     database = await configManager.loadDatabaseFile();
     database.bridge = bridge;
@@ -1198,9 +1250,9 @@ async function createAndInitializeDatabase(configManager, datalayerPort, bridgeO
         )} but there was no "contentApiUrlOverride" set. Falling back to built-in datalayer`
       );
     }
-    const level = new import_graphql7.TinaLevelClient(datalayerPort);
+    const level = new TinaLevelClient(datalayerPort);
     level.openConnection();
-    database = (0, import_graphql7.createDatabaseInternal)({
+    database = createDatabaseInternal({
       bridge,
       level,
       tinaDirectory: configManager.isUsingLegacyFolder ? LEGACY_TINA_FOLDER : TINA_FOLDER
@@ -1210,17 +1262,17 @@ async function createAndInitializeDatabase(configManager, datalayerPort, bridgeO
 }
 
 // src/next/commands/baseCommands.ts
-var import_clipanion = require("clipanion");
-var import_chalk4 = __toESM(require("chalk"));
+import { Command, Option } from "clipanion";
+import chalk4 from "chalk";
 
 // src/utils/start-subprocess.ts
-var import_child_process = __toESM(require("child_process"));
+import childProcess from "child_process";
 var startSubprocess2 = async ({ command: command2 }) => {
   if (typeof command2 === "string") {
     const commands = command2.split(" ");
     const firstCommand = commands[0];
     const args = commands.slice(1) || [];
-    const ps = import_child_process.default.spawn(firstCommand, args, {
+    const ps = childProcess.spawn(firstCommand, args, {
       stdio: "inherit",
       shell: true
     });
@@ -1244,45 +1296,42 @@ stack: ${code.stack || "No stack was provided"}`);
 };
 
 // src/next/commands/baseCommands.ts
-var import_graphql8 = require("@tinacms/graphql");
-var import_fs_extra3 = __toESM(require("fs-extra"));
-var BaseCommand = class extends import_clipanion.Command {
-  constructor() {
-    super(...arguments);
-    this.experimentalDataLayer = import_clipanion.Option.Boolean("--experimentalData", {
-      description: "DEPRECATED - Build the server with additional data querying capabilities"
-    });
-    this.isomorphicGitBridge = import_clipanion.Option.Boolean("--isomorphicGitBridge", {
-      description: "DEPRECATED - Enable Isomorphic Git Bridge Implementation"
-    });
-    this.port = import_clipanion.Option.String("-p,--port", "4001", {
-      description: "Specify a port to run the server on. (default 4001)"
-    });
-    this.datalayerPort = import_clipanion.Option.String("--datalayer-port", "9000", {
-      description: "Specify a port to run the datalayer server on. (default 9000)"
-    });
-    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.verbose = import_clipanion.Option.Boolean("-v,--verbose", false, {
-      description: "increase verbosity of logged output"
-    });
-    this.noSDK = import_clipanion.Option.Boolean("--noSDK", false, {
-      description: "DEPRECATED - This should now be set in the config at client.skip = true'. Don't generate the generated client SDK"
-    });
-    this.noTelemetry = import_clipanion.Option.Boolean("--noTelemetry", false, {
-      description: "Disable anonymous telemetry that is collected"
-    });
-  }
+import { getChangedFiles, getSha, shaExists } from "@tinacms/graphql";
+import fs3 from "fs-extra";
+var BaseCommand = class extends Command {
+  experimentalDataLayer = Option.Boolean("--experimentalData", {
+    description: "DEPRECATED - Build the server with additional data querying capabilities"
+  });
+  isomorphicGitBridge = Option.Boolean("--isomorphicGitBridge", {
+    description: "DEPRECATED - Enable Isomorphic Git Bridge Implementation"
+  });
+  port = Option.String("-p,--port", "4001", {
+    description: "Specify a port to run the server on. (default 4001)"
+  });
+  datalayerPort = Option.String("--datalayer-port", "9000", {
+    description: "Specify a port to run the datalayer server on. (default 9000)"
+  });
+  subCommand = Option.String("-c,--command", {
+    description: "The sub-command to run"
+  });
+  rootPath = Option.String("--rootPath", {
+    description: "Specify the root directory to run the CLI from (defaults to current working directory)"
+  });
+  verbose = Option.Boolean("-v,--verbose", false, {
+    description: "increase verbosity of logged output"
+  });
+  noSDK = Option.Boolean("--noSDK", false, {
+    description: "DEPRECATED - This should now be set in the config at client.skip = true'. Don't generate the generated client SDK"
+  });
+  noTelemetry = Option.Boolean("--noTelemetry", false, {
+    description: "Disable anonymous telemetry that is collected"
+  });
   async startSubCommand() {
     let subProc;
     if (this.subCommand) {
       subProc = await startSubprocess2({ command: this.subCommand });
       logger.info(
-        `Running web application with command: ${import_chalk4.default.cyan(this.subCommand)}`
+        `Running web application with command: ${chalk4.cyan(this.subCommand)}`
       );
     }
     function exitHandler(options, exitCode) {
@@ -1330,7 +1379,7 @@ var BaseCommand = class extends import_clipanion.Command {
         const rootPath = configManager.rootPath;
         let sha;
         try {
-          sha = await (0, import_graphql8.getSha)({ fs: import_fs_extra3.default, dir: rootPath });
+          sha = await getSha({ fs: fs3, dir: rootPath });
         } catch (e) {
           if (partialReindex) {
             console.error(
@@ -1340,7 +1389,7 @@ var BaseCommand = class extends import_clipanion.Command {
           }
         }
         const lastSha = await database.getMetadata("lastSha");
-        const exists = lastSha && await (0, import_graphql8.shaExists)({ fs: import_fs_extra3.default, dir: rootPath, sha: lastSha });
+        const exists = lastSha && await shaExists({ fs: fs3, dir: rootPath, sha: lastSha });
         let res;
         if (partialReindex && lastSha && exists && sha) {
           const pathFilter = {};
@@ -1354,8 +1403,8 @@ var BaseCommand = class extends import_clipanion.Command {
               matches: collection.match?.exclude || collection.match?.include ? tinaSchema.getMatches({ collection }) : void 0
             };
           }
-          const { added, modified, deleted } = await (0, import_graphql8.getChangedFiles)({
-            fs: import_fs_extra3.default,
+          const { added, modified, deleted } = await getChangedFiles({
+            fs: fs3,
             dir: rootPath,
             from: lastSha,
             to: sha,
@@ -1478,34 +1527,38 @@ var devHTML = (port) => `<!DOCTYPE html>
 </html>`;
 
 // src/next/commands/dev-command/server/index.ts
-var import_vite3 = require("vite");
+import { createServer as createViteServer } from "vite";
 
 // src/next/vite/index.ts
-var import_node_path2 = __toESM(require("node:path"));
-var import_plugin_react = __toESM(require("@vitejs/plugin-react"));
-var import_fs_extra4 = __toESM(require("fs-extra"));
-var import_normalize_path3 = __toESM(require("normalize-path"));
-var import_vite = require("vite");
+import path5 from "node:path";
+import react from "@vitejs/plugin-react";
+import fs4 from "fs-extra";
+import normalizePath3 from "normalize-path";
+import {
+  splitVendorChunkPlugin
+} from "vite";
 
 // src/next/vite/tailwind.ts
-var import_node_path = __toESM(require("node:path"));
-var import_aspect_ratio = __toESM(require("@tailwindcss/aspect-ratio"));
-var import_container_queries = __toESM(require("@tailwindcss/container-queries"));
-var import_typography = __toESM(require("@tailwindcss/typography"));
-var import_tailwindcss = __toESM(require("tailwindcss"));
-var import_defaultTheme = __toESM(require("tailwindcss/defaultTheme.js"));
+import path4 from "node:path";
+import aspectRatio from "@tailwindcss/aspect-ratio";
+import containerQueries from "@tailwindcss/container-queries";
+import twTypography from "@tailwindcss/typography";
+import tailwind from "tailwindcss";
+import defaultTheme from "tailwindcss/defaultTheme.js";
+import { createRequire as createRequire2 } from "module";
 var tinaTailwind = (spaPath, prebuildFilePath) => {
   return {
     name: "vite-plugin-tina",
     // @ts-ignore
     config: (viteConfig) => {
+      const require2 = createRequire2(import.meta.url);
       const plugins = [];
       const content = [
-        import_node_path.default.join(spaPath, "src/**/*.{vue,js,ts,jsx,tsx,svelte}"),
+        path4.join(spaPath, "src/**/*.{vue,js,ts,jsx,tsx,svelte}"),
         prebuildFilePath,
-        require.resolve("tinacms")
+        require2.resolve("tinacms")
       ];
-      const tw = (0, import_tailwindcss.default)({
+      const tw = tailwind({
         theme: {
           columns: {
             auto: "auto",
@@ -1717,7 +1770,7 @@ var tinaTailwind = (spaPath, prebuildFilePath) => {
               ring: "#0A0A0A"
             },
             fontFamily: {
-              sans: ["Inter", ...import_defaultTheme.default.fontFamily.sans]
+              sans: ["Inter", ...defaultTheme.fontFamily.sans]
             },
             lineHeight: {
               3: "12px",
@@ -1742,9 +1795,9 @@ var tinaTailwind = (spaPath, prebuildFilePath) => {
         },
         content,
         plugins: [
-          (0, import_typography.default)({ className: "tina-prose" }),
-          import_aspect_ratio.default,
-          import_container_queries.default
+          twTypography({ className: "tina-prose" }),
+          aspectRatio,
+          containerQueries
         ]
       });
       plugins.push(tw);
@@ -1765,35 +1818,35 @@ async function listFilesRecursively({
   config: config2,
   roothPath
 }) {
-  const fullDirectoryPath = import_node_path2.default.join(
+  const fullDirectoryPath = path5.join(
     roothPath,
     config2.publicFolder,
     directoryPath
   );
-  const exists = await import_fs_extra4.default.pathExists(fullDirectoryPath);
+  const exists = await fs4.pathExists(fullDirectoryPath);
   if (!exists) {
     return { "0": [] };
   }
-  const items = await import_fs_extra4.default.readdir(fullDirectoryPath);
+  const items = await fs4.readdir(fullDirectoryPath);
   const staticMediaItems = [];
   for (const item of items) {
-    const itemPath = import_node_path2.default.join(fullDirectoryPath, item);
-    const stats = await import_fs_extra4.default.promises.lstat(itemPath);
+    const itemPath = path5.join(fullDirectoryPath, item);
+    const stats = await fs4.promises.lstat(itemPath);
     const staticMediaItem = {
       id: item,
       filename: item,
       type: stats.isDirectory() ? "dir" : "file",
       directory: `${directoryPath.replace(config2.mediaRoot, "")}`,
-      src: `/${import_node_path2.default.join(directoryPath, item)}`,
+      src: `/${path5.join(directoryPath, item)}`,
       thumbnails: {
-        "75x75": `/${import_node_path2.default.join(directoryPath, item)}`,
-        "400x400": `/${import_node_path2.default.join(directoryPath, item)}`,
-        "1000x1000": `/${import_node_path2.default.join(directoryPath, item)}`
+        "75x75": `/${path5.join(directoryPath, item)}`,
+        "400x400": `/${path5.join(directoryPath, item)}`,
+        "1000x1000": `/${path5.join(directoryPath, item)}`
       }
     };
     if (stats.isDirectory()) {
       staticMediaItem.children = await listFilesRecursively({
-        directoryPath: import_node_path2.default.join(directoryPath, item),
+        directoryPath: path5.join(directoryPath, item),
         config: config2,
         roothPath
       });
@@ -1834,7 +1887,7 @@ var createConfig = async ({
       }
     }
   });
-  const staticMediaPath = import_node_path2.default.join(
+  const staticMediaPath = path5.join(
     configManager.generatedFolderPath,
     "static-media.json"
   );
@@ -1844,21 +1897,21 @@ var createConfig = async ({
       config: configManager.config.media.tina,
       roothPath: configManager.rootPath
     });
-    await import_fs_extra4.default.outputFile(staticMediaPath, JSON.stringify(staticMedia, null, 2));
+    await fs4.outputFile(staticMediaPath, JSON.stringify(staticMedia, null, 2));
   } else {
-    await import_fs_extra4.default.outputFile(staticMediaPath, `[]`);
+    await fs4.outputFile(staticMediaPath, `[]`);
   }
   const alias = {
     TINA_IMPORT: configManager.prebuildFilePath,
     SCHEMA_IMPORT: configManager.generatedGraphQLJSONPath,
     STATIC_MEDIA_IMPORT: staticMediaPath,
-    crypto: import_node_path2.default.join(configManager.spaRootPath, "src", "dummy-client.ts"),
-    fs: import_node_path2.default.join(configManager.spaRootPath, "src", "dummy-client.ts"),
-    os: import_node_path2.default.join(configManager.spaRootPath, "src", "dummy-client.ts"),
-    path: import_node_path2.default.join(configManager.spaRootPath, "src", "dummy-client.ts")
+    crypto: path5.join(configManager.spaRootPath, "src", "dummy-client.ts"),
+    fs: path5.join(configManager.spaRootPath, "src", "dummy-client.ts"),
+    os: path5.join(configManager.spaRootPath, "src", "dummy-client.ts"),
+    path: path5.join(configManager.spaRootPath, "src", "dummy-client.ts")
   };
   if (configManager.shouldSkipSDK()) {
-    alias["CLIENT_IMPORT"] = import_node_path2.default.join(
+    alias["CLIENT_IMPORT"] = path5.join(
       configManager.spaRootPath,
       "src",
       "dummy-client.ts"
@@ -1874,7 +1927,7 @@ var createConfig = async ({
   const version2 = `${fullVersion.major}.${fullVersion.minor}`;
   const config2 = {
     root: configManager.spaRootPath,
-    base: `/${basePath ? `${(0, import_normalize_path3.default)(basePath)}/` : ""}${(0, import_normalize_path3.default)(
+    base: `/${basePath ? `${normalizePath3(basePath)}/` : ""}${normalizePath3(
       configManager.config.build.outputFolder
     )}/`,
     appType: "spa",
@@ -1937,14 +1990,14 @@ var createConfig = async ({
        * `splitVendorChunkPlugin` is needed because `tinacms` is quite large,
        * Vite's chunking strategy chokes on memory issues for smaller machines (ie. on CI).
        */
-      (0, import_plugin_react.default)({
+      react({
         babel: {
           // Supresses the warning [NOTE] babel The code generator has deoptimised the styling of
           compact: true
         },
         fastRefresh: false
       }),
-      (0, import_vite.splitVendorChunkPlugin)(),
+      splitVendorChunkPlugin(),
       tinaTailwind(configManager.spaRootPath, configManager.prebuildFilePath),
       ...plugins
     ]
@@ -1953,21 +2006,21 @@ var createConfig = async ({
 };
 
 // src/next/vite/plugins.ts
-var import_pluginutils = require("@rollup/pluginutils");
-var import_fs = __toESM(require("fs"));
-var import_vite2 = require("vite");
-var import_esbuild2 = require("esbuild");
-var import_path6 = __toESM(require("path"));
-var import_body_parser = __toESM(require("body-parser"));
-var import_cors = __toESM(require("cors"));
-var import_graphql9 = require("@tinacms/graphql");
+import { createFilter } from "@rollup/pluginutils";
+import fs6 from "fs";
+import { transformWithEsbuild } from "vite";
+import { transform as esbuildTransform } from "esbuild";
+import path7 from "path";
+import bodyParser from "body-parser";
+import cors from "cors";
+import { resolve as gqlResolve } from "@tinacms/graphql";
 
 // src/next/commands/dev-command/server/media.ts
-var import_fs_extra5 = __toESM(require("fs-extra"));
-var import_path5 = __toESM(require("path"));
-var import_busboy = __toESM(require("busboy"));
+import fs5 from "fs-extra";
+import path6, { join } from "path";
+import busboy from "busboy";
 var createMediaRouter = (config2) => {
-  const mediaFolder = import_path5.default.join(
+  const mediaFolder = path6.join(
     config2.rootPath,
     config2.publicFolder,
     config2.mediaRoot
@@ -1991,12 +2044,12 @@ var createMediaRouter = (config2) => {
     res.end(JSON.stringify(didDelete));
   };
   const handlePost = async function(req, res) {
-    const bb = (0, import_busboy.default)({ headers: req.headers });
+    const bb = busboy({ headers: req.headers });
     bb.on("file", async (_name, file, _info) => {
       const fullPath = decodeURI(req.url?.slice("/media/upload/".length));
-      const saveTo = import_path5.default.join(mediaFolder, ...fullPath.split("/"));
-      await import_fs_extra5.default.ensureDir(import_path5.default.dirname(saveTo));
-      file.pipe(import_fs_extra5.default.createWriteStream(saveTo));
+      const saveTo = path6.join(mediaFolder, ...fullPath.split("/"));
+      await fs5.ensureDir(path6.dirname(saveTo));
+      file.pipe(fs5.createWriteStream(saveTo));
     });
     bb.on("error", (error) => {
       res.statusCode = 500;
@@ -2022,6 +2075,9 @@ var parseMediaFolder = (str) => {
   return returnString;
 };
 var MediaModel = class {
+  rootPath;
+  publicFolder;
+  mediaRoot;
   constructor({ rootPath, publicFolder, mediaRoot }) {
     this.rootPath = rootPath;
     this.mediaRoot = mediaRoot;
@@ -2029,23 +2085,23 @@ var MediaModel = class {
   }
   async listMedia(args) {
     try {
-      const folderPath = (0, import_path5.join)(
+      const folderPath = join(
         this.rootPath,
         this.publicFolder,
         this.mediaRoot,
         decodeURIComponent(args.searchPath)
       );
       const searchPath = parseMediaFolder(args.searchPath);
-      if (!await import_fs_extra5.default.pathExists(folderPath)) {
+      if (!await fs5.pathExists(folderPath)) {
         return {
           files: [],
           directories: []
         };
       }
-      const filesStr = await import_fs_extra5.default.readdir(folderPath);
+      const filesStr = await fs5.readdir(folderPath);
       const filesProm = filesStr.map(async (file) => {
-        const filePath = (0, import_path5.join)(folderPath, file);
-        const stat = await import_fs_extra5.default.stat(filePath);
+        const filePath = join(folderPath, file);
+        const stat = await fs5.stat(filePath);
         let src = `/${file}`;
         const isFile = stat.isFile();
         if (!isFile) {
@@ -2101,14 +2157,14 @@ var MediaModel = class {
   }
   async deleteMedia(args) {
     try {
-      const file = (0, import_path5.join)(
+      const file = join(
         this.rootPath,
         this.publicFolder,
         this.mediaRoot,
         decodeURIComponent(args.searchPath)
       );
-      await import_fs_extra5.default.stat(file);
-      await import_fs_extra5.default.remove(file);
+      await fs5.stat(file);
+      await fs5.remove(file);
       return { ok: true };
     } catch (error) {
       console.error(error);
@@ -2166,9 +2222,9 @@ var transformTsxPlugin = ({
   const plug = {
     name: "transform-tsx",
     async transform(code, id) {
-      const extName = import_path6.default.extname(id);
+      const extName = path7.extname(id);
       if (extName.startsWith(".tsx") || extName.startsWith(".ts")) {
-        const result = await (0, import_esbuild2.transform)(code, { loader: "tsx" });
+        const result = await esbuildTransform(code, { loader: "tsx" });
         return {
           code: result.code
         };
@@ -2187,8 +2243,8 @@ var devServerEndPointsPlugin = ({
   const plug = {
     name: "graphql-endpoints",
     configureServer(server) {
-      server.middlewares.use((0, import_cors.default)());
-      server.middlewares.use(import_body_parser.default.json({ limit: "5mb" }));
+      server.middlewares.use(cors());
+      server.middlewares.use(bodyParser.json({ limit: "5mb" }));
       server.middlewares.use(async (req, res, next) => {
         const mediaPaths = configManager.config.media?.tina;
         const mediaRouter = createMediaRouter({
@@ -2227,7 +2283,7 @@ var devServerEndPointsPlugin = ({
           const { query, variables } = req.body;
           let result;
           await databaseLock(async () => {
-            result = await (0, import_graphql9.resolve)({
+            result = await gqlResolve({
               config: {
                 useRelativeMedia: true
               },
@@ -2263,13 +2319,13 @@ function viteTransformExtension({
   include = "**/*.svg",
   exclude
 } = {}) {
-  const filter = (0, import_pluginutils.createFilter)(include, exclude);
+  const filter = createFilter(include, exclude);
   return {
     name: "vite-plugin-svgr",
     async transform(code, id) {
       if (filter(id)) {
         const { transform: transform2 } = await import("@svgr/core");
-        const svgCode = await import_fs.default.promises.readFile(
+        const svgCode = await fs6.promises.readFile(
           id.replace(/\?.*$/, ""),
           "utf8"
         );
@@ -2279,7 +2335,7 @@ function viteTransformExtension({
             previousExport: exportAsDefault ? null : code
           }
         });
-        const res = await (0, import_vite2.transformWithEsbuild)(componentCode, id, {
+        const res = await transformWithEsbuild(componentCode, id, {
           loader: "jsx",
           ...esbuildOptions
         });
@@ -2306,7 +2362,7 @@ var createDevServer = async (configManager, database, searchIndex, apiURL, noWat
     }),
     viteTransformExtension()
   ];
-  return (0, import_vite3.createServer)(
+  return createViteServer(
     await createConfig({
       configManager,
       database,
@@ -2336,37 +2392,30 @@ var createDevServer = async (configManager, database, searchIndex, apiURL, noWat
 
 // src/next/commands/dev-command/index.ts
 var DevCommand = class extends BaseCommand {
-  constructor() {
-    super(...arguments);
-    // NOTE: camelCase commands for string options don't work if there's an `=` used https://github.com/arcanis/clipanion/issues/141
-    this.watchFolders = import_clipanion2.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.noWatch = import_clipanion2.Option.Boolean("--noWatch", false, {
-      description: "Don't regenerate config on file changes"
-    });
-    this.outputSearchIndexPath = import_clipanion2.Option.String("--outputSearchIndexPath", {
-      description: "Path to write the search index to"
-    });
-    this.noServer = import_clipanion2.Option.Boolean("--no-server", false, {
-      description: "Do not start the dev server"
-    });
-    this.indexingLock = new import_async_lock.default();
-  }
-  static {
-    this.paths = [["dev"], ["server:start"]];
-  }
-  static {
-    // Prevent indexes and reads occurring at once
-    this.usage = import_clipanion2.Command.Usage({
-      category: `Commands`,
-      description: `Builds Tina and starts the dev server`,
-      examples: [
-        [`A basic example`, `$0 dev`],
-        [`A second example`, `$0 dev --rootPath`]
-      ]
-    });
-  }
+  static paths = [["dev"], ["server:start"]];
+  // NOTE: camelCase commands for string options don't work if there's an `=` used https://github.com/arcanis/clipanion/issues/141
+  watchFolders = Option2.String("-w,--watchFolders", {
+    description: "DEPRECATED - a list of folders (relative to where this is being run) that the cli will watch for changes"
+  });
+  noWatch = Option2.Boolean("--noWatch", false, {
+    description: "Don't regenerate config on file changes"
+  });
+  outputSearchIndexPath = Option2.String("--outputSearchIndexPath", {
+    description: "Path to write the search index to"
+  });
+  noServer = Option2.Boolean("--no-server", false, {
+    description: "Do not start the dev server"
+  });
+  indexingLock = new AsyncLock();
+  // Prevent indexes and reads occurring at once
+  static usage = Command2.Usage({
+    category: `Commands`,
+    description: `Builds Tina and starts the dev server`,
+    examples: [
+      [`A basic example`, `$0 dev`],
+      [`A second example`, `$0 dev --rootPath`]
+    ]
+  });
   async catch(error) {
     logger.error("Error occured during tinacms dev");
     console.error(error);
@@ -2403,7 +2452,7 @@ var DevCommand = class extends BaseCommand {
         } else {
           database.clearCache();
         }
-        const { tinaSchema: tinaSchema2, graphQLSchema: graphQLSchema2, lookup, queryDoc, fragDoc } = await (0, import_graphql10.buildSchema)(configManager.config);
+        const { tinaSchema: tinaSchema2, graphQLSchema: graphQLSchema2, lookup, queryDoc, fragDoc } = await buildSchema(configManager.config);
         const codegen2 = new Codegen({
           isLocal: true,
           configManager,
@@ -2417,29 +2466,32 @@ var DevCommand = class extends BaseCommand {
         });
         const apiURL2 = await codegen2.execute();
         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);
+          const schemaObject = await fs7.readJSON(
+            configManager.generatedSchemaJSONPath
+          );
+          const lookupObject = await fs7.readJSON(
+            configManager.generatedLookupJSONPath
+          );
+          const graphqlSchemaObject = await fs7.readJSON(
+            configManager.generatedGraphQLJSONPath
+          );
           const tinaLockFilename = "tina-lock.json";
           const tinaLockContent = JSON.stringify({
             schema: schemaObject,
             lookup: lookupObject,
             graphql: graphqlSchemaObject
           });
-          import_fs_extra6.default.writeFileSync(
-            import_path7.default.join(configManager.tinaFolderPath, tinaLockFilename),
+          fs7.writeFileSync(
+            path8.join(configManager.tinaFolderPath, tinaLockFilename),
             tinaLockContent
           );
           if (configManager.hasSeparateContentRoot()) {
             const rootPath = await configManager.getTinaFolderPath(
               configManager.contentRootPath
             );
-            const filePath = import_path7.default.join(rootPath, tinaLockFilename);
-            await import_fs_extra6.default.ensureFile(filePath);
-            await import_fs_extra6.default.outputFile(filePath, tinaLockContent);
+            const filePath = path8.join(rootPath, tinaLockFilename);
+            await fs7.ensureFile(filePath);
+            await fs7.outputFile(filePath, tinaLockContent);
           }
         }
         await this.indexContentWithSpinner({
@@ -2482,19 +2534,19 @@ ${dangerText(e.message)}
     const { apiURL, graphQLSchema, tinaSchema } = await setup({
       firstTime: true
     });
-    await import_fs_extra6.default.outputFile(configManager.outputHTMLFilePath, devHTML(this.port));
-    await import_fs_extra6.default.outputFile(
+    await fs7.outputFile(configManager.outputHTMLFilePath, devHTML(this.port));
+    await fs7.outputFile(
       configManager.outputGitignorePath,
       "index.html\nassets/"
     );
-    const searchIndexClient = new import_search.LocalSearchIndexClient({
+    const searchIndexClient = new LocalSearchIndexClient({
       stopwordLanguages: configManager.config.search?.tina?.stopwordLanguages,
       tokenSplitRegex: configManager.config.search?.tina?.tokenSplitRegex
     });
     await searchIndexClient.onStartIndexing();
-    const searchIndexer = new import_search.SearchIndexer({
+    const searchIndexer = new SearchIndexer({
       batchSize: configManager.config.search?.indexBatchSize || 100,
-      bridge: new import_graphql10.FilesystemBridge(
+      bridge: new FilesystemBridge2(
         configManager.rootPath,
         configManager.contentRootPath
       ),
@@ -2535,7 +2587,7 @@ ${dangerText(e.message)}
     );
     await server.listen(Number(this.port));
     if (!this.noWatch) {
-      import_chokidar.default.watch(configManager.watchList).on("change", async () => {
+      chokidar.watch(configManager.watchList).on("change", async () => {
         await dbLock(async () => {
           logger.info(`Tina config change detected, rebuilding`);
           await setup({ firstTime: false });
@@ -2612,14 +2664,14 @@ ${dangerText(e.message)}
   watchContentFiles(configManager, database, databaseLock, searchIndexer) {
     const collectionContentFiles = [];
     configManager.config.schema.collections.forEach((collection) => {
-      const collectionGlob = `${import_path7.default.join(
+      const collectionGlob = `${path8.join(
         configManager.contentRootPath,
         collection.path
       )}/**/*.${collection.format || "md"}`;
       collectionContentFiles.push(collectionGlob);
     });
     let ready = false;
-    import_chokidar.default.watch(collectionContentFiles).on("ready", () => {
+    chokidar.watch(collectionContentFiles).on("ready", () => {
       ready = true;
     }).on("add", async (addedFile) => {
       if (!ready) {
@@ -2656,27 +2708,34 @@ ${dangerText(e.message)}
         await callback();
       });
     };
-    import_chokidar.default.watch(configManager.userQueriesAndFragmentsGlob).on("add", executeCallback).on("change", executeCallback).on("unlink", executeCallback);
+    chokidar.watch(configManager.userQueriesAndFragmentsGlob).on("add", executeCallback).on("change", executeCallback).on("unlink", executeCallback);
   }
 };
 
 // src/next/commands/build-command/index.ts
-var import_crypto = __toESM(require("crypto"));
-var import_path8 = __toESM(require("path"));
-var import_core3 = require("@graphql-inspector/core");
-var import_graphql11 = require("@tinacms/graphql");
-var import_schema_tools2 = require("@tinacms/schema-tools");
-var import_search2 = require("@tinacms/search");
-var import_clipanion3 = require("clipanion");
-var import_fs_extra7 = __toESM(require("fs-extra"));
-var import_graphql12 = require("graphql");
-var import_progress2 = __toESM(require("progress"));
+import crypto from "crypto";
+import path9 from "path";
+import { diff } from "@graphql-inspector/core";
+import { FilesystemBridge as FilesystemBridge3, buildSchema as buildSchema2 } from "@tinacms/graphql";
+import { parseURL as parseURL2 } from "@tinacms/schema-tools";
+import {
+  SearchIndexer as SearchIndexer2,
+  TinaCMSSearchIndexClient
+} from "@tinacms/search";
+import { Command as Command3, Option as Option3 } from "clipanion";
+import fs8 from "fs-extra";
+import {
+  buildASTSchema as buildASTSchema2,
+  buildClientSchema,
+  getIntrospectionQuery
+} from "graphql";
+import Progress2 from "progress";
 
 // src/utils/index.ts
-var import_core2 = require("@graphql-inspector/core");
+import { ChangeType } from "@graphql-inspector/core";
 var getFaqLink = (type) => {
   switch (type) {
-    case import_core2.ChangeType.FieldRemoved: {
+    case ChangeType.FieldRemoved: {
       return "https://tina.io/docs/r/FAQ/#2-how-do-i-resolve-the-local-graphql-schema-doesnt-match-the-remote-graphql-schema-error";
     }
     default:
@@ -2698,7 +2757,7 @@ async function sleepAndCallFunc({
 }
 
 // src/next/commands/build-command/server.ts
-var import_vite5 = require("vite");
+import { build as build2 } from "vite";
 var buildProductionSpa = async (configManager, database, apiURL) => {
   const publicEnv = {};
   Object.keys(process.env).forEach((key) => {
@@ -2732,12 +2791,12 @@ var buildProductionSpa = async (configManager, database, apiURL) => {
       }
     }
   });
-  return (0, import_vite5.build)(config2);
+  return build2(config2);
 };
 
 // src/next/commands/build-command/waitForDB.ts
-var import_schema_tools = require("@tinacms/schema-tools");
-var import_progress = __toESM(require("progress"));
+import { parseURL } from "@tinacms/schema-tools";
+import Progress from "progress";
 var POLLING_INTERVAL = 5e3;
 var STATUS_INPROGRESS = "inprogress";
 var STATUS_COMPLETE = "complete";
@@ -2750,14 +2809,14 @@ var IndexFailedError = class extends Error {
 };
 var waitForDB = async (config2, apiUrl, previewName, verbose) => {
   const token = config2.token;
-  const { clientId, branch, isLocalClient, host } = (0, import_schema_tools.parseURL)(apiUrl);
+  const { clientId, branch, isLocalClient, host } = parseURL(apiUrl);
   if (isLocalClient || !host || !clientId || !branch) {
     if (verbose) {
       logger.info(logText("Not using TinaCloud, skipping DB check"));
     }
     return;
   }
-  const bar2 = new import_progress.default(
+  const bar2 = new Progress(
     "Checking indexing process in TinaCloud... :prog",
     1
   );
@@ -2820,51 +2879,44 @@ var waitForDB = async (config2, apiUrl, previewName, verbose) => {
 
 // src/next/commands/build-command/index.ts
 var BuildCommand = class extends BaseCommand {
-  constructor() {
-    super(...arguments);
-    this.localOption = import_clipanion3.Option.Boolean("--local", {
-      description: "Starts local Graphql server and builds the local client instead of production client"
-    });
-    this.skipIndexing = import_clipanion3.Option.Boolean("--skip-indexing", false, {
-      description: "Skips indexing the content. This can be used for building the site without indexing the content  (defaults to false)"
-    });
-    this.partialReindex = import_clipanion3.Option.Boolean("--partial-reindex", false, {
-      description: "Re-indexes only the content that has changed since the last build (defaults to false). Not currently supported for separate content repos."
-    });
-    this.tinaGraphQLVersion = import_clipanion3.Option.String("--tina-graphql-version", {
-      description: "Specify the version of @tinacms/graphql to use (defaults to latest)"
-    });
-    /**
-     * This option allows the user to skip the TinaCloud checks if they want to. This could be useful for mismatched GraphQL versions or if they want to build only using the local client and never connect to TinaCloud
-     */
-    this.skipCloudChecks = import_clipanion3.Option.Boolean("--skip-cloud-checks", false, {
-      description: "Skips checking the provided cloud config."
-    });
-    this.skipSearchIndex = import_clipanion3.Option.Boolean("--skip-search-index", false, {
-      description: "Skip indexing the site for search"
-    });
-    this.upstreamBranch = import_clipanion3.Option.String("--upstream-branch", {
-      description: "Optional upstream branch with the schema. If not specified, default will be used."
-    });
-    this.previewBaseBranch = import_clipanion3.Option.String("--preview-base-branch", {
-      description: "The base branch for the preview"
-    });
-    this.previewName = import_clipanion3.Option.String("--preview-name", {
-      description: "The name of the preview branch"
-    });
-    this.noClientBuildCache = import_clipanion3.Option.Boolean("--no-client-build-cache", false, {
-      description: "Disables the client build cache"
-    });
-  }
-  static {
-    this.paths = [["build"]];
-  }
-  static {
-    this.usage = import_clipanion3.Command.Usage({
-      category: `Commands`,
-      description: `Build the CMS and autogenerated modules for usage with TinaCloud`
-    });
-  }
+  static paths = [["build"]];
+  localOption = Option3.Boolean("--local", {
+    description: "Starts local Graphql server and builds the local client instead of production client"
+  });
+  skipIndexing = Option3.Boolean("--skip-indexing", false, {
+    description: "Skips indexing the content. This can be used for building the site without indexing the content  (defaults to false)"
+  });
+  partialReindex = Option3.Boolean("--partial-reindex", false, {
+    description: "Re-indexes only the content that has changed since the last build (defaults to false). Not currently supported for separate content repos."
+  });
+  tinaGraphQLVersion = Option3.String("--tina-graphql-version", {
+    description: "Specify the version of @tinacms/graphql to use (defaults to latest)"
+  });
+  /**
+   * This option allows the user to skip the TinaCloud checks if they want to. This could be useful for mismatched GraphQL versions or if they want to build only using the local client and never connect to TinaCloud
+   */
+  skipCloudChecks = Option3.Boolean("--skip-cloud-checks", false, {
+    description: "Skips checking the provided cloud config."
+  });
+  skipSearchIndex = Option3.Boolean("--skip-search-index", false, {
+    description: "Skip indexing the site for search"
+  });
+  upstreamBranch = Option3.String("--upstream-branch", {
+    description: "Optional upstream branch with the schema. If not specified, default will be used."
+  });
+  previewBaseBranch = Option3.String("--preview-base-branch", {
+    description: "The base branch for the preview"
+  });
+  previewName = Option3.String("--preview-name", {
+    description: "The name of the preview branch"
+  });
+  noClientBuildCache = Option3.Boolean("--no-client-build-cache", false, {
+    description: "Disables the client build cache"
+  });
+  static usage = Command3.Usage({
+    category: `Commands`,
+    description: `Build the CMS and autogenerated modules for usage with TinaCloud`
+  });
   async catch(error) {
     console.error(error);
     process.exit(1);
@@ -2909,7 +2961,7 @@ ${dangerText(e.message)}`);
       configManager,
       Number(this.datalayerPort)
     );
-    const { queryDoc, fragDoc, graphQLSchema, tinaSchema, lookup } = await (0, import_graphql11.buildSchema)(configManager.config);
+    const { queryDoc, fragDoc, graphQLSchema, tinaSchema, lookup } = await buildSchema2(configManager.config);
     const codegen2 = new Codegen({
       configManager,
       port: this.localOption ? Number(this.port) : void 0,
@@ -3017,7 +3069,7 @@ ${dangerText(e.message)}
       }
     }
     await buildProductionSpa(configManager, database, codegen2.productionUrl);
-    await import_fs_extra7.default.outputFile(
+    await fs8.outputFile(
       configManager.outputGitignorePath,
       "index.html\nassets/"
     );
@@ -3049,7 +3101,7 @@ ${dangerText(e.message)}
             "indexerToken not configured in tina search configuration."
           );
         }
-        client = new import_search2.TinaCMSSearchIndexClient({
+        client = new TinaCMSSearchIndexClient({
           apiUrl: `${configManager.config.tinaioConfig?.contentApiUrlOverride || "https://content.tinajs.io"}/searchIndex/${configManager.config?.clientId}`,
           branch: configManager.config?.branch,
           indexerToken: configManager.config?.search?.tina?.indexerToken,
@@ -3058,9 +3110,9 @@ ${dangerText(e.message)}
       } else {
         client = configManager.config?.search?.searchClient;
       }
-      const searchIndexer = new import_search2.SearchIndexer({
+      const searchIndexer = new SearchIndexer2({
         batchSize: configManager.config.search?.indexBatchSize || 100,
-        bridge: new import_graphql11.FilesystemBridge(
+        bridge: new FilesystemBridge3(
           configManager.rootPath,
           configManager.contentRootPath
         ),
@@ -3130,8 +3182,8 @@ ${dangerText(e.message)}
     const MAX_RETRIES = 5;
     const { config: config2 } = configManager;
     const token = config2.token;
-    const { clientId, branch, host } = (0, import_schema_tools2.parseURL)(apiURL);
-    const bar2 = new import_progress2.default("Checking clientId and token. :prog", 1);
+    const { clientId, branch, host } = parseURL2(apiURL);
+    const bar2 = new Progress2("Checking clientId and token. :prog", 1);
     const getBranchInfo = async () => {
       const url = `https://${host}/db/${clientId}/status/${previewBaseBranch || branch}`;
       const branchInfo2 = {
@@ -3185,7 +3237,7 @@ ${dangerText(e.message)}
     bar2.tick({
       prog: "\u2705"
     });
-    const branchBar = new import_progress2.default(
+    const branchBar = new Progress2(
       `Checking branch '${config2.branch}' is on TinaCloud. :prog`,
       1
     );
@@ -3225,7 +3277,7 @@ ${dangerText(e.message)}
   async syncProject(configManager, apiURL, options) {
     const { config: config2 } = configManager;
     const token = config2.token;
-    const { clientId, branch, host } = (0, import_schema_tools2.parseURL)(apiURL);
+    const { clientId, branch, host } = parseURL2(apiURL);
     const { previewName, previewBaseBranch, upstreamBranch } = options || {};
     let url = `https://${host}/db/${clientId}/reset/${branch}?refreshSchema=true&skipIfSchemaCurrent=true`;
     if (upstreamBranch && previewBaseBranch && previewName) {
@@ -3235,7 +3287,7 @@ ${dangerText(e.message)}
     } else if (upstreamBranch && !previewBaseBranch && !previewName) {
       url = `https://${host}/db/${clientId}/reset/${branch}?refreshSchema=true&skipIfSchemaCurrent=true&upstreamBranch=${upstreamBranch}`;
     }
-    const bar2 = new import_progress2.default("Syncing Project. :prog", 1);
+    const bar2 = new Progress2("Syncing Project. :prog", 1);
     try {
       const res = await request({
         token,
@@ -3276,7 +3328,7 @@ ${dangerText(e.message)}
     }
   }
   async checkGraphqlSchema(configManager, database, apiURL, timestamp) {
-    const bar2 = new import_progress2.default(
+    const bar2 = new Progress2(
       "Checking local GraphQL Schema matches server. :prog",
       1
     );
@@ -3298,11 +3350,11 @@ Additional info: Branch: ${config2.branch}, Client ID: ${config2.clientId} `;
       }
       throw new Error(errorMessage);
     }
-    const remoteGqlSchema = (0, import_graphql12.buildClientSchema)(remoteSchema);
+    const remoteGqlSchema = buildClientSchema(remoteSchema);
     const localSchemaDocument = await database.getGraphQLSchemaFromBridge();
-    const localGraphqlSchema = (0, import_graphql12.buildASTSchema)(localSchemaDocument);
+    const localGraphqlSchema = buildASTSchema2(localSchemaDocument);
     try {
-      const diffResult = await (0, import_core3.diff)(remoteGqlSchema, localGraphqlSchema);
+      const diffResult = await diff(remoteGqlSchema, localGraphqlSchema);
       if (diffResult.length === 0) {
         bar2.tick({
           prog: "\u2705"
@@ -3350,13 +3402,13 @@ Additional info:
     }
   }
   async checkTinaSchema(configManager, database, apiURL, previewName, verbose, timestamp) {
-    const bar2 = new import_progress2.default(
+    const bar2 = new Progress2(
       "Checking local Tina Schema matches server. :prog",
       1
     );
     const { config: config2 } = configManager;
     const token = config2.token;
-    const { clientId, branch, isLocalClient, host } = (0, import_schema_tools2.parseURL)(apiURL);
+    const { clientId, branch, isLocalClient, host } = parseURL2(apiURL);
     if (isLocalClient || !host || !clientId || !branch) {
       if (verbose) {
         logger.info(logText("Not using TinaCloud, skipping Tina Schema check"));
@@ -3384,11 +3436,11 @@ Additional info: Branch: ${config2.branch}, Client ID: ${config2.clientId} `;
     }
     const localTinaSchema = JSON.parse(
       await database.bridge.get(
-        import_path8.default.join(database.tinaDirectory, "__generated__", "_schema.json")
+        path9.join(database.tinaDirectory, "__generated__", "_schema.json")
       )
     );
     localTinaSchema.version = void 0;
-    const localTinaSchemaSha = import_crypto.default.createHash("sha256").update(JSON.stringify(localTinaSchema)).digest("hex");
+    const localTinaSchemaSha = crypto.createHash("sha256").update(JSON.stringify(localTinaSchema)).digest("hex");
     if (localTinaSchemaSha === remoteTinaSchemaSha) {
       bar2.tick({
         prog: "\u2705"
@@ -3466,7 +3518,7 @@ var fetchRemoteGraphqlSchema = async ({
     headers.append("X-API-KEY", token);
   }
   const body = JSON.stringify({
-    query: (0, import_graphql12.getIntrospectionQuery)(),
+    query: getIntrospectionQuery(),
     variables: {}
   });
   headers.append("Content-Type", "application/json");
@@ -3499,14 +3551,14 @@ var fetchSchemaSha = async ({
 };
 
 // src/next/commands/audit-command/index.ts
-var import_clipanion4 = require("clipanion");
-var import_graphql14 = require("@tinacms/graphql");
+import { Command as Command4, Option as Option4 } from "clipanion";
+import { buildSchema as buildSchema3 } from "@tinacms/graphql";
 
 // src/next/commands/audit-command/audit.ts
-var import_prompts = __toESM(require("prompts"));
-var import_metrics = require("@tinacms/metrics");
-var import_graphql13 = require("@tinacms/graphql");
-var import_chalk5 = __toESM(require("chalk"));
+import prompts from "prompts";
+import { Telemetry } from "@tinacms/metrics";
+import { resolve } from "@tinacms/graphql";
+import chalk5 from "chalk";
 var audit = async ({
   database,
   clean,
@@ -3514,7 +3566,7 @@ var audit = async ({
   noTelemetry,
   verbose
 }) => {
-  const telemetry = new import_metrics.Telemetry({ disabled: noTelemetry });
+  const telemetry = new Telemetry({ disabled: noTelemetry });
   await telemetry.submitRecord({
     event: {
       name: "tinacms:cli:audit:invoke",
@@ -3524,25 +3576,25 @@ var audit = async ({
   });
   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_chalk5.default.bold(
+      `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 ${chalk5.bold(
         "clean git tree"
       )} so unwanted changes can be undone.
 
 `
     );
-    const res = await (0, import_prompts.default)({
+    const res = await prompts({
       name: "useClean",
       type: "confirm",
       message: `Do you want to continue?`
     });
     if (!res.useClean) {
-      logger.warn(import_chalk5.default.yellowBright("\u26A0\uFE0F Audit not complete"));
+      logger.warn(chalk5.yellowBright("\u26A0\uFE0F Audit not complete"));
       process.exit(0);
     }
   }
   if (useDefaultValues && !clean) {
     logger.warn(
-      import_chalk5.default.yellowBright(
+      chalk5.yellowBright(
         "WARNING: using the `--useDefaultValues` without the `--clean` flag has no effect. Please re-run audit and add the `--clean` flag"
       )
     );
@@ -3570,10 +3622,10 @@ var audit = async ({
   }
   if (error) {
     logger.error(
-      import_chalk5.default.redBright(`\u203C\uFE0F Audit ${import_chalk5.default.bold("failed")} with errors`)
+      chalk5.redBright(`\u203C\uFE0F Audit ${chalk5.bold("failed")} with errors`)
     );
   } else {
-    logger.info(import_chalk5.default.greenBright("\u2705 Audit passed"));
+    logger.info(chalk5.greenBright("\u2705 Audit passed"));
   }
 };
 var auditDocuments = async (args) => {
@@ -3590,7 +3642,7 @@ var auditDocuments = async (args) => {
           }
         }
       }`;
-    const docResult = await (0, import_graphql13.resolve)({
+    const docResult = await resolve({
       database,
       query: documentQuery,
       variables: {},
@@ -3601,11 +3653,11 @@ var auditDocuments = async (args) => {
     if (docResult.errors) {
       error = true;
       docResult.errors.forEach((err) => {
-        logger.error(import_chalk5.default.red(err.message));
+        logger.error(chalk5.red(err.message));
         if (err.originalError.originalError) {
           logger.error(
             // @ts-ignore FIXME: this doesn't seem right
-            import_chalk5.default.red(`    ${err.originalError.originalError.message}`)
+            chalk5.red(`    ${err.originalError.originalError.message}`)
           );
         }
       });
@@ -3632,7 +3684,7 @@ var auditDocuments = async (args) => {
           params: $params
         ){__typename}
       }`;
-      const mutationRes = await (0, import_graphql13.resolve)({
+      const mutationRes = await resolve({
         database,
         query: mutation,
         variables: {
@@ -3647,7 +3699,7 @@ var auditDocuments = async (args) => {
       if (mutationRes.errors) {
         mutationRes.errors.forEach((err) => {
           error = true;
-          logger.error(import_chalk5.default.red(err.message));
+          logger.error(chalk5.red(err.message));
         });
       }
     }
@@ -3664,38 +3716,31 @@ function filterObject(obj) {
 }
 
 // src/next/commands/audit-command/index.ts
-var import_graphql15 = require("@tinacms/graphql");
-var AuditCommand = 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"
-    });
-    this.verbose = import_clipanion4.Option.Boolean("-v,--verbose", false, {
-      description: "increase verbosity of logged output"
-    });
-    this.clean = import_clipanion4.Option.Boolean("--clean", false, {
-      description: "Clean the output"
-    });
-    this.useDefaultValues = import_clipanion4.Option.Boolean("--useDefaultValues", false, {
-      description: "When cleaning the output, use defaults on the config"
-    });
-    this.noTelemetry = import_clipanion4.Option.Boolean("--noTelemetry", false, {
-      description: "Disable anonymous telemetry that is collected"
-    });
-    this.datalayerPort = import_clipanion4.Option.String("--datalayer-port", "9000", {
-      description: "Specify a port to run the datalayer server on. (default 9000)"
-    });
-  }
-  static {
-    this.paths = [["audit"]];
-  }
-  static {
-    this.usage = import_clipanion4.Command.Usage({
-      category: `Commands`,
-      description: `Audit config and content files`
-    });
-  }
+import { AuditFileSystemBridge } from "@tinacms/graphql";
+var AuditCommand = class extends Command4 {
+  static paths = [["audit"]];
+  rootPath = Option4.String("--rootPath", {
+    description: "Specify the root directory to run the CLI from"
+  });
+  verbose = Option4.Boolean("-v,--verbose", false, {
+    description: "increase verbosity of logged output"
+  });
+  clean = Option4.Boolean("--clean", false, {
+    description: "Clean the output"
+  });
+  useDefaultValues = Option4.Boolean("--useDefaultValues", false, {
+    description: "When cleaning the output, use defaults on the config"
+  });
+  noTelemetry = Option4.Boolean("--noTelemetry", false, {
+    description: "Disable anonymous telemetry that is collected"
+  });
+  datalayerPort = Option4.String("--datalayer-port", "9000", {
+    description: "Specify a port to run the datalayer server on. (default 9000)"
+  });
+  static usage = Command4.Usage({
+    category: `Commands`,
+    description: `Audit config and content files`
+  });
   async catch(error) {
     logger.error("Error occured during tinacms audit");
     if (this.verbose) {
@@ -3716,9 +3761,9 @@ var AuditCommand = class extends import_clipanion4.Command {
     const database = await createAndInitializeDatabase(
       configManager,
       Number(this.datalayerPort),
-      this.clean ? void 0 : new import_graphql15.AuditFileSystemBridge(configManager.rootPath)
+      this.clean ? void 0 : new AuditFileSystemBridge(configManager.rootPath)
     );
-    const { tinaSchema, graphQLSchema, lookup } = await (0, import_graphql14.buildSchema)(
+    const { tinaSchema, graphQLSchema, lookup } = await buildSchema3(
       configManager.config
     );
     const warnings = [];
@@ -3751,29 +3796,29 @@ var AuditCommand = class extends import_clipanion4.Command {
 };
 
 // src/next/commands/init-command/index.ts
-var import_clipanion6 = require("clipanion");
+import { Command as Command6, Option as Option6 } from "clipanion";
 
 // src/cmds/init/detectEnvironment.ts
-var import_fs_extra8 = __toESM(require("fs-extra"));
-var import_path9 = __toESM(require("path"));
+import fs9 from "fs-extra";
+import path10 from "path";
 var checkGitignoreForItem = async ({
   baseDir,
   line
 }) => {
-  const gitignoreContent = import_fs_extra8.default.readFileSync(import_path9.default.join(baseDir, ".gitignore")).toString();
+  const gitignoreContent = fs9.readFileSync(path10.join(baseDir, ".gitignore")).toString();
   return gitignoreContent.split("\n").some((item) => item === line);
 };
 var makeGeneratedFile = async (name2, generatedFileType, parentPath, opts) => {
   const result = {
-    fullPathTS: import_path9.default.join(
+    fullPathTS: path10.join(
       parentPath,
       `${name2}.${opts?.typescriptSuffix || opts?.extensionOverride || "ts"}`
     ),
-    fullPathJS: import_path9.default.join(
+    fullPathJS: path10.join(
       parentPath,
       `${name2}.${opts?.extensionOverride || "js"}`
     ),
-    fullPathOverride: opts?.extensionOverride ? import_path9.default.join(parentPath, `${name2}.${opts?.extensionOverride}`) : "",
+    fullPathOverride: opts?.extensionOverride ? path10.join(parentPath, `${name2}.${opts?.extensionOverride}`) : "",
     generatedFileType,
     name: name2,
     parentPath,
@@ -3791,8 +3836,8 @@ var makeGeneratedFile = async (name2, generatedFileType, parentPath, opts) => {
       };
     }
   };
-  result.typescriptExists = await import_fs_extra8.default.pathExists(result.fullPathTS);
-  result.javascriptExists = await import_fs_extra8.default.pathExists(result.fullPathJS);
+  result.typescriptExists = await fs9.pathExists(result.fullPathTS);
+  result.javascriptExists = await fs9.pathExists(result.fullPathJS);
   return result;
 };
 var detectEnvironment = async ({
@@ -3801,21 +3846,21 @@ var detectEnvironment = async ({
   rootPath,
   debug = false
 }) => {
-  const hasForestryConfig = await import_fs_extra8.default.pathExists(
-    import_path9.default.join(pathToForestryConfig, ".forestry", "settings.yml")
+  const hasForestryConfig = await fs9.pathExists(
+    path10.join(pathToForestryConfig, ".forestry", "settings.yml")
   );
-  const sampleContentPath = import_path9.default.join(
+  const sampleContentPath = path10.join(
     baseDir,
     "content",
     "posts",
     "hello-world.md"
   );
-  const usingSrc = import_fs_extra8.default.pathExistsSync(import_path9.default.join(baseDir, "src")) && (import_fs_extra8.default.pathExistsSync(import_path9.default.join(baseDir, "src", "app")) || import_fs_extra8.default.pathExistsSync(import_path9.default.join(baseDir, "src", "pages")));
-  const tinaFolder = import_path9.default.join(baseDir, "tina");
+  const usingSrc = fs9.pathExistsSync(path10.join(baseDir, "src")) && (fs9.pathExistsSync(path10.join(baseDir, "src", "app")) || fs9.pathExistsSync(path10.join(baseDir, "src", "pages")));
+  const tinaFolder = path10.join(baseDir, "tina");
   const tinaConfigExists = Boolean(
     // Does the tina folder exist?
-    await import_fs_extra8.default.pathExists(tinaFolder) && // Does the tina folder contain a config file?
-    (await import_fs_extra8.default.readdir(tinaFolder)).find((x) => x.includes("config"))
+    await fs9.pathExists(tinaFolder) && // Does the tina folder contain a config file?
+    (await fs9.readdir(tinaFolder)).find((x) => x.includes("config"))
   );
   const pagesDir = [baseDir, usingSrc ? "src" : false, "pages"].filter(
     Boolean
@@ -3827,12 +3872,12 @@ var detectEnvironment = async ({
     "next-api-handler": await makeGeneratedFile(
       "[...routes]",
       "next-api-handler",
-      import_path9.default.join(...pagesDir, "api", "tina")
+      path10.join(...pagesDir, "api", "tina")
     ),
     "reactive-example": await makeGeneratedFile(
       "[filename]",
       "reactive-example",
-      import_path9.default.join(...pagesDir, "demo", "blog"),
+      path10.join(...pagesDir, "demo", "blog"),
       {
         typescriptSuffix: "tsx"
       }
@@ -3840,22 +3885,22 @@ var detectEnvironment = async ({
     "users-json": await makeGeneratedFile(
       "index",
       "users-json",
-      import_path9.default.join(baseDir, "content", "users"),
+      path10.join(baseDir, "content", "users"),
       { extensionOverride: "json" }
     ),
     "sample-content": await makeGeneratedFile(
       "hello-world",
       "sample-content",
-      import_path9.default.join(baseDir, "content", "posts"),
+      path10.join(baseDir, "content", "posts"),
       { extensionOverride: "md" }
     )
   };
-  const hasSampleContent = await import_fs_extra8.default.pathExists(sampleContentPath);
-  const hasPackageJSON = await import_fs_extra8.default.pathExists("package.json");
+  const hasSampleContent = await fs9.pathExists(sampleContentPath);
+  const hasPackageJSON = await fs9.pathExists("package.json");
   let hasTinaDeps = false;
   if (hasPackageJSON) {
     try {
-      const packageJSON = await import_fs_extra8.default.readJSON("package.json");
+      const packageJSON = await fs9.readJSON("package.json");
       const deps = [];
       if (packageJSON?.dependencies) {
         deps.push(...Object.keys(packageJSON.dependencies));
@@ -3872,15 +3917,15 @@ var detectEnvironment = async ({
       );
     }
   }
-  const hasGitIgnore = await import_fs_extra8.default.pathExists(import_path9.default.join(".gitignore"));
+  const hasGitIgnore = await fs9.pathExists(path10.join(".gitignore"));
   const hasGitIgnoreNodeModules = hasGitIgnore && await checkGitignoreForItem({ baseDir, line: "node_modules" });
   const hasEnvTina = hasGitIgnore && await checkGitignoreForItem({ baseDir, line: ".env.tina" });
   const hasGitIgnoreEnv = hasGitIgnore && await checkGitignoreForItem({ baseDir, line: ".env" });
   let frontMatterFormat;
   if (hasForestryConfig) {
-    const hugoConfigPath = import_path9.default.join(rootPath, "config.toml");
-    if (await import_fs_extra8.default.pathExists(hugoConfigPath)) {
-      const hugoConfig = await import_fs_extra8.default.readFile(hugoConfigPath, "utf8");
+    const hugoConfigPath = path10.join(rootPath, "config.toml");
+    if (await fs9.pathExists(hugoConfigPath)) {
+      const hugoConfig = await fs9.readFile(hugoConfigPath, "utf8");
       const metaDataFormat = hugoConfig.toString().match(/metaDataFormat = "(.*)"/)?.[1];
       if (metaDataFormat && (metaDataFormat === "yaml" || metaDataFormat === "toml" || metaDataFormat === "json")) {
         frontMatterFormat = metaDataFormat;
@@ -3911,10 +3956,10 @@ var detectEnvironment = async ({
 var detectEnvironment_default = detectEnvironment;
 
 // src/cmds/init/prompts/index.ts
-var import_prompts6 = __toESM(require("prompts"));
+import prompts6 from "prompts";
 
 // src/cmds/init/prompts/askTinaCloudSetup.ts
-var import_prompts2 = __toESM(require("prompts"));
+import prompts2 from "prompts";
 var tinaCloudSetupQuestions = [
   {
     name: "clientId",
@@ -3936,7 +3981,7 @@ ${logText(
   }
 ];
 var askTinaCloudSetup = async ({ config: config2 }) => {
-  const { clientId, token } = await (0, import_prompts2.default)(tinaCloudSetupQuestions);
+  const { clientId, token } = await prompts2(tinaCloudSetupQuestions);
   config2.envVars.push(
     {
       key: "NEXT_PUBLIC_TINA_CLIENT_ID",
@@ -3950,7 +3995,7 @@ var askTinaCloudSetup = async ({ config: config2 }) => {
 };
 
 // src/cmds/init/prompts/gitProvider.ts
-var import_prompts3 = __toESM(require("prompts"));
+import prompts3 from "prompts";
 var supportedGitProviders = {
   github: {
     imports: [
@@ -3972,7 +4017,7 @@ var supportedGitProviders = {
   }
 };
 var chooseGitProvider = async ({ config: config2 }) => {
-  const result = await (0, import_prompts3.default)([
+  const result = await prompts3([
     {
       name: "githubToken",
       type: "text",
@@ -4017,7 +4062,7 @@ ${logText(
 };
 
 // src/cmds/init/prompts/databaseAdapter.ts
-var import_prompts4 = __toESM(require("prompts"));
+import prompts4 from "prompts";
 var supportedDatabaseAdapters = {
   ["upstash-redis"]: {
     databaseAdapterClassText: `new RedisLevel({
@@ -4063,7 +4108,7 @@ var databaseAdapterUpdateConfig = {
   other: async (_args) => {
   },
   mongodb: async ({ config: config2 }) => {
-    const result = await (0, import_prompts4.default)([
+    const result = await prompts4([
       {
         name: "mongoDBUri",
         type: "text",
@@ -4078,7 +4123,7 @@ var databaseAdapterUpdateConfig = {
     });
   },
   "upstash-redis": async ({ config: config2 }) => {
-    const result = await (0, import_prompts4.default)([
+    const result = await prompts4([
       {
         name: "kvRestApiUrl",
         type: "text",
@@ -4109,7 +4154,7 @@ var chooseDatabaseAdapter = async ({
   framework,
   config: config2
 }) => {
-  const answers = await (0, import_prompts4.default)([
+  const answers = await prompts4([
     {
       name: "dataLayerAdapter",
       message: "Select a self-hosted Database Adapter",
@@ -4139,8 +4184,8 @@ var chooseDatabaseAdapter = async ({
 };
 
 // src/cmds/init/prompts/authProvider.ts
-var import_crypto_js = __toESM(require("crypto-js"));
-var import_prompts5 = __toESM(require("prompts"));
+import crypto2 from "crypto-js";
+import prompts5 from "prompts";
 var supportedAuthProviders = {
   other: {
     name: "other"
@@ -4189,12 +4234,12 @@ var authProviderUpdateConfig = {
   },
   "tina-cloud": askTinaCloudSetup,
   "next-auth": async ({ config: config2 }) => {
-    const result = await (0, import_prompts5.default)([
+    const result = await prompts5([
       {
         name: "nextAuthSecret",
         type: "text",
         message: `What is the NextAuth.js Secret? (Hit enter to use a randomly generated secret)`,
-        initial: process.env.NEXTAUTH_SECRET || import_crypto_js.default.lib.WordArray.random(16).toString()
+        initial: process.env.NEXTAUTH_SECRET || crypto2.lib.WordArray.random(16).toString()
       }
     ]);
     config2.envVars.push({
@@ -4219,7 +4264,7 @@ var forestryDisclaimer = logText(
   `Note: This migration will update some of your content to match tina.  Please save a backup of your content before doing this migration. (This can be done with git)`
 );
 var askCommonSetUp = async () => {
-  const answers = await (0, import_prompts6.default)([
+  const answers = await prompts6([
     {
       name: "framework",
       type: "select",
@@ -4283,7 +4328,7 @@ ${forestryDisclaimer}`
       message: `What format are you using in your frontmatter?`
     });
   }
-  const answers = await (0, import_prompts6.default)(questions);
+  const answers = await prompts6(questions);
   return answers;
 };
 var askTinaSetupPrompts = async (params) => {
@@ -4308,11 +4353,11 @@ var askTinaSetupPrompts = async (params) => {
       )
     });
   }
-  const answers = await (0, import_prompts6.default)(questions);
+  const answers = await prompts6(questions);
   return answers;
 };
 var askIfUsingSelfHosted = async () => {
-  const answers = await (0, import_prompts6.default)([
+  const answers = await prompts6([
     {
       name: "hosting",
       type: "select",
@@ -4345,20 +4390,20 @@ var makeImportString = (imports) => {
 };
 
 // src/cmds/init/prompts/generatedFiles.ts
-var import_prompts7 = __toESM(require("prompts"));
+import prompts7 from "prompts";
 var askIfOverride = async ({
   generatedFile,
   usingTypescript
 }) => {
   if (usingTypescript) {
-    const result = await (0, import_prompts7.default)({
+    const result = await prompts7({
       name: `override`,
       type: "confirm",
       message: `Found existing file at ${generatedFile.fullPathTS}. Would you like to overwrite?`
     });
     return Boolean(result.override);
   } else {
-    const result = await (0, import_prompts7.default)({
+    const result = await prompts7({
       name: `override`,
       type: "confirm",
       message: `Found existing file at ${generatedFile.fullPathJS}. Would you like to overwrite?`
@@ -4493,24 +4538,25 @@ var CLICommand = class {
 };
 
 // src/cmds/init/apply.ts
-var import_path13 = __toESM(require("path"));
+import path14 from "path";
 
 // src/cmds/forestry-migrate/index.ts
-var import_fs_extra10 = __toESM(require("fs-extra"));
-var import_path11 = __toESM(require("path"));
-var import_js_yaml2 = __toESM(require("js-yaml"));
-var import_minimatch = require("minimatch");
-var import_graphql16 = require("@tinacms/graphql");
-var import_schema_tools3 = require("@tinacms/schema-tools");
+import fs11 from "fs-extra";
+import path12 from "path";
+import yaml2 from "js-yaml";
+import pkg from "minimatch";
+import { parseFile, stringifyFile } from "@tinacms/graphql";
+import { CONTENT_FORMATS } from "@tinacms/schema-tools";
 
 // src/cmds/forestry-migrate/util/index.ts
-var import_fs_extra9 = __toESM(require("fs-extra"));
-var import_path10 = __toESM(require("path"));
-var import_js_yaml = __toESM(require("js-yaml"));
-var import_zod = __toESM(require("zod"));
+import fs10 from "fs-extra";
+import path11 from "path";
+import yaml from "js-yaml";
+import z from "zod";
 
 // src/cmds/forestry-migrate/util/errorSingleton.ts
 var ErrorSingleton = class _ErrorSingleton {
+  static instance;
   /**
    * The Singleton's constructor should always be private to prevent direct
    * construction calls with the `new` operator.
@@ -4530,6 +4576,7 @@ var ErrorSingleton = class _ErrorSingleton {
     }
     return _ErrorSingleton.instance;
   }
+  collectionNameErrors;
   addErrorName(error) {
     this.collectionNameErrors.push(error);
   }
@@ -4552,8 +4599,8 @@ var ErrorSingleton = class _ErrorSingleton {
 };
 
 // src/cmds/forestry-migrate/util/codeTransformer.ts
-var import_prettier = require("prettier");
-var import_parser_typescript = __toESM(require("prettier/parser-typescript"));
+import { format } from "prettier";
+import TsParser from "prettier/parser-typescript.js";
 var addVariablesToCode = (codeWithTinaPrefix) => {
   const code = codeWithTinaPrefix.replace(
     /"__TINA_INTERNAL__:::(.*?):::"/g,
@@ -4590,7 +4637,7 @@ var makeTemplateFile = async ({
       `export function ${stringifyLabelWithField(
         template.templateObj.label
       )} (){
-        return ${addVariablesToCode(JSON.stringify(template.fields, null, 2)).code} ${usingTypescript ? "as TinaField[]" : ""} 
+        return ${addVariablesToCode(JSON.stringify(template.fields, null, 2)).code} ${usingTypescript ? "as TinaField[]" : ""}
       } `
     );
   }
@@ -4598,9 +4645,9 @@ var makeTemplateFile = async ({
 ${usingTypescript ? "import type { TinaField } from 'tinacms'" : ""}
 ${templateCodeText.join("\n")}
   `;
-  const formattedCode = (0, import_prettier.format)(templateCode, {
+  const formattedCode = format(templateCode, {
     parser: "typescript",
-    plugins: [import_parser_typescript.default]
+    plugins: [TsParser]
   });
   return { importStatements, templateCodeText: formattedCode };
 };
@@ -4632,82 +4679,82 @@ var stringifyTemplateName = (name2, template) => {
     return newName;
   }
 };
-var forestryConfigSchema = import_zod.default.object({
-  sections: import_zod.default.array(
-    import_zod.default.object({
-      type: import_zod.default.union([
-        import_zod.default.literal("directory"),
-        import_zod.default.literal("document"),
-        import_zod.default.literal("heading"),
-        import_zod.default.literal("jekyll-pages"),
-        import_zod.default.literal("jekyll-posts")
+var forestryConfigSchema = z.object({
+  sections: z.array(
+    z.object({
+      type: z.union([
+        z.literal("directory"),
+        z.literal("document"),
+        z.literal("heading"),
+        z.literal("jekyll-pages"),
+        z.literal("jekyll-posts")
       ]),
-      label: import_zod.default.string(),
-      path: import_zod.default.string().optional().nullable(),
-      match: import_zod.default.string().optional().nullable(),
-      exclude: import_zod.default.string().optional().nullable(),
-      create: import_zod.default.union([import_zod.default.literal("all"), import_zod.default.literal("documents"), import_zod.default.literal("none")]).optional(),
-      templates: import_zod.default.array(import_zod.default.string()).optional().nullable(),
-      new_doc_ext: import_zod.default.string().optional().nullable(),
-      read_only: import_zod.default.boolean().optional().nullable()
+      label: z.string(),
+      path: z.string().optional().nullable(),
+      match: z.string().optional().nullable(),
+      exclude: z.string().optional().nullable(),
+      create: z.union([z.literal("all"), z.literal("documents"), z.literal("none")]).optional(),
+      templates: z.array(z.string()).optional().nullable(),
+      new_doc_ext: z.string().optional().nullable(),
+      read_only: z.boolean().optional().nullable()
     })
   )
 });
-var forestryFieldWithoutField = import_zod.default.object({
+var forestryFieldWithoutField = z.object({
   // TODO: maybe better type this?
-  type: import_zod.default.union([
-    import_zod.default.literal("text"),
-    import_zod.default.literal("datetime"),
-    import_zod.default.literal("list"),
-    import_zod.default.literal("file"),
-    import_zod.default.literal("image_gallery"),
-    import_zod.default.literal("textarea"),
-    import_zod.default.literal("tag_list"),
-    import_zod.default.literal("number"),
-    import_zod.default.literal("boolean"),
-    import_zod.default.literal("field_group"),
-    import_zod.default.literal("field_group_list"),
-    import_zod.default.literal("select"),
-    import_zod.default.literal("include"),
-    import_zod.default.literal("blocks"),
-    import_zod.default.literal("color")
+  type: z.union([
+    z.literal("text"),
+    z.literal("datetime"),
+    z.literal("list"),
+    z.literal("file"),
+    z.literal("image_gallery"),
+    z.literal("textarea"),
+    z.literal("tag_list"),
+    z.literal("number"),
+    z.literal("boolean"),
+    z.literal("field_group"),
+    z.literal("field_group_list"),
+    z.literal("select"),
+    z.literal("include"),
+    z.literal("blocks"),
+    z.literal("color")
   ]),
-  template_types: import_zod.default.array(import_zod.default.string()).optional().nullable(),
-  name: import_zod.default.string(),
-  label: import_zod.default.string(),
-  default: import_zod.default.any().optional(),
-  template: import_zod.default.string().optional(),
-  config: import_zod.default.object({
+  template_types: z.array(z.string()).optional().nullable(),
+  name: z.string(),
+  label: z.string(),
+  default: z.any().optional(),
+  template: z.string().optional(),
+  config: z.object({
     // min and max are used for lists
-    min: import_zod.default.number().optional().nullable(),
-    max: import_zod.default.number().optional().nullable(),
-    required: import_zod.default.boolean().optional().nullable(),
-    use_select: import_zod.default.boolean().optional().nullable(),
-    date_format: import_zod.default.string().optional().nullable(),
-    time_format: import_zod.default.string().optional().nullable(),
-    options: import_zod.default.array(import_zod.default.string()).optional().nullable(),
-    source: import_zod.default.object({
-      type: import_zod.default.union([
-        import_zod.default.literal("custom"),
-        import_zod.default.literal("pages"),
-        import_zod.default.literal("documents"),
-        import_zod.default.literal("simple"),
+    min: z.number().optional().nullable(),
+    max: z.number().optional().nullable(),
+    required: z.boolean().optional().nullable(),
+    use_select: z.boolean().optional().nullable(),
+    date_format: z.string().optional().nullable(),
+    time_format: z.string().optional().nullable(),
+    options: z.array(z.string()).optional().nullable(),
+    source: z.object({
+      type: z.union([
+        z.literal("custom"),
+        z.literal("pages"),
+        z.literal("documents"),
+        z.literal("simple"),
         // TODO: I want to ignore this key if its invalid
-        import_zod.default.string()
+        z.string()
       ]).optional().nullable(),
-      section: import_zod.default.string().optional().nullable()
+      section: z.string().optional().nullable()
     }).optional()
   }).optional()
 });
-var forestryField = import_zod.default.lazy(
+var forestryField = z.lazy(
   () => forestryFieldWithoutField.extend({
-    fields: import_zod.default.array(forestryField).optional()
+    fields: z.array(forestryField).optional()
   })
 );
-var FrontmatterTemplateSchema = import_zod.default.object({
-  label: import_zod.default.string(),
-  hide_body: import_zod.default.boolean().optional(),
-  fields: import_zod.default.array(forestryField).optional()
+var FrontmatterTemplateSchema = z.object({
+  label: z.string(),
+  hide_body: z.boolean().optional(),
+  fields: z.array(forestryField).optional()
 });
 var transformForestryFieldsToTinaFields = ({
   fields,
@@ -4930,7 +4977,7 @@ var transformForestryFieldsToTinaFields = ({
   return tinaFields;
 };
 var getFieldsFromTemplates = ({ tem, pathToForestryConfig, skipBlocks = false }) => {
-  const templatePath = import_path10.default.join(
+  const templatePath = path11.join(
     pathToForestryConfig,
     ".forestry",
     "front_matter",
@@ -4939,7 +4986,7 @@ var getFieldsFromTemplates = ({ tem, pathToForestryConfig, skipBlocks = false })
   );
   let templateString = "";
   try {
-    templateString = import_fs_extra9.default.readFileSync(templatePath).toString();
+    templateString = fs10.readFileSync(templatePath).toString();
   } catch {
     throw new Error(
       `Could not find template ${tem} at ${templatePath}
@@ -4947,7 +4994,7 @@ var getFieldsFromTemplates = ({ tem, pathToForestryConfig, skipBlocks = false })
  This will require manual migration.`
     );
   }
-  const templateObj = import_js_yaml.default.load(templateString);
+  const templateObj = yaml.load(templateString);
   const template = parseTemplates({ val: templateObj });
   const fields = transformForestryFieldsToTinaFields({
     fields: template.fields,
@@ -4967,6 +5014,7 @@ var parseSections = ({ val }) => {
 };
 
 // src/cmds/forestry-migrate/index.ts
+var { minimatch } = pkg;
 var BODY_FIELD = {
   // This is the body field
   type: "rich-text",
@@ -4995,7 +5043,7 @@ var transformForestryMatchToTinaMatch = (match) => {
 };
 function checkExt(ext) {
   const extReal = ext.replace(".", "");
-  if (import_schema_tools3.CONTENT_FORMATS.includes(extReal)) {
+  if (CONTENT_FORMATS.includes(extReal)) {
     return extReal;
   } else {
     return false;
@@ -5004,9 +5052,9 @@ function checkExt(ext) {
 var generateAllTemplates = async ({
   pathToForestryConfig
 }) => {
-  const allTemplates = (await import_fs_extra10.default.readdir(
-    import_path11.default.join(pathToForestryConfig, ".forestry", "front_matter", "templates")
-  )).map((tem) => import_path11.default.basename(tem, ".yml"));
+  const allTemplates = (await fs11.readdir(
+    path12.join(pathToForestryConfig, ".forestry", "front_matter", "templates")
+  )).map((tem) => path12.basename(tem, ".yml"));
   const templateMap = /* @__PURE__ */ new Map();
   const proms = allTemplates.map(async (tem) => {
     try {
@@ -5016,7 +5064,7 @@ var generateAllTemplates = async ({
       });
       templateMap.set(tem, { fields, templateObj });
     } catch (e) {
-      logger.log(`Error parsing template frontmatter template', tem + '.yml'`);
+      logger.warn(`Error parsing template frontmatter template, ${tem}.yml`);
       console.error(e);
       templateMap.set(tem, { fields: [], templateObj: {} });
     }
@@ -5060,7 +5108,7 @@ var generateCollectionFromForestrySection = (args) => {
   }
   if (section.type === "directory") {
     if (!section?.path || section.path === "/" || section.path === "./" || section.path === ".") {
-      logger.log(
+      logger.warn(
         warnText(
           `Warning: Section ${section.label} is using a Root Path. Currently, Tina Does not support Root paths see ${linkText(
             "https://github.com/tinacms/tinacms/issues/3768"
@@ -5081,7 +5129,7 @@ var generateCollectionFromForestrySection = (args) => {
             glob = section.path + "/" + section.match;
           }
           if (pages.some((page) => {
-            return (0, import_minimatch.minimatch)(page, glob);
+            return minimatch(page, glob);
           })) {
             forestryTemplates.push(templateKey);
           }
@@ -5151,9 +5199,9 @@ var generateCollectionFromForestrySection = (args) => {
     return c;
   } else if (section.type === "document") {
     const filePath = section.path;
-    const extname = import_path11.default.extname(filePath);
-    const fileName = import_path11.default.basename(filePath, extname);
-    const dir = import_path11.default.dirname(filePath);
+    const extname = path12.extname(filePath);
+    const fileName = path12.basename(filePath, extname);
+    const dir = path12.dirname(filePath);
     const ext = checkExt(extname);
     if (ext) {
       const fields = [];
@@ -5197,7 +5245,7 @@ var generateCollectionFromForestrySection = (args) => {
         fields
       };
     } else {
-      logger.log(
+      logger.warn(
         warnText(
           `Error: document section has an unsupported file extension: ${extname} in ${section.path}`
         )
@@ -5215,8 +5263,8 @@ var generateCollections = async ({
     templateMap,
     usingTypescript
   });
-  const forestryConfig = await import_fs_extra10.default.readFile(
-    import_path11.default.join(pathToForestryConfig, ".forestry", "settings.yml")
+  const forestryConfig = await fs11.readFile(
+    path12.join(pathToForestryConfig, ".forestry", "settings.yml")
   );
   rewriteTemplateKeysInDocs({
     templateMap,
@@ -5226,7 +5274,7 @@ var generateCollections = async ({
     }
   });
   const collections = parseSections({
-    val: import_js_yaml2.default.load(forestryConfig.toString())
+    val: yaml2.load(forestryConfig.toString())
   }).sections.map(
     (section) => generateCollectionFromForestrySection({
       section,
@@ -5246,13 +5294,13 @@ var rewriteTemplateKeysInDocs = (args) => {
     const { templateObj } = templateMap.get(templateKey);
     templateObj?.pages?.forEach((page) => {
       try {
-        const filePath = import_path11.default.join(page);
-        if (import_fs_extra10.default.lstatSync(filePath).isDirectory()) {
+        const filePath = path12.join(page);
+        if (fs11.lstatSync(filePath).isDirectory()) {
           return;
         }
-        const extname = import_path11.default.extname(filePath);
-        const fileContent = import_fs_extra10.default.readFileSync(filePath).toString();
-        const content = (0, import_graphql16.parseFile)(
+        const extname = path12.extname(filePath);
+        const fileContent = fs11.readFileSync(filePath).toString();
+        const content = parseFile(
           fileContent,
           extname,
           (yup) => yup.object({}),
@@ -5262,9 +5310,9 @@ var rewriteTemplateKeysInDocs = (args) => {
           _template: stringifyLabel(templateKey),
           ...content
         };
-        import_fs_extra10.default.writeFileSync(
+        fs11.writeFileSync(
           filePath,
-          (0, import_graphql16.stringifyFile)(newContent, extname, true, markdownParseConfig)
+          stringifyFile(newContent, extname, true, markdownParseConfig)
         );
       } catch (error) {
         console.log(
@@ -5276,32 +5324,25 @@ var rewriteTemplateKeysInDocs = (args) => {
 };
 
 // src/cmds/init/apply.ts
-var import_metrics2 = require("@tinacms/metrics");
-var import_fs_extra13 = __toESM(require("fs-extra"));
+import { Telemetry as Telemetry2 } from "@tinacms/metrics";
+import fs14 from "fs-extra";
 
 // src/next/commands/codemod-command/index.ts
-var import_clipanion5 = require("clipanion");
-var import_fs_extra11 = __toESM(require("fs-extra"));
-var import_path12 = __toESM(require("path"));
-var CodemodCommand = class extends import_clipanion5.Command {
-  constructor() {
-    super(...arguments);
-    this.rootPath = import_clipanion5.Option.String("--rootPath", {
-      description: "Specify the root directory to run the CLI from"
-    });
-    this.verbose = import_clipanion5.Option.Boolean("-v,--verbose", false, {
-      description: "increase verbosity of logged output"
-    });
-  }
-  static {
-    this.paths = [["codemod"], ["codemod", "move-tina-folder"]];
-  }
-  static {
-    this.usage = import_clipanion5.Command.Usage({
-      category: `Commands`,
-      description: `Use codemods for various Tina tasks`
-    });
-  }
+import { Command as Command5, Option as Option5 } from "clipanion";
+import fs12 from "fs-extra";
+import path13 from "path";
+var CodemodCommand = class extends Command5 {
+  static paths = [["codemod"], ["codemod", "move-tina-folder"]];
+  rootPath = Option5.String("--rootPath", {
+    description: "Specify the root directory to run the CLI from"
+  });
+  verbose = Option5.Boolean("-v,--verbose", false, {
+    description: "increase verbosity of logged output"
+  });
+  static usage = Command5.Usage({
+    category: `Commands`,
+    description: `Use codemods for various Tina tasks`
+  });
   async catch(error) {
     console.log(error);
   }
@@ -5330,13 +5371,13 @@ var moveTinaFolder = async (rootPath = process.cwd()) => {
     logger.error(e.message);
     process.exit(1);
   }
-  const tinaDestination = import_path12.default.join(configManager.rootPath, "tina");
-  if (await import_fs_extra11.default.existsSync(tinaDestination)) {
+  const tinaDestination = path13.join(configManager.rootPath, "tina");
+  if (await fs12.existsSync(tinaDestination)) {
     logger.info(
       `Folder already exists at ${tinaDestination}. Either delete this folder to complete the codemod, or ensure you have properly copied your config from the ".tina" folder.`
     );
   } else {
-    await import_fs_extra11.default.moveSync(configManager.tinaFolderPath, tinaDestination);
+    await fs12.moveSync(configManager.tinaFolderPath, tinaDestination);
     await writeGitignore(configManager.rootPath);
     logger.info(
       "Move to 'tina' folder complete. Be sure to update any imports of the autogenerated client!"
@@ -5344,8 +5385,8 @@ var moveTinaFolder = async (rootPath = process.cwd()) => {
   }
 };
 var writeGitignore = async (rootPath) => {
-  await import_fs_extra11.default.outputFileSync(
-    import_path12.default.join(rootPath, "tina", ".gitignore"),
+  await fs12.outputFileSync(
+    path13.join(rootPath, "tina", ".gitignore"),
     "__generated__"
   );
 };
@@ -5753,7 +5794,7 @@ Suspendisse facilisis, mi ac scelerisque interdum, ligula ex imperdiet felis, a
 `;
 
 // src/cmds/init/apply.ts
-var import_prettier2 = require("prettier");
+import { format as format2 } from "prettier";
 
 // src/utils/script-helpers.ts
 function generateGqlScript(scriptValue, opts) {
@@ -5776,38 +5817,38 @@ function extendNextScripts(scripts, opts) {
 }
 
 // src/cmds/init/codegen/index.ts
-var import_typescript3 = __toESM(require("typescript"));
-var import_fs_extra12 = __toESM(require("fs-extra"));
+import ts2 from "typescript";
+import fs13 from "fs-extra";
 
 // src/cmds/init/codegen/util.ts
-var import_typescript2 = __toESM(require("typescript"));
-var makeTransformer = (makeVisitor) => (ctx) => (node) => import_typescript2.default.visitNode(node, makeVisitor(ctx));
+import ts from "typescript";
+var makeTransformer = (makeVisitor) => (ctx) => (node) => ts.visitNode(node, makeVisitor(ctx));
 function parseExpression(expression) {
-  const sourceFile = import_typescript2.default.createSourceFile(
+  const sourceFile = ts.createSourceFile(
     "temp.ts",
     expression,
-    import_typescript2.default.ScriptTarget.Latest
+    ts.ScriptTarget.Latest
   );
   if (sourceFile.statements.length !== 1) {
     throw new Error("Expected one statement");
   }
   const statement = sourceFile.statements[0];
-  if (!import_typescript2.default.isExpressionStatement(statement)) {
+  if (!ts.isExpressionStatement(statement)) {
     throw new Error("Expected an expression statement");
   }
   return [sourceFile, statement.expression];
 }
 function parseVariableStatement(stmt) {
-  const sourceFile = import_typescript2.default.createSourceFile(
+  const sourceFile = ts.createSourceFile(
     "temp.ts",
     stmt,
-    import_typescript2.default.ScriptTarget.Latest
+    ts.ScriptTarget.Latest
   );
   if (sourceFile.statements.length !== 1) {
     throw new Error("Expected one statement");
   }
   const statement = sourceFile.statements[0];
-  if (!import_typescript2.default.isVariableStatement(statement)) {
+  if (!ts.isVariableStatement(statement)) {
     throw new Error("Expected a variable statement");
   }
   return [sourceFile, statement];
@@ -5815,7 +5856,7 @@ function parseVariableStatement(stmt) {
 
 // src/cmds/init/codegen/index.ts
 var makeVariableStatementVisitor = (sourceFile, variableStmtSourceFile, variableStmt) => (ctx) => (node) => {
-  if (import_typescript3.default.isSourceFile(node)) {
+  if (ts2.isSourceFile(node)) {
     const newStatements = [...node.statements];
     let encounteredImports = false;
     let firstNonImportStatementIdx = -1;
@@ -5823,7 +5864,7 @@ var makeVariableStatementVisitor = (sourceFile, variableStmtSourceFile, variable
     const [newVarDec] = variableStmt.declarationList.declarations;
     const newVarDecName = newVarDec.name.getText(variableStmtSourceFile);
     for (let i = 0; i < newStatements.length; i++) {
-      const isImport = import_typescript3.default.isImportDeclaration(newStatements[i]);
+      const isImport = ts2.isImportDeclaration(newStatements[i]);
       if (isImport && !encounteredImports) {
         encounteredImports = true;
       }
@@ -5831,9 +5872,9 @@ var makeVariableStatementVisitor = (sourceFile, variableStmtSourceFile, variable
         firstNonImportStatementIdx = i;
       }
       const stmt = newStatements[i];
-      if (import_typescript3.default.isVariableStatement(stmt)) {
+      if (ts2.isVariableStatement(stmt)) {
         const [dec] = stmt.declarationList.declarations;
-        if (dec.name && import_typescript3.default.isIdentifier(dec.name) && dec.name.getText(sourceFile) === newVarDecName) {
+        if (dec.name && ts2.isIdentifier(dec.name) && dec.name.getText(sourceFile) === newVarDecName) {
           existingStatementIdx = i;
         }
       }
@@ -5847,19 +5888,19 @@ var makeVariableStatementVisitor = (sourceFile, variableStmtSourceFile, variable
     if (existingStatementIdx === -1) {
       newStatements.splice(firstNonImportStatementIdx, 0, variableStmt);
     }
-    return import_typescript3.default.factory.updateSourceFile(node, newStatements);
+    return ts2.factory.updateSourceFile(node, newStatements);
   }
 };
 var makeImportsVisitor = (sourceFile, importMap) => (ctx) => (node) => {
-  if (import_typescript3.default.isSourceFile(node)) {
+  if (ts2.isSourceFile(node)) {
     const newStatements = [...node.statements];
     let changed = false;
     for (const [moduleName, imports] of Object.entries(importMap)) {
       let foundImportStatement = false;
       for (const statement of newStatements) {
-        if (import_typescript3.default.isImportDeclaration(statement) && import_typescript3.default.isStringLiteral(statement.moduleSpecifier) && statement.moduleSpecifier.text === moduleName) {
+        if (ts2.isImportDeclaration(statement) && ts2.isStringLiteral(statement.moduleSpecifier) && statement.moduleSpecifier.text === moduleName) {
           foundImportStatement = true;
-          const existingImports = statement.importClause?.namedBindings && import_typescript3.default.isNamedImports(statement.importClause.namedBindings) ? statement.importClause.namedBindings.elements.map(
+          const existingImports = statement.importClause?.namedBindings && ts2.isNamedImports(statement.importClause.namedBindings) ? statement.importClause.namedBindings.elements.map(
             (e) => e.name.text
           ) : [];
           const newImports = [
@@ -5870,22 +5911,22 @@ var makeImportsVisitor = (sourceFile, importMap) => (ctx) => (node) => {
             ])
           ];
           const importSpecifiers = newImports.map(
-            (i) => import_typescript3.default.factory.createImportSpecifier(
+            (i) => ts2.factory.createImportSpecifier(
               void 0,
-              import_typescript3.default.factory.createIdentifier(i),
-              import_typescript3.default.factory.createIdentifier(i)
+              ts2.factory.createIdentifier(i),
+              ts2.factory.createIdentifier(i)
             )
           );
-          const namedImports = import_typescript3.default.factory.createNamedImports(importSpecifiers);
-          const importClause = import_typescript3.default.factory.createImportClause(
+          const namedImports = ts2.factory.createNamedImports(importSpecifiers);
+          const importClause = ts2.factory.createImportClause(
             false,
             void 0,
             namedImports
           );
-          const importDec = import_typescript3.default.factory.createImportDeclaration(
+          const importDec = ts2.factory.createImportDeclaration(
             void 0,
             importClause,
-            import_typescript3.default.factory.createStringLiteral(moduleName)
+            ts2.factory.createStringLiteral(moduleName)
           );
           newStatements[newStatements.indexOf(statement)] = importDec;
           changed = true;
@@ -5893,45 +5934,45 @@ var makeImportsVisitor = (sourceFile, importMap) => (ctx) => (node) => {
       }
       if (!foundImportStatement) {
         const importSpecifiers = imports.map(
-          (i) => import_typescript3.default.factory.createImportSpecifier(
+          (i) => ts2.factory.createImportSpecifier(
             void 0,
-            import_typescript3.default.factory.createIdentifier(i),
-            import_typescript3.default.factory.createIdentifier(i)
+            ts2.factory.createIdentifier(i),
+            ts2.factory.createIdentifier(i)
           )
         );
-        const namedImports = import_typescript3.default.factory.createNamedImports(importSpecifiers);
-        const importClause = import_typescript3.default.factory.createImportClause(
+        const namedImports = ts2.factory.createNamedImports(importSpecifiers);
+        const importClause = ts2.factory.createImportClause(
           false,
           void 0,
           namedImports
         );
-        const importDec = import_typescript3.default.factory.createImportDeclaration(
+        const importDec = ts2.factory.createImportDeclaration(
           void 0,
           importClause,
-          import_typescript3.default.factory.createStringLiteral(moduleName)
+          ts2.factory.createStringLiteral(moduleName)
         );
         newStatements.unshift(importDec);
         changed = true;
       }
     }
     if (changed) {
-      return import_typescript3.default.factory.updateSourceFile(node, newStatements);
+      return ts2.factory.updateSourceFile(node, newStatements);
     }
   }
 };
 var makeAddExpressionToSchemaCollectionVisitor = (sourceFile, functionName, newExpressionSourceFile, newExpression) => (ctx) => {
   const visit2 = (node) => {
-    if (import_typescript3.default.isCallExpression(node) && import_typescript3.default.isIdentifier(node.expression) && node.expression.text === functionName && node.arguments.length > 0 && import_typescript3.default.isObjectLiteralExpression(node.arguments[0])) {
+    if (ts2.isCallExpression(node) && ts2.isIdentifier(node.expression) && node.expression.text === functionName && node.arguments.length > 0 && ts2.isObjectLiteralExpression(node.arguments[0])) {
       const configObject = node.arguments[0];
       const updateProperties = configObject.properties.map((property) => {
-        if (import_typescript3.default.isPropertyAssignment(property)) {
+        if (ts2.isPropertyAssignment(property)) {
           const thisPropertyName = property.name.getText(sourceFile);
-          if (thisPropertyName === "schema" && import_typescript3.default.isPropertyAssignment(property) && import_typescript3.default.isObjectLiteralExpression(property.initializer)) {
+          if (thisPropertyName === "schema" && ts2.isPropertyAssignment(property) && ts2.isObjectLiteralExpression(property.initializer)) {
             const schemaObject = property.initializer;
             const collectionsProperty = schemaObject.properties.find(
-              (p) => import_typescript3.default.isPropertyAssignment(p) && p.name.getText(sourceFile) === "collections"
+              (p) => ts2.isPropertyAssignment(p) && p.name.getText(sourceFile) === "collections"
             );
-            if (collectionsProperty && import_typescript3.default.isPropertyAssignment(collectionsProperty) && import_typescript3.default.isArrayLiteralExpression(collectionsProperty.initializer)) {
+            if (collectionsProperty && ts2.isPropertyAssignment(collectionsProperty) && ts2.isArrayLiteralExpression(collectionsProperty.initializer)) {
               const collectionsArray = collectionsProperty.initializer;
               const collectionItems = collectionsArray.elements.map(
                 (e) => e.getText(sourceFile)
@@ -5941,16 +5982,16 @@ var makeAddExpressionToSchemaCollectionVisitor = (sourceFile, functionName, newE
               )) {
                 return property;
               }
-              return import_typescript3.default.factory.updatePropertyAssignment(
+              return ts2.factory.updatePropertyAssignment(
                 property,
                 property.name,
-                import_typescript3.default.factory.createObjectLiteralExpression(
+                ts2.factory.createObjectLiteralExpression(
                   schemaObject.properties.map((subProp) => {
-                    if (import_typescript3.default.isPropertyAssignment(subProp) && subProp.name.getText(sourceFile) === "collections" && import_typescript3.default.isArrayLiteralExpression(subProp.initializer)) {
-                      return import_typescript3.default.factory.updatePropertyAssignment(
+                    if (ts2.isPropertyAssignment(subProp) && subProp.name.getText(sourceFile) === "collections" && ts2.isArrayLiteralExpression(subProp.initializer)) {
+                      return ts2.factory.updatePropertyAssignment(
                         subProp,
                         subProp.name,
-                        import_typescript3.default.factory.createArrayLiteralExpression(
+                        ts2.factory.createArrayLiteralExpression(
                           [newExpression, ...subProp.initializer.elements],
                           true
                         )
@@ -5966,56 +6007,56 @@ var makeAddExpressionToSchemaCollectionVisitor = (sourceFile, functionName, newE
         }
         return property;
       });
-      return import_typescript3.default.factory.createCallExpression(
+      return ts2.factory.createCallExpression(
         node.expression,
         node.typeArguments,
-        [import_typescript3.default.factory.createObjectLiteralExpression(updateProperties, true)]
+        [ts2.factory.createObjectLiteralExpression(updateProperties, true)]
       );
     }
-    return import_typescript3.default.visitEachChild(node, visit2, ctx);
+    return ts2.visitEachChild(node, visit2, ctx);
   };
   return (sourceFile2) => {
-    return import_typescript3.default.visitEachChild(sourceFile2, visit2, ctx);
+    return ts2.visitEachChild(sourceFile2, visit2, ctx);
   };
 };
 var makeUpdateObjectLiteralPropertyVisitor = (sourceFile, functionName, propertyName, propertyValueExpressionSourceFile, propertyValue) => (ctx) => {
   const visitor = (node) => {
-    if (import_typescript3.default.isCallExpression(node) && import_typescript3.default.isIdentifier(node.expression) && node.expression.text === functionName && node.arguments.length > 0 && import_typescript3.default.isObjectLiteralExpression(node.arguments[0])) {
+    if (ts2.isCallExpression(node) && ts2.isIdentifier(node.expression) && node.expression.text === functionName && node.arguments.length > 0 && ts2.isObjectLiteralExpression(node.arguments[0])) {
       let foundProperty = false;
       const configObject = node.arguments[0];
       const updateProperties = configObject.properties.map((property) => {
-        if (import_typescript3.default.isPropertyAssignment(property) || import_typescript3.default.isShorthandPropertyAssignment(property)) {
+        if (ts2.isPropertyAssignment(property) || ts2.isShorthandPropertyAssignment(property)) {
           const name2 = property.name.getText(sourceFile);
           if (name2 === propertyName) {
             foundProperty = true;
-            return import_typescript3.default.factory.createPropertyAssignment(name2, propertyValue);
+            return ts2.factory.createPropertyAssignment(name2, propertyValue);
           }
         }
         return property;
       });
       if (!foundProperty) {
         updateProperties.unshift(
-          import_typescript3.default.factory.createPropertyAssignment(propertyName, propertyValue)
+          ts2.factory.createPropertyAssignment(propertyName, propertyValue)
         );
       }
-      return import_typescript3.default.factory.createCallExpression(
+      return ts2.factory.createCallExpression(
         node.expression,
         node.typeArguments,
-        [import_typescript3.default.factory.createObjectLiteralExpression(updateProperties, true)]
+        [ts2.factory.createObjectLiteralExpression(updateProperties, true)]
       );
     }
-    return import_typescript3.default.visitEachChild(node, visitor, ctx);
+    return ts2.visitEachChild(node, visitor, ctx);
   };
   return (sourceFile2) => {
-    return import_typescript3.default.visitNode(sourceFile2, visitor);
+    return ts2.visitNode(sourceFile2, visitor);
   };
 };
 var addSelfHostedTinaAuthToConfig = async (config2, configFile) => {
   const pathToConfig = configFile.resolve(config2.typescript).path;
-  const sourceFile = import_typescript3.default.createSourceFile(
+  const sourceFile = ts2.createSourceFile(
     pathToConfig,
-    import_fs_extra12.default.readFileSync(pathToConfig, "utf8"),
-    config2.typescript ? import_typescript3.default.ScriptTarget.Latest : import_typescript3.default.ScriptTarget.ESNext
+    fs13.readFileSync(pathToConfig, "utf8"),
+    config2.typescript ? ts2.ScriptTarget.Latest : ts2.ScriptTarget.ESNext
   );
   const { configImports, configAuthProviderClass, extraTinaCollections } = config2.authProvider;
   const importMap = {
@@ -6028,7 +6069,7 @@ var addSelfHostedTinaAuthToConfig = async (config2, configFile) => {
       {}
     )
   };
-  const transformedSourceFileResult = import_typescript3.default.transform(
+  const transformedSourceFileResult = ts2.transform(
     sourceFile,
     [
       makeImportsVisitor(sourceFile, {
@@ -6064,13 +6105,14 @@ var addSelfHostedTinaAuthToConfig = async (config2, configFile) => {
       )
     ].map((visitor) => makeTransformer(visitor))
   );
-  return import_fs_extra12.default.writeFile(
+  return fs13.writeFile(
     pathToConfig,
-    import_typescript3.default.createPrinter({ omitTrailingSemicolon: true }).printFile(transformedSourceFileResult.transformed[0])
+    ts2.createPrinter({ omitTrailingSemicolon: true }).printFile(transformedSourceFileResult.transformed[0])
   );
 };
 
 // src/cmds/init/apply.ts
+import { exec } from "child_process";
 async function apply({
   env,
   params,
@@ -6181,8 +6223,8 @@ async function apply({
     await addConfigFile({
       configArgs: {
         config: config2,
-        publicFolder: import_path13.default.join(
-          import_path13.default.relative(process.cwd(), pathToForestryConfig),
+        publicFolder: path14.join(
+          path14.relative(process.cwd(), pathToForestryConfig),
           config2.publicFolder
         ),
         collections,
@@ -6239,7 +6281,7 @@ var reportTelemetry = async ({
   if (noTelemetry) {
     logger.info(logText("Telemetry disabled"));
   }
-  const telemetry = new import_metrics2.Telemetry({ disabled: noTelemetry });
+  const telemetry = new Telemetry2({ disabled: noTelemetry });
   const schemaFileType = usingTypescript ? "ts" : "js";
   await telemetry.submitRecord({
     event: {
@@ -6255,18 +6297,18 @@ var createPackageJSON = async () => {
 };
 var createGitignore = async ({ baseDir }) => {
   logger.info(logText("No .gitignore found, creating one"));
-  import_fs_extra13.default.outputFileSync(import_path13.default.join(baseDir, ".gitignore"), "node_modules");
+  fs14.outputFileSync(path14.join(baseDir, ".gitignore"), "node_modules");
 };
 var updateGitIgnore = async ({
   baseDir,
   items
 }) => {
   logger.info(logText(`Adding ${items.join(",")} to .gitignore`));
-  const gitignoreContent = import_fs_extra13.default.readFileSync(import_path13.default.join(baseDir, ".gitignore")).toString();
+  const gitignoreContent = fs14.readFileSync(path14.join(baseDir, ".gitignore")).toString();
   const newGitignoreContent = [...gitignoreContent.split("\n"), ...items].join(
     "\n"
   );
-  await import_fs_extra13.default.writeFile(import_path13.default.join(baseDir, ".gitignore"), newGitignoreContent);
+  await fs14.writeFile(path14.join(baseDir, ".gitignore"), newGitignoreContent);
 };
 var addDependencies = async (config2, env, params) => {
   const { packageManager } = config2;
@@ -6341,7 +6383,7 @@ var writeGeneratedFile = async ({
   if (exists) {
     if (overwrite) {
       logger.info(`Overwriting file at ${path15}... \u2705`);
-      import_fs_extra13.default.outputFileSync(path15, content);
+      fs14.outputFileSync(path15, content);
     } else {
       logger.info(`Not overwriting file at ${path15}.`);
       logger.info(
@@ -6351,8 +6393,8 @@ ${indentText(content)}}`)
     }
   } else {
     logger.info(`Adding file at ${path15}... \u2705`);
-    await import_fs_extra13.default.ensureDir(parentPath);
-    import_fs_extra13.default.outputFileSync(path15, content);
+    await fs14.ensureDir(parentPath);
+    fs14.outputFileSync(path15, content);
   }
 };
 var addConfigFile = async ({
@@ -6361,7 +6403,7 @@ var addConfigFile = async ({
   generatedFile,
   config: config2
 }) => {
-  const content = (0, import_prettier2.format)(generateConfig(configArgs), {
+  const content = format2(generateConfig(configArgs), {
     parser: "babel"
   });
   await writeGeneratedFile({
@@ -6391,7 +6433,7 @@ var addNextApiRoute = async ({
   generatedFile,
   env
 }) => {
-  const content = (0, import_prettier2.format)(nextApiRouteTemplate({ config: config2, env }), {
+  const content = format2(nextApiRouteTemplate({ config: config2, env }), {
     parser: "babel"
   });
   await writeGeneratedFile({
@@ -6430,7 +6472,7 @@ var addContentFile = async ({
         return () => ({
           exists: env.sampleContentExists,
           path: env.sampleContentPath,
-          parentPath: import_path13.default.dirname(env.sampleContentPath)
+          parentPath: path14.dirname(env.sampleContentPath)
         });
       }
     },
@@ -6453,10 +6495,10 @@ ${titleText(" TinaCMS ")} backend initialized!`));
       return `${x.key}=${x.value || "***"}`;
     }).join("\n") + `
 TINA_PUBLIC_IS_LOCAL=true`;
-    const envFile = import_path13.default.join(process.cwd(), ".env");
-    if (!import_fs_extra13.default.existsSync(envFile)) {
+    const envFile = path14.join(process.cwd(), ".env");
+    if (!fs14.existsSync(envFile)) {
       logger.info(`Adding .env file to your project... \u2705`);
-      import_fs_extra13.default.writeFileSync(envFile, envFileText);
+      fs14.writeFileSync(envFile, envFileText);
     } else {
       logger.info(
         "Please add the following environment variables to your .env file"
@@ -6478,9 +6520,7 @@ ${titleText(" TinaCMS ")} has been initialized!`));
     );
     if (framework.name === "hugo") {
       logger.info(
-        focusText("Hugo is required. "),
-        "Don't have Hugo installed? Follow this guide to set it up: ",
-        linkText("https://gohugo.io/installation/")
+        focusText("Hugo is required. ") + "Don't have Hugo installed? Follow this guide to set it up: " + linkText("https://gohugo.io/installation/")
       );
     }
     logger.info(
@@ -6527,7 +6567,7 @@ var addReactiveFile = {
     baseDir,
     dataLayer
   }) => {
-    const packageJsonPath = import_path13.default.join(baseDir, "package.json");
+    const packageJsonPath = path14.join(baseDir, "package.json");
     await writeGeneratedFile({
       generatedFile,
       typescript: config2.typescript,
@@ -6540,7 +6580,7 @@ var addReactiveFile = {
       })
     });
     logger.info("Adding a nextjs example... \u2705");
-    const packageJson = JSON.parse(import_fs_extra13.default.readFileSync(packageJsonPath).toString());
+    const packageJson = JSON.parse(fs14.readFileSync(packageJsonPath).toString());
     const scripts = packageJson.scripts || {};
     const updatedPackageJson = JSON.stringify(
       {
@@ -6553,11 +6593,10 @@ var addReactiveFile = {
       null,
       2
     );
-    import_fs_extra13.default.writeFileSync(packageJsonPath, updatedPackageJson);
+    fs14.writeFileSync(packageJsonPath, updatedPackageJson);
   }
 };
 function execShellCommand(cmd) {
-  const exec = require("child_process").exec;
   return new Promise((resolve2, reject) => {
     exec(cmd, (error, stdout, stderr) => {
       if (error) {
@@ -6603,34 +6642,27 @@ var command = new CLICommand({
 });
 
 // src/next/commands/init-command/index.ts
-var InitCommand = class extends import_clipanion6.Command {
-  constructor() {
-    super(...arguments);
-    this.pathToForestryConfig = import_clipanion6.Option.String("--forestryPath", {
-      description: "Specify the relative path to the .forestry directory, if importing an existing forestry site."
-    });
-    this.rootPath = import_clipanion6.Option.String("--rootPath", {
-      description: "Specify the root directory to run the CLI from (defaults to current working directory)"
-    });
-    this.debug = import_clipanion6.Option.Boolean("--debug", false, {
-      description: "Enable debug logging"
-    });
-    this.noTelemetry = import_clipanion6.Option.Boolean("--noTelemetry", false, {
-      description: "Disable anonymous telemetry that is collected"
-    });
-    this.tinaVersion = import_clipanion6.Option.String("--tinaVersion", {
-      description: "Specify a version for tina dependencies"
-    });
-  }
-  static {
-    this.paths = [["init"], ["init", "backend"]];
-  }
-  static {
-    this.usage = import_clipanion6.Command.Usage({
-      category: `Commands`,
-      description: `Add Tina to an existing project`
-    });
-  }
+var InitCommand = class extends Command6 {
+  static paths = [["init"], ["init", "backend"]];
+  pathToForestryConfig = Option6.String("--forestryPath", {
+    description: "Specify the relative path to the .forestry directory, if importing an existing forestry site."
+  });
+  rootPath = Option6.String("--rootPath", {
+    description: "Specify the root directory to run the CLI from (defaults to current working directory)"
+  });
+  debug = Option6.Boolean("--debug", false, {
+    description: "Enable debug logging"
+  });
+  noTelemetry = Option6.Boolean("--noTelemetry", false, {
+    description: "Disable anonymous telemetry that is collected"
+  });
+  tinaVersion = Option6.String("--tinaVersion", {
+    description: "Specify a version for tina dependencies"
+  });
+  static usage = Command6.Usage({
+    category: `Commands`,
+    description: `Add Tina to an existing project`
+  });
   async catch(error) {
     logger.error("Error occured during tinacms init");
     console.error(error);
@@ -6652,28 +6684,24 @@ var InitCommand = class extends import_clipanion6.Command {
 };
 
 // src/next/commands/searchindex-command/index.ts
-var import_clipanion7 = require("clipanion");
-var import_graphql17 = require("@tinacms/graphql");
-var import_search3 = require("@tinacms/search");
-var SearchIndexCommand = class extends import_clipanion7.Command {
-  constructor() {
-    super(...arguments);
-    this.rootPath = import_clipanion7.Option.String("--rootPath", {
-      description: "Specify the root directory to run the CLI from (defaults to current working directory)"
-    });
-    this.verbose = import_clipanion7.Option.Boolean("-v,--verbose", false, {
-      description: "increase verbosity of logged output"
-    });
-  }
-  static {
-    this.paths = [["search-index"]];
-  }
-  static {
-    this.usage = import_clipanion7.Command.Usage({
-      category: `Commands`,
-      description: `Index the site for search`
-    });
-  }
+import { Command as Command7, Option as Option7 } from "clipanion";
+import { createSchema, FilesystemBridge as FilesystemBridge4 } from "@tinacms/graphql";
+import {
+  SearchIndexer as SearchIndexer3,
+  TinaCMSSearchIndexClient as TinaCMSSearchIndexClient2
+} from "@tinacms/search";
+var SearchIndexCommand = class extends Command7 {
+  static paths = [["search-index"]];
+  rootPath = Option7.String("--rootPath", {
+    description: "Specify the root directory to run the CLI from (defaults to current working directory)"
+  });
+  verbose = Option7.Boolean("-v,--verbose", false, {
+    description: "increase verbosity of logged output"
+  });
+  static usage = Command7.Usage({
+    category: `Commands`,
+    description: `Index the site for search`
+  });
   async catch(error) {
     logger.error("Error occured during tinacms search-index");
     console.error(error);
@@ -6695,7 +6723,7 @@ var SearchIndexCommand = class extends import_clipanion7.Command {
       process.exit(1);
     }
     const { schema } = configManager.config;
-    const tinaSchema = await (0, import_graphql17.createSchema)({
+    const tinaSchema = await createSchema({
       schema: { ...schema, config: configManager.config }
     });
     let client;
@@ -6723,7 +6751,7 @@ var SearchIndexCommand = class extends import_clipanion7.Command {
           "indexerToken not configured in tina search configuration."
         );
       }
-      client = new import_search3.TinaCMSSearchIndexClient({
+      client = new TinaCMSSearchIndexClient2({
         apiUrl: `${configManager.config.tinaioConfig?.contentApiUrlOverride || "https://content.tinajs.io"}/searchIndex/${configManager.config?.clientId}`,
         branch: configManager.config?.branch,
         indexerToken: configManager.config?.search?.tina?.indexerToken,
@@ -6732,9 +6760,9 @@ var SearchIndexCommand = class extends import_clipanion7.Command {
     } else {
       client = configManager.config?.search?.searchClient;
     }
-    const searchIndexer = new import_search3.SearchIndexer({
+    const searchIndexer = new SearchIndexer3({
       batchSize: configManager.config.search?.indexBatchSize || 100,
-      bridge: new import_graphql17.FilesystemBridge(
+      bridge: new FilesystemBridge4(
         configManager.rootPath,
         configManager.contentRootPath
       ),
@@ -6762,7 +6790,7 @@ var SearchIndexCommand = class extends import_clipanion7.Command {
 };
 
 // src/index.ts
-var cli = new import_clipanion8.Cli({
+var cli = new Cli({
   binaryName: `tinacms`,
   binaryLabel: `TinaCMS`,
   binaryVersion: version
@@ -6773,7 +6801,10 @@ cli.register(AuditCommand);
 cli.register(InitCommand);
 cli.register(CodemodCommand);
 cli.register(SearchIndexCommand);
-cli.register(import_clipanion8.Builtins.DefinitionsCommand);
-cli.register(import_clipanion8.Builtins.HelpCommand);
-cli.register(import_clipanion8.Builtins.VersionCommand);
+cli.register(Builtins.DefinitionsCommand);
+cli.register(Builtins.HelpCommand);
+cli.register(Builtins.VersionCommand);
 var index_default = cli;
+export {
+  index_default as default
+};