@tinacms/cli 2.3.1 → 2.4.1

package/dist/index.js

@@ -2,17 +2,17 @@
 import { Cli, Builtins } from "clipanion";
 
 // package.json
-var version = "2.3.1";
+var version = "2.4.1";
 
 // src/next/commands/dev-command/index.ts
-import path9 from "path";
+import path10 from "path";
 import { FilesystemBridge as FilesystemBridge2, buildSchema } from "@tinacms/graphql";
 import { Telemetry } from "@tinacms/metrics";
 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 fs8 from "fs-extra";
+import fs9 from "fs-extra";
 
 // src/logger/index.ts
 import chalk from "chalk";
@@ -816,9 +816,8 @@ var unlinkIfExists = async (filepath) => {
 };
 
 // src/next/config-manager.ts
-import fs3 from "fs-extra";
-import path4 from "path";
-import os from "os";
+import fs4 from "fs-extra";
+import path5 from "path";
 import { pathToFileURL } from "url";
 import * as esbuild from "esbuild";
 import * as dotenv from "dotenv";
@@ -877,6 +876,76 @@ async function resolveContentRootPath(params) {
   return params.rootPath;
 }
 
+// src/next/external-resolver.ts
+var EXTERNAL_BASELINE = ["better-sqlite3"];
+var resolveDatabaseExternals = (config2) => {
+  const userExternals = config2?.build?.externalDependencies ?? [];
+  return [...EXTERNAL_BASELINE, ...userExternals];
+};
+
+// src/next/cache-manager.ts
+import fs3 from "fs-extra";
+import path4 from "path";
+var buildReadOnlyMountErrorMessage = (cacheParentPath, underlyingError) => `TinaCMS cannot write to ${cacheParentPath}.
+
+Tina v3 needs write access to your project's tina/__generated__/.cache/ directory at build time. This usually means your project directory is read-only \u2014 common in some Docker setups (\`:ro\` volumes), AWS Lambda's \`/var/task\`, sandboxed CI runners, or restricted file permissions.
+
+To resolve, either:
+  - Make the project directory writable (e.g. remount with read-write access, or copy the project to a writable location), or
+  - Run \`tinacms build\` against a writable copy of your project and deploy the resulting artifacts.
+
+Underlying error: ${underlyingError.code} ${underlyingError.message}`;
+var READONLY_ERROR_CODES = /* @__PURE__ */ new Set(["EACCES", "EROFS", "EPERM"]);
+var prepareCacheLocation = async (generatedFolderPath, now = Date.now()) => {
+  const parentPath = path4.join(generatedFolderPath, ".cache");
+  try {
+    if (await fs3.pathExists(parentPath)) {
+      await fs3.remove(parentPath);
+    }
+    await fs3.ensureDir(parentPath);
+  } catch (err) {
+    const code = err?.code;
+    if (code && READONLY_ERROR_CODES.has(code)) {
+      throw new Error(
+        buildReadOnlyMountErrorMessage(parentPath, err)
+      );
+    }
+    throw err;
+  }
+  return {
+    parentPath,
+    buildPath: path4.join(parentPath, String(now))
+  };
+};
+var reapBuildSubdir = (buildSubdirPath, buildParentPath) => {
+  fs3.removeSync(buildSubdirPath);
+  try {
+    fs3.rmdirSync(buildParentPath);
+  } catch (err) {
+    if (err?.code !== "ENOTEMPTY") throw err;
+  }
+};
+
+// src/next/build-database-esbuild-config.ts
+var buildDatabaseEsbuildConfig = (opts) => ({
+  entryPoints: [opts.entryPoint],
+  bundle: true,
+  platform: "node",
+  format: "esm",
+  outfile: opts.outfile,
+  loader: opts.loader,
+  external: opts.external,
+  // 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);`
+  }
+});
+
 // src/next/config-manager.ts
 var TINA_FOLDER = "tina";
 var LEGACY_TINA_FOLDER = ".tina";
@@ -936,7 +1005,7 @@ var ConfigManager = class {
     this.legacyNoSDK = legacyNoSDK;
   }
   isUsingTs() {
-    return [".ts", ".tsx"].includes(path4.extname(this.tinaConfigFilePath));
+    return [".ts", ".tsx"].includes(path5.extname(this.tinaConfigFilePath));
   }
   hasSelfHostedConfig() {
     return !!this.selfHostedDatabaseFilePath;
@@ -961,12 +1030,12 @@ var ConfigManager = class {
         )
       );
     }
-    this.envFilePath = path4.resolve(
-      path4.join(this.tinaFolderPath, "..", ".env")
+    this.envFilePath = path5.resolve(
+      path5.join(this.tinaFolderPath, "..", ".env")
     );
     dotenv.config({ path: this.envFilePath });
     this.tinaConfigFilePath = await this.getPathWithExtension(
-      path4.join(this.tinaFolderPath, "config")
+      path5.join(this.tinaFolderPath, "config")
     );
     if (!this.tinaConfigFilePath) {
       throw new Error(
@@ -974,89 +1043,86 @@ var ConfigManager = class {
       );
     }
     this.selfHostedDatabaseFilePath = await this.getPathWithExtension(
-      path4.join(this.tinaFolderPath, "database")
-    );
-    this.generatedFolderPath = path4.join(this.tinaFolderPath, GENERATED_FOLDER);
-    this.generatedCachePath = path4.join(
-      this.generatedFolderPath,
-      ".cache",
-      String((/* @__PURE__ */ new Date()).getTime())
+      path5.join(this.tinaFolderPath, "database")
     );
-    this.generatedGraphQLGQLPath = path4.join(
+    this.generatedFolderPath = path5.join(this.tinaFolderPath, GENERATED_FOLDER);
+    const cacheLocation = await prepareCacheLocation(this.generatedFolderPath);
+    this.generatedCachePath = cacheLocation.buildPath;
+    this.generatedGraphQLGQLPath = path5.join(
       this.generatedFolderPath,
       GRAPHQL_GQL_FILE
     );
-    this.generatedGraphQLJSONPath = path4.join(
+    this.generatedGraphQLJSONPath = path5.join(
       this.generatedFolderPath,
       GRAPHQL_JSON_FILE
     );
-    this.generatedSchemaJSONPath = path4.join(
+    this.generatedSchemaJSONPath = path5.join(
       this.generatedFolderPath,
       SCHEMA_JSON_FILE
     );
-    this.generatedLookupJSONPath = path4.join(
+    this.generatedLookupJSONPath = path5.join(
       this.generatedFolderPath,
       LOOKUP_JSON_FILE
     );
-    this.generatedQueriesFilePath = path4.join(
+    this.generatedQueriesFilePath = path5.join(
       this.generatedFolderPath,
       "queries.gql"
     );
-    this.generatedFragmentsFilePath = path4.join(
+    this.generatedFragmentsFilePath = path5.join(
       this.generatedFolderPath,
       "frags.gql"
     );
-    this.generatedTypesTSFilePath = path4.join(
+    this.generatedTypesTSFilePath = path5.join(
       this.generatedFolderPath,
       "types.ts"
     );
-    this.generatedTypesJSFilePath = path4.join(
+    this.generatedTypesJSFilePath = path5.join(
       this.generatedFolderPath,
       "types.js"
     );
-    this.generatedTypesDFilePath = path4.join(
+    this.generatedTypesDFilePath = path5.join(
       this.generatedFolderPath,
       "types.d.ts"
     );
-    this.userQueriesAndFragmentsGlob = path4.join(
+    this.userQueriesAndFragmentsGlob = path5.join(
       this.tinaFolderPath,
       "queries/**/*.{graphql,gql}"
     );
-    this.generatedQueriesAndFragmentsGlob = path4.join(
+    this.generatedQueriesAndFragmentsGlob = path5.join(
       this.generatedFolderPath,
       "*.{graphql,gql}"
     );
-    this.generatedClientTSFilePath = path4.join(
+    this.generatedClientTSFilePath = path5.join(
       this.generatedFolderPath,
       "client.ts"
     );
-    this.generatedClientJSFilePath = path4.join(
+    this.generatedClientJSFilePath = path5.join(
       this.generatedFolderPath,
       "client.js"
     );
-    this.generatedClientDFilePath = path4.join(
+    this.generatedClientDFilePath = path5.join(
       this.generatedFolderPath,
       "client.d.ts"
     );
-    this.generatedDatabaseClientDFilePath = path4.join(
+    this.generatedDatabaseClientDFilePath = path5.join(
       this.generatedFolderPath,
       "databaseClient.d.ts"
     );
-    this.generatedDatabaseClientTSFilePath = path4.join(
+    this.generatedDatabaseClientTSFilePath = path5.join(
       this.generatedFolderPath,
       "databaseClient.ts"
     );
-    this.generatedDatabaseClientJSFilePath = path4.join(
+    this.generatedDatabaseClientJSFilePath = path5.join(
       this.generatedFolderPath,
       "databaseClient.js"
     );
-    const clientExists = this.isUsingTs() ? await fs3.pathExists(this.generatedClientTSFilePath) : await fs3.pathExists(this.generatedClientJSFilePath);
+    const clientExists = this.isUsingTs() ? await fs4.pathExists(this.generatedClientTSFilePath) : await fs4.pathExists(this.generatedClientJSFilePath);
     if (!clientExists) {
       const file = "export default ()=>({})\nexport const client = ()=>({})";
       if (this.isUsingTs()) {
-        await fs3.outputFile(this.generatedClientTSFilePath, file);
+        await fs4.outputFile(this.generatedClientTSFilePath, file);
       } else {
-        await fs3.outputFile(this.generatedClientJSFilePath, file);
+        await fs4.outputFile(this.generatedClientJSFilePath, file);
       }
     }
     const { config: config2, prebuildPath, watchList } = await this.loadConfigFile(
@@ -1066,16 +1132,16 @@ var ConfigManager = class {
     this.watchList = watchList;
     this.config = config2;
     this.prebuildFilePath = prebuildPath;
-    this.publicFolderPath = path4.join(
+    this.publicFolderPath = path5.join(
       this.rootPath,
       this.config.build.publicFolder
     );
-    this.outputFolderPath = path4.join(
+    this.outputFolderPath = path5.join(
       this.publicFolderPath,
       this.config.build.outputFolder
     );
-    this.outputHTMLFilePath = path4.join(this.outputFolderPath, "index.html");
-    this.outputGitignorePath = path4.join(this.outputFolderPath, ".gitignore");
+    this.outputHTMLFilePath = path5.join(this.outputFolderPath, "index.html");
+    this.outputGitignorePath = path5.join(this.outputFolderPath, ".gitignore");
     this.contentRootPath = await resolveContentRootPath({
       rootPath: this.rootPath,
       tinaFolderPath: this.tinaFolderPath,
@@ -1083,17 +1149,17 @@ var ConfigManager = class {
       localContentPath: this.config.localContentPath
     });
     this.spaMainPath = require2.resolve("@tinacms/app");
-    this.spaRootPath = path4.join(this.spaMainPath, "..", "..");
+    this.spaRootPath = path5.join(this.spaMainPath, "..", "..");
   }
   async getTinaFolderPath(rootPath) {
-    const tinaFolderPath = path4.join(rootPath, TINA_FOLDER);
-    const tinaFolderExists = await fs3.pathExists(tinaFolderPath);
+    const tinaFolderPath = path5.join(rootPath, TINA_FOLDER);
+    const tinaFolderExists = await fs4.pathExists(tinaFolderPath);
     if (tinaFolderExists) {
       this.isUsingLegacyFolder = false;
       return tinaFolderPath;
     }
-    const legacyFolderPath = path4.join(rootPath, LEGACY_TINA_FOLDER);
-    const legacyFolderExists = await fs3.pathExists(legacyFolderPath);
+    const legacyFolderPath = path5.join(rootPath, LEGACY_TINA_FOLDER);
+    const legacyFolderExists = await fs4.pathExists(legacyFolderPath);
     if (legacyFolderExists) {
       this.isUsingLegacyFolder = true;
       return legacyFolderPath;
@@ -1112,7 +1178,7 @@ var ConfigManager = class {
         patch: version2[2] || "x"
       };
     }
-    const generatedSchema = fs3.readJSONSync(this.generatedSchemaJSONPath);
+    const generatedSchema = fs4.readJSONSync(this.generatedSchemaJSONPath);
     if (!generatedSchema || !(typeof generatedSchema?.version !== "undefined")) {
       throw new Error(
         `Can not find Tina GraphQL version in ${this.generatedSchemaJSONPath}`
@@ -1123,40 +1189,40 @@ var ConfigManager = class {
   printGeneratedClientFilePath() {
     if (this.isUsingTs()) {
       return normalizePath2(
-        path4.relative(this.rootPath, this.generatedClientTSFilePath)
+        path5.relative(this.rootPath, this.generatedClientTSFilePath)
       );
     }
     return normalizePath2(
-      path4.relative(this.rootPath, this.generatedClientJSFilePath)
+      path5.relative(this.rootPath, this.generatedClientJSFilePath)
     );
   }
   printGeneratedTypesFilePath() {
     return normalizePath2(
-      path4.relative(this.rootPath, this.generatedTypesTSFilePath)
+      path5.relative(this.rootPath, this.generatedTypesTSFilePath)
     );
   }
   printoutputHTMLFilePath() {
     return normalizePath2(
-      path4.relative(this.publicFolderPath, this.outputHTMLFilePath)
+      path5.relative(this.publicFolderPath, this.outputHTMLFilePath)
     );
   }
   printRelativePath(filename) {
     if (filename) {
-      return normalizePath2(path4.relative(this.rootPath, filename));
+      return normalizePath2(path5.relative(this.rootPath, filename));
     }
     throw `No path provided to print`;
   }
   printPrebuildFilePath() {
     return normalizePath2(
-      path4.relative(
-        path4.join(this.rootPath, this.tinaFolderPath),
+      path5.relative(
+        path5.join(this.rootPath, this.tinaFolderPath),
         this.prebuildFilePath
       )
     );
   }
   printContentRelativePath(filename) {
     if (filename) {
-      return normalizePath2(path4.relative(this.contentRootPath, filename));
+      return normalizePath2(path5.relative(this.contentRootPath, filename));
     }
     throw `No path provided to print`;
   }
@@ -1172,7 +1238,7 @@ var ConfigManager = class {
           return;
         }
         const filepathWithExtension = `${filepath}.${ext}`;
-        const exists = fs3.existsSync(filepathWithExtension);
+        const exists = fs4.existsSync(filepathWithExtension);
         if (exists) {
           result = filepathWithExtension;
         }
@@ -1181,41 +1247,34 @@ var ConfigManager = class {
     return result;
   }
   async loadDatabaseFile() {
-    const tmpdir = path4.join(os.tmpdir(), Date.now().toString());
-    const outfile = path4.join(tmpdir, "database.build.mjs");
-    await esbuild.build({
-      entryPoints: [this.selfHostedDatabaseFilePath],
-      bundle: true,
-      platform: "node",
-      format: "esm",
-      outfile,
-      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 buildDir = path5.join(this.generatedCachePath, "database");
+    const outfile = path5.join(buildDir, "database.build.mjs");
+    const external = resolveDatabaseExternals(this.config);
+    await esbuild.build(
+      buildDatabaseEsbuildConfig({
+        entryPoint: this.selfHostedDatabaseFilePath,
+        outfile,
+        external,
+        loader: loaders
+      })
+    );
     const result = await import(pathToFileURL(outfile).href);
-    fs3.removeSync(outfile);
+    reapBuildSubdir(buildDir, this.generatedCachePath);
     return result.default;
   }
   async loadConfigFile(generatedFolderPath, configFilePath) {
-    const tmpdir = path4.join(os.tmpdir(), Date.now().toString());
-    const preBuildConfigPath = path4.join(
+    const buildDir = path5.join(this.generatedCachePath, "config");
+    const preBuildConfigPath = path5.join(
       this.generatedFolderPath,
       "config.prebuild.jsx"
     );
-    const outfile = path4.join(tmpdir, "config.build.jsx");
-    const outfile2 = path4.join(tmpdir, "config.build.mjs");
-    const tempTSConfigFile = path4.join(tmpdir, "tsconfig.json");
+    const outfile = path5.join(buildDir, "config.build.jsx");
+    const outfile2 = path5.join(buildDir, "config.build.mjs");
+    const tempTSConfigFile = path5.join(buildDir, "tsconfig.json");
     const esmRequireBanner = {
       js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`
     };
-    fs3.outputFileSync(tempTSConfigFile, "{}");
+    fs4.outputFileSync(tempTSConfigFile, "{}");
     const result2 = await esbuild.build({
       entryPoints: [configFilePath],
       bundle: true,
@@ -1265,8 +1324,7 @@ var ConfigManager = class {
       console.error(e);
       throw e;
     }
-    fs3.removeSync(outfile);
-    fs3.removeSync(outfile2);
+    reapBuildSubdir(buildDir, this.generatedCachePath);
     return {
       config: result.default,
       prebuildPath: preBuildConfigPath,
@@ -1391,7 +1449,7 @@ stack: ${code.stack || "No stack was provided"}`);
 
 // src/next/commands/baseCommands.ts
 import { getChangedFiles, getSha, shaExists } from "@tinacms/graphql";
-import fs4 from "fs-extra";
+import fs5 from "fs-extra";
 var BaseCommand = class extends Command {
   experimentalDataLayer = Option.Boolean("--experimentalData", {
     description: "DEPRECATED - Build the server with additional data querying capabilities"
@@ -1473,7 +1531,7 @@ var BaseCommand = class extends Command {
         const rootPath = configManager.rootPath;
         let sha;
         try {
-          sha = await getSha({ fs: fs4, dir: rootPath });
+          sha = await getSha({ fs: fs5, dir: rootPath });
         } catch (e) {
           if (partialReindex) {
             console.error(
@@ -1483,7 +1541,7 @@ var BaseCommand = class extends Command {
           }
         }
         const lastSha = await database.getMetadata("lastSha");
-        const exists = lastSha && await shaExists({ fs: fs4, dir: rootPath, sha: lastSha });
+        const exists = lastSha && await shaExists({ fs: fs5, dir: rootPath, sha: lastSha });
         let res;
         if (partialReindex && lastSha && exists && sha) {
           const pathFilter = {};
@@ -1498,14 +1556,14 @@ var BaseCommand = class extends Command {
             };
           }
           const { added, modified, deleted } = await getChangedFiles({
-            fs: fs4,
+            fs: fs5,
             dir: rootPath,
             from: lastSha,
             to: sha,
             pathFilter
           });
           const tinaPathUpdates = modified.filter(
-            (path17) => path17.startsWith(".tina/__generated__/_schema.json") || path17.startsWith("tina/tina-lock.json")
+            (path18) => path18.startsWith(".tina/__generated__/_schema.json") || path18.startsWith("tina/tina-lock.json")
           );
           if (tinaPathUpdates.length > 0) {
             res = await database.indexContent({
@@ -1624,9 +1682,9 @@ var devHTML = (port) => `<!DOCTYPE html>
 import { createServer as createViteServer } from "vite";
 
 // src/next/vite/index.ts
-import path6 from "node:path";
+import path7 from "node:path";
 import react from "@vitejs/plugin-react";
-import fs5 from "fs-extra";
+import fs6 from "fs-extra";
 import normalizePath3 from "normalize-path";
 import {
   splitVendorChunkPlugin
@@ -1693,7 +1751,7 @@ function filterPublicEnv(env = process.env) {
 }
 
 // src/next/vite/tailwind.ts
-import path5 from "node:path";
+import path6 from "node:path";
 import aspectRatio from "@tailwindcss/aspect-ratio";
 import containerQueries from "@tailwindcss/container-queries";
 import twTypography from "@tailwindcss/typography";
@@ -1708,7 +1766,7 @@ var tinaTailwind = (spaPath, prebuildFilePath) => {
       const require2 = createRequire2(import.meta.url);
       const plugins = [];
       const content = [
-        path5.join(spaPath, "src/**/*.{vue,js,ts,jsx,tsx,svelte}"),
+        path6.join(spaPath, "src/**/*.{vue,js,ts,jsx,tsx,svelte}"),
         prebuildFilePath,
         require2.resolve("tinacms")
       ];
@@ -1972,35 +2030,35 @@ async function listFilesRecursively({
   config: config2,
   roothPath
 }) {
-  const fullDirectoryPath = path6.join(
+  const fullDirectoryPath = path7.join(
     roothPath,
     config2.publicFolder,
     directoryPath
   );
-  const exists = await fs5.pathExists(fullDirectoryPath);
+  const exists = await fs6.pathExists(fullDirectoryPath);
   if (!exists) {
     return { "0": [] };
   }
-  const items = await fs5.readdir(fullDirectoryPath);
+  const items = await fs6.readdir(fullDirectoryPath);
   const staticMediaItems = [];
   for (const item of items) {
-    const itemPath = path6.join(fullDirectoryPath, item);
-    const stats = await fs5.promises.lstat(itemPath);
+    const itemPath = path7.join(fullDirectoryPath, item);
+    const stats = await fs6.promises.lstat(itemPath);
     const staticMediaItem = {
       id: item,
       filename: item,
       type: stats.isDirectory() ? "dir" : "file",
       directory: `${directoryPath.replace(config2.mediaRoot, "")}`,
-      src: `/${path6.join(directoryPath, item)}`,
+      src: `/${path7.join(directoryPath, item)}`,
       thumbnails: {
-        "75x75": `/${path6.join(directoryPath, item)}`,
-        "400x400": `/${path6.join(directoryPath, item)}`,
-        "1000x1000": `/${path6.join(directoryPath, item)}`
+        "75x75": `/${path7.join(directoryPath, item)}`,
+        "400x400": `/${path7.join(directoryPath, item)}`,
+        "1000x1000": `/${path7.join(directoryPath, item)}`
       }
     };
     if (stats.isDirectory()) {
       staticMediaItem.children = await listFilesRecursively({
-        directoryPath: path6.join(directoryPath, item),
+        directoryPath: path7.join(directoryPath, item),
         config: config2,
         roothPath
       });
@@ -2025,7 +2083,7 @@ var createConfig = async ({
   rollupOptions
 }) => {
   const publicEnv = filterPublicEnv();
-  const staticMediaPath = path6.join(
+  const staticMediaPath = path7.join(
     configManager.generatedFolderPath,
     "static-media.json"
   );
@@ -2035,21 +2093,21 @@ var createConfig = async ({
       config: configManager.config.media.tina,
       roothPath: configManager.rootPath
     });
-    await fs5.outputFile(staticMediaPath, JSON.stringify(staticMedia, null, 2));
+    await fs6.outputFile(staticMediaPath, JSON.stringify(staticMedia, null, 2));
   } else {
-    await fs5.outputFile(staticMediaPath, `[]`);
+    await fs6.outputFile(staticMediaPath, `[]`);
   }
   const alias = {
     TINA_IMPORT: configManager.prebuildFilePath,
     SCHEMA_IMPORT: configManager.generatedGraphQLJSONPath,
     STATIC_MEDIA_IMPORT: staticMediaPath,
-    crypto: path6.join(configManager.spaRootPath, "src", "dummy-client.ts"),
-    fs: path6.join(configManager.spaRootPath, "src", "dummy-client.ts"),
-    os: path6.join(configManager.spaRootPath, "src", "dummy-client.ts"),
-    path: path6.join(configManager.spaRootPath, "src", "dummy-client.ts")
+    crypto: path7.join(configManager.spaRootPath, "src", "dummy-client.ts"),
+    fs: path7.join(configManager.spaRootPath, "src", "dummy-client.ts"),
+    os: path7.join(configManager.spaRootPath, "src", "dummy-client.ts"),
+    path: path7.join(configManager.spaRootPath, "src", "dummy-client.ts")
   };
   if (configManager.shouldSkipSDK()) {
-    alias["CLIENT_IMPORT"] = path6.join(
+    alias["CLIENT_IMPORT"] = path7.join(
       configManager.spaRootPath,
       "src",
       "dummy-client.ts"
@@ -2159,8 +2217,8 @@ var createConfig = async ({
 };
 
 // src/next/vite/plugins.ts
-import fs7 from "fs";
-import path8 from "path";
+import fs8 from "fs";
+import path9 from "path";
 import { createFilter } from "@rollup/pluginutils";
 import { resolve as gqlResolve } from "@tinacms/graphql";
 import bodyParser from "body-parser";
@@ -2169,11 +2227,11 @@ import { transform as esbuildTransform } from "esbuild";
 import { transformWithEsbuild } from "vite";
 
 // src/next/commands/dev-command/server/media.ts
-import path7, { join } from "path";
+import path8, { join } from "path";
 import busboy from "busboy";
-import fs6 from "fs-extra";
+import fs7 from "fs-extra";
 var createMediaRouter = (config2) => {
-  const mediaFolder = path7.join(
+  const mediaFolder = path8.join(
     config2.rootPath,
     config2.publicFolder,
     config2.mediaRoot
@@ -2237,8 +2295,8 @@ var createMediaRouter = (config2) => {
         );
         return;
       }
-      await fs6.ensureDir(path7.dirname(saveTo));
-      file.pipe(fs6.createWriteStream(saveTo));
+      await fs7.ensureDir(path8.dirname(saveTo));
+      file.pipe(fs7.createWriteStream(saveTo));
     });
     bb.on("error", (error) => {
       responded = true;
@@ -2268,18 +2326,18 @@ var parseMediaFolder = (str) => {
 var ENCODED_TRAVERSAL_RE = /%2e%2e|%2f|%5c/i;
 function resolveRealPath(candidate) {
   try {
-    return fs6.realpathSync(candidate);
+    return fs7.realpathSync(candidate);
   } catch {
-    const parent = path7.dirname(candidate);
+    const parent = path8.dirname(candidate);
     if (parent === candidate) return candidate;
-    return path7.join(resolveRealPath(parent), path7.basename(candidate));
+    return path8.join(resolveRealPath(parent), path8.basename(candidate));
   }
 }
 function assertSymlinkWithinBase(resolved, resolvedBase, userPath) {
   try {
-    const realBase = fs6.realpathSync(resolvedBase);
+    const realBase = fs7.realpathSync(resolvedBase);
     const realResolved = resolveRealPath(resolved);
-    if (realResolved !== realBase && !realResolved.startsWith(realBase + path7.sep)) {
+    if (realResolved !== realBase && !realResolved.startsWith(realBase + path8.sep)) {
       throw new PathTraversalError(userPath);
     }
   } catch (err) {
@@ -2290,13 +2348,13 @@ function resolveWithinBase(userPath, baseDir) {
   if (ENCODED_TRAVERSAL_RE.test(userPath)) {
     throw new PathTraversalError(userPath);
   }
-  const resolvedBase = path7.resolve(baseDir);
-  const resolved = path7.resolve(path7.join(baseDir, userPath));
+  const resolvedBase = path8.resolve(baseDir);
+  const resolved = path8.resolve(path8.join(baseDir, userPath));
   if (resolved === resolvedBase) {
     assertSymlinkWithinBase(resolved, resolvedBase, userPath);
     return resolvedBase;
   }
-  if (resolved.startsWith(resolvedBase + path7.sep)) {
+  if (resolved.startsWith(resolvedBase + path8.sep)) {
     assertSymlinkWithinBase(resolved, resolvedBase, userPath);
     return resolved;
   }
@@ -2306,12 +2364,12 @@ function resolveStrictlyWithinBase(userPath, baseDir) {
   if (ENCODED_TRAVERSAL_RE.test(userPath)) {
     throw new PathTraversalError(userPath);
   }
-  const resolvedBase = path7.resolve(baseDir) + path7.sep;
-  const resolved = path7.resolve(path7.join(baseDir, userPath));
+  const resolvedBase = path8.resolve(baseDir) + path8.sep;
+  const resolved = path8.resolve(path8.join(baseDir, userPath));
   if (!resolved.startsWith(resolvedBase)) {
     throw new PathTraversalError(userPath);
   }
-  assertSymlinkWithinBase(resolved, path7.resolve(baseDir), userPath);
+  assertSymlinkWithinBase(resolved, path8.resolve(baseDir), userPath);
   return resolved;
 }
 var MediaModel = class {
@@ -2328,16 +2386,16 @@ var MediaModel = class {
       const mediaBase = join(this.rootPath, this.publicFolder, this.mediaRoot);
       const validatedPath = resolveWithinBase(args.searchPath, mediaBase);
       const searchPath = parseMediaFolder(args.searchPath);
-      if (!await fs6.pathExists(validatedPath)) {
+      if (!await fs7.pathExists(validatedPath)) {
         return {
           files: [],
           directories: []
         };
       }
-      const filesStr = await fs6.readdir(validatedPath);
+      const filesStr = await fs7.readdir(validatedPath);
       const filesProm = filesStr.map(async (file) => {
         const filePath = join(validatedPath, file);
-        const stat = await fs6.stat(filePath);
+        const stat = await fs7.stat(filePath);
         let src = `/${file}`;
         const isFile = stat.isFile();
         if (!isFile) {
@@ -2396,8 +2454,8 @@ var MediaModel = class {
     try {
       const mediaBase = join(this.rootPath, this.publicFolder, this.mediaRoot);
       const file = resolveStrictlyWithinBase(args.searchPath, mediaBase);
-      await fs6.stat(file);
-      await fs6.remove(file);
+      await fs7.stat(file);
+      await fs7.remove(file);
       return { ok: true };
     } catch (error) {
       if (error instanceof PathTraversalError) throw error;
@@ -2505,7 +2563,7 @@ var transformTsxPlugin = ({
   const plug = {
     name: "transform-tsx",
     async transform(code, id) {
-      const extName = path8.extname(id);
+      const extName = path9.extname(id);
       if (extName.startsWith(".tsx") || extName.startsWith(".ts")) {
         const result = await esbuildTransform(code, { loader: "tsx" });
         return {
@@ -2616,7 +2674,7 @@ function viteTransformExtension({
     async transform(code, id) {
       if (filter(id)) {
         const { transform: transform2 } = await import("@svgr/core");
-        const svgCode = await fs7.promises.readFile(
+        const svgCode = await fs8.promises.readFile(
           id.replace(/\?.*$/, ""),
           "utf8"
         );
@@ -2708,7 +2766,7 @@ var DevCommand = class extends BaseCommand {
     ]
   });
   async catch(error) {
-    logger.error("Error occured during tinacms dev");
+    logger.error("Error occurred during tinacms dev");
     console.error(error);
     process.exit(1);
   }
@@ -2766,13 +2824,13 @@ var DevCommand = class extends BaseCommand {
         });
         const apiURL2 = await codegen2.execute();
         if (!configManager.isUsingLegacyFolder) {
-          const schemaObject = await fs8.readJSON(
+          const schemaObject = await fs9.readJSON(
             configManager.generatedSchemaJSONPath
           );
-          const lookupObject = await fs8.readJSON(
+          const lookupObject = await fs9.readJSON(
             configManager.generatedLookupJSONPath
           );
-          const graphqlSchemaObject = await fs8.readJSON(
+          const graphqlSchemaObject = await fs9.readJSON(
             configManager.generatedGraphQLJSONPath
           );
           const tinaLockFilename = "tina-lock.json";
@@ -2781,8 +2839,8 @@ var DevCommand = class extends BaseCommand {
             lookup: lookupObject,
             graphql: graphqlSchemaObject
           });
-          fs8.writeFileSync(
-            path9.join(configManager.tinaFolderPath, tinaLockFilename),
+          fs9.writeFileSync(
+            path10.join(configManager.tinaFolderPath, tinaLockFilename),
             tinaLockContent
           );
         }
@@ -2826,8 +2884,8 @@ ${dangerText(e.message)}
     const { apiURL, graphQLSchema, tinaSchema } = await setup({
       firstTime: true
     });
-    await fs8.outputFile(configManager.outputHTMLFilePath, devHTML(this.port));
-    await fs8.outputFile(
+    await fs9.outputFile(configManager.outputHTMLFilePath, devHTML(this.port));
+    await fs9.outputFile(
       configManager.outputGitignorePath,
       "index.html\nassets/"
     );
@@ -2972,7 +3030,7 @@ ${dangerText(e.message)}
   watchContentFiles(configManager, database, databaseLock, searchIndexer) {
     const collectionContentFiles = [];
     configManager.config.schema.collections.forEach((collection) => {
-      const collectionGlob = `${path9.join(
+      const collectionGlob = `${path10.join(
         configManager.contentRootPath,
         collection.path
       )}/**/*.${collection.format || "md"}`;
@@ -3022,17 +3080,16 @@ ${dangerText(e.message)}
 
 // src/next/commands/build-command/index.ts
 import crypto from "crypto";
-import path10 from "path";
+import path11 from "path";
 import { diff } from "@graphql-inspector/core";
 import { FilesystemBridge as FilesystemBridge3, buildSchema as buildSchema2 } from "@tinacms/graphql";
-import { Telemetry as Telemetry2 } from "@tinacms/metrics";
 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 fs9 from "fs-extra";
+import fs10 from "fs-extra";
 import {
   buildASTSchema as buildASTSchema2,
   buildClientSchema,
@@ -3169,6 +3226,75 @@ var waitForDB = async (config2, apiUrl, previewName, verbose) => {
   });
 };
 
+// src/utils/posthog.ts
+import { randomUUID } from "node:crypto";
+import { PostHog } from "posthog-node";
+
+// src/utils/fetchPostHogConfig.ts
+async function fetchPostHogConfig(endpointUrl) {
+  try {
+    const response = await fetch(endpointUrl, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      // Cap latency for offline / firewalled developers. Endpoint is
+      // typically single-digit ms when reachable; a timeout returns {}
+      // and disables telemetry for this run, which is the right behavior.
+      signal: AbortSignal.timeout(2e3)
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to fetch PostHog config: ${response.statusText}`);
+    }
+    const config2 = await response.json();
+    return {
+      POSTHOG_API_KEY: config2.api_key,
+      POSTHOG_ENDPOINT: config2.host
+    };
+  } catch {
+    return {};
+  }
+}
+
+// src/utils/posthog.ts
+function generateSessionId() {
+  return randomUUID();
+}
+var BuildInvokeEvent = "tinacms-cli-build-invoke";
+var BuildFinishedEvent = "tinacms-cli-build-finished";
+async function initializePostHog(configEndpoint, disableGeoip) {
+  if (process.env.TINA_DEV === "true") return null;
+  let apiKey;
+  let endpoint;
+  if (configEndpoint) {
+    const config2 = await fetchPostHogConfig(configEndpoint);
+    apiKey = config2.POSTHOG_API_KEY;
+    endpoint = config2.POSTHOG_ENDPOINT;
+  }
+  if (!apiKey) return null;
+  return new PostHog(apiKey, {
+    host: endpoint,
+    disableGeoip: disableGeoip ?? true
+  });
+}
+function postHogCapture(client, distinctId, event, properties) {
+  if (!client) {
+    return;
+  }
+  try {
+    client.capture({
+      distinctId,
+      event,
+      properties: {
+        ...properties,
+        system: "tinacms/cli"
+      }
+    });
+  } catch (error) {
+    console.error("Error capturing event:", error);
+  }
+}
+
 // src/next/commands/build-command/index.ts
 var BuildCommand = class extends BaseCommand {
   static paths = [["build"]];
@@ -3212,7 +3338,17 @@ var BuildCommand = class extends BaseCommand {
     category: `Commands`,
     description: `Build the CMS and autogenerated modules for usage with TinaCloud`
   });
+  posthogClient = null;
+  buildStartedAt = 0;
+  buildRunId = generateSessionId();
   async catch(error) {
+    const errorCode = error?.errorCode ?? "ERR_BUILD_FAILED";
+    postHogCapture(this.posthogClient, this.buildRunId, BuildFinishedEvent, {
+      success: false,
+      durationMs: Date.now() - this.buildStartedAt,
+      errorCode
+    });
+    if (this.posthogClient) await this.posthogClient.shutdown();
     console.error(error);
     process.exit(1);
   }
@@ -3249,6 +3385,27 @@ var BuildCommand = class extends BaseCommand {
       process.exit(1);
     }
     const localContentOnly = this.contentOption === "local";
+    this.posthogClient = this.noTelemetry ? null : await initializePostHog(
+      "https://identity-v2.tinajs.io/v2/posthog-token",
+      false
+    );
+    const buildInvokeEventPayload = {
+      hasLocalOption: Boolean(this.localOption),
+      hasContentLocal: localContentOnly,
+      skipIndexing: Boolean(this.skipIndexing),
+      partialReindex: Boolean(this.partialReindex),
+      hasPreviewName: Boolean(this.previewName),
+      specifiesTinaGraphQLVersions: Boolean(this.tinaGraphQLVersion),
+      skipCloudChecks: Boolean(this.skipCloudChecks),
+      skipSearchIndex: Boolean(this.skipSearchIndex)
+    };
+    this.buildStartedAt = Date.now();
+    postHogCapture(
+      this.posthogClient,
+      this.buildRunId,
+      BuildInvokeEvent,
+      buildInvokeEventPayload
+    );
     try {
       await configManager.processConfig();
     } catch (e) {
@@ -3257,15 +3414,10 @@ ${dangerText(e.message)}`);
       logger.error(
         dangerText("Unable to build, please fix your Tina config and try again")
       );
-      process.exit(1);
+      throw Object.assign(new Error(e.message), {
+        errorCode: "ERR_CONFIG_LOAD_FAILED"
+      });
     }
-    const telemetry = new Telemetry2({ disabled: this.noTelemetry });
-    await telemetry.submitRecord({
-      event: {
-        name: "tinacms:cli:build:invoke",
-        hasLocalContentPath: Boolean(configManager.config.localContentPath)
-      }
-    });
     if (localContentOnly && !this.localOption) {
       const config2 = configManager.config;
       const missing = [];
@@ -3273,12 +3425,11 @@ ${dangerText(e.message)}`);
       if (!config2.clientId) missing.push("clientId");
       if (!config2.token) missing.push("token");
       if (missing.length > 0) {
-        logger.error(
-          `${dangerText(
-            `ERROR: --content=local requires ${missing.join(", ")} to be configured, since the generated client must point to TinaCloud.`
-          )}`
-        );
-        process.exit(1);
+        const message = `--content=local requires ${missing.join(", ")} to be configured, since the generated client must point to TinaCloud.`;
+        logger.error(`${dangerText(`ERROR: ${message}`)}`);
+        throw Object.assign(new Error(message), {
+          errorCode: "ERR_MISSING_CLOUD_CREDS"
+        });
       }
     }
     let server;
@@ -3321,7 +3472,9 @@ ${dangerText(e.message)}
         if (this.verbose) {
           console.error(e);
         }
-        process.exit(1);
+        throw Object.assign(new Error(e.message), {
+          errorCode: "ERR_INDEXING_FAILED"
+        });
       }
     }
     if (this.localOption || localContentOnly) {
@@ -3394,11 +3547,13 @@ ${dangerText(e.message)}
         if (this.verbose) {
           console.error(e);
         }
-        process.exit(1);
+        throw Object.assign(new Error(e.message), {
+          errorCode: "ERR_CLOUD_CHECK_FAILED"
+        });
       }
     }
     await buildProductionSpa(configManager, database, codegen2.productionUrl);
-    await fs9.outputFile(
+    await fs10.outputFile(
       configManager.outputGitignorePath,
       "index.html\nassets/"
     );
@@ -3466,7 +3621,9 @@ ${dangerText(e.message)}
       });
       if (err) {
         logger.error(`${dangerText(`ERROR: ${err.message}`)}`);
-        process.exit(1);
+        throw Object.assign(new Error(err.message), {
+          errorCode: "ERR_SEARCH_INDEX_FAILED"
+        });
       }
     }
     const summaryItems = [];
@@ -3512,6 +3669,11 @@ ${dangerText(e.message)}
         process.env.NODE_ENV = "production";
       }
     }
+    postHogCapture(this.posthogClient, this.buildRunId, BuildFinishedEvent, {
+      success: true,
+      durationMs: Date.now() - this.buildStartedAt
+    });
+    if (this.posthogClient) await this.posthogClient.shutdown();
     if (this.subCommand) {
       await this.startSubCommand();
     } else {
@@ -3776,7 +3938,7 @@ Additional info: Branch: ${config2.branch}, Client ID: ${config2.clientId} `;
     }
     const localTinaSchema = JSON.parse(
       await database.bridge.get(
-        path10.join(database.tinaDirectory, "__generated__", "_schema.json")
+        path11.join(database.tinaDirectory, "__generated__", "_schema.json")
       )
     );
     localTinaSchema.version = void 0;
@@ -3896,7 +4058,7 @@ import { buildSchema as buildSchema3 } from "@tinacms/graphql";
 
 // src/next/commands/audit-command/audit.ts
 import prompts from "prompts";
-import { Telemetry as Telemetry3 } from "@tinacms/metrics";
+import { Telemetry as Telemetry2 } from "@tinacms/metrics";
 import { resolve } from "@tinacms/graphql";
 import chalk5 from "chalk";
 var audit = async ({
@@ -3906,7 +4068,7 @@ var audit = async ({
   noTelemetry,
   verbose
 }) => {
-  const telemetry = new Telemetry3({ disabled: noTelemetry });
+  const telemetry = new Telemetry2({ disabled: noTelemetry });
   await telemetry.submitRecord({
     event: {
       name: "tinacms:cli:audit:invoke",
@@ -4082,7 +4244,7 @@ var AuditCommand = class extends Command4 {
     description: `Audit config and content files`
   });
   async catch(error) {
-    logger.error("Error occured during tinacms audit");
+    logger.error("Error occurred during tinacms audit");
     if (this.verbose) {
       console.error(error);
     }
@@ -4139,26 +4301,26 @@ var AuditCommand = class extends Command4 {
 import { Command as Command6, Option as Option6 } from "clipanion";
 
 // src/cmds/init/detectEnvironment.ts
-import fs10 from "fs-extra";
-import path11 from "path";
+import fs11 from "fs-extra";
+import path12 from "path";
 var checkGitignoreForItem = async ({
   baseDir,
   line
 }) => {
-  const gitignoreContent = fs10.readFileSync(path11.join(baseDir, ".gitignore")).toString();
+  const gitignoreContent = fs11.readFileSync(path12.join(baseDir, ".gitignore")).toString();
   return gitignoreContent.split("\n").some((item) => item === line);
 };
 var makeGeneratedFile = async (name2, generatedFileType, parentPath, opts) => {
   const result = {
-    fullPathTS: path11.join(
+    fullPathTS: path12.join(
       parentPath,
       `${name2}.${opts?.typescriptSuffix || opts?.extensionOverride || "ts"}`
     ),
-    fullPathJS: path11.join(
+    fullPathJS: path12.join(
       parentPath,
       `${name2}.${opts?.extensionOverride || "js"}`
     ),
-    fullPathOverride: opts?.extensionOverride ? path11.join(parentPath, `${name2}.${opts?.extensionOverride}`) : "",
+    fullPathOverride: opts?.extensionOverride ? path12.join(parentPath, `${name2}.${opts?.extensionOverride}`) : "",
     generatedFileType,
     name: name2,
     parentPath,
@@ -4176,8 +4338,8 @@ var makeGeneratedFile = async (name2, generatedFileType, parentPath, opts) => {
       };
     }
   };
-  result.typescriptExists = await fs10.pathExists(result.fullPathTS);
-  result.javascriptExists = await fs10.pathExists(result.fullPathJS);
+  result.typescriptExists = await fs11.pathExists(result.fullPathTS);
+  result.javascriptExists = await fs11.pathExists(result.fullPathJS);
   return result;
 };
 var detectEnvironment = async ({
@@ -4186,21 +4348,21 @@ var detectEnvironment = async ({
   rootPath,
   debug = false
 }) => {
-  const hasForestryConfig = await fs10.pathExists(
-    path11.join(pathToForestryConfig, ".forestry", "settings.yml")
+  const hasForestryConfig = await fs11.pathExists(
+    path12.join(pathToForestryConfig, ".forestry", "settings.yml")
   );
-  const sampleContentPath = path11.join(
+  const sampleContentPath = path12.join(
     baseDir,
     "content",
     "posts",
     "hello-world.md"
   );
-  const usingSrc = fs10.pathExistsSync(path11.join(baseDir, "src")) && (fs10.pathExistsSync(path11.join(baseDir, "src", "app")) || fs10.pathExistsSync(path11.join(baseDir, "src", "pages")));
-  const tinaFolder = path11.join(baseDir, "tina");
+  const usingSrc = fs11.pathExistsSync(path12.join(baseDir, "src")) && (fs11.pathExistsSync(path12.join(baseDir, "src", "app")) || fs11.pathExistsSync(path12.join(baseDir, "src", "pages")));
+  const tinaFolder = path12.join(baseDir, "tina");
   const tinaConfigExists = Boolean(
     // Does the tina folder exist?
-    await fs10.pathExists(tinaFolder) && // Does the tina folder contain a config file?
-    (await fs10.readdir(tinaFolder)).find((x) => x.includes("config"))
+    await fs11.pathExists(tinaFolder) && // Does the tina folder contain a config file?
+    (await fs11.readdir(tinaFolder)).find((x) => x.includes("config"))
   );
   const pagesDir = [baseDir, usingSrc ? "src" : false, "pages"].filter(
     Boolean
@@ -4212,12 +4374,12 @@ var detectEnvironment = async ({
     "next-api-handler": await makeGeneratedFile(
       "[...routes]",
       "next-api-handler",
-      path11.join(...pagesDir, "api", "tina")
+      path12.join(...pagesDir, "api", "tina")
     ),
     "reactive-example": await makeGeneratedFile(
       "[filename]",
       "reactive-example",
-      path11.join(...pagesDir, "demo", "blog"),
+      path12.join(...pagesDir, "demo", "blog"),
       {
         typescriptSuffix: "tsx"
       }
@@ -4225,22 +4387,22 @@ var detectEnvironment = async ({
     "users-json": await makeGeneratedFile(
       "index",
       "users-json",
-      path11.join(baseDir, "content", "users"),
+      path12.join(baseDir, "content", "users"),
       { extensionOverride: "json" }
     ),
     "sample-content": await makeGeneratedFile(
       "hello-world",
       "sample-content",
-      path11.join(baseDir, "content", "posts"),
+      path12.join(baseDir, "content", "posts"),
       { extensionOverride: "md" }
     )
   };
-  const hasSampleContent = await fs10.pathExists(sampleContentPath);
-  const hasPackageJSON = await fs10.pathExists("package.json");
+  const hasSampleContent = await fs11.pathExists(sampleContentPath);
+  const hasPackageJSON = await fs11.pathExists("package.json");
   let hasTinaDeps = false;
   if (hasPackageJSON) {
     try {
-      const packageJSON = await fs10.readJSON("package.json");
+      const packageJSON = await fs11.readJSON("package.json");
       const deps = [];
       if (packageJSON?.dependencies) {
         deps.push(...Object.keys(packageJSON.dependencies));
@@ -4257,15 +4419,19 @@ var detectEnvironment = async ({
       );
     }
   }
-  const hasGitIgnore = await fs10.pathExists(path11.join(".gitignore"));
+  const hasGitIgnore = await fs11.pathExists(path12.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" });
+  const hasGitIgnoreTinaGenerated = hasGitIgnore && await checkGitignoreForItem({
+    baseDir,
+    line: "tina/__generated__"
+  });
   let frontMatterFormat;
   if (hasForestryConfig) {
-    const hugoConfigPath = path11.join(rootPath, "config.toml");
-    if (await fs10.pathExists(hugoConfigPath)) {
-      const hugoConfig = await fs10.readFile(hugoConfigPath, "utf8");
+    const hugoConfigPath = path12.join(rootPath, "config.toml");
+    if (await fs11.pathExists(hugoConfigPath)) {
+      const hugoConfig = await fs11.readFile(hugoConfigPath, "utf8");
       const metaDataFormat = hugoConfig.toString().match(/metaDataFormat = "(.*)"/)?.[1];
       if (metaDataFormat && (metaDataFormat === "yaml" || metaDataFormat === "toml" || metaDataFormat === "json")) {
         frontMatterFormat = metaDataFormat;
@@ -4279,6 +4445,7 @@ var detectEnvironment = async ({
     gitIgnoreNodeModulesExists: hasGitIgnoreNodeModules,
     gitIgnoreEnvExists: hasGitIgnoreEnv,
     gitIgnoreTinaEnvExists: hasEnvTina,
+    gitIgnoreTinaGeneratedExists: hasGitIgnoreTinaGenerated,
     packageJSONExists: hasPackageJSON,
     sampleContentExists: hasSampleContent,
     sampleContentPath,
@@ -4878,19 +5045,19 @@ var CLICommand = class {
 };
 
 // src/cmds/init/apply.ts
-import path15 from "path";
+import path16 from "path";
 
 // src/cmds/forestry-migrate/index.ts
-import fs12 from "fs-extra";
-import path13 from "path";
+import fs13 from "fs-extra";
+import path14 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
-import fs11 from "fs-extra";
-import path12 from "path";
+import fs12 from "fs-extra";
+import path13 from "path";
 import yaml from "js-yaml";
 import z2 from "zod";
 
@@ -5317,7 +5484,7 @@ var transformForestryFieldsToTinaFields = ({
   return tinaFields;
 };
 var getFieldsFromTemplates = ({ tem, pathToForestryConfig, skipBlocks = false }) => {
-  const templatePath = path12.join(
+  const templatePath = path13.join(
     pathToForestryConfig,
     ".forestry",
     "front_matter",
@@ -5326,7 +5493,7 @@ var getFieldsFromTemplates = ({ tem, pathToForestryConfig, skipBlocks = false })
   );
   let templateString = "";
   try {
-    templateString = fs11.readFileSync(templatePath).toString();
+    templateString = fs12.readFileSync(templatePath).toString();
   } catch {
     throw new Error(
       `Could not find template ${tem} at ${templatePath}
@@ -5392,9 +5559,9 @@ function checkExt(ext) {
 var generateAllTemplates = async ({
   pathToForestryConfig
 }) => {
-  const allTemplates = (await fs12.readdir(
-    path13.join(pathToForestryConfig, ".forestry", "front_matter", "templates")
-  )).map((tem) => path13.basename(tem, ".yml"));
+  const allTemplates = (await fs13.readdir(
+    path14.join(pathToForestryConfig, ".forestry", "front_matter", "templates")
+  )).map((tem) => path14.basename(tem, ".yml"));
   const templateMap = /* @__PURE__ */ new Map();
   const proms = allTemplates.map(async (tem) => {
     try {
@@ -5539,9 +5706,9 @@ var generateCollectionFromForestrySection = (args) => {
     return c;
   } else if (section.type === "document") {
     const filePath = section.path;
-    const extname = path13.extname(filePath);
-    const fileName = path13.basename(filePath, extname);
-    const dir = path13.dirname(filePath);
+    const extname = path14.extname(filePath);
+    const fileName = path14.basename(filePath, extname);
+    const dir = path14.dirname(filePath);
     const ext = checkExt(extname);
     if (ext) {
       const fields = [];
@@ -5603,8 +5770,8 @@ var generateCollections = async ({
     templateMap,
     usingTypescript
   });
-  const forestryConfig = await fs12.readFile(
-    path13.join(pathToForestryConfig, ".forestry", "settings.yml")
+  const forestryConfig = await fs13.readFile(
+    path14.join(pathToForestryConfig, ".forestry", "settings.yml")
   );
   rewriteTemplateKeysInDocs({
     templateMap,
@@ -5634,12 +5801,12 @@ var rewriteTemplateKeysInDocs = (args) => {
     const { templateObj } = templateMap.get(templateKey);
     templateObj?.pages?.forEach((page) => {
       try {
-        const filePath = path13.join(page);
-        if (fs12.lstatSync(filePath).isDirectory()) {
+        const filePath = path14.join(page);
+        if (fs13.lstatSync(filePath).isDirectory()) {
           return;
         }
-        const extname = path13.extname(filePath);
-        const fileContent = fs12.readFileSync(filePath).toString();
+        const extname = path14.extname(filePath);
+        const fileContent = fs13.readFileSync(filePath).toString();
         const content = parseFile(
           fileContent,
           extname,
@@ -5650,7 +5817,7 @@ var rewriteTemplateKeysInDocs = (args) => {
           _template: stringifyLabel(templateKey),
           ...content
         };
-        fs12.writeFileSync(
+        fs13.writeFileSync(
           filePath,
           stringifyFile(newContent, extname, true, markdownParseConfig)
         );
@@ -5664,13 +5831,13 @@ var rewriteTemplateKeysInDocs = (args) => {
 };
 
 // src/cmds/init/apply.ts
-import { Telemetry as Telemetry4 } from "@tinacms/metrics";
-import fs15 from "fs-extra";
+import { Telemetry as Telemetry3 } from "@tinacms/metrics";
+import fs16 from "fs-extra";
 
 // src/next/commands/codemod-command/index.ts
 import { Command as Command5, Option as Option5 } from "clipanion";
-import fs13 from "fs-extra";
-import path14 from "path";
+import fs14 from "fs-extra";
+import path15 from "path";
 var CodemodCommand = class extends Command5 {
   static paths = [["codemod"], ["codemod", "move-tina-folder"]];
   rootPath = Option5.String("--rootPath", {
@@ -5711,13 +5878,13 @@ var moveTinaFolder = async (rootPath = process.cwd()) => {
     logger.error(e.message);
     process.exit(1);
   }
-  const tinaDestination = path14.join(configManager.rootPath, "tina");
-  if (await fs13.existsSync(tinaDestination)) {
+  const tinaDestination = path15.join(configManager.rootPath, "tina");
+  if (await fs14.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 fs13.moveSync(configManager.tinaFolderPath, tinaDestination);
+    await fs14.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!"
@@ -5725,8 +5892,8 @@ var moveTinaFolder = async (rootPath = process.cwd()) => {
   }
 };
 var writeGitignore = async (rootPath) => {
-  await fs13.outputFileSync(
-    path14.join(rootPath, "tina", ".gitignore"),
+  await fs14.outputFileSync(
+    path15.join(rootPath, "tina", ".gitignore"),
     "__generated__"
   );
 };
@@ -6164,7 +6331,7 @@ function extendNextScripts(scripts, opts) {
 
 // src/cmds/init/codegen/index.ts
 import ts2 from "typescript";
-import fs14 from "fs-extra";
+import fs15 from "fs-extra";
 
 // src/cmds/init/codegen/util.ts
 import ts from "typescript";
@@ -6401,7 +6568,7 @@ var addSelfHostedTinaAuthToConfig = async (config2, configFile) => {
   const pathToConfig = configFile.resolve(config2.typescript).path;
   const sourceFile = ts2.createSourceFile(
     pathToConfig,
-    fs14.readFileSync(pathToConfig, "utf8"),
+    fs15.readFileSync(pathToConfig, "utf8"),
     config2.typescript ? ts2.ScriptTarget.Latest : ts2.ScriptTarget.ESNext
   );
   const { configImports, configAuthProviderClass, extraTinaCollections } = config2.authProvider;
@@ -6451,7 +6618,7 @@ var addSelfHostedTinaAuthToConfig = async (config2, configFile) => {
       )
     ].map((visitor) => makeTransformer(visitor))
   );
-  return fs14.writeFile(
+  return fs15.writeFile(
     pathToConfig,
     ts2.createPrinter({ omitTrailingSemicolon: true }).printFile(transformedSourceFileResult.transformed[0])
   );
@@ -6508,6 +6675,9 @@ async function apply({
     if (!env.gitIgnoreEnvExists) {
       itemsToAdd.push(".env");
     }
+    if (!env.gitIgnoreTinaGeneratedExists) {
+      itemsToAdd.push("tina/__generated__");
+    }
     if (itemsToAdd.length > 0) {
       await updateGitIgnore({ baseDir, items: itemsToAdd });
     }
@@ -6569,8 +6739,8 @@ async function apply({
     await addConfigFile({
       configArgs: {
         config: config2,
-        publicFolder: path15.join(
-          path15.relative(process.cwd(), pathToForestryConfig),
+        publicFolder: path16.join(
+          path16.relative(process.cwd(), pathToForestryConfig),
           config2.publicFolder
         ),
         collections,
@@ -6627,7 +6797,7 @@ var reportTelemetry = async ({
   if (noTelemetry) {
     logger.info(logText("Telemetry disabled"));
   }
-  const telemetry = new Telemetry4({ disabled: noTelemetry });
+  const telemetry = new Telemetry3({ disabled: noTelemetry });
   const schemaFileType = usingTypescript ? "ts" : "js";
   await telemetry.submitRecord({
     event: {
@@ -6643,18 +6813,21 @@ var createPackageJSON = async () => {
 };
 var createGitignore = async ({ baseDir }) => {
   logger.info(logText("No .gitignore found, creating one"));
-  fs15.outputFileSync(path15.join(baseDir, ".gitignore"), "node_modules");
+  fs16.outputFileSync(
+    path16.join(baseDir, ".gitignore"),
+    "node_modules\ntina/__generated__\n"
+  );
 };
 var updateGitIgnore = async ({
   baseDir,
   items
 }) => {
   logger.info(logText(`Adding ${items.join(",")} to .gitignore`));
-  const gitignoreContent = fs15.readFileSync(path15.join(baseDir, ".gitignore")).toString();
+  const gitignoreContent = fs16.readFileSync(path16.join(baseDir, ".gitignore")).toString();
   const newGitignoreContent = [...gitignoreContent.split("\n"), ...items].join(
     "\n"
   );
-  await fs15.writeFile(path15.join(baseDir, ".gitignore"), newGitignoreContent);
+  await fs16.writeFile(path16.join(baseDir, ".gitignore"), newGitignoreContent);
 };
 var addDependencies = async (config2, env, params) => {
   const { packageManager } = config2;
@@ -6725,22 +6898,22 @@ var writeGeneratedFile = async ({
   content,
   typescript
 }) => {
-  const { exists, path: path17, parentPath } = generatedFile.resolve(typescript);
+  const { exists, path: path18, parentPath } = generatedFile.resolve(typescript);
   if (exists) {
     if (overwrite) {
-      logger.info(`Overwriting file at ${path17}... \u2705`);
-      fs15.outputFileSync(path17, content);
+      logger.info(`Overwriting file at ${path18}... \u2705`);
+      fs16.outputFileSync(path18, content);
     } else {
-      logger.info(`Not overwriting file at ${path17}.`);
+      logger.info(`Not overwriting file at ${path18}.`);
       logger.info(
-        logText(`Please add the following to ${path17}:
+        logText(`Please add the following to ${path18}:
 ${indentText(content)}}`)
       );
     }
   } else {
-    logger.info(`Adding file at ${path17}... \u2705`);
-    await fs15.ensureDir(parentPath);
-    fs15.outputFileSync(path17, content);
+    logger.info(`Adding file at ${path18}... \u2705`);
+    await fs16.ensureDir(parentPath);
+    fs16.outputFileSync(path18, content);
   }
 };
 var addConfigFile = async ({
@@ -6818,7 +6991,7 @@ var addContentFile = async ({
         return () => ({
           exists: env.sampleContentExists,
           path: env.sampleContentPath,
-          parentPath: path15.dirname(env.sampleContentPath)
+          parentPath: path16.dirname(env.sampleContentPath)
         });
       }
     },
@@ -6841,10 +7014,10 @@ ${titleText(" TinaCMS ")} backend initialized!`));
       return `${x.key}=${x.value || "***"}`;
     }).join("\n") + `
 TINA_PUBLIC_IS_LOCAL=true`;
-    const envFile = path15.join(process.cwd(), ".env");
-    if (!fs15.existsSync(envFile)) {
+    const envFile = path16.join(process.cwd(), ".env");
+    if (!fs16.existsSync(envFile)) {
       logger.info(`Adding .env file to your project... \u2705`);
-      fs15.writeFileSync(envFile, envFileText);
+      fs16.writeFileSync(envFile, envFileText);
     } else {
       logger.info(
         "Please add the following environment variables to your .env file"
@@ -6913,7 +7086,7 @@ var addReactiveFile = {
     baseDir,
     dataLayer
   }) => {
-    const packageJsonPath = path15.join(baseDir, "package.json");
+    const packageJsonPath = path16.join(baseDir, "package.json");
     await writeGeneratedFile({
       generatedFile,
       typescript: config2.typescript,
@@ -6926,7 +7099,7 @@ var addReactiveFile = {
       })
     });
     logger.info("Adding a nextjs example... \u2705");
-    const packageJson = JSON.parse(fs15.readFileSync(packageJsonPath).toString());
+    const packageJson = JSON.parse(fs16.readFileSync(packageJsonPath).toString());
     const scripts = packageJson.scripts || {};
     const updatedPackageJson = JSON.stringify(
       {
@@ -6939,7 +7112,7 @@ var addReactiveFile = {
       null,
       2
     );
-    fs15.writeFileSync(packageJsonPath, updatedPackageJson);
+    fs16.writeFileSync(packageJsonPath, updatedPackageJson);
   }
 };
 function execShellCommand(cmd) {
@@ -7010,7 +7183,7 @@ var InitCommand = class extends Command6 {
     description: `Add Tina to an existing project`
   });
   async catch(error) {
-    logger.error("Error occured during tinacms init");
+    logger.error("Error occurred during tinacms init");
     console.error(error);
     process.exit(1);
   }
@@ -7049,7 +7222,7 @@ var SearchIndexCommand = class extends Command7 {
     description: `Index the site for search`
   });
   async catch(error) {
-    logger.error("Error occured during tinacms search-index");
+    logger.error("Error occurred during tinacms search-index");
     console.error(error);
     process.exit(1);
   }
@@ -7139,8 +7312,8 @@ var SearchIndexCommand = class extends Command7 {
 import { Command as Command8, Option as Option8 } from "clipanion";
 
 // src/next/commands/doctor-command/doctor.ts
-import path16 from "path";
-import fs16 from "fs-extra";
+import path17 from "path";
+import fs17 from "fs-extra";
 import yaml3 from "js-yaml";
 var DEPENDENCY_TYPES = [
   "dependencies",
@@ -7173,11 +7346,11 @@ function getTinaDependencies(packageJson) {
   );
 }
 async function readProjectPackageJson(rootPath) {
-  const packageJsonPath = path16.join(rootPath, "package.json");
-  if (!await fs16.pathExists(packageJsonPath)) {
+  const packageJsonPath = path17.join(rootPath, "package.json");
+  if (!await fs17.pathExists(packageJsonPath)) {
     throw new Error(`No package.json found at ${packageJsonPath}`);
   }
-  return fs16.readJSON(packageJsonPath);
+  return fs17.readJSON(packageJsonPath);
 }
 async function resolveInstalledVersions({
   rootPath,
@@ -7300,14 +7473,14 @@ function isLocalReference(version2) {
   );
 }
 async function readNodeModulesVersion(rootPath, packageName) {
-  const packageJsonPath = path16.join(
+  const packageJsonPath = path17.join(
     rootPath,
     "node_modules",
     ...packageName.split("/"),
     "package.json"
   );
-  if (!await fs16.pathExists(packageJsonPath)) return void 0;
-  const packageJson = await fs16.readJSON(packageJsonPath);
+  if (!await fs17.pathExists(packageJsonPath)) return void 0;
+  const packageJson = await fs17.readJSON(packageJsonPath);
   return typeof packageJson.version === "string" ? packageJson.version : void 0;
 }
 async function readLockfileVersions(rootPath) {
@@ -7323,10 +7496,10 @@ async function readLockfileVersions(rootPath) {
   return /* @__PURE__ */ new Map();
 }
 async function readPackageLockVersions(rootPath) {
-  const lockfilePath = path16.join(rootPath, "package-lock.json");
+  const lockfilePath = path17.join(rootPath, "package-lock.json");
   const versions = /* @__PURE__ */ new Map();
-  if (!await fs16.pathExists(lockfilePath)) return versions;
-  const lockfile = await fs16.readJSON(lockfilePath);
+  if (!await fs17.pathExists(lockfilePath)) return versions;
+  const lockfile = await fs17.readJSON(lockfilePath);
   for (const [key, value] of Object.entries(lockfile.packages || {})) {
     if (!key.startsWith("node_modules/")) continue;
     const name2 = key.replace(/^node_modules\//, "");
@@ -7344,10 +7517,10 @@ async function readPackageLockVersions(rootPath) {
   return versions;
 }
 async function readPnpmLockVersions(rootPath) {
-  const lockfilePath = path16.join(rootPath, "pnpm-lock.yaml");
+  const lockfilePath = path17.join(rootPath, "pnpm-lock.yaml");
   const versions = /* @__PURE__ */ new Map();
-  if (!await fs16.pathExists(lockfilePath)) return versions;
-  const lockfile = yaml3.load(await fs16.readFile(lockfilePath, "utf8"));
+  if (!await fs17.pathExists(lockfilePath)) return versions;
+  const lockfile = yaml3.load(await fs17.readFile(lockfilePath, "utf8"));
   const rootImporter = lockfile?.importers?.["."];
   for (const dependencyType of DEPENDENCY_TYPES) {
     for (const [name2, value] of Object.entries(
@@ -7367,10 +7540,10 @@ async function readPnpmLockVersions(rootPath) {
   return versions;
 }
 async function readYarnLockVersions(rootPath) {
-  const lockfilePath = path16.join(rootPath, "yarn.lock");
+  const lockfilePath = path17.join(rootPath, "yarn.lock");
   const versions = /* @__PURE__ */ new Map();
-  if (!await fs16.pathExists(lockfilePath)) return versions;
-  const contents = await fs16.readFile(lockfilePath, "utf8");
+  if (!await fs17.pathExists(lockfilePath)) return versions;
+  const contents = await fs17.readFile(lockfilePath, "utf8");
   if (contents.includes("__metadata:")) {
     return readYarnBerryLockVersions(contents);
   }