@tinacms/cli 2.2.3 → 2.2.5

package/dist/index.js

@@ -2,16 +2,16 @@
 import { Cli, Builtins } from "clipanion";
 
 // package.json
-var version = "2.2.3";
+var version = "2.2.5";
 
 // src/next/commands/dev-command/index.ts
-import path8 from "path";
+import path9 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";
+import fs8 from "fs-extra";
 
 // src/logger/index.ts
 import chalk from "chalk";
@@ -472,22 +472,28 @@ var Codegen = class {
   localUrl;
   // production url
   productionUrl;
+  // URL for the local GraphQL server used during --content=local builds
+  localBuildUrl;
   graphqlSchemaDoc;
   tinaSchema;
   lookup;
   noClientBuildCache;
+  // When true, queries run locally but the generated client points to TinaCloud
+  localContentBuild;
   constructor({
     configManager,
     port,
     queryDoc,
     fragDoc,
     isLocal,
+    localContentBuild,
     graphqlSchemaDoc,
     tinaSchema,
     lookup,
     noClientBuildCache
   }) {
     this.isLocal = isLocal;
+    this.localContentBuild = localContentBuild || false;
     this.graphqlSchemaDoc = graphqlSchemaDoc;
     this.configManager = configManager;
     this.port = port;
@@ -536,10 +542,11 @@ var Codegen = class {
       JSON.stringify(this.tinaSchema.schema)
     );
     await this.writeConfigFile("_lookup.json", JSON.stringify(this.lookup));
-    const { apiURL, localUrl, tinaCloudUrl } = this._createApiUrl();
+    const { apiURL, localUrl, tinaCloudUrl, localBuildUrl } = this._createApiUrl();
     this.apiURL = apiURL;
     this.localUrl = localUrl;
     this.productionUrl = tinaCloudUrl;
+    this.localBuildUrl = localBuildUrl;
     if (this.configManager.shouldSkipSDK()) {
       await this.removeGeneratedFilesIfExists();
       return apiURL;
@@ -638,13 +645,19 @@ var Codegen = class {
     }
     let localUrl = `http://localhost:${this.port}/graphql`;
     let tinaCloudUrl = `${baseUrl}/${version2}/content/${clientId}/github/${branch}`;
-    let apiURL = this.isLocal ? `http://localhost:${this.port}/graphql` : `${baseUrl}/${version2}/content/${clientId}/github/${branch}`;
+    let apiURL;
+    if (this.isLocal && !this.localContentBuild) {
+      apiURL = `http://localhost:${this.port}/graphql`;
+    } else {
+      apiURL = `${baseUrl}/${version2}/content/${clientId}/github/${branch}`;
+    }
     if (this.configManager.config.contentApiUrlOverride) {
       apiURL = this.configManager.config.contentApiUrlOverride;
       localUrl = apiURL;
       tinaCloudUrl = apiURL;
     }
-    return { apiURL, localUrl, tinaCloudUrl };
+    const localBuildUrl = this.port ? `http://localhost:${this.port}/graphql` : void 0;
+    return { apiURL, localUrl, tinaCloudUrl, localBuildUrl };
   }
   getApiURL() {
     if (!this.apiURL)
@@ -747,7 +760,7 @@ export default databaseClient;
 import { queries } from "./types";
 export const client = createClient({ ${this.noClientBuildCache === false ? `cacheDir: '${normalizePath(
       this.configManager.generatedCachePath
-    )}', ` : ""}url: '${apiURL}', token: '${token}', queries, ${errorPolicy ? `errorPolicy: '${errorPolicy}'` : ""} });
+    )}', ` : ""}url: ${this.localContentBuild ? `process.env.TINA_LOCAL_URL || '${apiURL}'` : `'${apiURL}'`}, token: '${token}', queries, ${errorPolicy ? `errorPolicy: '${errorPolicy}'` : ""} });
 export default client;
   `;
     return { apiURL, clientString };
@@ -806,16 +819,22 @@ var unlinkIfExists = async (filepath) => {
 };
 
 // src/next/config-manager.ts
-import fs2 from "fs-extra";
-import path3 from "path";
+import fs3 from "fs-extra";
+import path4 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 chalk4 from "chalk";
 import { createRequire } from "module";
 
+// src/next/resolve-content-root.ts
+import fs2 from "fs-extra";
+import path3 from "path";
+import chalk3 from "chalk";
+import { z } from "zod";
+
 // src/utils/path.ts
 import path2 from "path";
 function stripNativeTrailingSlash(p) {
@@ -835,6 +854,33 @@ var PathTraversalError = class extends Error {
   }
 };
 
+// src/next/resolve-content-root.ts
+var localContentPathSchema = z.string().min(1).optional();
+async function resolveContentRootPath(params) {
+  const localContentPath = localContentPathSchema.parse(
+    params.localContentPath
+  );
+  if (!localContentPath) {
+    return params.rootPath;
+  }
+  const fullLocalContentPath = stripNativeTrailingSlash(
+    path3.join(params.tinaFolderPath, localContentPath)
+  );
+  const exists = await fs2.pathExists(fullLocalContentPath);
+  if (exists) {
+    logger.info(`Using separate content repo at ${fullLocalContentPath}`);
+    return fullLocalContentPath;
+  }
+  logger.warn(
+    `${chalk3.yellow("Warning:")} The localContentPath ${chalk3.cyan(
+      fullLocalContentPath
+    )} does not exist. Please create it or remove the localContentPath from your config file at ${chalk3.cyan(
+      params.tinaConfigFilePath
+    )}`
+  );
+  return params.rootPath;
+}
+
 // src/next/config-manager.ts
 var TINA_FOLDER = "tina";
 var LEGACY_TINA_FOLDER = ".tina";
@@ -894,7 +940,7 @@ var ConfigManager = class {
     this.legacyNoSDK = legacyNoSDK;
   }
   isUsingTs() {
-    return [".ts", ".tsx"].includes(path3.extname(this.tinaConfigFilePath));
+    return [".ts", ".tsx"].includes(path4.extname(this.tinaConfigFilePath));
   }
   hasSelfHostedConfig() {
     return !!this.selfHostedDatabaseFilePath;
@@ -911,12 +957,12 @@ var ConfigManager = class {
   async processConfig() {
     const require2 = createRequire(import.meta.url);
     this.tinaFolderPath = await this.getTinaFolderPath(this.rootPath);
-    this.envFilePath = path3.resolve(
-      path3.join(this.tinaFolderPath, "..", ".env")
+    this.envFilePath = path4.resolve(
+      path4.join(this.tinaFolderPath, "..", ".env")
     );
     dotenv.config({ path: this.envFilePath });
     this.tinaConfigFilePath = await this.getPathWithExtension(
-      path3.join(this.tinaFolderPath, "config")
+      path4.join(this.tinaFolderPath, "config")
     );
     if (!this.tinaConfigFilePath) {
       throw new Error(
@@ -924,89 +970,89 @@ var ConfigManager = class {
       );
     }
     this.selfHostedDatabaseFilePath = await this.getPathWithExtension(
-      path3.join(this.tinaFolderPath, "database")
+      path4.join(this.tinaFolderPath, "database")
     );
-    this.generatedFolderPath = path3.join(this.tinaFolderPath, GENERATED_FOLDER);
-    this.generatedCachePath = path3.join(
+    this.generatedFolderPath = path4.join(this.tinaFolderPath, GENERATED_FOLDER);
+    this.generatedCachePath = path4.join(
       this.generatedFolderPath,
       ".cache",
       String((/* @__PURE__ */ new Date()).getTime())
     );
-    this.generatedGraphQLGQLPath = path3.join(
+    this.generatedGraphQLGQLPath = path4.join(
       this.generatedFolderPath,
       GRAPHQL_GQL_FILE
     );
-    this.generatedGraphQLJSONPath = path3.join(
+    this.generatedGraphQLJSONPath = path4.join(
       this.generatedFolderPath,
       GRAPHQL_JSON_FILE
     );
-    this.generatedSchemaJSONPath = path3.join(
+    this.generatedSchemaJSONPath = path4.join(
       this.generatedFolderPath,
       SCHEMA_JSON_FILE
     );
-    this.generatedLookupJSONPath = path3.join(
+    this.generatedLookupJSONPath = path4.join(
       this.generatedFolderPath,
       LOOKUP_JSON_FILE
     );
-    this.generatedQueriesFilePath = path3.join(
+    this.generatedQueriesFilePath = path4.join(
       this.generatedFolderPath,
       "queries.gql"
     );
-    this.generatedFragmentsFilePath = path3.join(
+    this.generatedFragmentsFilePath = path4.join(
       this.generatedFolderPath,
       "frags.gql"
     );
-    this.generatedTypesTSFilePath = path3.join(
+    this.generatedTypesTSFilePath = path4.join(
       this.generatedFolderPath,
       "types.ts"
     );
-    this.generatedTypesJSFilePath = path3.join(
+    this.generatedTypesJSFilePath = path4.join(
       this.generatedFolderPath,
       "types.js"
     );
-    this.generatedTypesDFilePath = path3.join(
+    this.generatedTypesDFilePath = path4.join(
       this.generatedFolderPath,
       "types.d.ts"
     );
-    this.userQueriesAndFragmentsGlob = path3.join(
+    this.userQueriesAndFragmentsGlob = path4.join(
       this.tinaFolderPath,
       "queries/**/*.{graphql,gql}"
     );
-    this.generatedQueriesAndFragmentsGlob = path3.join(
+    this.generatedQueriesAndFragmentsGlob = path4.join(
       this.generatedFolderPath,
       "*.{graphql,gql}"
     );
-    this.generatedClientTSFilePath = path3.join(
+    this.generatedClientTSFilePath = path4.join(
       this.generatedFolderPath,
       "client.ts"
     );
-    this.generatedClientJSFilePath = path3.join(
+    this.generatedClientJSFilePath = path4.join(
       this.generatedFolderPath,
       "client.js"
     );
-    this.generatedClientDFilePath = path3.join(
+    this.generatedClientDFilePath = path4.join(
       this.generatedFolderPath,
       "client.d.ts"
     );
-    this.generatedDatabaseClientDFilePath = path3.join(
+    this.generatedDatabaseClientDFilePath = path4.join(
       this.generatedFolderPath,
       "databaseClient.d.ts"
     );
-    this.generatedDatabaseClientTSFilePath = path3.join(
+    this.generatedDatabaseClientTSFilePath = path4.join(
       this.generatedFolderPath,
       "databaseClient.ts"
     );
-    this.generatedDatabaseClientJSFilePath = path3.join(
+    this.generatedDatabaseClientJSFilePath = path4.join(
       this.generatedFolderPath,
       "databaseClient.js"
     );
-    const clientExists = this.isUsingTs() ? await fs2.pathExists(this.generatedClientTSFilePath) : await fs2.pathExists(this.generatedClientJSFilePath);
+    const clientExists = this.isUsingTs() ? await fs3.pathExists(this.generatedClientTSFilePath) : await fs3.pathExists(this.generatedClientJSFilePath);
     if (!clientExists) {
       const file = "export default ()=>({})\nexport const client = ()=>({})";
       if (this.isUsingTs()) {
-        await fs2.outputFile(this.generatedClientTSFilePath, file);
+        await fs3.outputFile(this.generatedClientTSFilePath, file);
       } else {
-        await fs2.outputFile(this.generatedClientJSFilePath, file);
+        await fs3.outputFile(this.generatedClientJSFilePath, file);
       }
     }
     const { config: config2, prebuildPath, watchList } = await this.loadConfigFile(
@@ -1016,62 +1062,47 @@ var ConfigManager = class {
     this.watchList = watchList;
     this.config = config2;
     this.prebuildFilePath = prebuildPath;
-    this.publicFolderPath = path3.join(
+    this.publicFolderPath = path4.join(
       this.rootPath,
       this.config.build.publicFolder
     );
-    this.outputFolderPath = path3.join(
+    this.outputFolderPath = path4.join(
       this.publicFolderPath,
       this.config.build.outputFolder
     );
-    this.outputHTMLFilePath = path3.join(this.outputFolderPath, "index.html");
-    this.outputGitignorePath = path3.join(this.outputFolderPath, ".gitignore");
-    const fullLocalContentPath = stripNativeTrailingSlash(
-      path3.join(this.tinaFolderPath, this.config.localContentPath || "")
-    );
-    if (this.config.localContentPath) {
-      const localContentPathExists = await fs2.pathExists(fullLocalContentPath);
-      if (localContentPathExists) {
-        logger.info(`Using separate content repo at ${fullLocalContentPath}`);
-        this.contentRootPath = fullLocalContentPath;
-      } else {
-        logger.warn(
-          `${chalk3.yellow("Warning:")} The localContentPath ${chalk3.cyan(
-            fullLocalContentPath
-          )} does not exist. Please create it or remove the localContentPath from your config file at ${chalk3.cyan(
-            this.tinaConfigFilePath
-          )}`
-        );
-      }
-    }
-    if (!this.contentRootPath) {
-      this.contentRootPath = this.rootPath;
-    }
-    this.generatedFolderPathContentRepo = path3.join(
+    this.outputHTMLFilePath = path4.join(this.outputFolderPath, "index.html");
+    this.outputGitignorePath = path4.join(this.outputFolderPath, ".gitignore");
+    this.contentRootPath = await resolveContentRootPath({
+      rootPath: this.rootPath,
+      tinaFolderPath: this.tinaFolderPath,
+      tinaConfigFilePath: this.tinaConfigFilePath,
+      localContentPath: this.config.localContentPath
+    });
+    this.generatedFolderPathContentRepo = path4.join(
       await this.getTinaFolderPath(this.contentRootPath, {
         isContentRoot: this.hasSeparateContentRoot()
       }),
       GENERATED_FOLDER
     );
     this.spaMainPath = require2.resolve("@tinacms/app");
-    this.spaRootPath = path3.join(this.spaMainPath, "..", "..");
+    this.spaRootPath = path4.join(this.spaMainPath, "..", "..");
   }
   async getTinaFolderPath(rootPath, { isContentRoot } = {}) {
-    const tinaFolderPath = path3.join(rootPath, TINA_FOLDER);
-    const tinaFolderExists = await fs2.pathExists(tinaFolderPath);
+    const tinaFolderPath = path4.join(rootPath, TINA_FOLDER);
+    const tinaFolderExists = await fs3.pathExists(tinaFolderPath);
     if (tinaFolderExists) {
       this.isUsingLegacyFolder = false;
       return tinaFolderPath;
     }
-    const legacyFolderPath = path3.join(rootPath, LEGACY_TINA_FOLDER);
-    const legacyFolderExists = await fs2.pathExists(legacyFolderPath);
+    const legacyFolderPath = path4.join(rootPath, LEGACY_TINA_FOLDER);
+    const legacyFolderExists = await fs3.pathExists(legacyFolderPath);
     if (legacyFolderExists) {
       this.isUsingLegacyFolder = true;
       return legacyFolderPath;
     }
     if (isContentRoot) {
       throw new Error(
-        `Unable to find a ${chalk3.cyan("tina/")} folder in your content root at ${chalk3.cyan(rootPath)}. When using localContentPath, the content directory must contain a ${chalk3.cyan("tina/")} folder for generated files. Create one with: mkdir ${path3.join(rootPath, TINA_FOLDER)}`
+        `Unable to find a ${chalk4.cyan("tina/")} folder in your content root at ${chalk4.cyan(rootPath)}. When using localContentPath, the content directory must contain a ${chalk4.cyan("tina/")} folder for generated files. Create one with: mkdir ${path4.join(rootPath, TINA_FOLDER)}`
       );
     }
     throw new Error(
@@ -1088,7 +1119,7 @@ var ConfigManager = class {
         patch: version2[2] || "x"
       };
     }
-    const generatedSchema = fs2.readJSONSync(this.generatedSchemaJSONPath);
+    const generatedSchema = fs3.readJSONSync(this.generatedSchemaJSONPath);
     if (!generatedSchema || !(typeof generatedSchema?.version !== "undefined")) {
       throw new Error(
         `Can not find Tina GraphQL version in ${this.generatedSchemaJSONPath}`
@@ -1135,7 +1166,7 @@ var ConfigManager = class {
           return;
         }
         const filepathWithExtension = `${filepath}.${ext}`;
-        const exists = fs2.existsSync(filepathWithExtension);
+        const exists = fs3.existsSync(filepathWithExtension);
         if (exists) {
           result = filepathWithExtension;
         }
@@ -1144,8 +1175,8 @@ var ConfigManager = class {
     return result;
   }
   async loadDatabaseFile() {
-    const tmpdir = path3.join(os.tmpdir(), Date.now().toString());
-    const outfile = path3.join(tmpdir, "database.build.mjs");
+    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,
@@ -1163,22 +1194,22 @@ var ConfigManager = class {
       }
     });
     const result = await import(pathToFileURL(outfile).href);
-    fs2.removeSync(outfile);
+    fs3.removeSync(outfile);
     return result.default;
   }
   async loadConfigFile(generatedFolderPath, configFilePath) {
-    const tmpdir = path3.join(os.tmpdir(), Date.now().toString());
-    const preBuildConfigPath = path3.join(
+    const tmpdir = path4.join(os.tmpdir(), Date.now().toString());
+    const preBuildConfigPath = path4.join(
       this.generatedFolderPath,
       "config.prebuild.jsx"
     );
-    const outfile = path3.join(tmpdir, "config.build.jsx");
-    const outfile2 = path3.join(tmpdir, "config.build.mjs");
-    const tempTSConfigFile = path3.join(tmpdir, "tsconfig.json");
+    const outfile = path4.join(tmpdir, "config.build.jsx");
+    const outfile2 = path4.join(tmpdir, "config.build.mjs");
+    const tempTSConfigFile = path4.join(tmpdir, "tsconfig.json");
     const esmRequireBanner = {
       js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`
     };
-    fs2.outputFileSync(tempTSConfigFile, "{}");
+    fs3.outputFileSync(tempTSConfigFile, "{}");
     const result2 = await esbuild.build({
       entryPoints: [configFilePath],
       bundle: true,
@@ -1228,8 +1259,8 @@ var ConfigManager = class {
       console.error(e);
       throw e;
     }
-    fs2.removeSync(outfile);
-    fs2.removeSync(outfile2);
+    fs3.removeSync(outfile);
+    fs3.removeSync(outfile2);
     return {
       config: result.default,
       prebuildPath: preBuildConfigPath,
@@ -1320,7 +1351,7 @@ async function createAndInitializeDatabase(configManager, datalayerPort, bridgeO
 
 // src/next/commands/baseCommands.ts
 import { Command, Option } from "clipanion";
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 
 // src/utils/start-subprocess.ts
 import childProcess from "child_process";
@@ -1354,7 +1385,7 @@ stack: ${code.stack || "No stack was provided"}`);
 
 // src/next/commands/baseCommands.ts
 import { getChangedFiles, getSha, shaExists } from "@tinacms/graphql";
-import fs3 from "fs-extra";
+import fs4 from "fs-extra";
 var BaseCommand = class extends Command {
   experimentalDataLayer = Option.Boolean("--experimentalData", {
     description: "DEPRECATED - Build the server with additional data querying capabilities"
@@ -1388,7 +1419,7 @@ var BaseCommand = class extends Command {
     if (this.subCommand) {
       subProc = await startSubprocess2({ command: this.subCommand });
       logger.info(
-        `Running web application with command: ${chalk4.cyan(this.subCommand)}`
+        `Running web application with command: ${chalk5.cyan(this.subCommand)}`
       );
     }
     function exitHandler(options, exitCode) {
@@ -1436,7 +1467,7 @@ var BaseCommand = class extends Command {
         const rootPath = configManager.rootPath;
         let sha;
         try {
-          sha = await getSha({ fs: fs3, dir: rootPath });
+          sha = await getSha({ fs: fs4, dir: rootPath });
         } catch (e) {
           if (partialReindex) {
             console.error(
@@ -1446,7 +1477,7 @@ var BaseCommand = class extends Command {
           }
         }
         const lastSha = await database.getMetadata("lastSha");
-        const exists = lastSha && await shaExists({ fs: fs3, dir: rootPath, sha: lastSha });
+        const exists = lastSha && await shaExists({ fs: fs4, dir: rootPath, sha: lastSha });
         let res;
         if (partialReindex && lastSha && exists && sha) {
           const pathFilter = {};
@@ -1461,14 +1492,14 @@ var BaseCommand = class extends Command {
             };
           }
           const { added, modified, deleted } = await getChangedFiles({
-            fs: fs3,
+            fs: fs4,
             dir: rootPath,
             from: lastSha,
             to: sha,
             pathFilter
           });
           const tinaPathUpdates = modified.filter(
-            (path15) => path15.startsWith(".tina/__generated__/_schema.json") || path15.startsWith("tina/tina-lock.json")
+            (path16) => path16.startsWith(".tina/__generated__/_schema.json") || path16.startsWith("tina/tina-lock.json")
           );
           if (tinaPathUpdates.length > 0) {
             res = await database.indexContent({
@@ -1587,9 +1618,9 @@ var devHTML = (port) => `<!DOCTYPE html>
 import { createServer as createViteServer } from "vite";
 
 // src/next/vite/index.ts
-import path5 from "node:path";
+import path6 from "node:path";
 import react from "@vitejs/plugin-react";
-import fs4 from "fs-extra";
+import fs5 from "fs-extra";
 import normalizePath3 from "normalize-path";
 import {
   splitVendorChunkPlugin
@@ -1656,7 +1687,7 @@ function filterPublicEnv(env = process.env) {
 }
 
 // src/next/vite/tailwind.ts
-import path4 from "node:path";
+import path5 from "node:path";
 import aspectRatio from "@tailwindcss/aspect-ratio";
 import containerQueries from "@tailwindcss/container-queries";
 import twTypography from "@tailwindcss/typography";
@@ -1671,7 +1702,7 @@ var tinaTailwind = (spaPath, prebuildFilePath) => {
       const require2 = createRequire2(import.meta.url);
       const plugins = [];
       const content = [
-        path4.join(spaPath, "src/**/*.{vue,js,ts,jsx,tsx,svelte}"),
+        path5.join(spaPath, "src/**/*.{vue,js,ts,jsx,tsx,svelte}"),
         prebuildFilePath,
         require2.resolve("tinacms")
       ];
@@ -1935,35 +1966,35 @@ async function listFilesRecursively({
   config: config2,
   roothPath
 }) {
-  const fullDirectoryPath = path5.join(
+  const fullDirectoryPath = path6.join(
     roothPath,
     config2.publicFolder,
     directoryPath
   );
-  const exists = await fs4.pathExists(fullDirectoryPath);
+  const exists = await fs5.pathExists(fullDirectoryPath);
   if (!exists) {
     return { "0": [] };
   }
-  const items = await fs4.readdir(fullDirectoryPath);
+  const items = await fs5.readdir(fullDirectoryPath);
   const staticMediaItems = [];
   for (const item of items) {
-    const itemPath = path5.join(fullDirectoryPath, item);
-    const stats = await fs4.promises.lstat(itemPath);
+    const itemPath = path6.join(fullDirectoryPath, item);
+    const stats = await fs5.promises.lstat(itemPath);
     const staticMediaItem = {
       id: item,
       filename: item,
       type: stats.isDirectory() ? "dir" : "file",
       directory: `${directoryPath.replace(config2.mediaRoot, "")}`,
-      src: `/${path5.join(directoryPath, item)}`,
+      src: `/${path6.join(directoryPath, item)}`,
       thumbnails: {
-        "75x75": `/${path5.join(directoryPath, item)}`,
-        "400x400": `/${path5.join(directoryPath, item)}`,
-        "1000x1000": `/${path5.join(directoryPath, item)}`
+        "75x75": `/${path6.join(directoryPath, item)}`,
+        "400x400": `/${path6.join(directoryPath, item)}`,
+        "1000x1000": `/${path6.join(directoryPath, item)}`
       }
     };
     if (stats.isDirectory()) {
       staticMediaItem.children = await listFilesRecursively({
-        directoryPath: path5.join(directoryPath, item),
+        directoryPath: path6.join(directoryPath, item),
         config: config2,
         roothPath
       });
@@ -1988,7 +2019,7 @@ var createConfig = async ({
   rollupOptions
 }) => {
   const publicEnv = filterPublicEnv();
-  const staticMediaPath = path5.join(
+  const staticMediaPath = path6.join(
     configManager.generatedFolderPath,
     "static-media.json"
   );
@@ -1998,21 +2029,21 @@ var createConfig = async ({
       config: configManager.config.media.tina,
       roothPath: configManager.rootPath
     });
-    await fs4.outputFile(staticMediaPath, JSON.stringify(staticMedia, null, 2));
+    await fs5.outputFile(staticMediaPath, JSON.stringify(staticMedia, null, 2));
   } else {
-    await fs4.outputFile(staticMediaPath, `[]`);
+    await fs5.outputFile(staticMediaPath, `[]`);
   }
   const alias = {
     TINA_IMPORT: configManager.prebuildFilePath,
     SCHEMA_IMPORT: configManager.generatedGraphQLJSONPath,
     STATIC_MEDIA_IMPORT: staticMediaPath,
-    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")
+    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")
   };
   if (configManager.shouldSkipSDK()) {
-    alias["CLIENT_IMPORT"] = path5.join(
+    alias["CLIENT_IMPORT"] = path6.join(
       configManager.spaRootPath,
       "src",
       "dummy-client.ts"
@@ -2122,8 +2153,8 @@ var createConfig = async ({
 };
 
 // src/next/vite/plugins.ts
-import fs6 from "fs";
-import path7 from "path";
+import fs7 from "fs";
+import path8 from "path";
 import { createFilter } from "@rollup/pluginutils";
 import { resolve as gqlResolve } from "@tinacms/graphql";
 import bodyParser from "body-parser";
@@ -2132,11 +2163,11 @@ import { transform as esbuildTransform } from "esbuild";
 import { transformWithEsbuild } from "vite";
 
 // src/next/commands/dev-command/server/media.ts
-import path6, { join } from "path";
+import path7, { join } from "path";
 import busboy from "busboy";
-import fs5 from "fs-extra";
+import fs6 from "fs-extra";
 var createMediaRouter = (config2) => {
-  const mediaFolder = path6.join(
+  const mediaFolder = path7.join(
     config2.rootPath,
     config2.publicFolder,
     config2.mediaRoot
@@ -2200,8 +2231,8 @@ var createMediaRouter = (config2) => {
         );
         return;
       }
-      await fs5.ensureDir(path6.dirname(saveTo));
-      file.pipe(fs5.createWriteStream(saveTo));
+      await fs6.ensureDir(path7.dirname(saveTo));
+      file.pipe(fs6.createWriteStream(saveTo));
     });
     bb.on("error", (error) => {
       responded = true;
@@ -2231,18 +2262,18 @@ var parseMediaFolder = (str) => {
 var ENCODED_TRAVERSAL_RE = /%2e%2e|%2f|%5c/i;
 function resolveRealPath(candidate) {
   try {
-    return fs5.realpathSync(candidate);
+    return fs6.realpathSync(candidate);
   } catch {
-    const parent = path6.dirname(candidate);
+    const parent = path7.dirname(candidate);
     if (parent === candidate) return candidate;
-    return path6.join(resolveRealPath(parent), path6.basename(candidate));
+    return path7.join(resolveRealPath(parent), path7.basename(candidate));
   }
 }
 function assertSymlinkWithinBase(resolved, resolvedBase, userPath) {
   try {
-    const realBase = fs5.realpathSync(resolvedBase);
+    const realBase = fs6.realpathSync(resolvedBase);
     const realResolved = resolveRealPath(resolved);
-    if (realResolved !== realBase && !realResolved.startsWith(realBase + path6.sep)) {
+    if (realResolved !== realBase && !realResolved.startsWith(realBase + path7.sep)) {
       throw new PathTraversalError(userPath);
     }
   } catch (err) {
@@ -2253,13 +2284,13 @@ function resolveWithinBase(userPath, baseDir) {
   if (ENCODED_TRAVERSAL_RE.test(userPath)) {
     throw new PathTraversalError(userPath);
   }
-  const resolvedBase = path6.resolve(baseDir);
-  const resolved = path6.resolve(path6.join(baseDir, userPath));
+  const resolvedBase = path7.resolve(baseDir);
+  const resolved = path7.resolve(path7.join(baseDir, userPath));
   if (resolved === resolvedBase) {
     assertSymlinkWithinBase(resolved, resolvedBase, userPath);
     return resolvedBase;
   }
-  if (resolved.startsWith(resolvedBase + path6.sep)) {
+  if (resolved.startsWith(resolvedBase + path7.sep)) {
     assertSymlinkWithinBase(resolved, resolvedBase, userPath);
     return resolved;
   }
@@ -2269,12 +2300,12 @@ function resolveStrictlyWithinBase(userPath, baseDir) {
   if (ENCODED_TRAVERSAL_RE.test(userPath)) {
     throw new PathTraversalError(userPath);
   }
-  const resolvedBase = path6.resolve(baseDir) + path6.sep;
-  const resolved = path6.resolve(path6.join(baseDir, userPath));
+  const resolvedBase = path7.resolve(baseDir) + path7.sep;
+  const resolved = path7.resolve(path7.join(baseDir, userPath));
   if (!resolved.startsWith(resolvedBase)) {
     throw new PathTraversalError(userPath);
   }
-  assertSymlinkWithinBase(resolved, path6.resolve(baseDir), userPath);
+  assertSymlinkWithinBase(resolved, path7.resolve(baseDir), userPath);
   return resolved;
 }
 var MediaModel = class {
@@ -2291,16 +2322,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 fs5.pathExists(validatedPath)) {
+      if (!await fs6.pathExists(validatedPath)) {
         return {
           files: [],
           directories: []
         };
       }
-      const filesStr = await fs5.readdir(validatedPath);
+      const filesStr = await fs6.readdir(validatedPath);
       const filesProm = filesStr.map(async (file) => {
         const filePath = join(validatedPath, file);
-        const stat = await fs5.stat(filePath);
+        const stat = await fs6.stat(filePath);
         let src = `/${file}`;
         const isFile = stat.isFile();
         if (!isFile) {
@@ -2359,8 +2390,8 @@ var MediaModel = class {
     try {
       const mediaBase = join(this.rootPath, this.publicFolder, this.mediaRoot);
       const file = resolveStrictlyWithinBase(args.searchPath, mediaBase);
-      await fs5.stat(file);
-      await fs5.remove(file);
+      await fs6.stat(file);
+      await fs6.remove(file);
       return { ok: true };
     } catch (error) {
       if (error instanceof PathTraversalError) throw error;
@@ -2468,7 +2499,7 @@ var transformTsxPlugin = ({
   const plug = {
     name: "transform-tsx",
     async transform(code, id) {
-      const extName = path7.extname(id);
+      const extName = path8.extname(id);
       if (extName.startsWith(".tsx") || extName.startsWith(".ts")) {
         const result = await esbuildTransform(code, { loader: "tsx" });
         return {
@@ -2579,7 +2610,7 @@ function viteTransformExtension({
     async transform(code, id) {
       if (filter(id)) {
         const { transform: transform2 } = await import("@svgr/core");
-        const svgCode = await fs6.promises.readFile(
+        const svgCode = await fs7.promises.readFile(
           id.replace(/\?.*$/, ""),
           "utf8"
         );
@@ -2720,13 +2751,13 @@ var DevCommand = class extends BaseCommand {
         });
         const apiURL2 = await codegen2.execute();
         if (!configManager.isUsingLegacyFolder) {
-          const schemaObject = await fs7.readJSON(
+          const schemaObject = await fs8.readJSON(
             configManager.generatedSchemaJSONPath
           );
-          const lookupObject = await fs7.readJSON(
+          const lookupObject = await fs8.readJSON(
             configManager.generatedLookupJSONPath
           );
-          const graphqlSchemaObject = await fs7.readJSON(
+          const graphqlSchemaObject = await fs8.readJSON(
             configManager.generatedGraphQLJSONPath
           );
           const tinaLockFilename = "tina-lock.json";
@@ -2735,8 +2766,8 @@ var DevCommand = class extends BaseCommand {
             lookup: lookupObject,
             graphql: graphqlSchemaObject
           });
-          fs7.writeFileSync(
-            path8.join(configManager.tinaFolderPath, tinaLockFilename),
+          fs8.writeFileSync(
+            path9.join(configManager.tinaFolderPath, tinaLockFilename),
             tinaLockContent
           );
           if (configManager.hasSeparateContentRoot()) {
@@ -2744,9 +2775,9 @@ var DevCommand = class extends BaseCommand {
               configManager.contentRootPath,
               { isContentRoot: true }
             );
-            const filePath = path8.join(rootPath, tinaLockFilename);
-            await fs7.ensureFile(filePath);
-            await fs7.outputFile(filePath, tinaLockContent);
+            const filePath = path9.join(rootPath, tinaLockFilename);
+            await fs8.ensureFile(filePath);
+            await fs8.outputFile(filePath, tinaLockContent);
           }
         }
         await this.indexContentWithSpinner({
@@ -2789,8 +2820,8 @@ ${dangerText(e.message)}
     const { apiURL, graphQLSchema, tinaSchema } = await setup({
       firstTime: true
     });
-    await fs7.outputFile(configManager.outputHTMLFilePath, devHTML(this.port));
-    await fs7.outputFile(
+    await fs8.outputFile(configManager.outputHTMLFilePath, devHTML(this.port));
+    await fs8.outputFile(
       configManager.outputGitignorePath,
       "index.html\nassets/"
     );
@@ -2935,7 +2966,7 @@ ${dangerText(e.message)}
   watchContentFiles(configManager, database, databaseLock, searchIndexer) {
     const collectionContentFiles = [];
     configManager.config.schema.collections.forEach((collection) => {
-      const collectionGlob = `${path8.join(
+      const collectionGlob = `${path9.join(
         configManager.contentRootPath,
         collection.path
       )}/**/*.${collection.format || "md"}`;
@@ -2985,7 +3016,7 @@ ${dangerText(e.message)}
 
 // src/next/commands/build-command/index.ts
 import crypto from "crypto";
-import path9 from "path";
+import path10 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";
@@ -2994,7 +3025,7 @@ import {
   TinaCMSSearchIndexClient
 } from "@tinacms/search";
 import { Command as Command3, Option as Option3 } from "clipanion";
-import fs8 from "fs-extra";
+import fs9 from "fs-extra";
 import {
   buildASTSchema as buildASTSchema2,
   buildClientSchema,
@@ -3137,6 +3168,9 @@ var BuildCommand = class extends BaseCommand {
   localOption = Option3.Boolean("--local", {
     description: "Starts local Graphql server and builds the local client instead of production client"
   });
+  contentOption = Option3.String("--content", {
+    description: "Source for content during the build. Use `--content=local` to build from local content for fast builds while still generating a production client that connects to TinaCloud when deployed."
+  });
   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)"
   });
@@ -3199,6 +3233,15 @@ var BuildCommand = class extends BaseCommand {
       );
       process.exit(1);
     }
+    if (this.contentOption !== void 0 && this.contentOption !== "local") {
+      logger.error(
+        `${dangerText(
+          `ERROR: --content only accepts 'local'. Received '${this.contentOption}'.`
+        )}`
+      );
+      process.exit(1);
+    }
+    const localContentOnly = this.contentOption === "local";
     try {
       await configManager.processConfig();
     } catch (e) {
@@ -3209,6 +3252,21 @@ ${dangerText(e.message)}`);
       );
       process.exit(1);
     }
+    if (localContentOnly && !this.localOption) {
+      const config2 = configManager.config;
+      const missing = [];
+      if (!config2.branch) missing.push("branch");
+      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);
+      }
+    }
     let server;
     createDBServer(Number(this.datalayerPort));
     const database = await createAndInitializeDatabase(
@@ -3216,10 +3274,12 @@ ${dangerText(e.message)}`);
       Number(this.datalayerPort)
     );
     const { queryDoc, fragDoc, graphQLSchema, tinaSchema, lookup } = await buildSchema2(configManager.config);
+    const useLocalServer = this.localOption || localContentOnly;
     const codegen2 = new Codegen({
       configManager,
-      port: this.localOption ? Number(this.port) : void 0,
-      isLocal: this.localOption,
+      port: useLocalServer ? Number(this.port) : void 0,
+      isLocal: useLocalServer,
+      localContentBuild: localContentOnly && !this.localOption,
       queryDoc,
       fragDoc,
       graphqlSchemaDoc: graphQLSchema,
@@ -3228,8 +3288,8 @@ ${dangerText(e.message)}`);
       noClientBuildCache: this.noClientBuildCache
     });
     const apiURL = await codegen2.execute();
-    if ((configManager.hasSelfHostedConfig() || this.localOption) && !this.skipIndexing) {
-      const text = this.localOption ? void 0 : "Indexing to self-hosted data layer";
+    if ((configManager.hasSelfHostedConfig() || this.localOption || localContentOnly) && !this.skipIndexing) {
+      const text = this.localOption || localContentOnly ? void 0 : "Indexing to self-hosted data layer";
       try {
         await this.indexContentWithSpinner({
           text,
@@ -3250,12 +3310,13 @@ ${dangerText(e.message)}
         process.exit(1);
       }
     }
-    if (this.localOption) {
+    if (this.localOption || localContentOnly) {
+      const serverUrl = codegen2.localBuildUrl || apiURL;
       server = await createDevServer(
         configManager,
         database,
         null,
-        apiURL,
+        serverUrl,
         true,
         (lockedFn) => lockedFn()
       );
@@ -3323,11 +3384,16 @@ ${dangerText(e.message)}
       }
     }
     await buildProductionSpa(configManager, database, codegen2.productionUrl);
-    await fs8.outputFile(
+    await fs9.outputFile(
       configManager.outputGitignorePath,
       "index.html\nassets/"
     );
-    if (configManager.config.search && !this.skipSearchIndex && !this.localOption) {
+    if (localContentOnly && configManager.config.search && !this.skipSearchIndex) {
+      logger.warn(
+        `${warnText("WARN: Search indexing skipped when building with --content=local. The search index on TinaCloud was not updated.")}`
+      );
+    }
+    if (configManager.config.search && !this.skipSearchIndex && !this.localOption && !localContentOnly) {
       let client;
       const hasTinaSearch = Boolean(configManager.config?.search?.tina);
       if (hasTinaSearch) {
@@ -3426,6 +3492,12 @@ ${dangerText(e.message)}
         ...summaryItems
       ]
     });
+    if (localContentOnly && codegen2.localBuildUrl) {
+      process.env.TINA_LOCAL_URL = codegen2.localBuildUrl;
+      if (!process.env.NODE_ENV || process.env.NODE_ENV !== "production") {
+        process.env.NODE_ENV = "production";
+      }
+    }
     if (this.subCommand) {
       await this.startSubCommand();
     } else {
@@ -3690,7 +3762,7 @@ Additional info: Branch: ${config2.branch}, Client ID: ${config2.clientId} `;
     }
     const localTinaSchema = JSON.parse(
       await database.bridge.get(
-        path9.join(database.tinaDirectory, "__generated__", "_schema.json")
+        path10.join(database.tinaDirectory, "__generated__", "_schema.json")
       )
     );
     localTinaSchema.version = void 0;
@@ -3812,7 +3884,7 @@ import { buildSchema as buildSchema3 } from "@tinacms/graphql";
 import prompts from "prompts";
 import { Telemetry } from "@tinacms/metrics";
 import { resolve } from "@tinacms/graphql";
-import chalk5 from "chalk";
+import chalk6 from "chalk";
 var audit = async ({
   database,
   clean,
@@ -3830,7 +3902,7 @@ 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 ${chalk5.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 ${chalk6.bold(
         "clean git tree"
       )} so unwanted changes can be undone.
 
@@ -3842,13 +3914,13 @@ var audit = async ({
       message: `Do you want to continue?`
     });
     if (!res.useClean) {
-      logger.warn(chalk5.yellowBright("\u26A0\uFE0F Audit not complete"));
+      logger.warn(chalk6.yellowBright("\u26A0\uFE0F Audit not complete"));
       process.exit(0);
     }
   }
   if (useDefaultValues && !clean) {
     logger.warn(
-      chalk5.yellowBright(
+      chalk6.yellowBright(
         "WARNING: using the `--useDefaultValues` without the `--clean` flag has no effect. Please re-run audit and add the `--clean` flag"
       )
     );
@@ -3876,10 +3948,10 @@ var audit = async ({
   }
   if (error) {
     logger.error(
-      chalk5.redBright(`\u203C\uFE0F Audit ${chalk5.bold("failed")} with errors`)
+      chalk6.redBright(`\u203C\uFE0F Audit ${chalk6.bold("failed")} with errors`)
     );
   } else {
-    logger.info(chalk5.greenBright("\u2705 Audit passed"));
+    logger.info(chalk6.greenBright("\u2705 Audit passed"));
   }
 };
 var auditDocuments = async (args) => {
@@ -3907,11 +3979,11 @@ var auditDocuments = async (args) => {
     if (docResult.errors) {
       error = true;
       docResult.errors.forEach((err) => {
-        logger.error(chalk5.red(err.message));
+        logger.error(chalk6.red(err.message));
         if (err.originalError.originalError) {
           logger.error(
             // @ts-ignore FIXME: this doesn't seem right
-            chalk5.red(`    ${err.originalError.originalError.message}`)
+            chalk6.red(`    ${err.originalError.originalError.message}`)
           );
         }
       });
@@ -3953,7 +4025,7 @@ var auditDocuments = async (args) => {
       if (mutationRes.errors) {
         mutationRes.errors.forEach((err) => {
           error = true;
-          logger.error(chalk5.red(err.message));
+          logger.error(chalk6.red(err.message));
         });
       }
     }
@@ -4053,26 +4125,26 @@ var AuditCommand = class extends Command4 {
 import { Command as Command6, Option as Option6 } from "clipanion";
 
 // src/cmds/init/detectEnvironment.ts
-import fs9 from "fs-extra";
-import path10 from "path";
+import fs10 from "fs-extra";
+import path11 from "path";
 var checkGitignoreForItem = async ({
   baseDir,
   line
 }) => {
-  const gitignoreContent = fs9.readFileSync(path10.join(baseDir, ".gitignore")).toString();
+  const gitignoreContent = fs10.readFileSync(path11.join(baseDir, ".gitignore")).toString();
   return gitignoreContent.split("\n").some((item) => item === line);
 };
 var makeGeneratedFile = async (name2, generatedFileType, parentPath, opts) => {
   const result = {
-    fullPathTS: path10.join(
+    fullPathTS: path11.join(
       parentPath,
       `${name2}.${opts?.typescriptSuffix || opts?.extensionOverride || "ts"}`
     ),
-    fullPathJS: path10.join(
+    fullPathJS: path11.join(
       parentPath,
       `${name2}.${opts?.extensionOverride || "js"}`
     ),
-    fullPathOverride: opts?.extensionOverride ? path10.join(parentPath, `${name2}.${opts?.extensionOverride}`) : "",
+    fullPathOverride: opts?.extensionOverride ? path11.join(parentPath, `${name2}.${opts?.extensionOverride}`) : "",
     generatedFileType,
     name: name2,
     parentPath,
@@ -4090,8 +4162,8 @@ var makeGeneratedFile = async (name2, generatedFileType, parentPath, opts) => {
       };
     }
   };
-  result.typescriptExists = await fs9.pathExists(result.fullPathTS);
-  result.javascriptExists = await fs9.pathExists(result.fullPathJS);
+  result.typescriptExists = await fs10.pathExists(result.fullPathTS);
+  result.javascriptExists = await fs10.pathExists(result.fullPathJS);
   return result;
 };
 var detectEnvironment = async ({
@@ -4100,21 +4172,21 @@ var detectEnvironment = async ({
   rootPath,
   debug = false
 }) => {
-  const hasForestryConfig = await fs9.pathExists(
-    path10.join(pathToForestryConfig, ".forestry", "settings.yml")
+  const hasForestryConfig = await fs10.pathExists(
+    path11.join(pathToForestryConfig, ".forestry", "settings.yml")
   );
-  const sampleContentPath = path10.join(
+  const sampleContentPath = path11.join(
     baseDir,
     "content",
     "posts",
     "hello-world.md"
   );
-  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 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 tinaConfigExists = Boolean(
     // Does the tina folder exist?
-    await fs9.pathExists(tinaFolder) && // Does the tina folder contain a config file?
-    (await fs9.readdir(tinaFolder)).find((x) => x.includes("config"))
+    await fs10.pathExists(tinaFolder) && // Does the tina folder contain a config file?
+    (await fs10.readdir(tinaFolder)).find((x) => x.includes("config"))
   );
   const pagesDir = [baseDir, usingSrc ? "src" : false, "pages"].filter(
     Boolean
@@ -4126,12 +4198,12 @@ var detectEnvironment = async ({
     "next-api-handler": await makeGeneratedFile(
       "[...routes]",
       "next-api-handler",
-      path10.join(...pagesDir, "api", "tina")
+      path11.join(...pagesDir, "api", "tina")
     ),
     "reactive-example": await makeGeneratedFile(
       "[filename]",
       "reactive-example",
-      path10.join(...pagesDir, "demo", "blog"),
+      path11.join(...pagesDir, "demo", "blog"),
       {
         typescriptSuffix: "tsx"
       }
@@ -4139,22 +4211,22 @@ var detectEnvironment = async ({
     "users-json": await makeGeneratedFile(
       "index",
       "users-json",
-      path10.join(baseDir, "content", "users"),
+      path11.join(baseDir, "content", "users"),
       { extensionOverride: "json" }
     ),
     "sample-content": await makeGeneratedFile(
       "hello-world",
       "sample-content",
-      path10.join(baseDir, "content", "posts"),
+      path11.join(baseDir, "content", "posts"),
       { extensionOverride: "md" }
     )
   };
-  const hasSampleContent = await fs9.pathExists(sampleContentPath);
-  const hasPackageJSON = await fs9.pathExists("package.json");
+  const hasSampleContent = await fs10.pathExists(sampleContentPath);
+  const hasPackageJSON = await fs10.pathExists("package.json");
   let hasTinaDeps = false;
   if (hasPackageJSON) {
     try {
-      const packageJSON = await fs9.readJSON("package.json");
+      const packageJSON = await fs10.readJSON("package.json");
       const deps = [];
       if (packageJSON?.dependencies) {
         deps.push(...Object.keys(packageJSON.dependencies));
@@ -4171,15 +4243,15 @@ var detectEnvironment = async ({
       );
     }
   }
-  const hasGitIgnore = await fs9.pathExists(path10.join(".gitignore"));
+  const hasGitIgnore = await fs10.pathExists(path11.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 = path10.join(rootPath, "config.toml");
-    if (await fs9.pathExists(hugoConfigPath)) {
-      const hugoConfig = await fs9.readFile(hugoConfigPath, "utf8");
+    const hugoConfigPath = path11.join(rootPath, "config.toml");
+    if (await fs10.pathExists(hugoConfigPath)) {
+      const hugoConfig = await fs10.readFile(hugoConfigPath, "utf8");
       const metaDataFormat = hugoConfig.toString().match(/metaDataFormat = "(.*)"/)?.[1];
       if (metaDataFormat && (metaDataFormat === "yaml" || metaDataFormat === "toml" || metaDataFormat === "json")) {
         frontMatterFormat = metaDataFormat;
@@ -4792,21 +4864,21 @@ var CLICommand = class {
 };
 
 // src/cmds/init/apply.ts
-import path14 from "path";
+import path15 from "path";
 
 // src/cmds/forestry-migrate/index.ts
-import fs11 from "fs-extra";
-import path12 from "path";
+import fs12 from "fs-extra";
+import path13 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 fs10 from "fs-extra";
-import path11 from "path";
+import fs11 from "fs-extra";
+import path12 from "path";
 import yaml from "js-yaml";
-import z from "zod";
+import z2 from "zod";
 
 // src/cmds/forestry-migrate/util/errorSingleton.ts
 var ErrorSingleton = class _ErrorSingleton {
@@ -4845,7 +4917,7 @@ var ErrorSingleton = class _ErrorSingleton {
       });
       logger.error(
         `If you wish to edit any of the following templates, you will have to update your content and code to use the new name. See ${linkText(
-          "https://tina.io/docs/forestry/common-errors/#migrating-fields-with-non-alphanumeric-characters"
+          "https://tina.io/docs/r/forestry-common-errors#migrating-fields-with-non-alphanumeric-characters"
         )} for more information.`
       );
     }
@@ -4933,82 +5005,82 @@ var stringifyTemplateName = (name2, template) => {
     return newName;
   }
 };
-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")
+var forestryConfigSchema = z2.object({
+  sections: z2.array(
+    z2.object({
+      type: z2.union([
+        z2.literal("directory"),
+        z2.literal("document"),
+        z2.literal("heading"),
+        z2.literal("jekyll-pages"),
+        z2.literal("jekyll-posts")
       ]),
-      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()
+      label: z2.string(),
+      path: z2.string().optional().nullable(),
+      match: z2.string().optional().nullable(),
+      exclude: z2.string().optional().nullable(),
+      create: z2.union([z2.literal("all"), z2.literal("documents"), z2.literal("none")]).optional(),
+      templates: z2.array(z2.string()).optional().nullable(),
+      new_doc_ext: z2.string().optional().nullable(),
+      read_only: z2.boolean().optional().nullable()
     })
   )
 });
-var forestryFieldWithoutField = z.object({
+var forestryFieldWithoutField = z2.object({
   // TODO: maybe better type this?
-  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")
+  type: z2.union([
+    z2.literal("text"),
+    z2.literal("datetime"),
+    z2.literal("list"),
+    z2.literal("file"),
+    z2.literal("image_gallery"),
+    z2.literal("textarea"),
+    z2.literal("tag_list"),
+    z2.literal("number"),
+    z2.literal("boolean"),
+    z2.literal("field_group"),
+    z2.literal("field_group_list"),
+    z2.literal("select"),
+    z2.literal("include"),
+    z2.literal("blocks"),
+    z2.literal("color")
   ]),
-  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({
+  template_types: z2.array(z2.string()).optional().nullable(),
+  name: z2.string(),
+  label: z2.string(),
+  default: z2.any().optional(),
+  template: z2.string().optional(),
+  config: z2.object({
     // min and max are used for lists
-    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"),
+    min: z2.number().optional().nullable(),
+    max: z2.number().optional().nullable(),
+    required: z2.boolean().optional().nullable(),
+    use_select: z2.boolean().optional().nullable(),
+    date_format: z2.string().optional().nullable(),
+    time_format: z2.string().optional().nullable(),
+    options: z2.array(z2.string()).optional().nullable(),
+    source: z2.object({
+      type: z2.union([
+        z2.literal("custom"),
+        z2.literal("pages"),
+        z2.literal("documents"),
+        z2.literal("simple"),
         // TODO: I want to ignore this key if its invalid
-        z.string()
+        z2.string()
       ]).optional().nullable(),
-      section: z.string().optional().nullable()
+      section: z2.string().optional().nullable()
     }).optional()
   }).optional()
 });
-var forestryField = z.lazy(
+var forestryField = z2.lazy(
   () => forestryFieldWithoutField.extend({
-    fields: z.array(forestryField).optional()
+    fields: z2.array(forestryField).optional()
   })
 );
-var FrontmatterTemplateSchema = z.object({
-  label: z.string(),
-  hide_body: z.boolean().optional(),
-  fields: z.array(forestryField).optional()
+var FrontmatterTemplateSchema = z2.object({
+  label: z2.string(),
+  hide_body: z2.boolean().optional(),
+  fields: z2.array(forestryField).optional()
 });
 var transformForestryFieldsToTinaFields = ({
   fields,
@@ -5231,7 +5303,7 @@ var transformForestryFieldsToTinaFields = ({
   return tinaFields;
 };
 var getFieldsFromTemplates = ({ tem, pathToForestryConfig, skipBlocks = false }) => {
-  const templatePath = path11.join(
+  const templatePath = path12.join(
     pathToForestryConfig,
     ".forestry",
     "front_matter",
@@ -5240,7 +5312,7 @@ var getFieldsFromTemplates = ({ tem, pathToForestryConfig, skipBlocks = false })
   );
   let templateString = "";
   try {
-    templateString = fs10.readFileSync(templatePath).toString();
+    templateString = fs11.readFileSync(templatePath).toString();
   } catch {
     throw new Error(
       `Could not find template ${tem} at ${templatePath}
@@ -5289,7 +5361,7 @@ var transformForestryMatchToTinaMatch = (match) => {
   if (match !== newMatch) {
     logger.info(
       `Info: Match ${match} was transformed to ${newMatch}. See ${linkText(
-        "https://tina.io/docs/forestry/common-errors/#info-match-match-was-transformed-to-newmatch"
+        "https://tina.io/docs/r/forestry-common-errors#info-match-match-was-transformed-to-newmatch"
       )}`
     );
   }
@@ -5306,9 +5378,9 @@ function checkExt(ext) {
 var generateAllTemplates = async ({
   pathToForestryConfig
 }) => {
-  const allTemplates = (await fs11.readdir(
-    path12.join(pathToForestryConfig, ".forestry", "front_matter", "templates")
-  )).map((tem) => path12.basename(tem, ".yml"));
+  const allTemplates = (await fs12.readdir(
+    path13.join(pathToForestryConfig, ".forestry", "front_matter", "templates")
+  )).map((tem) => path13.basename(tem, ".yml"));
   const templateMap = /* @__PURE__ */ new Map();
   const proms = allTemplates.map(async (tem) => {
     try {
@@ -5433,7 +5505,7 @@ var generateCollectionFromForestrySection = (args) => {
       logger.warn(
         warnText(
           `No templates found for section ${section.label}. Please see ${linkText(
-            "https://tina.io/docs/forestry/content-modelling/"
+            "https://tina.io/docs/r/forestry-content-modelling"
           )} for more information`
         )
       );
@@ -5453,9 +5525,9 @@ var generateCollectionFromForestrySection = (args) => {
     return c;
   } else if (section.type === "document") {
     const filePath = section.path;
-    const extname = path12.extname(filePath);
-    const fileName = path12.basename(filePath, extname);
-    const dir = path12.dirname(filePath);
+    const extname = path13.extname(filePath);
+    const fileName = path13.basename(filePath, extname);
+    const dir = path13.dirname(filePath);
     const ext = checkExt(extname);
     if (ext) {
       const fields = [];
@@ -5517,8 +5589,8 @@ var generateCollections = async ({
     templateMap,
     usingTypescript
   });
-  const forestryConfig = await fs11.readFile(
-    path12.join(pathToForestryConfig, ".forestry", "settings.yml")
+  const forestryConfig = await fs12.readFile(
+    path13.join(pathToForestryConfig, ".forestry", "settings.yml")
   );
   rewriteTemplateKeysInDocs({
     templateMap,
@@ -5548,12 +5620,12 @@ var rewriteTemplateKeysInDocs = (args) => {
     const { templateObj } = templateMap.get(templateKey);
     templateObj?.pages?.forEach((page) => {
       try {
-        const filePath = path12.join(page);
-        if (fs11.lstatSync(filePath).isDirectory()) {
+        const filePath = path13.join(page);
+        if (fs12.lstatSync(filePath).isDirectory()) {
           return;
         }
-        const extname = path12.extname(filePath);
-        const fileContent = fs11.readFileSync(filePath).toString();
+        const extname = path13.extname(filePath);
+        const fileContent = fs12.readFileSync(filePath).toString();
         const content = parseFile(
           fileContent,
           extname,
@@ -5564,7 +5636,7 @@ var rewriteTemplateKeysInDocs = (args) => {
           _template: stringifyLabel(templateKey),
           ...content
         };
-        fs11.writeFileSync(
+        fs12.writeFileSync(
           filePath,
           stringifyFile(newContent, extname, true, markdownParseConfig)
         );
@@ -5579,12 +5651,12 @@ var rewriteTemplateKeysInDocs = (args) => {
 
 // src/cmds/init/apply.ts
 import { Telemetry as Telemetry2 } from "@tinacms/metrics";
-import fs14 from "fs-extra";
+import fs15 from "fs-extra";
 
 // src/next/commands/codemod-command/index.ts
 import { Command as Command5, Option as Option5 } from "clipanion";
-import fs12 from "fs-extra";
-import path13 from "path";
+import fs13 from "fs-extra";
+import path14 from "path";
 var CodemodCommand = class extends Command5 {
   static paths = [["codemod"], ["codemod", "move-tina-folder"]];
   rootPath = Option5.String("--rootPath", {
@@ -5625,13 +5697,13 @@ var moveTinaFolder = async (rootPath = process.cwd()) => {
     logger.error(e.message);
     process.exit(1);
   }
-  const tinaDestination = path13.join(configManager.rootPath, "tina");
-  if (await fs12.existsSync(tinaDestination)) {
+  const tinaDestination = path14.join(configManager.rootPath, "tina");
+  if (await fs13.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 fs12.moveSync(configManager.tinaFolderPath, tinaDestination);
+    await fs13.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!"
@@ -5639,8 +5711,8 @@ var moveTinaFolder = async (rootPath = process.cwd()) => {
   }
 };
 var writeGitignore = async (rootPath) => {
-  await fs12.outputFileSync(
-    path13.join(rootPath, "tina", ".gitignore"),
+  await fs13.outputFileSync(
+    path14.join(rootPath, "tina", ".gitignore"),
     "__generated__"
   );
 };
@@ -6078,7 +6150,7 @@ function extendNextScripts(scripts, opts) {
 
 // src/cmds/init/codegen/index.ts
 import ts2 from "typescript";
-import fs13 from "fs-extra";
+import fs14 from "fs-extra";
 
 // src/cmds/init/codegen/util.ts
 import ts from "typescript";
@@ -6315,7 +6387,7 @@ var addSelfHostedTinaAuthToConfig = async (config2, configFile) => {
   const pathToConfig = configFile.resolve(config2.typescript).path;
   const sourceFile = ts2.createSourceFile(
     pathToConfig,
-    fs13.readFileSync(pathToConfig, "utf8"),
+    fs14.readFileSync(pathToConfig, "utf8"),
     config2.typescript ? ts2.ScriptTarget.Latest : ts2.ScriptTarget.ESNext
   );
   const { configImports, configAuthProviderClass, extraTinaCollections } = config2.authProvider;
@@ -6365,7 +6437,7 @@ var addSelfHostedTinaAuthToConfig = async (config2, configFile) => {
       )
     ].map((visitor) => makeTransformer(visitor))
   );
-  return fs13.writeFile(
+  return fs14.writeFile(
     pathToConfig,
     ts2.createPrinter({ omitTrailingSemicolon: true }).printFile(transformedSourceFileResult.transformed[0])
   );
@@ -6381,7 +6453,7 @@ async function apply({
   if (config2.framework.name === "other" && config2.hosting === "self-host") {
     logger.error(
       logText(
-        "Self-hosted Tina requires init setup only works with next.js right now. Please check out the docs for info on how to setup Tina on another framework: https://tina.io/docs/self-hosted/existing-site/"
+        "Self-hosted Tina requires init setup only works with next.js right now. Please check out the docs for info on how to setup Tina on another framework: https://tina.io/docs/r/self-hosting-nextjs"
       )
     );
     return;
@@ -6483,8 +6555,8 @@ async function apply({
     await addConfigFile({
       configArgs: {
         config: config2,
-        publicFolder: path14.join(
-          path14.relative(process.cwd(), pathToForestryConfig),
+        publicFolder: path15.join(
+          path15.relative(process.cwd(), pathToForestryConfig),
           config2.publicFolder
         ),
         collections,
@@ -6557,18 +6629,18 @@ var createPackageJSON = async () => {
 };
 var createGitignore = async ({ baseDir }) => {
   logger.info(logText("No .gitignore found, creating one"));
-  fs14.outputFileSync(path14.join(baseDir, ".gitignore"), "node_modules");
+  fs15.outputFileSync(path15.join(baseDir, ".gitignore"), "node_modules");
 };
 var updateGitIgnore = async ({
   baseDir,
   items
 }) => {
   logger.info(logText(`Adding ${items.join(",")} to .gitignore`));
-  const gitignoreContent = fs14.readFileSync(path14.join(baseDir, ".gitignore")).toString();
+  const gitignoreContent = fs15.readFileSync(path15.join(baseDir, ".gitignore")).toString();
   const newGitignoreContent = [...gitignoreContent.split("\n"), ...items].join(
     "\n"
   );
-  await fs14.writeFile(path14.join(baseDir, ".gitignore"), newGitignoreContent);
+  await fs15.writeFile(path15.join(baseDir, ".gitignore"), newGitignoreContent);
 };
 var addDependencies = async (config2, env, params) => {
   const { packageManager } = config2;
@@ -6639,22 +6711,22 @@ var writeGeneratedFile = async ({
   content,
   typescript
 }) => {
-  const { exists, path: path15, parentPath } = generatedFile.resolve(typescript);
+  const { exists, path: path16, parentPath } = generatedFile.resolve(typescript);
   if (exists) {
     if (overwrite) {
-      logger.info(`Overwriting file at ${path15}... \u2705`);
-      fs14.outputFileSync(path15, content);
+      logger.info(`Overwriting file at ${path16}... \u2705`);
+      fs15.outputFileSync(path16, content);
     } else {
-      logger.info(`Not overwriting file at ${path15}.`);
+      logger.info(`Not overwriting file at ${path16}.`);
       logger.info(
-        logText(`Please add the following to ${path15}:
+        logText(`Please add the following to ${path16}:
 ${indentText(content)}}`)
       );
     }
   } else {
-    logger.info(`Adding file at ${path15}... \u2705`);
-    await fs14.ensureDir(parentPath);
-    fs14.outputFileSync(path15, content);
+    logger.info(`Adding file at ${path16}... \u2705`);
+    await fs15.ensureDir(parentPath);
+    fs15.outputFileSync(path16, content);
   }
 };
 var addConfigFile = async ({
@@ -6732,7 +6804,7 @@ var addContentFile = async ({
         return () => ({
           exists: env.sampleContentExists,
           path: env.sampleContentPath,
-          parentPath: path14.dirname(env.sampleContentPath)
+          parentPath: path15.dirname(env.sampleContentPath)
         });
       }
     },
@@ -6755,10 +6827,10 @@ ${titleText(" TinaCMS ")} backend initialized!`));
       return `${x.key}=${x.value || "***"}`;
     }).join("\n") + `
 TINA_PUBLIC_IS_LOCAL=true`;
-    const envFile = path14.join(process.cwd(), ".env");
-    if (!fs14.existsSync(envFile)) {
+    const envFile = path15.join(process.cwd(), ".env");
+    if (!fs15.existsSync(envFile)) {
       logger.info(`Adding .env file to your project... \u2705`);
-      fs14.writeFileSync(envFile, envFileText);
+      fs15.writeFileSync(envFile, envFileText);
     } else {
       logger.info(
         "Please add the following environment variables to your .env file"
@@ -6766,7 +6838,7 @@ TINA_PUBLIC_IS_LOCAL=true`;
       logger.info(indentText(envFileText));
     }
     logger.info(
-      "Before you can run your site you will need to update it to use the backend client.\nSee docs for more info: https://tina.io/docs/self-hosted/querying-data/"
+      "Before you can run your site you will need to update it to use the backend client.\nSee docs for more info: https://tina.io/docs/r/self-hosted-querying-data"
     );
     logger.info(
       "If you are deploying to vercel make sure to add the environment variables to your project."
@@ -6827,7 +6899,7 @@ var addReactiveFile = {
     baseDir,
     dataLayer
   }) => {
-    const packageJsonPath = path14.join(baseDir, "package.json");
+    const packageJsonPath = path15.join(baseDir, "package.json");
     await writeGeneratedFile({
       generatedFile,
       typescript: config2.typescript,
@@ -6840,7 +6912,7 @@ var addReactiveFile = {
       })
     });
     logger.info("Adding a nextjs example... \u2705");
-    const packageJson = JSON.parse(fs14.readFileSync(packageJsonPath).toString());
+    const packageJson = JSON.parse(fs15.readFileSync(packageJsonPath).toString());
     const scripts = packageJson.scripts || {};
     const updatedPackageJson = JSON.stringify(
       {
@@ -6853,7 +6925,7 @@ var addReactiveFile = {
       null,
       2
     );
-    fs14.writeFileSync(packageJsonPath, updatedPackageJson);
+    fs15.writeFileSync(packageJsonPath, updatedPackageJson);
   }
 };
 function execShellCommand(cmd) {