@tinacms/cli 2.2.4 → 2.2.6

package/dist/index.js

@@ -2,16 +2,16 @@
 import { Cli, Builtins } from "clipanion";
 
 // package.json
-var version = "2.2.4";
+var version = "2.2.6";
 
 // 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";
@@ -691,7 +691,7 @@ var Codegen = class {
 import { resolve } from "@tinacms/datalayer";
 import type { TinaClient } from "tinacms/dist/client";
 
-import { queries } from "./types";
+import { queries } from "${this.configManager.isUsingTs() ? "./types.ts" : "./types.js"}";
 import database from "../database";
 
 export async function databaseRequest({ query, variables, user }) {
@@ -757,7 +757,7 @@ export default databaseClient;
     const errorPolicy = this.configManager.config?.client?.errorPolicy;
     const apiURL = this.getApiURL();
     const clientString = `import { createClient } from "tinacms/dist/client";
-import { queries } from "./types";
+import { queries } from "${this.configManager.isUsingTs() ? "./types.ts" : "./types.js"}";
 export const client = createClient({ ${this.noClientBuildCache === false ? `cacheDir: '${normalizePath(
       this.configManager.generatedCachePath
     )}', ` : ""}url: ${this.localContentBuild ? `process.env.TINA_LOCAL_URL || '${apiURL}'` : `'${apiURL}'`}, token: '${token}', queries, ${errorPolicy ? `errorPolicy: '${errorPolicy}'` : ""} });
@@ -819,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) {
@@ -848,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";
@@ -861,6 +894,7 @@ var ConfigManager = class {
   rootPath;
   tinaFolderPath;
   isUsingLegacyFolder;
+  hasWarnedLegacyFolder = false;
   tinaConfigFilePath;
   tinaSpaPackagePath;
   contentRootPath;
@@ -907,7 +941,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;
@@ -924,12 +958,20 @@ 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")
+    if (this.isUsingLegacyFolder && !this.hasWarnedLegacyFolder) {
+      this.hasWarnedLegacyFolder = true;
+      logger.warn(
+        warnText(
+          "WARN: Detected legacy `.tina/` config folder. `tina-lock.json` is only generated for the new `tina/` layout, and TinaCloud requires it to index your schema. Migrate by renaming `.tina/` to `tina/` (the contents stay the same). See https://tina.io/docs/tina-folder/overview/."
+        )
+      );
+    }
+    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(
@@ -937,89 +979,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(
@@ -1029,62 +1071,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(
@@ -1101,7 +1128,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}`
@@ -1111,28 +1138,41 @@ var ConfigManager = class {
   }
   printGeneratedClientFilePath() {
     if (this.isUsingTs()) {
-      return this.generatedClientTSFilePath.replace(`${this.rootPath}/`, "");
+      return normalizePath2(
+        path4.relative(this.rootPath, this.generatedClientTSFilePath)
+      );
     }
-    return this.generatedClientJSFilePath.replace(`${this.rootPath}/`, "");
+    return normalizePath2(
+      path4.relative(this.rootPath, this.generatedClientJSFilePath)
+    );
   }
   printGeneratedTypesFilePath() {
-    return this.generatedTypesTSFilePath.replace(`${this.rootPath}/`, "");
+    return normalizePath2(
+      path4.relative(this.rootPath, this.generatedTypesTSFilePath)
+    );
   }
   printoutputHTMLFilePath() {
-    return this.outputHTMLFilePath.replace(`${this.publicFolderPath}/`, "");
+    return normalizePath2(
+      path4.relative(this.publicFolderPath, this.outputHTMLFilePath)
+    );
   }
   printRelativePath(filename) {
     if (filename) {
-      return filename.replace(/\\/g, "/").replace(`${this.rootPath}/`, "");
+      return normalizePath2(path4.relative(this.rootPath, filename));
     }
     throw `No path provided to print`;
   }
   printPrebuildFilePath() {
-    return this.prebuildFilePath.replace(/\\/g, "/").replace(`${this.rootPath}/${this.tinaFolderPath}/`, "");
+    return normalizePath2(
+      path4.relative(
+        path4.join(this.rootPath, this.tinaFolderPath),
+        this.prebuildFilePath
+      )
+    );
   }
   printContentRelativePath(filename) {
     if (filename) {
-      return filename.replace(/\\/g, "/").replace(`${this.contentRootPath}/`, "");
+      return normalizePath2(path4.relative(this.contentRootPath, filename));
     }
     throw `No path provided to print`;
   }
@@ -1148,7 +1188,7 @@ var ConfigManager = class {
           return;
         }
         const filepathWithExtension = `${filepath}.${ext}`;
-        const exists = fs2.existsSync(filepathWithExtension);
+        const exists = fs3.existsSync(filepathWithExtension);
         if (exists) {
           result = filepathWithExtension;
         }
@@ -1157,8 +1197,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,
@@ -1176,22 +1216,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,
@@ -1241,8 +1281,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,
@@ -1333,7 +1373,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";
@@ -1367,7 +1407,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"
@@ -1401,7 +1441,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) {
@@ -1449,7 +1489,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(
@@ -1459,7 +1499,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 = {};
@@ -1474,14 +1514,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")
+            (path17) => path17.startsWith(".tina/__generated__/_schema.json") || path17.startsWith("tina/tina-lock.json")
           );
           if (tinaPathUpdates.length > 0) {
             res = await database.indexContent({
@@ -1600,9 +1640,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
@@ -1669,7 +1709,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";
@@ -1684,7 +1724,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")
       ];
@@ -1948,35 +1988,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
       });
@@ -2001,7 +2041,7 @@ var createConfig = async ({
   rollupOptions
 }) => {
   const publicEnv = filterPublicEnv();
-  const staticMediaPath = path5.join(
+  const staticMediaPath = path6.join(
     configManager.generatedFolderPath,
     "static-media.json"
   );
@@ -2011,21 +2051,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"
@@ -2135,8 +2175,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";
@@ -2145,11 +2185,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
@@ -2213,8 +2253,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;
@@ -2244,18 +2284,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) {
@@ -2266,13 +2306,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;
   }
@@ -2282,12 +2322,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 {
@@ -2304,16 +2344,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) {
@@ -2372,8 +2412,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;
@@ -2481,7 +2521,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 {
@@ -2592,7 +2632,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"
         );
@@ -2733,13 +2773,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";
@@ -2748,8 +2788,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()) {
@@ -2757,9 +2797,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({
@@ -2802,8 +2842,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/"
     );
@@ -2948,7 +2988,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"}`;
@@ -2998,7 +3038,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";
@@ -3007,7 +3047,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,
@@ -3366,7 +3406,7 @@ ${dangerText(e.message)}
       }
     }
     await buildProductionSpa(configManager, database, codegen2.productionUrl);
-    await fs8.outputFile(
+    await fs9.outputFile(
       configManager.outputGitignorePath,
       "index.html\nassets/"
     );
@@ -3744,7 +3784,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;
@@ -3866,7 +3906,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,
@@ -3884,7 +3924,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.
 
@@ -3896,13 +3936,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"
       )
     );
@@ -3930,10 +3970,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) => {
@@ -3961,11 +4001,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}`)
           );
         }
       });
@@ -4007,7 +4047,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));
         });
       }
     }
@@ -4107,26 +4147,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,
@@ -4144,8 +4184,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 ({
@@ -4154,21 +4194,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
@@ -4180,12 +4220,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"
       }
@@ -4193,22 +4233,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));
@@ -4225,15 +4265,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;
@@ -4846,21 +4886,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 {
@@ -4987,82 +5027,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,
@@ -5285,7 +5325,7 @@ var transformForestryFieldsToTinaFields = ({
   return tinaFields;
 };
 var getFieldsFromTemplates = ({ tem, pathToForestryConfig, skipBlocks = false }) => {
-  const templatePath = path11.join(
+  const templatePath = path12.join(
     pathToForestryConfig,
     ".forestry",
     "front_matter",
@@ -5294,7 +5334,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}
@@ -5360,9 +5400,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 {
@@ -5507,9 +5547,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 = [];
@@ -5571,8 +5611,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,
@@ -5602,12 +5642,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,
@@ -5618,7 +5658,7 @@ var rewriteTemplateKeysInDocs = (args) => {
           _template: stringifyLabel(templateKey),
           ...content
         };
-        fs11.writeFileSync(
+        fs12.writeFileSync(
           filePath,
           stringifyFile(newContent, extname, true, markdownParseConfig)
         );
@@ -5633,12 +5673,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", {
@@ -5679,13 +5719,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!"
@@ -5693,8 +5733,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__"
   );
 };
@@ -6132,7 +6172,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";
@@ -6369,7 +6409,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;
@@ -6419,7 +6459,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])
   );
@@ -6537,8 +6577,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,
@@ -6611,18 +6651,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;
@@ -6693,22 +6733,22 @@ var writeGeneratedFile = async ({
   content,
   typescript
 }) => {
-  const { exists, path: path15, parentPath } = generatedFile.resolve(typescript);
+  const { exists, path: path17, parentPath } = generatedFile.resolve(typescript);
   if (exists) {
     if (overwrite) {
-      logger.info(`Overwriting file at ${path15}... \u2705`);
-      fs14.outputFileSync(path15, content);
+      logger.info(`Overwriting file at ${path17}... \u2705`);
+      fs15.outputFileSync(path17, content);
     } else {
-      logger.info(`Not overwriting file at ${path15}.`);
+      logger.info(`Not overwriting file at ${path17}.`);
       logger.info(
-        logText(`Please add the following to ${path15}:
+        logText(`Please add the following to ${path17}:
 ${indentText(content)}}`)
       );
     }
   } else {
-    logger.info(`Adding file at ${path15}... \u2705`);
-    await fs14.ensureDir(parentPath);
-    fs14.outputFileSync(path15, content);
+    logger.info(`Adding file at ${path17}... \u2705`);
+    await fs15.ensureDir(parentPath);
+    fs15.outputFileSync(path17, content);
   }
 };
 var addConfigFile = async ({
@@ -6786,7 +6826,7 @@ var addContentFile = async ({
         return () => ({
           exists: env.sampleContentExists,
           path: env.sampleContentPath,
-          parentPath: path14.dirname(env.sampleContentPath)
+          parentPath: path15.dirname(env.sampleContentPath)
         });
       }
     },
@@ -6809,10 +6849,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"
@@ -6881,7 +6921,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,
@@ -6894,7 +6934,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(
       {
@@ -6907,7 +6947,7 @@ var addReactiveFile = {
       null,
       2
     );
-    fs14.writeFileSync(packageJsonPath, updatedPackageJson);
+    fs15.writeFileSync(packageJsonPath, updatedPackageJson);
   }
 };
 function execShellCommand(cmd) {
@@ -7103,6 +7143,356 @@ var SearchIndexCommand = class extends Command7 {
   }
 };
 
+// src/next/commands/doctor-command/index.ts
+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 yaml3 from "js-yaml";
+var DEPENDENCY_TYPES = [
+  "dependencies",
+  "devDependencies",
+  "optionalDependencies",
+  "peerDependencies"
+];
+var LOCAL_REFERENCE_PREFIXES = [
+  "file:",
+  "link:",
+  "patch:",
+  "portal:",
+  "workspace:"
+];
+function isTinaPackage(name2) {
+  return name2 === "tinacms" || name2 === "create-tina-app" || name2.startsWith("@tinacms/") || name2.startsWith("tinacms-") || name2.startsWith("next-tinacms-");
+}
+function getTinaDependencies(packageJson) {
+  const dependencies = /* @__PURE__ */ new Map();
+  for (const dependencyType of DEPENDENCY_TYPES) {
+    for (const [name2, declared] of Object.entries(
+      packageJson[dependencyType] || {}
+    )) {
+      if (!isTinaPackage(name2) || dependencies.has(name2)) continue;
+      dependencies.set(name2, { name: name2, declared, dependencyType });
+    }
+  }
+  return [...dependencies.values()].sort(
+    (a, b) => a.name.localeCompare(b.name)
+  );
+}
+async function readProjectPackageJson(rootPath) {
+  const packageJsonPath = path16.join(rootPath, "package.json");
+  if (!await fs16.pathExists(packageJsonPath)) {
+    throw new Error(`No package.json found at ${packageJsonPath}`);
+  }
+  return fs16.readJSON(packageJsonPath);
+}
+async function resolveInstalledVersions({
+  rootPath,
+  dependencies
+}) {
+  const lockfileVersions = await readLockfileVersions(rootPath);
+  return Promise.all(
+    dependencies.map(async (dependency) => {
+      const installed = await readNodeModulesVersion(rootPath, dependency.name) || lockfileVersions.get(dependency.name);
+      return { ...dependency, installed };
+    })
+  );
+}
+async function fetchLatestVersion(packageName, timeoutMs) {
+  const controller = new AbortController();
+  const timeout2 = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(
+      `https://registry.npmjs.org/${encodeURIComponent(packageName)}`,
+      { signal: controller.signal }
+    );
+    if (!response.ok) {
+      throw new Error(`npm registry returned ${response.status}`);
+    }
+    const body = await response.json();
+    const latest = body?.["dist-tags"]?.latest;
+    if (typeof latest !== "string" || latest.length === 0) {
+      throw new Error("npm registry response did not include dist-tags.latest");
+    }
+    return latest;
+  } finally {
+    clearTimeout(timeout2);
+  }
+}
+function classifyDependency(dependency, latest, error) {
+  if (!dependency.installed) {
+    return {
+      ...dependency,
+      latest,
+      status: "unknown",
+      error: "Installed version could not be resolved from node_modules or lockfile"
+    };
+  }
+  if (isLocalReference(dependency.installed)) {
+    return {
+      ...dependency,
+      latest,
+      status: "local",
+      error
+    };
+  }
+  if (!latest || error) {
+    return {
+      ...dependency,
+      latest,
+      status: "unknown",
+      error
+    };
+  }
+  return {
+    ...dependency,
+    latest,
+    status: normalizeVersion(dependency.installed) === normalizeVersion(latest) ? "current" : "outdated"
+  };
+}
+async function checkTinaDependencies({
+  dependencies,
+  fetchLatest
+}) {
+  return Promise.all(
+    dependencies.map(async (dependency) => {
+      try {
+        const latest = await fetchLatest(dependency.name);
+        return classifyDependency(dependency, latest);
+      } catch (error) {
+        return classifyDependency(
+          dependency,
+          void 0,
+          error instanceof Error ? error.message : String(error)
+        );
+      }
+    })
+  );
+}
+function formatDoctorTable(results) {
+  const rows = [
+    ["Package", "Type", "Declared", "Installed", "Latest", "Status"],
+    ...results.map((result) => [
+      result.name,
+      result.dependencyType,
+      result.declared,
+      result.installed || "-",
+      result.latest || "-",
+      formatStatus(result)
+    ])
+  ];
+  const widths = rows[0].map(
+    (_, column) => Math.max(...rows.map((row) => row[column].length))
+  );
+  return rows.map((row, rowIndex) => {
+    const line = row.map((cell, column) => cell.padEnd(widths[column])).join("  ");
+    return rowIndex === 0 ? `${line}
+${widths.map((w) => "-".repeat(w)).join("  ")}` : line;
+  }).join("\n");
+}
+function formatStatus(result) {
+  if (result.status === "outdated") return "OUTDATED";
+  if (result.status === "local") return "LOCAL";
+  if (result.status === "unknown")
+    return `UNKNOWN${result.error ? ` (${result.error})` : ""}`;
+  return "CURRENT";
+}
+function normalizeVersion(version2) {
+  return version2.trim().replace(/^v/, "").split("(")[0].trim();
+}
+function isLocalReference(version2) {
+  const normalized = version2.trim();
+  return LOCAL_REFERENCE_PREFIXES.some(
+    (prefix) => normalized.startsWith(prefix)
+  );
+}
+async function readNodeModulesVersion(rootPath, packageName) {
+  const packageJsonPath = path16.join(
+    rootPath,
+    "node_modules",
+    ...packageName.split("/"),
+    "package.json"
+  );
+  if (!await fs16.pathExists(packageJsonPath)) return void 0;
+  const packageJson = await fs16.readJSON(packageJsonPath);
+  return typeof packageJson.version === "string" ? packageJson.version : void 0;
+}
+async function readLockfileVersions(rootPath) {
+  const readers = [
+    readPackageLockVersions,
+    readPnpmLockVersions,
+    readYarnLockVersions
+  ];
+  for (const reader of readers) {
+    const versions = await reader(rootPath);
+    if (versions.size > 0) return versions;
+  }
+  return /* @__PURE__ */ new Map();
+}
+async function readPackageLockVersions(rootPath) {
+  const lockfilePath = path16.join(rootPath, "package-lock.json");
+  const versions = /* @__PURE__ */ new Map();
+  if (!await fs16.pathExists(lockfilePath)) return versions;
+  const lockfile = await fs16.readJSON(lockfilePath);
+  for (const [key, value] of Object.entries(lockfile.packages || {})) {
+    if (!key.startsWith("node_modules/")) continue;
+    const name2 = key.replace(/^node_modules\//, "");
+    const version2 = value.version;
+    if (isTinaPackage(name2) && typeof version2 === "string") {
+      versions.set(name2, version2);
+    }
+  }
+  for (const [name2, value] of Object.entries(lockfile.dependencies || {})) {
+    const version2 = value.version;
+    if (isTinaPackage(name2) && typeof version2 === "string") {
+      versions.set(name2, version2);
+    }
+  }
+  return versions;
+}
+async function readPnpmLockVersions(rootPath) {
+  const lockfilePath = path16.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"));
+  const rootImporter = lockfile?.importers?.["."];
+  for (const dependencyType of DEPENDENCY_TYPES) {
+    for (const [name2, value] of Object.entries(
+      rootImporter?.[dependencyType] || {}
+    )) {
+      if (!isTinaPackage(name2)) continue;
+      const version2 = typeof value === "string" ? value : typeof value.version === "string" ? value.version : void 0;
+      if (version2) versions.set(name2, normalizeInstalledVersion(version2));
+    }
+  }
+  for (const key of Object.keys(lockfile?.packages || {})) {
+    const parsed = parsePnpmPackageKey(key);
+    if (parsed && isTinaPackage(parsed.name) && !versions.has(parsed.name)) {
+      versions.set(parsed.name, parsed.version);
+    }
+  }
+  return versions;
+}
+async function readYarnLockVersions(rootPath) {
+  const lockfilePath = path16.join(rootPath, "yarn.lock");
+  const versions = /* @__PURE__ */ new Map();
+  if (!await fs16.pathExists(lockfilePath)) return versions;
+  const contents = await fs16.readFile(lockfilePath, "utf8");
+  if (contents.includes("__metadata:")) {
+    return readYarnBerryLockVersions(contents);
+  }
+  const lines = contents.split("\n");
+  let activeNames = [];
+  for (const line of lines) {
+    if (line.length > 0 && !line.startsWith(" ") && line.includes("@")) {
+      activeNames = extractYarnPackageNames(line);
+      continue;
+    }
+    const version2 = line.match(/^\s+version\s+"([^"]+)"/)?.[1];
+    if (!version2) continue;
+    for (const name2 of activeNames) {
+      if (isTinaPackage(name2) && !versions.has(name2)) {
+        versions.set(name2, version2);
+      }
+    }
+  }
+  return versions;
+}
+function readYarnBerryLockVersions(contents) {
+  const versions = /* @__PURE__ */ new Map();
+  const lockfile = yaml3.load(contents);
+  for (const [descriptor, value] of Object.entries(lockfile || {})) {
+    if (descriptor === "__metadata") continue;
+    const name2 = extractYarnBerryPackageName(descriptor);
+    const version2 = getYarnBerryInstalledVersion(descriptor, value?.version);
+    if (name2 && isTinaPackage(name2) && version2) {
+      versions.set(name2, version2);
+    }
+  }
+  return versions;
+}
+function parsePnpmPackageKey(key) {
+  const normalized = key.replace(/^\//, "");
+  const match = normalized.match(/^(@[^/]+\/[^@]+|[^@/]+)@([^(/]+)/);
+  if (!match) return void 0;
+  return { name: match[1], version: normalizeVersion(match[2]) };
+}
+function normalizeInstalledVersion(version2) {
+  return isLocalReference(version2) ? version2 : normalizeVersion(version2);
+}
+function extractYarnPackageNames(line) {
+  return line.replace(/:$/, "").split(/,\s*/).map((descriptor) => descriptor.trim().replace(/^"|"$/g, "")).map((descriptor) => {
+    if (descriptor.startsWith("@")) {
+      const [, scope, name2] = descriptor.match(/^(@[^/]+)\/([^@]+)/) || [];
+      return scope && name2 ? `${scope}/${name2}` : descriptor;
+    }
+    return descriptor.split("@")[0];
+  }).filter(Boolean);
+}
+function extractYarnBerryPackageName(descriptor) {
+  if (descriptor.startsWith("@")) {
+    return descriptor.match(/^(@[^/]+\/[^@]+)/)?.[1];
+  }
+  return descriptor.split("@")[0] || void 0;
+}
+function getYarnBerryInstalledVersion(descriptor, version2) {
+  const name2 = extractYarnBerryPackageName(descriptor);
+  const reference = name2 ? descriptor.slice(name2.length + 1) : void 0;
+  if (reference && isLocalReference(reference)) return reference;
+  return typeof version2 === "string" ? normalizeInstalledVersion(version2) : void 0;
+}
+
+// src/next/commands/doctor-command/index.ts
+var DoctorCommand = class extends Command8 {
+  static paths = [["doctor"]];
+  rootPath = Option8.String("--rootPath", {
+    description: "Specify the root directory to inspect (defaults to current working directory)"
+  });
+  json = Option8.Boolean("--json", false, {
+    description: "Print machine-readable JSON output"
+  });
+  timeout = Option8.String("--timeout", "5000", {
+    description: "npm registry request timeout in milliseconds"
+  });
+  static usage = Command8.Usage({
+    category: "Commands",
+    description: "Check direct TinaCMS dependencies against npm latest"
+  });
+  async catch(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.error(`Error occurred during tinacms doctor: ${message}`);
+    process.exit(1);
+  }
+  async execute() {
+    const rootPath = this.rootPath || process.cwd();
+    const timeoutMs = Number(this.timeout);
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+      logger.error("--timeout must be a positive number");
+      return 1;
+    }
+    const packageJson = await readProjectPackageJson(rootPath);
+    const dependencies = await resolveInstalledVersions({
+      rootPath,
+      dependencies: getTinaDependencies(packageJson)
+    });
+    const results = await checkTinaDependencies({
+      dependencies,
+      fetchLatest: (name2) => fetchLatestVersion(name2, timeoutMs)
+    });
+    if (this.json) {
+      logger.info(JSON.stringify({ rootPath, results }, null, 2));
+    } else if (results.length === 0) {
+      logger.info("No direct TinaCMS dependencies found.");
+    } else {
+      logger.info(formatDoctorTable(results));
+    }
+    const hasOutdated = results.some((result) => result.status === "outdated");
+    const hasUnknown = results.some((result) => result.status === "unknown");
+    return hasOutdated || hasUnknown ? 1 : 0;
+  }
+};
+
 // src/index.ts
 var cli = new Cli({
   binaryName: `tinacms`,
@@ -7115,6 +7505,7 @@ cli.register(AuditCommand);
 cli.register(InitCommand);
 cli.register(CodemodCommand);
 cli.register(SearchIndexCommand);
+cli.register(DoctorCommand);
 cli.register(Builtins.DefinitionsCommand);
 cli.register(Builtins.HelpCommand);
 cli.register(Builtins.VersionCommand);