@tinacms/cli 2.5.5 → 2.6.0

package/dist/index.js

@@ -2,17 +2,17 @@
 import { Cli, Builtins } from "clipanion";
 
 // package.json
-var version = "2.5.4";
+var version = "2.6.0";
 
 // src/next/commands/dev-command/index.ts
-import path10 from "path";
+import path12 from "path";
 import { FilesystemBridge as FilesystemBridge2, buildSchema } from "@tinacms/graphql";
 import { Telemetry } from "@tinacms/metrics";
 import { LocalSearchIndexClient, SearchIndexer } from "@tinacms/search";
-import AsyncLock from "async-lock";
 import chokidar from "chokidar";
 import { Command as Command2, Option as Option2 } from "clipanion";
-import fs9 from "fs-extra";
+import fs10 from "fs-extra";
+import { AsyncLock } from "tinacms/dist/client";
 
 // src/logger/index.ts
 import chalk from "chalk";
@@ -191,9 +191,12 @@ var titleText = chalk2.bgHex("d2f1f8").hex("ec4816");
 var CONFIRMATION_TEXT = chalk2.dim("enter to confirm");
 
 // src/next/codegen/index.ts
-import fs from "fs-extra";
 import path from "path";
+import { mapUserFields } from "@tinacms/graphql";
+import { transform } from "esbuild";
+import fs from "fs-extra";
 import { buildASTSchema, printSchema as printSchema2 } from "graphql";
+import normalizePath from "normalize-path";
 
 // src/next/codegen/codegen/index.ts
 import { parse, printSchema } from "graphql";
@@ -369,6 +372,9 @@ var plugin = (schema, documents, config2) => {
 };
 
 // src/next/codegen/codegen/index.ts
+var reexportExact = (types) => `${types}
+export type { Exact };
+`;
 var generateTypes = async (schema, queryPathGlob = process.cwd(), fragDocPath = process.cwd(), apiURL) => {
   let docs = [];
   let fragDocs = [];
@@ -379,7 +385,11 @@ var generateTypes = async (schema, queryPathGlob = process.cwd(), fragDocPath =
     filename: process.cwd(),
     schema: parse(printSchema(schema)),
     documents: [...docs, ...fragDocs],
-    config: {},
+    config: {
+      // The JSON scalar still carries rich-text bodies, which callers pass
+      // straight to <TinaMarkdown/>; codegen's `unknown` default won't assign.
+      defaultScalarType: "any"
+    },
     plugins: [
       { typescript: {} },
       { typescriptOperations: {} },
@@ -401,7 +411,7 @@ var generateTypes = async (schema, queryPathGlob = process.cwd(), fragDocPath =
       AddGeneratedClient: AddGeneratedClient(apiURL)
     }
   });
-  return res;
+  return reexportExact(res);
 };
 var loadGraphQLDocuments = async (globPath) => {
   let result = [];
@@ -423,11 +433,6 @@ var loadGraphQLDocuments = async (globPath) => {
   return result;
 };
 
-// src/next/codegen/index.ts
-import { transform } from "esbuild";
-import { mapUserFields } from "@tinacms/graphql";
-import normalizePath from "normalize-path";
-
 // src/next/codegen/stripSearchTokenFromConfig.ts
 function stripSearchTokenFromConfig(config2) {
   const cfg = config2;
@@ -816,26 +821,165 @@ var unlinkIfExists = async (filepath) => {
 };
 
 // src/next/config-manager.ts
-import fs4 from "fs-extra";
+import { createRequire } from "module";
 import path5 from "path";
 import { pathToFileURL } from "url";
-import * as esbuild from "esbuild";
 import * as dotenv from "dotenv";
+import * as esbuild from "esbuild";
+import fs4 from "fs-extra";
 import normalizePath2 from "normalize-path";
-import { createRequire } from "module";
 
-// src/next/resolve-content-root.ts
+// src/next/build-database-esbuild-config.ts
+var buildDatabaseEsbuildConfig = (opts) => ({
+  entryPoints: [opts.entryPoint],
+  bundle: true,
+  platform: "node",
+  format: "esm",
+  outfile: opts.outfile,
+  loader: opts.loader,
+  external: opts.external,
+  // Provide a require() polyfill for ESM bundles containing CommonJS packages.
+  // Some bundled packages (e.g., 'scmp' used by 'mongodb-level') use
+  // require('crypto'). When esbuild inlines these CommonJS packages, it keeps
+  // the require() calls, but ESM doesn't have a global require. This banner
+  // creates one using Node.js's official createRequire API, allowing the
+  // bundled CommonJS code to work in ESM.
+  banner: {
+    js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`
+  }
+});
+
+// src/next/cache-manager.ts
 import fs2 from "fs-extra";
-import path3 from "path";
+import path2 from "path";
+var buildReadOnlyMountErrorMessage = (cacheParentPath, underlyingError) => `TinaCMS cannot write to ${cacheParentPath}.
+
+Tina v3 needs write access to your project's tina/__generated__/.cache/ directory at build time. This usually means your project directory is read-only \u2014 common in some Docker setups (\`:ro\` volumes), AWS Lambda's \`/var/task\`, sandboxed CI runners, or restricted file permissions.
+
+To resolve, either:
+  - Make the project directory writable (e.g. remount with read-write access, or copy the project to a writable location), or
+  - Run \`tinacms build\` against a writable copy of your project and deploy the resulting artifacts.
+
+Underlying error: ${underlyingError.code} ${underlyingError.message}`;
+var READONLY_ERROR_CODES = /* @__PURE__ */ new Set(["EACCES", "EROFS", "EPERM"]);
+var prepareCacheLocation = async (generatedFolderPath, now = Date.now()) => {
+  const parentPath = path2.join(generatedFolderPath, ".cache");
+  try {
+    if (await fs2.pathExists(parentPath)) {
+      await fs2.remove(parentPath);
+    }
+    await fs2.ensureDir(parentPath);
+  } catch (err) {
+    const code = err?.code;
+    if (code && READONLY_ERROR_CODES.has(code)) {
+      throw new Error(
+        buildReadOnlyMountErrorMessage(parentPath, err)
+      );
+    }
+    throw err;
+  }
+  return {
+    parentPath,
+    buildPath: path2.join(parentPath, String(now))
+  };
+};
+var reapBuildSubdir = (buildSubdirPath, buildParentPath) => {
+  fs2.removeSync(buildSubdirPath);
+  try {
+    fs2.rmdirSync(buildParentPath);
+  } catch (err) {
+    if (err?.code !== "ENOTEMPTY") throw err;
+  }
+};
+
+// src/next/config-build-error.ts
+var isObject = (value) => typeof value === "object" && value !== null;
+var isTinaPackage = (specifier) => specifier === "tinacms" || specifier.startsWith("@tinacms/");
+var collectResolveTargets = (text) => {
+  if (!text) {
+    return [];
+  }
+  const targets = [];
+  const pattern = /Could not resolve "([^"]+)"/g;
+  for (const match of text.matchAll(pattern)) {
+    targets.push(match[1]);
+  }
+  return targets;
+};
+var getUnresolvedTinaPackage = (error) => {
+  if (!isObject(error)) {
+    return null;
+  }
+  const esbuildError = error;
+  const targets = [
+    ...(esbuildError.errors ?? []).flatMap(
+      (item) => collectResolveTargets(item.text)
+    ),
+    ...collectResolveTargets(esbuildError.message)
+  ];
+  return targets.find(isTinaPackage) ?? null;
+};
+var getResolveLocation = (error) => {
+  if (!isObject(error)) {
+    return null;
+  }
+  const esbuildError = error;
+  const entry = (esbuildError.errors ?? []).find(
+    (item) => collectResolveTargets(item.text).some(isTinaPackage)
+  );
+  return entry?.location ?? null;
+};
+var formatConfigBuildError = ({
+  error,
+  rootPath
+}) => {
+  const unresolvedPackage = getUnresolvedTinaPackage(error);
+  if (!unresolvedPackage) {
+    return error;
+  }
+  const lines = [
+    `Unable to resolve the "${unresolvedPackage}" package while building your Tina config.`,
+    "",
+    `Tina looked from: ${rootPath}`
+  ];
+  const location = getResolveLocation(error);
+  if (location?.file) {
+    const position = [location.line, location.column].filter((value) => typeof value === "number").join(":");
+    lines.push(
+      "",
+      `Failing import: ${location.file}${position ? `:${position}` : ""}`
+    );
+    if (location.lineText) {
+      lines.push(`  ${location.lineText.trim()}`);
+    }
+  }
+  lines.push(
+    "",
+    "Make sure the TinaCMS packages are installed in this project and that you are running the CLI from the project root.",
+    "If they are installed, check parent directories for package-manager files that can interfere with module resolution, such as package.json, node_modules, yarn.lock, or .pnp.cjs."
+  );
+  return new Error(lines.join("\n"));
+};
+
+// src/next/external-resolver.ts
+var EXTERNAL_BASELINE = ["better-sqlite3"];
+var resolveDatabaseExternals = (config2) => {
+  const userExternals = config2?.build?.externalDependencies ?? [];
+  return [...EXTERNAL_BASELINE, ...userExternals];
+};
+
+// src/next/resolve-content-root.ts
+import fs3 from "fs-extra";
+import path4 from "path";
 import chalk3 from "chalk";
 import { z } from "zod";
 
 // src/utils/path.ts
-import path2 from "path";
+import path3 from "path";
 function stripNativeTrailingSlash(p) {
-  const { root } = path2.parse(p);
+  const { root } = path3.parse(p);
   let str = p;
-  while (str.length > root.length && str.endsWith(path2.sep)) {
+  while (str.length > root.length && str.endsWith(path3.sep)) {
     str = str.slice(0, -1);
   }
   return str;
@@ -859,9 +1003,9 @@ async function resolveContentRootPath(params) {
     return params.rootPath;
   }
   const fullLocalContentPath = stripNativeTrailingSlash(
-    path3.join(params.tinaFolderPath, localContentPath)
+    path4.join(params.tinaFolderPath, localContentPath)
   );
-  const exists = await fs2.pathExists(fullLocalContentPath);
+  const exists = await fs3.pathExists(fullLocalContentPath);
   if (exists) {
     logger.info(`Using separate content repo at ${fullLocalContentPath}`);
     return fullLocalContentPath;
@@ -876,76 +1020,6 @@ async function resolveContentRootPath(params) {
   return params.rootPath;
 }
 
-// src/next/external-resolver.ts
-var EXTERNAL_BASELINE = ["better-sqlite3"];
-var resolveDatabaseExternals = (config2) => {
-  const userExternals = config2?.build?.externalDependencies ?? [];
-  return [...EXTERNAL_BASELINE, ...userExternals];
-};
-
-// src/next/cache-manager.ts
-import fs3 from "fs-extra";
-import path4 from "path";
-var buildReadOnlyMountErrorMessage = (cacheParentPath, underlyingError) => `TinaCMS cannot write to ${cacheParentPath}.
-
-Tina v3 needs write access to your project's tina/__generated__/.cache/ directory at build time. This usually means your project directory is read-only \u2014 common in some Docker setups (\`:ro\` volumes), AWS Lambda's \`/var/task\`, sandboxed CI runners, or restricted file permissions.
-
-To resolve, either:
-  - Make the project directory writable (e.g. remount with read-write access, or copy the project to a writable location), or
-  - Run \`tinacms build\` against a writable copy of your project and deploy the resulting artifacts.
-
-Underlying error: ${underlyingError.code} ${underlyingError.message}`;
-var READONLY_ERROR_CODES = /* @__PURE__ */ new Set(["EACCES", "EROFS", "EPERM"]);
-var prepareCacheLocation = async (generatedFolderPath, now = Date.now()) => {
-  const parentPath = path4.join(generatedFolderPath, ".cache");
-  try {
-    if (await fs3.pathExists(parentPath)) {
-      await fs3.remove(parentPath);
-    }
-    await fs3.ensureDir(parentPath);
-  } catch (err) {
-    const code = err?.code;
-    if (code && READONLY_ERROR_CODES.has(code)) {
-      throw new Error(
-        buildReadOnlyMountErrorMessage(parentPath, err)
-      );
-    }
-    throw err;
-  }
-  return {
-    parentPath,
-    buildPath: path4.join(parentPath, String(now))
-  };
-};
-var reapBuildSubdir = (buildSubdirPath, buildParentPath) => {
-  fs3.removeSync(buildSubdirPath);
-  try {
-    fs3.rmdirSync(buildParentPath);
-  } catch (err) {
-    if (err?.code !== "ENOTEMPTY") throw err;
-  }
-};
-
-// src/next/build-database-esbuild-config.ts
-var buildDatabaseEsbuildConfig = (opts) => ({
-  entryPoints: [opts.entryPoint],
-  bundle: true,
-  platform: "node",
-  format: "esm",
-  outfile: opts.outfile,
-  loader: opts.loader,
-  external: opts.external,
-  // Provide a require() polyfill for ESM bundles containing CommonJS packages.
-  // Some bundled packages (e.g., 'scmp' used by 'mongodb-level') use
-  // require('crypto'). When esbuild inlines these CommonJS packages, it keeps
-  // the require() calls, but ESM doesn't have a global require. This banner
-  // creates one using Node.js's official createRequire API, allowing the
-  // bundled CommonJS code to work in ESM.
-  banner: {
-    js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`
-  }
-});
-
 // src/next/config-manager.ts
 var TINA_FOLDER = "tina";
 var LEGACY_TINA_FOLDER = ".tina";
@@ -1250,14 +1324,21 @@ var ConfigManager = class {
     const buildDir = path5.join(this.generatedCachePath, "database");
     const outfile = path5.join(buildDir, "database.build.mjs");
     const external = resolveDatabaseExternals(this.config);
-    await esbuild.build(
-      buildDatabaseEsbuildConfig({
-        entryPoint: this.selfHostedDatabaseFilePath,
-        outfile,
-        external,
-        loader: loaders
-      })
-    );
+    try {
+      await esbuild.build(
+        buildDatabaseEsbuildConfig({
+          entryPoint: this.selfHostedDatabaseFilePath,
+          outfile,
+          external,
+          loader: loaders
+        })
+      );
+    } catch (e) {
+      throw formatConfigBuildError({
+        error: e,
+        rootPath: path5.resolve(this.rootPath)
+      });
+    }
     const result = await import(pathToFileURL(outfile).href);
     reapBuildSubdir(buildDir, this.generatedCachePath);
     return result.default;
@@ -1274,20 +1355,26 @@ var ConfigManager = class {
     const esmRequireBanner = {
       js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`
     };
+    const resolvedRootPath = path5.resolve(this.rootPath);
     fs4.outputFileSync(tempTSConfigFile, "{}");
-    const result2 = await esbuild.build({
-      entryPoints: [configFilePath],
-      bundle: true,
-      target: ["esnext"],
-      platform: "browser",
-      format: "esm",
-      logLevel: "silent",
-      packages: "external",
-      ignoreAnnotations: true,
-      outfile: preBuildConfigPath,
-      loader: loaders,
-      metafile: true
-    });
+    let result2;
+    try {
+      result2 = await esbuild.build({
+        entryPoints: [configFilePath],
+        bundle: true,
+        target: ["esnext"],
+        platform: "browser",
+        format: "esm",
+        logLevel: "silent",
+        packages: "external",
+        ignoreAnnotations: true,
+        outfile: preBuildConfigPath,
+        loader: loaders,
+        metafile: true
+      });
+    } catch (e) {
+      throw formatConfigBuildError({ error: e, rootPath: resolvedRootPath });
+    }
     const flattenedList = [];
     Object.keys(result2.metafile.inputs).forEach((key) => {
       if (key.includes("node_modules") || key.includes("__generated__")) {
@@ -1295,27 +1382,31 @@ var ConfigManager = class {
       }
       flattenedList.push(key);
     });
-    await esbuild.build({
-      entryPoints: [configFilePath],
-      bundle: true,
-      target: ["esnext"],
-      logLevel: "silent",
-      platform: "node",
-      format: "esm",
-      outfile,
-      loader: loaders,
-      banner: esmRequireBanner
-    });
-    await esbuild.build({
-      entryPoints: [outfile],
-      bundle: true,
-      logLevel: "silent",
-      platform: "node",
-      target: ["esnext"],
-      format: "esm",
-      outfile: outfile2,
-      loader: loaders
-    });
+    try {
+      await esbuild.build({
+        entryPoints: [configFilePath],
+        bundle: true,
+        target: ["esnext"],
+        logLevel: "silent",
+        platform: "node",
+        format: "esm",
+        outfile,
+        loader: loaders,
+        banner: esmRequireBanner
+      });
+      await esbuild.build({
+        entryPoints: [outfile],
+        bundle: true,
+        logLevel: "silent",
+        platform: "node",
+        target: ["esnext"],
+        format: "esm",
+        outfile: outfile2,
+        loader: loaders
+      });
+    } catch (e) {
+      throw formatConfigBuildError({ error: e, rootPath: resolvedRootPath });
+    }
     let result;
     try {
       result = await import(pathToFileURL(outfile2).href);
@@ -1414,294 +1505,23 @@ async function createAndInitializeDatabase(configManager, datalayerPort, bridgeO
   return database;
 }
 
-// src/next/commands/baseCommands.ts
-import { Command, Option } from "clipanion";
-import chalk4 from "chalk";
-
-// src/utils/start-subprocess.ts
-import childProcess from "child_process";
-var startSubprocess2 = async ({ command: command2 }) => {
-  if (typeof command2 === "string") {
-    const commands = command2.split(" ");
-    const firstCommand = commands[0];
-    const args = commands.slice(1) || [];
-    const ps = childProcess.spawn(firstCommand, args, {
-      stdio: "inherit",
-      shell: true
-    });
-    ps.on("error", (code) => {
-      logger.error(
-        dangerText(
-          `An error has occurred in the Next.js child process. Error message below`
-        )
-      );
-      logger.error(`name: ${code.name}
-message: ${code.message}
+// src/next/vite/index.ts
+import path7 from "node:path";
+import react from "@vitejs/plugin-react";
+import fs5 from "fs-extra";
+import normalizePath3 from "normalize-path";
 
-stack: ${code.stack || "No stack was provided"}`);
-    });
-    ps.on("close", (code) => {
-      logger.info(`child process exited with code ${code}`);
-      process.exit(code);
-    });
-    return ps;
-  }
-};
-
-// src/next/commands/baseCommands.ts
-import { getChangedFiles, getSha, shaExists } from "@tinacms/graphql";
-import fs5 from "fs-extra";
-var BaseCommand = class extends Command {
-  experimentalDataLayer = Option.Boolean("--experimentalData", {
-    description: "DEPRECATED - Build the server with additional data querying capabilities"
-  });
-  isomorphicGitBridge = Option.Boolean("--isomorphicGitBridge", {
-    description: "DEPRECATED - Enable Isomorphic Git Bridge Implementation"
-  });
-  port = Option.String("-p,--port", "4001", {
-    description: "Specify a port to run the server on. (default 4001)"
-  });
-  datalayerPort = Option.String("--datalayer-port", "9000", {
-    description: "Specify a port to run the datalayer server on. (default 9000)"
-  });
-  subCommand = Option.String("-c,--command", {
-    description: "The sub-command to run"
-  });
-  rootPath = Option.String("--rootPath", {
-    description: "Specify the root directory to run the CLI from (defaults to current working directory)"
-  });
-  verbose = Option.Boolean("-v,--verbose", false, {
-    description: "increase verbosity of logged output"
-  });
-  noSDK = Option.Boolean("--noSDK", false, {
-    description: "DEPRECATED - This should now be set in the config at client.skip = true'. Don't generate the generated client SDK"
-  });
-  noTelemetry = Option.Boolean("--noTelemetry", false, {
-    description: "Disable anonymous telemetry that is collected"
-  });
-  async startSubCommand() {
-    let subProc;
-    if (this.subCommand) {
-      subProc = await startSubprocess2({ command: this.subCommand });
-      logger.info(
-        `Running web application with command: ${chalk4.cyan(this.subCommand)}`
-      );
-    }
-    function exitHandler(options, exitCode) {
-      if (subProc) {
-        subProc.kill();
-      }
-      process.exit();
-    }
-    process.on("exit", exitHandler);
-    process.on("SIGINT", exitHandler);
-    process.on("SIGUSR1", exitHandler);
-    process.on("SIGUSR2", exitHandler);
-    process.on("uncaughtException", (error) => {
-      logger.error(`Uncaught exception ${error.name}`);
-      console.error(error);
-    });
-  }
-  logDeprecationWarnings() {
-    if (this.isomorphicGitBridge) {
-      logger.warn("--isomorphicGitBridge has been deprecated");
-    }
-    if (this.experimentalDataLayer) {
-      logger.warn(
-        "--experimentalDataLayer has been deprecated, the data layer is now built-in automatically"
-      );
-    }
-    if (this.noSDK) {
-      logger.warn(
-        "--noSDK has been deprecated, and will be unsupported in a future release. This should be set in the config at client.skip = true"
-      );
-    }
-  }
-  async indexContentWithSpinner({
-    database,
-    graphQLSchema,
-    tinaSchema,
-    configManager,
-    partialReindex,
-    text
-  }) {
-    const textToUse = text || "Indexing local files";
-    const warnings = [];
-    await spin({
-      waitFor: async () => {
-        const rootPath = configManager.rootPath;
-        let sha;
-        try {
-          sha = await getSha({ fs: fs5, dir: rootPath });
-        } catch (e) {
-          if (partialReindex) {
-            console.error(
-              "Failed to get sha. NOTE: `--partial-reindex` only supported for git repositories"
-            );
-            throw e;
-          }
-        }
-        const lastSha = await database.getMetadata("lastSha");
-        const exists = lastSha && await shaExists({ fs: fs5, dir: rootPath, sha: lastSha });
-        let res;
-        if (partialReindex && lastSha && exists && sha) {
-          const pathFilter = {};
-          if (configManager.isUsingLegacyFolder) {
-            pathFilter[".tina/__generated__/_schema.json"] = {};
-          } else {
-            pathFilter["tina/tina-lock.json"] = {};
-          }
-          for (const collection of tinaSchema.getCollections()) {
-            pathFilter[collection.path] = {
-              matches: collection.match?.exclude || collection.match?.include ? tinaSchema.getMatches({ collection }) : void 0
-            };
-          }
-          const { added, modified, deleted } = await getChangedFiles({
-            fs: fs5,
-            dir: rootPath,
-            from: lastSha,
-            to: sha,
-            pathFilter
-          });
-          const tinaPathUpdates = modified.filter(
-            (path20) => path20.startsWith(".tina/__generated__/_schema.json") || path20.startsWith("tina/tina-lock.json")
-          );
-          if (tinaPathUpdates.length > 0) {
-            res = await database.indexContent({
-              graphQLSchema,
-              tinaSchema
-            });
-          } else {
-            if (added.length > 0 || modified.length > 0) {
-              await database.indexContentByPaths([...added, ...modified]);
-            }
-            if (deleted.length > 0) {
-              await database.deleteContentByPaths(deleted);
-            }
-          }
-        } else {
-          res = await database.indexContent({
-            graphQLSchema,
-            tinaSchema
-          });
-        }
-        if (sha) {
-          await database.setMetadata("lastSha", sha);
-        }
-        if (res?.warnings) {
-          warnings.push(...res.warnings);
-        }
-      },
-      text: textToUse
-    });
-    if (warnings.length > 0) {
-      logger.warn(`Indexing completed with ${warnings.length} warning(s)`);
-      warnings.forEach((warning) => {
-        logger.warn(warnText(`${warning}`));
-      });
-    }
-  }
-};
-
-// src/next/commands/dev-command/html.ts
-var errorHTML = `<style type="text/css">
-#no-assets-placeholder body {
-  font-family: sans-serif;
-  font-size: 16px;
-  line-height: 1.4;
-  color: #333;
-  background-color: #f5f5f5;
-}
-#no-assets-placeholder {
-  max-width: 600px;
-  margin: 0 auto;
-  padding: 40px;
-  text-align: center;
-  background-color: #fff;
-  box-shadow: 0px 0px 20px rgba(0, 0, 0, 0.1);
-}
-#no-assets-placeholder h1 {
-  font-size: 24px;
-  margin-bottom: 20px;
-}
-#no-assets-placeholder p {
-  margin-bottom: 10px;
-}
-#no-assets-placeholder a {
-  color: #0077cc;
-  text-decoration: none;
-}
-#no-assets-placeholder a:hover {
-  text-decoration: underline;
-}
-</style>
-<div id="no-assets-placeholder">
-<h1>Failed loading TinaCMS assets</h1>
-<p>
-  Your TinaCMS configuration may be misconfigured, and we could not load
-  the assets for this page.
-</p>
-<p>
-  Please visit <a href="https://tina.io/docs/r/FAQ/#13-how-do-i-resolve-failed-loading-tinacms-assets-error">this doc</a> for help.
-</p>
-</div>
-</div>`.trim().replace(/[\r\n\s]+/g, " ");
-var devHTML = (port) => `<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>TinaCMS</title>
-  </head>
-
-  <!-- if development -->
-  <script type="module">
-    import RefreshRuntime from 'http://localhost:${port}/@react-refresh'
-    RefreshRuntime.injectIntoGlobalHook(window)
-    window.$RefreshReg$ = () => {}
-    window.$RefreshSig$ = () => (type) => type
-    window.__vite_plugin_react_preamble_installed__ = true
-  </script>
-  <script type="module" src="http://localhost:${port}/@vite/client"></script>
-  <script>
-  function handleLoadError() {
-    // Assets have failed to load
-    document.getElementById('root').innerHTML = '${errorHTML}';
-  }
-  </script>
-  <script
-    type="module"
-    src="http://localhost:${port}/src/main.tsx"
-    onerror="handleLoadError()"
-  ></script>
-  <body class="tina-tailwind">
-    <div id="root"></div>
-  </body>
-</html>`;
-
-// src/next/commands/dev-command/server/index.ts
-import { createServer as createViteServer } from "vite";
-
-// src/next/vite/index.ts
-import path7 from "node:path";
-import react from "@vitejs/plugin-react";
-import fs6 from "fs-extra";
-import normalizePath3 from "normalize-path";
-import {
-  splitVendorChunkPlugin
-} from "vite";
-
-// src/next/vite/cors.ts
-var LOCALHOST_RE = /^https?:\/\/(?:localhost|127\.0\.0\.1|\[::1\])(:\d+)?$/;
-var PRIVATE_NETWORK_RE = /^https?:\/\/(?:10\.\d{1,3}\.\d{1,3}\.\d{1,3}|172\.(?:1[6-9]|2\d|3[01])\.\d{1,3}\.\d{1,3}|192\.168\.\d{1,3}\.\d{1,3})(:\d+)?$/;
-function expandOrigins(raw) {
-  const hasPrivate = raw.some((o) => o === "private");
-  const filtered = raw.filter((o) => o !== "private");
-  return hasPrivate ? [...filtered, PRIVATE_NETWORK_RE] : filtered;
-}
-function isOriginAllowed(origin, allowedOrigins = []) {
-  if (!origin) {
-    return true;
+// src/next/vite/cors.ts
+var LOCALHOST_RE = /^https?:\/\/(?:localhost|127\.0\.0\.1|\[::1\])(:\d+)?$/;
+var PRIVATE_NETWORK_RE = /^https?:\/\/(?:10\.\d{1,3}\.\d{1,3}\.\d{1,3}|172\.(?:1[6-9]|2\d|3[01])\.\d{1,3}\.\d{1,3}|192\.168\.\d{1,3}\.\d{1,3})(:\d+)?$/;
+function expandOrigins(raw) {
+  const hasPrivate = raw.some((o) => o === "private");
+  const filtered = raw.filter((o) => o !== "private");
+  return hasPrivate ? [...filtered, PRIVATE_NETWORK_RE] : filtered;
+}
+function isOriginAllowed(origin, allowedOrigins = []) {
+  if (!origin) {
+    return true;
   }
   if (LOCALHOST_RE.test(origin)) {
     return true;
@@ -2034,15 +1854,15 @@ async function listFilesRecursively({
     config2.publicFolder,
     directoryPath
   );
-  const exists = await fs6.pathExists(fullDirectoryPath);
+  const exists = await fs5.pathExists(fullDirectoryPath);
   if (!exists) {
     return { "0": [] };
   }
-  const items = await fs6.readdir(fullDirectoryPath);
+  const items = await fs5.readdir(fullDirectoryPath);
   const staticMediaItems = [];
   for (const item of items) {
     const itemPath = path7.join(fullDirectoryPath, item);
-    const stats = await fs6.promises.lstat(itemPath);
+    const stats = await fs5.promises.lstat(itemPath);
     const staticMediaItem = {
       id: item,
       filename: item,
@@ -2074,6 +1894,12 @@ async function listFilesRecursively({
   }
   return chunkArrayIntoObject(staticMediaItems, 20);
 }
+var getBasePath = (configManager) => {
+  const basePath = configManager.config.build.basePath;
+  return `/${basePath ? `${normalizePath3(basePath)}/` : ""}${normalizePath3(
+    configManager.config.build.outputFolder
+  )}/`;
+};
 var createConfig = async ({
   configManager,
   apiURL,
@@ -2092,9 +1918,9 @@ var createConfig = async ({
       config: configManager.config.media.tina,
       roothPath: configManager.rootPath
     });
-    await fs6.outputFile(staticMediaPath, JSON.stringify(staticMedia, null, 2));
+    await fs5.outputFile(staticMediaPath, JSON.stringify(staticMedia, null, 2));
   } else {
-    await fs6.outputFile(staticMediaPath, `[]`);
+    await fs5.outputFile(staticMediaPath, `[]`);
   }
   const alias = {
     TINA_IMPORT: configManager.prebuildFilePath,
@@ -2114,17 +1940,11 @@ var createConfig = async ({
   } else {
     alias["CLIENT_IMPORT"] = configManager.isUsingTs() ? configManager.generatedTypesTSFilePath : configManager.generatedTypesJSFilePath;
   }
-  let basePath;
-  if (configManager.config.build.basePath) {
-    basePath = configManager.config.build.basePath;
-  }
   const fullVersion = configManager.getTinaGraphQLVersion();
   const version2 = `${fullVersion.major}.${fullVersion.minor}`;
   const config2 = {
     root: configManager.spaRootPath,
-    base: `/${basePath ? `${normalizePath3(basePath)}/` : ""}${normalizePath3(
-      configManager.config.build.outputFolder
-    )}/`,
+    base: getBasePath(configManager),
     appType: "spa",
     resolve: {
       alias,
@@ -2141,11 +1961,13 @@ var createConfig = async ({
        *  - `process.env.__NEXT_CROSS_ORIGIN`
        *  - `process.env.__NEXT_I18N_SUPPORT`
        *
-       * Also, interestingly some of the advice for handling this doesn't work, references to replacing
-       * `process.env` with `{}` are problematic, because browsers don't understand the `{}.` syntax,
-       * but node does. This was a surprise, but using `new Object()` seems to do the trick.
+       * esbuild >=0.25 (bundled by vite >=6) requires define values to be
+       * entity names or JS literals; the `new Object(...)` workaround is
+       * rejected. A plain JSON object literal is safe: esbuild hoists it
+       * into a variable before substituting, so the historical `{}.`
+       * browser-syntax problem can't occur.
        */
-      "process.env": `new Object(${JSON.stringify(publicEnv)})`,
+      "process.env": JSON.stringify(publicEnv),
       // Used by picomatch https://github.com/micromatch/picomatch/blob/master/lib/utils.js#L4
       "process.platform": `"${process.platform}"`,
       __API_URL__: `"${apiURL}"`,
@@ -2196,18 +2018,12 @@ var createConfig = async ({
       rollupOptions
     },
     plugins: [
-      /**
-       * `splitVendorChunkPlugin` is needed because `tinacms` is quite large,
-       * Vite's chunking strategy chokes on memory issues for smaller machines (ie. on CI).
-       */
       react({
         babel: {
           // Supresses the warning [NOTE] babel The code generator has deoptimised the styling of
           compact: true
-        },
-        fastRefresh: false
+        }
       }),
-      splitVendorChunkPlugin(),
       tinaTailwind(configManager.spaRootPath, configManager.prebuildFilePath),
       ...plugins
     ]
@@ -2215,9 +2031,446 @@ var createConfig = async ({
   return config2;
 };
 
+// src/next/commands/baseCommands.ts
+import { createRequire as createRequire3 } from "module";
+import path9 from "path";
+import { fileURLToPath } from "url";
+import chalk4 from "chalk";
+import { Command, Option } from "clipanion";
+import { getChangedFiles, getSha, shaExists } from "@tinacms/graphql";
+import fs7 from "fs-extra";
+
+// src/utils/start-subprocess.ts
+import childProcess from "child_process";
+var startSubprocess2 = async ({ command: command2 }) => {
+  if (typeof command2 === "string") {
+    const commands = command2.split(" ");
+    const firstCommand = commands[0];
+    const args = commands.slice(1) || [];
+    const ps = childProcess.spawn(firstCommand, args, {
+      stdio: "inherit",
+      shell: true
+    });
+    ps.on("error", (code) => {
+      logger.error(
+        dangerText(
+          `An error has occurred in the Next.js child process. Error message below`
+        )
+      );
+      logger.error(`name: ${code.name}
+message: ${code.message}
+
+stack: ${code.stack || "No stack was provided"}`);
+    });
+    ps.on("close", (code) => {
+      logger.info(`child process exited with code ${code}`);
+      process.exit(code);
+    });
+    return ps;
+  }
+};
+
+// src/next/version-coherence.ts
+import path8 from "path";
+import fs6 from "fs-extra";
+var CORE_PACKAGES = [
+  "tinacms",
+  "@tinacms/graphql",
+  "@tinacms/schema-tools"
+];
+var PLAIN_SEMVER = /^(\d+)\.(\d+)\.(\d+)$/;
+var parsePlainVersion = (version2) => {
+  const match = PLAIN_SEMVER.exec(version2);
+  if (!match) {
+    return void 0;
+  }
+  return [Number(match[1]), Number(match[2]), Number(match[3])];
+};
+var compareVersions = (a, b) => a[0] - b[0] || a[1] - b[1] || a[2] - b[2];
+var satisfiesDeclaredRange = (version2, spec) => {
+  const resolved = parsePlainVersion(version2);
+  if (!resolved) {
+    return void 0;
+  }
+  const isCaret = spec.startsWith("^");
+  const base = parsePlainVersion(isCaret ? spec.slice(1) : spec);
+  if (!base) {
+    return void 0;
+  }
+  if (!isCaret) {
+    return compareVersions(resolved, base) === 0;
+  }
+  if (resolved[0] !== base[0]) {
+    return false;
+  }
+  if (base[0] === 0) {
+    if (resolved[1] !== base[1]) {
+      return false;
+    }
+    if (base[1] === 0 && resolved[2] !== base[2]) {
+      return false;
+    }
+  }
+  return compareVersions(resolved, base) >= 0;
+};
+var readPackageJson = (dir) => {
+  try {
+    return fs6.readJSONSync(path8.join(dir, "package.json"));
+  } catch (_) {
+    return void 0;
+  }
+};
+var findPackageJsonAbove = (startDir, packageName) => {
+  let dir = startDir;
+  while (true) {
+    const packageJson = readPackageJson(dir);
+    if (packageJson?.name === packageName && packageJson.version) {
+      return { dir, packageJson };
+    }
+    const parent = path8.dirname(dir);
+    if (parent === dir) {
+      return void 0;
+    }
+    dir = parent;
+  }
+};
+var findInNodeModulesAbove = (packageName, fromDir) => {
+  let dir = fromDir;
+  while (true) {
+    const candidate = path8.join(dir, "node_modules", ...packageName.split("/"));
+    const packageJson = readPackageJson(candidate);
+    if (packageJson?.name === packageName && packageJson.version) {
+      return { version: packageJson.version, dir: candidate };
+    }
+    const parent = path8.dirname(dir);
+    if (parent === dir) {
+      return void 0;
+    }
+    dir = parent;
+  }
+};
+var resolvePackage = (packageName, fromDir, resolveEntry) => {
+  try {
+    const entry = resolveEntry(packageName, fromDir);
+    const found = findPackageJsonAbove(path8.dirname(entry), packageName);
+    if (found?.packageJson.version) {
+      return { version: found.packageJson.version, dir: found.dir };
+    }
+  } catch (_) {
+    return findInNodeModulesAbove(packageName, fromDir);
+  }
+  return void 0;
+};
+var getVersionCoherenceWarnings = (input) => {
+  const warnings = [];
+  for (const name2 of CORE_PACKAGES) {
+    const spec = input.cliDependencies[name2];
+    const resolved = input.resolvedFromProject[name2];
+    if (!spec || !resolved) {
+      continue;
+    }
+    if (satisfiesDeclaredRange(resolved.version, spec) === false) {
+      warnings.push(
+        `${name2}@${resolved.version} is installed, but @tinacms/cli@${input.cliVersion} expects ${name2}@${spec}`
+      );
+    }
+  }
+  const fromProject = input.resolvedFromProject["tinacms"];
+  const fromApp = input.tinacmsResolvedFromApp;
+  if (fromProject && fromApp && fromProject.version !== fromApp.version) {
+    warnings.push(
+      `multiple copies of tinacms are installed: ${fromProject.version} (${fromProject.dir}) and ${fromApp.version} (${fromApp.dir}) - the admin UI bundles only one of them`
+    );
+  }
+  return warnings;
+};
+var collectVersionCoherenceWarnings = ({
+  rootPath,
+  cliModuleDir,
+  resolveEntry
+}) => {
+  try {
+    const cli2 = findPackageJsonAbove(cliModuleDir, "@tinacms/cli");
+    if (!cli2?.packageJson.version) {
+      return [];
+    }
+    const resolvedFromProject = {};
+    for (const name2 of CORE_PACKAGES) {
+      resolvedFromProject[name2] = resolvePackage(name2, rootPath, resolveEntry);
+    }
+    const app = resolvePackage("@tinacms/app", cliModuleDir, resolveEntry);
+    const tinacmsResolvedFromApp = app ? resolvePackage("tinacms", app.dir, resolveEntry) : void 0;
+    return getVersionCoherenceWarnings({
+      cliVersion: cli2.packageJson.version,
+      cliDependencies: cli2.packageJson.dependencies || {},
+      resolvedFromProject,
+      tinacmsResolvedFromApp
+    });
+  } catch (_) {
+    return [];
+  }
+};
+
+// src/next/commands/baseCommands.ts
+var BaseCommand = class extends Command {
+  experimentalDataLayer = Option.Boolean("--experimentalData", {
+    description: "DEPRECATED - Build the server with additional data querying capabilities"
+  });
+  isomorphicGitBridge = Option.Boolean("--isomorphicGitBridge", {
+    description: "DEPRECATED - Enable Isomorphic Git Bridge Implementation"
+  });
+  port = Option.String("-p,--port", "4001", {
+    description: "Specify a port to run the server on. (default 4001)"
+  });
+  datalayerPort = Option.String("--datalayer-port", "9000", {
+    description: "Specify a port to run the datalayer server on. (default 9000)"
+  });
+  subCommand = Option.String("-c,--command", {
+    description: "The sub-command to run"
+  });
+  rootPath = Option.String("--rootPath", {
+    description: "Specify the root directory to run the CLI from (defaults to current working directory)"
+  });
+  verbose = Option.Boolean("-v,--verbose", false, {
+    description: "increase verbosity of logged output"
+  });
+  noSDK = Option.Boolean("--noSDK", false, {
+    description: "DEPRECATED - This should now be set in the config at client.skip = true'. Don't generate the generated client SDK"
+  });
+  noTelemetry = Option.Boolean("--noTelemetry", false, {
+    description: "Disable anonymous telemetry that is collected"
+  });
+  async startSubCommand() {
+    let subProc;
+    if (this.subCommand) {
+      subProc = await startSubprocess2({ command: this.subCommand });
+      logger.info(
+        `Running web application with command: ${chalk4.cyan(this.subCommand)}`
+      );
+    }
+    function exitHandler(options, exitCode) {
+      if (subProc) {
+        subProc.kill();
+      }
+      process.exit();
+    }
+    process.on("exit", exitHandler);
+    process.on("SIGINT", exitHandler);
+    process.on("SIGUSR1", exitHandler);
+    process.on("SIGUSR2", exitHandler);
+    process.on("uncaughtException", (error) => {
+      logger.error(`Uncaught exception ${error.name}`);
+      console.error(error);
+    });
+  }
+  warnOnVersionSkew(rootPath) {
+    try {
+      const moduleDir = path9.dirname(fileURLToPath(import.meta.url));
+      const require2 = createRequire3(import.meta.url);
+      const warnings = collectVersionCoherenceWarnings({
+        rootPath,
+        cliModuleDir: moduleDir,
+        resolveEntry: (packageName, fromDir) => require2.resolve(packageName, { paths: [fromDir] })
+      });
+      if (warnings.length > 0) {
+        logger.warn(
+          warnText("WARN: TinaCMS package version mismatch detected:")
+        );
+        warnings.forEach((warning) => {
+          logger.warn(warnText(`  - ${warning}`));
+        });
+        logger.warn(
+          warnText(
+            "A held-back package (stale lockfile entry, partial upgrade, pnpm minimumReleaseAge) can leave the admin UI on an older tinacms where newer documented features are silently missing. Upgrade the packages above to matching releases and reinstall."
+          )
+        );
+      }
+    } catch (_) {
+    }
+  }
+  logDeprecationWarnings() {
+    if (this.isomorphicGitBridge) {
+      logger.warn("--isomorphicGitBridge has been deprecated");
+    }
+    if (this.experimentalDataLayer) {
+      logger.warn(
+        "--experimentalDataLayer has been deprecated, the data layer is now built-in automatically"
+      );
+    }
+    if (this.noSDK) {
+      logger.warn(
+        "--noSDK has been deprecated, and will be unsupported in a future release. This should be set in the config at client.skip = true"
+      );
+    }
+  }
+  async indexContentWithSpinner({
+    database,
+    graphQLSchema,
+    tinaSchema,
+    configManager,
+    partialReindex,
+    text
+  }) {
+    const textToUse = text || "Indexing local files";
+    const warnings = [];
+    await spin({
+      waitFor: async () => {
+        const rootPath = configManager.rootPath;
+        let sha;
+        try {
+          sha = await getSha({ fs: fs7, dir: rootPath });
+        } catch (e) {
+          if (partialReindex) {
+            console.error(
+              "Failed to get sha. NOTE: `--partial-reindex` only supported for git repositories"
+            );
+            throw e;
+          }
+        }
+        const lastSha = await database.getMetadata("lastSha");
+        const exists = lastSha && await shaExists({ fs: fs7, dir: rootPath, sha: lastSha });
+        let res;
+        if (partialReindex && lastSha && exists && sha) {
+          const pathFilter = {};
+          if (configManager.isUsingLegacyFolder) {
+            pathFilter[".tina/__generated__/_schema.json"] = {};
+          } else {
+            pathFilter["tina/tina-lock.json"] = {};
+          }
+          for (const collection of tinaSchema.getCollections()) {
+            pathFilter[collection.path] = {
+              matches: collection.match?.exclude || collection.match?.include ? tinaSchema.getMatches({ collection }) : void 0
+            };
+          }
+          const { added, modified, deleted } = await getChangedFiles({
+            fs: fs7,
+            dir: rootPath,
+            from: lastSha,
+            to: sha,
+            pathFilter
+          });
+          const tinaPathUpdates = modified.filter(
+            (path22) => path22.startsWith(".tina/__generated__/_schema.json") || path22.startsWith("tina/tina-lock.json")
+          );
+          if (tinaPathUpdates.length > 0) {
+            res = await database.indexContent({
+              graphQLSchema,
+              tinaSchema
+            });
+          } else {
+            if (added.length > 0 || modified.length > 0) {
+              await database.indexContentByPaths([...added, ...modified]);
+            }
+            if (deleted.length > 0) {
+              await database.deleteContentByPaths(deleted);
+            }
+          }
+        } else {
+          res = await database.indexContent({
+            graphQLSchema,
+            tinaSchema
+          });
+        }
+        if (sha) {
+          await database.setMetadata("lastSha", sha);
+        }
+        if (res?.warnings) {
+          warnings.push(...res.warnings);
+        }
+      },
+      text: textToUse
+    });
+    if (warnings.length > 0) {
+      logger.warn(`Indexing completed with ${warnings.length} warning(s)`);
+      warnings.forEach((warning) => {
+        logger.warn(warnText(`${warning}`));
+      });
+    }
+  }
+};
+
+// src/next/commands/dev-command/html.ts
+var errorHTML = `<style type="text/css">
+#no-assets-placeholder body {
+  font-family: sans-serif;
+  font-size: 16px;
+  line-height: 1.4;
+  color: #333;
+  background-color: #f5f5f5;
+}
+#no-assets-placeholder {
+  max-width: 600px;
+  margin: 0 auto;
+  padding: 40px;
+  text-align: center;
+  background-color: #fff;
+  box-shadow: 0px 0px 20px rgba(0, 0, 0, 0.1);
+}
+#no-assets-placeholder h1 {
+  font-size: 24px;
+  margin-bottom: 20px;
+}
+#no-assets-placeholder p {
+  margin-bottom: 10px;
+}
+#no-assets-placeholder a {
+  color: #0077cc;
+  text-decoration: none;
+}
+#no-assets-placeholder a:hover {
+  text-decoration: underline;
+}
+</style>
+<div id="no-assets-placeholder">
+<h1>Failed loading TinaCMS assets</h1>
+<p>
+  Your TinaCMS configuration may be misconfigured, and we could not load
+  the assets for this page.
+</p>
+<p>
+  Please visit <a href="https://tina.io/docs/r/FAQ/#13-how-do-i-resolve-failed-loading-tinacms-assets-error">this doc</a> for help.
+</p>
+</div>
+</div>`.trim().replace(/[\r\n\s]+/g, " ");
+var devHTML = (port, basePath) => `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>TinaCMS</title>
+  </head>
+
+  <!-- if development -->
+  <script type="module">
+    import RefreshRuntime from 'http://localhost:${port}${basePath}@react-refresh'
+    RefreshRuntime.injectIntoGlobalHook(window)
+    window.$RefreshReg$ = () => {}
+    window.$RefreshSig$ = () => (type) => type
+    window.__vite_plugin_react_preamble_installed__ = true
+  </script>
+  <script type="module" src="http://localhost:${port}${basePath}@vite/client"></script>
+  <script>
+  function handleLoadError() {
+    // Assets have failed to load
+    document.getElementById('root').innerHTML = '${errorHTML}';
+  }
+  </script>
+  <script
+    type="module"
+    src="http://localhost:${port}${basePath}src/main.tsx"
+    onerror="handleLoadError()"
+  ></script>
+  <body class="tina-tailwind">
+    <div id="root"></div>
+  </body>
+</html>`;
+
+// src/next/commands/dev-command/server/index.ts
+import { createServer as createViteServer } from "vite";
+
 // src/next/vite/plugins.ts
-import fs8 from "fs";
-import path9 from "path";
+import fs9 from "fs";
+import path11 from "path";
 import { createFilter } from "@rollup/pluginutils";
 import { resolve as gqlResolve } from "@tinacms/graphql";
 import bodyParser from "body-parser";
@@ -2226,11 +2479,12 @@ import { transform as esbuildTransform } from "esbuild";
 import { transformWithEsbuild } from "vite";
 
 // src/next/commands/dev-command/server/media.ts
-import path8, { join } from "path";
+import { randomUUID } from "crypto";
+import path10, { join } from "path";
 import busboy from "busboy";
-import fs7 from "fs-extra";
+import fs8 from "fs-extra";
 var createMediaRouter = (config2) => {
-  const mediaFolder = path8.join(
+  const mediaFolder = path10.join(
     config2.rootPath,
     config2.publicFolder,
     config2.mediaRoot
@@ -2244,10 +2498,12 @@ var createMediaRouter = (config2) => {
       );
       const limit = requestURL.searchParams.get("limit");
       const cursor = requestURL.searchParams.get("cursor");
+      const search = requestURL.searchParams.get("search");
       const media = await mediaModel.listMedia({
         searchPath: folder,
         cursor,
-        limit
+        limit,
+        search
       });
       res.end(JSON.stringify(media));
     } catch (error) {
@@ -2273,6 +2529,39 @@ var createMediaRouter = (config2) => {
       throw error;
     }
   };
+  const handleRename = async (req, res) => {
+    const body = req.body;
+    const { from, to } = body || {};
+    if (typeof from !== "string" || typeof to !== "string" || !from || !to) {
+      res.statusCode = 400;
+      res.end(
+        JSON.stringify({
+          code: "INVALID_FILENAME",
+          message: 'Both "from" and "to" are required.'
+        })
+      );
+      return;
+    }
+    try {
+      const result = await mediaModel.renameMedia({ from, to });
+      if ("code" in result) {
+        res.statusCode = RENAME_ERROR_STATUS[result.code];
+        res.end(JSON.stringify({ code: result.code, message: result.message }));
+        return;
+      }
+      res.statusCode = 200;
+      res.end(JSON.stringify({ success: true, from, to }));
+    } catch (error) {
+      if (error instanceof PathTraversalError) {
+        res.statusCode = 403;
+        res.end(
+          JSON.stringify({ code: "INVALID_PATH", message: error.message })
+        );
+        return;
+      }
+      throw error;
+    }
+  };
   const handlePost = async function(req, res) {
     const bb = busboy({ headers: req.headers });
     let responded = false;
@@ -2294,8 +2583,8 @@ var createMediaRouter = (config2) => {
         );
         return;
       }
-      await fs7.ensureDir(path8.dirname(saveTo));
-      file.pipe(fs7.createWriteStream(saveTo));
+      await fs8.ensureDir(path10.dirname(saveTo));
+      file.pipe(fs8.createWriteStream(saveTo));
     });
     bb.on("error", (error) => {
       responded = true;
@@ -2313,7 +2602,7 @@ var createMediaRouter = (config2) => {
     });
     req.pipe(bb);
   };
-  return { handleList, handleDelete, handlePost };
+  return { handleList, handleDelete, handlePost, handleRename };
 };
 var parseMediaFolder = (str) => {
   let returnString = str;
@@ -2322,21 +2611,35 @@ var parseMediaFolder = (str) => {
     returnString = returnString.substr(0, returnString.length - 1);
   return returnString;
 };
+var RENAME_ERROR_STATUS = {
+  NOT_FOUND: 404,
+  NAME_COLLISION: 409,
+  UNSUPPORTED: 400,
+  BACKEND_FAILURE: 500
+};
+var StagedRenameError = class extends Error {
+  constructor(stagingName) {
+    super(`Left the file as "${stagingName}" in the same folder.`);
+    this.stagingName = stagingName;
+  }
+  stagingName;
+};
+var isDestinationExistsError = (error) => error?.code === "EEXIST" || /dest already exists/i.test(error?.message || "");
 var ENCODED_TRAVERSAL_RE = /%2e%2e|%2f|%5c/i;
 function resolveRealPath(candidate) {
   try {
-    return fs7.realpathSync(candidate);
+    return fs8.realpathSync(candidate);
   } catch {
-    const parent = path8.dirname(candidate);
+    const parent = path10.dirname(candidate);
     if (parent === candidate) return candidate;
-    return path8.join(resolveRealPath(parent), path8.basename(candidate));
+    return path10.join(resolveRealPath(parent), path10.basename(candidate));
   }
 }
 function assertSymlinkWithinBase(resolved, resolvedBase, userPath) {
   try {
-    const realBase = fs7.realpathSync(resolvedBase);
+    const realBase = fs8.realpathSync(resolvedBase);
     const realResolved = resolveRealPath(resolved);
-    if (realResolved !== realBase && !realResolved.startsWith(realBase + path8.sep)) {
+    if (realResolved !== realBase && !realResolved.startsWith(realBase + path10.sep)) {
       throw new PathTraversalError(userPath);
     }
   } catch (err) {
@@ -2347,13 +2650,13 @@ function resolveWithinBase(userPath, baseDir) {
   if (ENCODED_TRAVERSAL_RE.test(userPath)) {
     throw new PathTraversalError(userPath);
   }
-  const resolvedBase = path8.resolve(baseDir);
-  const resolved = path8.resolve(path8.join(baseDir, userPath));
+  const resolvedBase = path10.resolve(baseDir);
+  const resolved = path10.resolve(path10.join(baseDir, userPath));
   if (resolved === resolvedBase) {
     assertSymlinkWithinBase(resolved, resolvedBase, userPath);
     return resolvedBase;
   }
-  if (resolved.startsWith(resolvedBase + path8.sep)) {
+  if (resolved.startsWith(resolvedBase + path10.sep)) {
     assertSymlinkWithinBase(resolved, resolvedBase, userPath);
     return resolved;
   }
@@ -2363,12 +2666,12 @@ function resolveStrictlyWithinBase(userPath, baseDir) {
   if (ENCODED_TRAVERSAL_RE.test(userPath)) {
     throw new PathTraversalError(userPath);
   }
-  const resolvedBase = path8.resolve(baseDir) + path8.sep;
-  const resolved = path8.resolve(path8.join(baseDir, userPath));
+  const resolvedBase = path10.resolve(baseDir) + path10.sep;
+  const resolved = path10.resolve(path10.join(baseDir, userPath));
   if (!resolved.startsWith(resolvedBase)) {
     throw new PathTraversalError(userPath);
   }
-  assertSymlinkWithinBase(resolved, path8.resolve(baseDir), userPath);
+  assertSymlinkWithinBase(resolved, path10.resolve(baseDir), userPath);
   return resolved;
 }
 var MediaModel = class {
@@ -2385,16 +2688,27 @@ 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 fs7.pathExists(validatedPath)) {
+      if (!await fs8.pathExists(validatedPath)) {
         return {
           files: [],
           directories: []
         };
       }
-      const filesStr = await fs7.readdir(validatedPath);
+      const search = args.search?.trim().toLowerCase();
+      if (search) {
+        return await this.searchMedia({
+          mediaBase,
+          validatedPath,
+          searchPath,
+          search,
+          cursor: args.cursor,
+          limit: args.limit
+        });
+      }
+      const filesStr = await fs8.readdir(validatedPath);
       const filesProm = filesStr.map(async (file) => {
         const filePath = join(validatedPath, file);
-        const stat = await fs7.stat(filePath);
+        const stat = await fs8.stat(filePath);
         let src = `/${file}`;
         const isFile = stat.isFile();
         if (!isFile) {
@@ -2430,10 +2744,11 @@ var MediaModel = class {
         }
         return 0;
       });
-      const limitItems = sortedItems.slice(offset, offset + limit);
-      const files = limitItems.filter((x) => x.isFile);
-      const directories = limitItems.filter((x) => !x.isFile).map((x) => x.src);
-      const cursor = rawItems.length > offset + limit ? String(offset + limit) : null;
+      const allDirectories = sortedItems.filter((x) => !x.isFile).map((x) => x.src);
+      const allFiles = sortedItems.filter((x) => x.isFile);
+      const directories = offset === 0 ? allDirectories : [];
+      const files = allFiles.slice(offset, offset + limit);
+      const cursor = allFiles.length > offset + limit ? String(offset + limit) : null;
       return {
         files,
         directories,
@@ -2449,12 +2764,156 @@ var MediaModel = class {
       };
     }
   }
+  async searchMedia({
+    mediaBase,
+    validatedPath,
+    searchPath,
+    search,
+    cursor,
+    limit
+  }) {
+    const resolvedBase = path10.resolve(mediaBase);
+    const files = [];
+    const directories = [];
+    const visitedDirs = /* @__PURE__ */ new Set([resolveRealPath(validatedPath)]);
+    const walk = async (dir, relPrefix) => {
+      let entries;
+      try {
+        entries = await fs8.readdir(dir);
+      } catch {
+        return;
+      }
+      const stats = await Promise.all(
+        entries.map(async (entry) => {
+          const absPath = join(dir, entry);
+          try {
+            assertSymlinkWithinBase(absPath, resolvedBase, absPath);
+          } catch {
+            return null;
+          }
+          try {
+            return { entry, absPath, stat: await fs8.stat(absPath) };
+          } catch {
+            return null;
+          }
+        })
+      );
+      for (const entryStat of stats) {
+        if (!entryStat) continue;
+        const { entry, absPath, stat } = entryStat;
+        const relPath = relPrefix ? `${relPrefix}/${entry}` : entry;
+        if (stat.isDirectory()) {
+          const realDir = resolveRealPath(absPath);
+          if (visitedDirs.has(realDir)) continue;
+          visitedDirs.add(realDir);
+          if (entry.toLowerCase().includes(search)) {
+            directories.push(`/${relPath}`);
+          }
+          await walk(absPath, relPath);
+          continue;
+        }
+        if (!relPath.toLowerCase().includes(search)) continue;
+        let src = `/${relPath}`;
+        if (searchPath) src = `/${searchPath}${src}`;
+        if (this.mediaRoot) src = `/${this.mediaRoot}${src}`;
+        files.push({ src, filename: relPath, size: stat.size });
+      }
+    };
+    await walk(validatedPath, "");
+    files.sort((a, b) => a.filename.localeCompare(b.filename));
+    directories.sort();
+    const offset = Number(cursor) || 0;
+    const pageSize = Number(limit) || 20;
+    return {
+      files: files.slice(offset, offset + pageSize),
+      directories: offset === 0 ? directories : [],
+      cursor: files.length > offset + pageSize ? String(offset + pageSize) : null
+    };
+  }
+  /**
+   * @security Both paths go through `resolveStrictlyWithinBase`, which rejects
+   * traversal, symlink escapes and the media root itself.
+   */
+  async renameMedia(args) {
+    const mediaBase = join(this.rootPath, this.publicFolder, this.mediaRoot);
+    const source = resolveStrictlyWithinBase(args.from, mediaBase);
+    const destination = resolveStrictlyWithinBase(args.to, mediaBase);
+    try {
+      const stats = await fs8.stat(source);
+      if (stats.isDirectory()) {
+        return {
+          ok: false,
+          code: "UNSUPPORTED",
+          message: "Renaming folders is not supported."
+        };
+      }
+    } catch {
+      return {
+        ok: false,
+        code: "NOT_FOUND",
+        message: `"${args.from}" does not exist.`
+      };
+    }
+    const isCaseOnlyRename = source !== destination && source.toLowerCase() === destination.toLowerCase();
+    if (!isCaseOnlyRename && await fs8.pathExists(destination)) {
+      return {
+        ok: false,
+        code: "NAME_COLLISION",
+        message: `"${args.to}" already exists.`
+      };
+    }
+    try {
+      await fs8.ensureDir(path10.dirname(destination));
+      if (isCaseOnlyRename) {
+        await this.renameViaStaging(source, destination);
+      } else {
+        await fs8.move(source, destination, { overwrite: false });
+      }
+      return { ok: true };
+    } catch (error) {
+      if (isDestinationExistsError(error)) {
+        return {
+          ok: false,
+          code: "NAME_COLLISION",
+          message: `"${args.to}" already exists.`
+        };
+      }
+      console.error(error);
+      return {
+        ok: false,
+        code: "BACKEND_FAILURE",
+        message: error instanceof StagedRenameError ? `Failed to rename the file. ${error.message}` : "Failed to rename the file."
+      };
+    }
+  }
+  /**
+   * A case-insensitive filesystem can treat `a.jpg` -> `A.jpg` as a no-op, so
+   * hop through a unique sibling name. On failure the source is put back; if
+   * even that fails the file survives under the staging name, which
+   * StagedRenameError reports rather than leaving it to be found by accident.
+   */
+  async renameViaStaging(source, destination) {
+    const stagingName = `.tina-rename-${randomUUID()}`;
+    const staging = join(path10.dirname(source), stagingName);
+    await fs8.move(source, staging, { overwrite: false });
+    try {
+      await fs8.move(staging, destination, { overwrite: false });
+    } catch (error) {
+      try {
+        await fs8.move(staging, source, { overwrite: false });
+      } catch (restoreError) {
+        console.error(restoreError);
+        throw new StagedRenameError(stagingName);
+      }
+      throw error;
+    }
+  }
   async deleteMedia(args) {
     try {
       const mediaBase = join(this.rootPath, this.publicFolder, this.mediaRoot);
       const file = resolveStrictlyWithinBase(args.searchPath, mediaBase);
-      await fs7.stat(file);
-      await fs7.remove(file);
+      await fs8.stat(file);
+      await fs8.remove(file);
       return { ok: true };
     } catch (error) {
       if (error instanceof PathTraversalError) throw error;
@@ -2562,7 +3021,7 @@ var transformTsxPlugin = ({
   const plug = {
     name: "transform-tsx",
     async transform(code, id) {
-      const extName = path9.extname(id);
+      const extName = path11.extname(id);
       if (extName.startsWith(".tsx") || extName.startsWith(".ts")) {
         const result = await esbuildTransform(code, { loader: "tsx" });
         return {
@@ -2573,6 +3032,7 @@ var transformTsxPlugin = ({
   };
   return plug;
 };
+var isMediaRenameRequest = (req) => req.method === "POST" && (req.url || "").split("?")[0] === "/media/rename";
 var devServerEndPointsPlugin = ({
   configManager,
   apiURL,
@@ -2585,6 +3045,7 @@ var devServerEndPointsPlugin = ({
   const isStateChangingRequest = (req) => {
     const url = req.url || "";
     if (url.startsWith("/media/upload")) return true;
+    if (isMediaRenameRequest(req)) return true;
     if (url.startsWith("/media") && req.method === "DELETE") return true;
     if (url.startsWith("/graphql") && req.method === "POST") return true;
     if ((url.startsWith("/searchIndex") || url.startsWith("/v2/searchIndex")) && (req.method === "POST" || req.method === "DELETE"))
@@ -2622,6 +3083,10 @@ var devServerEndPointsPlugin = ({
           await mediaRouter.handlePost(req, res);
           return;
         }
+        if (isMediaRenameRequest(req)) {
+          await mediaRouter.handleRename(req, res);
+          return;
+        }
         if (req.url.startsWith("/media")) {
           if (req.method === "DELETE") {
             await mediaRouter.handleDelete(req, res);
@@ -2686,7 +3151,7 @@ function viteTransformExtension({
     async transform(code, id) {
       if (filter(id)) {
         const { transform: transform2 } = await import("@svgr/core");
-        const svgCode = await fs8.promises.readFile(
+        const svgCode = await fs9.promises.readFile(
           id.replace(/\?.*$/, ""),
           "utf8"
         );
@@ -2797,6 +3262,7 @@ var DevCommand = class extends BaseCommand {
     });
     logger.info("\u{1F999} TinaCMS Dev Server is initializing...");
     this.logDeprecationWarnings();
+    this.warnOnVersionSkew(configManager.rootPath);
     createDBServer(Number(this.datalayerPort));
     let database = null;
     const dbLock = async (fn) => {
@@ -2836,13 +3302,13 @@ var DevCommand = class extends BaseCommand {
         });
         const apiURL2 = await codegen2.execute();
         if (!configManager.isUsingLegacyFolder) {
-          const schemaObject = await fs9.readJSON(
+          const schemaObject = await fs10.readJSON(
             configManager.generatedSchemaJSONPath
           );
-          const lookupObject = await fs9.readJSON(
+          const lookupObject = await fs10.readJSON(
             configManager.generatedLookupJSONPath
           );
-          const graphqlSchemaObject = await fs9.readJSON(
+          const graphqlSchemaObject = await fs10.readJSON(
             configManager.generatedGraphQLJSONPath
           );
           const tinaLockFilename = "tina-lock.json";
@@ -2851,8 +3317,8 @@ var DevCommand = class extends BaseCommand {
             lookup: lookupObject,
             graphql: graphqlSchemaObject
           });
-          fs9.writeFileSync(
-            path10.join(configManager.tinaFolderPath, tinaLockFilename),
+          fs10.writeFileSync(
+            path12.join(configManager.tinaFolderPath, tinaLockFilename),
             tinaLockContent
           );
         }
@@ -2896,8 +3362,11 @@ ${dangerText(e.message)}
     const { apiURL, graphQLSchema, tinaSchema } = await setup({
       firstTime: true
     });
-    await fs9.outputFile(configManager.outputHTMLFilePath, devHTML(this.port));
-    await fs9.outputFile(
+    await fs10.outputFile(
+      configManager.outputHTMLFilePath,
+      devHTML(this.port, getBasePath(configManager))
+    );
+    await fs10.outputFile(
       configManager.outputGitignorePath,
       "index.html\nassets/"
     );
@@ -3042,7 +3511,7 @@ ${dangerText(e.message)}
   watchContentFiles(configManager, database, databaseLock, searchIndexer) {
     const collectionContentFiles = [];
     configManager.config.schema.collections.forEach((collection) => {
-      const collectionGlob = `${path10.join(
+      const collectionGlob = `${path12.join(
         configManager.contentRootPath,
         collection.path
       )}/**/*.${collection.format || "md"}`;
@@ -3092,8 +3561,10 @@ ${dangerText(e.message)}
 
 // src/next/commands/build-command/index.ts
 import crypto from "crypto";
-import path11 from "path";
-import { diff } from "@graphql-inspector/core";
+import path13 from "path";
+import {
+  diff
+} from "@graphql-inspector/core";
 import { FilesystemBridge as FilesystemBridge3, buildSchema as buildSchema2 } from "@tinacms/graphql";
 import { parseURL as parseURL2 } from "@tinacms/schema-tools";
 import {
@@ -3101,7 +3572,7 @@ import {
   TinaCMSSearchIndexClient
 } from "@tinacms/search";
 import { Command as Command3, Option as Option3 } from "clipanion";
-import fs10 from "fs-extra";
+import fs11 from "fs-extra";
 import {
   buildASTSchema as buildASTSchema2,
   buildClientSchema,
@@ -3121,6 +3592,78 @@ var getFaqLink = (type) => {
   }
 };
 
+// src/utils/posthog.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { PostHog } from "posthog-node";
+
+// src/utils/fetchPostHogConfig.ts
+async function fetchPostHogConfig(endpointUrl) {
+  try {
+    const response = await fetch(endpointUrl, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      // Cap latency for offline / firewalled developers. Endpoint is
+      // typically single-digit ms when reachable; a timeout returns {}
+      // and disables telemetry for this run, which is the right behavior.
+      signal: AbortSignal.timeout(2e3)
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to fetch PostHog config: ${response.statusText}`);
+    }
+    const config2 = await response.json();
+    return {
+      POSTHOG_API_KEY: config2.api_key,
+      POSTHOG_ENDPOINT: config2.host
+    };
+  } catch {
+    return {};
+  }
+}
+
+// src/utils/posthog.ts
+function generateSessionId() {
+  return randomUUID2();
+}
+var BuildInvokeEvent = "tinacms-cli-build-invoke";
+var BuildFinishedEvent = "tinacms-cli-build-finished";
+async function initializePostHog(configEndpoint, disableGeoip) {
+  if (process.env.TINA_DEV === "true") return null;
+  let apiKey;
+  let endpoint;
+  if (configEndpoint) {
+    const config2 = await fetchPostHogConfig(configEndpoint);
+    apiKey = config2.POSTHOG_API_KEY;
+    endpoint = config2.POSTHOG_ENDPOINT;
+  }
+  if (!apiKey) return null;
+  return new PostHog(apiKey, {
+    host: endpoint,
+    disableGeoip: disableGeoip ?? true
+  });
+}
+function postHogCapture(client, distinctId, event, properties) {
+  if (!client) {
+    return;
+  }
+  try {
+    client.capture({
+      distinctId,
+      event,
+      properties: {
+        ...properties,
+        system: "tinacms/cli",
+        // Bill as anonymous events: distinctId is a throwaway per-run UUID, so
+        // person profiles would be single-use junk at ~4x the event price.
+        $process_person_profile: false
+      }
+    });
+  } catch (error) {
+    console.error("Error capturing event:", error);
+  }
+}
+
 // src/utils/sleep.ts
 function timeout(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
@@ -3238,75 +3781,6 @@ var waitForDB = async (config2, apiUrl, previewName, verbose) => {
   });
 };
 
-// src/utils/posthog.ts
-import { randomUUID } from "node:crypto";
-import { PostHog } from "posthog-node";
-
-// src/utils/fetchPostHogConfig.ts
-async function fetchPostHogConfig(endpointUrl) {
-  try {
-    const response = await fetch(endpointUrl, {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      // Cap latency for offline / firewalled developers. Endpoint is
-      // typically single-digit ms when reachable; a timeout returns {}
-      // and disables telemetry for this run, which is the right behavior.
-      signal: AbortSignal.timeout(2e3)
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to fetch PostHog config: ${response.statusText}`);
-    }
-    const config2 = await response.json();
-    return {
-      POSTHOG_API_KEY: config2.api_key,
-      POSTHOG_ENDPOINT: config2.host
-    };
-  } catch {
-    return {};
-  }
-}
-
-// src/utils/posthog.ts
-function generateSessionId() {
-  return randomUUID();
-}
-var BuildInvokeEvent = "tinacms-cli-build-invoke";
-var BuildFinishedEvent = "tinacms-cli-build-finished";
-async function initializePostHog(configEndpoint, disableGeoip) {
-  if (process.env.TINA_DEV === "true") return null;
-  let apiKey;
-  let endpoint;
-  if (configEndpoint) {
-    const config2 = await fetchPostHogConfig(configEndpoint);
-    apiKey = config2.POSTHOG_API_KEY;
-    endpoint = config2.POSTHOG_ENDPOINT;
-  }
-  if (!apiKey) return null;
-  return new PostHog(apiKey, {
-    host: endpoint,
-    disableGeoip: disableGeoip ?? true
-  });
-}
-function postHogCapture(client, distinctId, event, properties) {
-  if (!client) {
-    return;
-  }
-  try {
-    client.capture({
-      distinctId,
-      event,
-      properties: {
-        ...properties,
-        system: "tinacms/cli"
-      }
-    });
-  } catch (error) {
-    console.error("Error capturing event:", error);
-  }
-}
-
 // src/next/commands/build-command/index.ts
 var BuildCommand = class extends BaseCommand {
   static paths = [["build"]];
@@ -3372,6 +3846,7 @@ var BuildCommand = class extends BaseCommand {
       tinaGraphQLVersion: this.tinaGraphQLVersion,
       legacyNoSDK: this.noSDK
     });
+    this.warnOnVersionSkew(configManager.rootPath);
     if (this.previewName && !this.previewBaseBranch) {
       logger.error(
         `${dangerText(
@@ -3565,7 +4040,7 @@ ${dangerText(e.message)}
       }
     }
     await buildProductionSpa(configManager, database, codegen2.productionUrl);
-    await fs10.outputFile(
+    await fs11.outputFile(
       configManager.outputGitignorePath,
       "index.html\nassets/"
     );
@@ -3950,7 +4425,7 @@ Additional info: Branch: ${config2.branch}, Client ID: ${config2.clientId} `;
     }
     const localTinaSchema = JSON.parse(
       await database.bridge.get(
-        path11.join(database.tinaDirectory, "__generated__", "_schema.json")
+        path13.join(database.tinaDirectory, "__generated__", "_schema.json")
       )
     );
     localTinaSchema.version = void 0;
@@ -4313,19 +4788,19 @@ var AuditCommand = class extends Command4 {
 import { Command as Command6, Option as Option6 } from "clipanion";
 
 // src/cmds/init/detectEnvironment.ts
-import fs12 from "fs-extra";
-import path13 from "path";
+import fs13 from "fs-extra";
+import path15 from "path";
 
 // src/cmds/init/astro-config-detect.ts
-import fs11 from "fs";
-import path12 from "path";
+import fs12 from "fs";
+import path14 from "path";
 var isDefaultAstroConfig = (source) => {
   const stripped = source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*$/gm, "").replace(/\s+/g, " ").trim();
   return /^import\s*\{\s*defineConfig\s*\}\s*from\s*['"]astro\/config['"]\s*;?\s*export\s+default\s+defineConfig\(\s*\{\s*\}\s*\)\s*;?$/.test(
     stripped
   );
 };
-var findExistingPaths = (baseDir, relPaths) => relPaths.filter((rel) => fs11.existsSync(path12.join(baseDir, rel)));
+var findExistingPaths = (baseDir, relPaths) => relPaths.filter((rel) => fs12.existsSync(path14.join(baseDir, rel)));
 var parseAstroMajor = (version2) => {
   const match = version2 ? String(version2).match(/(\d+)/) : null;
   return match ? Number(match[1]) : void 0;
@@ -4341,20 +4816,20 @@ var checkGitignoreForItem = async ({
   baseDir,
   line
 }) => {
-  const gitignoreContent = fs12.readFileSync(path13.join(baseDir, ".gitignore")).toString();
+  const gitignoreContent = fs13.readFileSync(path15.join(baseDir, ".gitignore")).toString();
   return gitignoreContent.split("\n").some((item) => item === line);
 };
 var makeGeneratedFile = async (name2, generatedFileType, parentPath, opts) => {
   const result = {
-    fullPathTS: path13.join(
+    fullPathTS: path15.join(
       parentPath,
       `${name2}.${opts?.typescriptSuffix || opts?.extensionOverride || "ts"}`
     ),
-    fullPathJS: path13.join(
+    fullPathJS: path15.join(
       parentPath,
       `${name2}.${opts?.extensionOverride || "js"}`
     ),
-    fullPathOverride: opts?.extensionOverride ? path13.join(parentPath, `${name2}.${opts?.extensionOverride}`) : "",
+    fullPathOverride: opts?.extensionOverride ? path15.join(parentPath, `${name2}.${opts?.extensionOverride}`) : "",
     generatedFileType,
     name: name2,
     parentPath,
@@ -4372,8 +4847,8 @@ var makeGeneratedFile = async (name2, generatedFileType, parentPath, opts) => {
       };
     }
   };
-  result.typescriptExists = await fs12.pathExists(result.fullPathTS);
-  result.javascriptExists = await fs12.pathExists(result.fullPathJS);
+  result.typescriptExists = await fs13.pathExists(result.fullPathTS);
+  result.javascriptExists = await fs13.pathExists(result.fullPathJS);
   return result;
 };
 var detectEnvironment = async ({
@@ -4382,21 +4857,21 @@ var detectEnvironment = async ({
   rootPath,
   debug = false
 }) => {
-  const hasForestryConfig = await fs12.pathExists(
-    path13.join(pathToForestryConfig, ".forestry", "settings.yml")
+  const hasForestryConfig = await fs13.pathExists(
+    path15.join(pathToForestryConfig, ".forestry", "settings.yml")
   );
-  const sampleContentPath = path13.join(
+  const sampleContentPath = path15.join(
     baseDir,
     "content",
     "posts",
     "hello-world.md"
   );
-  const usingSrc = fs12.pathExistsSync(path13.join(baseDir, "src")) && (fs12.pathExistsSync(path13.join(baseDir, "src", "app")) || fs12.pathExistsSync(path13.join(baseDir, "src", "pages")));
-  const tinaFolder = path13.join(baseDir, "tina");
+  const usingSrc = fs13.pathExistsSync(path15.join(baseDir, "src")) && (fs13.pathExistsSync(path15.join(baseDir, "src", "app")) || fs13.pathExistsSync(path15.join(baseDir, "src", "pages")));
+  const tinaFolder = path15.join(baseDir, "tina");
   const tinaConfigExists = Boolean(
     // Does the tina folder exist?
-    await fs12.pathExists(tinaFolder) && // Does the tina folder contain a config file?
-    (await fs12.readdir(tinaFolder)).find((x) => x.includes("config"))
+    await fs13.pathExists(tinaFolder) && // Does the tina folder contain a config file?
+    (await fs13.readdir(tinaFolder)).find((x) => x.includes("config"))
   );
   const pagesDir = [baseDir, usingSrc ? "src" : false, "pages"].filter(
     Boolean
@@ -4408,12 +4883,12 @@ var detectEnvironment = async ({
     "next-api-handler": await makeGeneratedFile(
       "[...routes]",
       "next-api-handler",
-      path13.join(...pagesDir, "api", "tina")
+      path15.join(...pagesDir, "api", "tina")
     ),
     "reactive-example": await makeGeneratedFile(
       "[filename]",
       "reactive-example",
-      path13.join(...pagesDir, "demo", "blog"),
+      path15.join(...pagesDir, "demo", "blog"),
       {
         typescriptSuffix: "tsx"
       }
@@ -4421,24 +4896,24 @@ var detectEnvironment = async ({
     "users-json": await makeGeneratedFile(
       "index",
       "users-json",
-      path13.join(baseDir, "content", "users"),
+      path15.join(baseDir, "content", "users"),
       { extensionOverride: "json" }
     ),
     "sample-content": await makeGeneratedFile(
       "hello-world",
       "sample-content",
-      path13.join(baseDir, "content", "posts"),
+      path15.join(baseDir, "content", "posts"),
       { extensionOverride: "md" }
     )
   };
-  const hasSampleContent = await fs12.pathExists(sampleContentPath);
-  const hasPackageJSON = await fs12.pathExists("package.json");
+  const hasSampleContent = await fs13.pathExists(sampleContentPath);
+  const hasPackageJSON = await fs13.pathExists("package.json");
   let hasTinaDeps = false;
   let hasReactDep = false;
   let astroMajor;
   if (hasPackageJSON) {
     try {
-      const packageJSON = await fs12.readJSON("package.json");
+      const packageJSON = await fs13.readJSON("package.json");
       const deps = [];
       if (packageJSON?.dependencies) {
         deps.push(...Object.keys(packageJSON.dependencies));
@@ -4461,7 +4936,7 @@ var detectEnvironment = async ({
       );
     }
   }
-  const hasGitIgnore = await fs12.pathExists(path13.join(".gitignore"));
+  const hasGitIgnore = await fs13.pathExists(path15.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" });
@@ -4471,9 +4946,9 @@ var detectEnvironment = async ({
   });
   let frontMatterFormat;
   if (hasForestryConfig) {
-    const hugoConfigPath = path13.join(rootPath, "config.toml");
-    if (await fs12.pathExists(hugoConfigPath)) {
-      const hugoConfig = await fs12.readFile(hugoConfigPath, "utf8");
+    const hugoConfigPath = path15.join(rootPath, "config.toml");
+    if (await fs13.pathExists(hugoConfigPath)) {
+      const hugoConfig = await fs13.readFile(hugoConfigPath, "utf8");
       const metaDataFormat = hugoConfig.toString().match(/metaDataFormat = "(.*)"/)?.[1];
       if (metaDataFormat && (metaDataFormat === "yaml" || metaDataFormat === "toml" || metaDataFormat === "json")) {
         frontMatterFormat = metaDataFormat;
@@ -5098,6 +5573,7 @@ var CLICommand = class {
   constructor(handler) {
     this.handler = handler;
   }
+  handler;
   async execute(params) {
     await this.handler.setup(params);
     const environment = await this.handler.detectEnvironment(params);
@@ -5107,19 +5583,19 @@ var CLICommand = class {
 };
 
 // src/cmds/init/apply.ts
-import path18 from "path";
+import path20 from "path";
 
 // src/cmds/forestry-migrate/index.ts
-import fs14 from "fs-extra";
-import path15 from "path";
+import fs15 from "fs-extra";
+import path17 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 fs13 from "fs-extra";
-import path14 from "path";
+import fs14 from "fs-extra";
+import path16 from "path";
 import yaml from "js-yaml";
 import z2 from "zod";
 
@@ -5561,7 +6037,7 @@ var transformForestryFieldsToTinaFields = ({
   return tinaFields;
 };
 var getFieldsFromTemplates = ({ tem, pathToForestryConfig, skipBlocks = false }) => {
-  const templatePath = path14.join(
+  const templatePath = path16.join(
     pathToForestryConfig,
     ".forestry",
     "front_matter",
@@ -5570,7 +6046,7 @@ var getFieldsFromTemplates = ({ tem, pathToForestryConfig, skipBlocks = false })
   );
   let templateString = "";
   try {
-    templateString = fs13.readFileSync(templatePath).toString();
+    templateString = fs14.readFileSync(templatePath).toString();
   } catch {
     throw new Error(
       `Could not find template ${tem} at ${templatePath}
@@ -5629,9 +6105,9 @@ function checkExt(ext) {
 var generateAllTemplates = async ({
   pathToForestryConfig
 }) => {
-  const allTemplates = (await fs14.readdir(
-    path15.join(pathToForestryConfig, ".forestry", "front_matter", "templates")
-  )).map((tem) => path15.basename(tem, ".yml"));
+  const allTemplates = (await fs15.readdir(
+    path17.join(pathToForestryConfig, ".forestry", "front_matter", "templates")
+  )).map((tem) => path17.basename(tem, ".yml"));
   const templateMap = /* @__PURE__ */ new Map();
   const proms = allTemplates.map(async (tem) => {
     try {
@@ -5776,9 +6252,9 @@ var generateCollectionFromForestrySection = (args) => {
     return c;
   } else if (section.type === "document") {
     const filePath = section.path;
-    const extname = path15.extname(filePath);
-    const fileName = path15.basename(filePath, extname);
-    const dir = path15.dirname(filePath);
+    const extname = path17.extname(filePath);
+    const fileName = path17.basename(filePath, extname);
+    const dir = path17.dirname(filePath);
     const ext = checkExt(extname);
     if (ext) {
       const fields = [];
@@ -5840,8 +6316,8 @@ var generateCollections = async ({
     templateMap,
     usingTypescript
   });
-  const forestryConfig = await fs14.readFile(
-    path15.join(pathToForestryConfig, ".forestry", "settings.yml")
+  const forestryConfig = await fs15.readFile(
+    path17.join(pathToForestryConfig, ".forestry", "settings.yml")
   );
   rewriteTemplateKeysInDocs({
     templateMap,
@@ -5871,12 +6347,12 @@ var rewriteTemplateKeysInDocs = (args) => {
     const { templateObj } = templateMap.get(templateKey);
     templateObj?.pages?.forEach((page) => {
       try {
-        const filePath = path15.join(page);
-        if (fs14.lstatSync(filePath).isDirectory()) {
+        const filePath = path17.join(page);
+        if (fs15.lstatSync(filePath).isDirectory()) {
           return;
         }
-        const extname = path15.extname(filePath);
-        const fileContent = fs14.readFileSync(filePath).toString();
+        const extname = path17.extname(filePath);
+        const fileContent = fs15.readFileSync(filePath).toString();
         const content = parseFile(
           fileContent,
           extname,
@@ -5887,7 +6363,7 @@ var rewriteTemplateKeysInDocs = (args) => {
           _template: stringifyLabel(templateKey),
           ...content
         };
-        fs14.writeFileSync(
+        fs15.writeFileSync(
           filePath,
           stringifyFile(newContent, extname, true, markdownParseConfig)
         );
@@ -5902,12 +6378,12 @@ var rewriteTemplateKeysInDocs = (args) => {
 
 // src/cmds/init/apply.ts
 import { Telemetry as Telemetry3 } from "@tinacms/metrics";
-import fs18 from "fs-extra";
+import fs19 from "fs-extra";
 
 // src/next/commands/codemod-command/index.ts
 import { Command as Command5, Option as Option5 } from "clipanion";
-import fs15 from "fs-extra";
-import path16 from "path";
+import fs16 from "fs-extra";
+import path18 from "path";
 var CodemodCommand = class extends Command5 {
   static paths = [["codemod"], ["codemod", "move-tina-folder"]];
   rootPath = Option5.String("--rootPath", {
@@ -5948,13 +6424,13 @@ var moveTinaFolder = async (rootPath = process.cwd()) => {
     logger.error(e.message);
     process.exit(1);
   }
-  const tinaDestination = path16.join(configManager.rootPath, "tina");
-  if (await fs15.existsSync(tinaDestination)) {
+  const tinaDestination = path18.join(configManager.rootPath, "tina");
+  if (await fs16.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 fs15.moveSync(configManager.tinaFolderPath, tinaDestination);
+    await fs16.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!"
@@ -5962,8 +6438,8 @@ var moveTinaFolder = async (rootPath = process.cwd()) => {
   }
 };
 var writeGitignore = async (rootPath) => {
-  await fs15.outputFileSync(
-    path16.join(rootPath, "tina", ".gitignore"),
+  await fs16.outputFileSync(
+    path18.join(rootPath, "tina", ".gitignore"),
     "__generated__"
   );
 };
@@ -6022,7 +6498,7 @@ const BlogPage = (props) => {
             {' '}
             Check out this guide
           </a>{' '}
-          to see how add TinaCMS to an existing Next.js site.
+          to see how to add TinaCMS to an existing Next.js site.
         </div>
       </div>
     </>
@@ -6474,8 +6950,8 @@ function extendAstroScripts(scripts) {
 }
 
 // src/cmds/init/astro-visual-editing.ts
-import fs16 from "fs-extra";
-import path17 from "path";
+import fs17 from "fs-extra";
+import path19 from "path";
 var TS_NOCHECK = "// @ts-nocheck (generated types/client appear after your first tinacms dev run)\n";
 var DEMO_FILES = {
   "src/lib/tina/data.ts": `${TS_NOCHECK}import { requestWithMetadata } from '@tinacms/astro/data';
@@ -6746,8 +7222,8 @@ var ASTRO_CONFIG_FILES = [
   "astro.config.cjs",
   "astro.config.cts"
 ];
-var findAstroConfig = (baseDir) => ASTRO_CONFIG_FILES.map((file) => path17.join(baseDir, file)).find(
-  (p) => fs16.existsSync(p)
+var findAstroConfig = (baseDir) => ASTRO_CONFIG_FILES.map((file) => path19.join(baseDir, file)).find(
+  (p) => fs17.existsSync(p)
 );
 var setupAstroVisualEditing = ({
   baseDir
@@ -6765,17 +7241,17 @@ var setupAstroVisualEditing = ({
     return { configHandled: true, demoScaffolded: false };
   }
   for (const rel of relPaths) {
-    fs16.outputFileSync(path17.join(baseDir, rel), DEMO_FILES[rel]);
+    fs17.outputFileSync(path19.join(baseDir, rel), DEMO_FILES[rel]);
   }
   logger.info("Adding a visual-editing demo at /tinacms-demo... \u2705");
   const configPath = findAstroConfig(baseDir);
   if (!configPath) {
-    fs16.writeFileSync(path17.join(baseDir, "astro.config.mjs"), ASTRO_CONFIG);
+    fs17.writeFileSync(path19.join(baseDir, "astro.config.mjs"), ASTRO_CONFIG);
     logger.info("Creating astro.config for visual editing... \u2705");
     return { configHandled: true, demoScaffolded: true };
   }
-  if (isDefaultAstroConfig(fs16.readFileSync(configPath).toString())) {
-    fs16.writeFileSync(configPath, ASTRO_CONFIG);
+  if (isDefaultAstroConfig(fs17.readFileSync(configPath).toString())) {
+    fs17.writeFileSync(configPath, ASTRO_CONFIG);
     logger.info("Wiring astro.config for visual editing... \u2705");
     return { configHandled: true, demoScaffolded: true };
   }
@@ -6787,7 +7263,7 @@ var logAstroConfigGuidance = () => {
 
 // src/cmds/init/codegen/index.ts
 import ts2 from "typescript";
-import fs17 from "fs-extra";
+import fs18 from "fs-extra";
 
 // src/cmds/init/codegen/util.ts
 import ts from "typescript";
@@ -7024,7 +7500,7 @@ var addSelfHostedTinaAuthToConfig = async (config2, configFile) => {
   const pathToConfig = configFile.resolve(config2.typescript).path;
   const sourceFile = ts2.createSourceFile(
     pathToConfig,
-    fs17.readFileSync(pathToConfig, "utf8"),
+    fs18.readFileSync(pathToConfig, "utf8"),
     config2.typescript ? ts2.ScriptTarget.Latest : ts2.ScriptTarget.ESNext
   );
   const { configImports, configAuthProviderClass, extraTinaCollections } = config2.authProvider;
@@ -7074,7 +7550,7 @@ var addSelfHostedTinaAuthToConfig = async (config2, configFile) => {
       )
     ].map((visitor) => makeTransformer(visitor))
   );
-  return fs17.writeFile(
+  return fs18.writeFile(
     pathToConfig,
     ts2.createPrinter({ omitTrailingSemicolon: true }).printFile(transformedSourceFileResult.transformed[0])
   );
@@ -7200,8 +7676,8 @@ async function apply({
     await addConfigFile({
       configArgs: {
         config: config2,
-        publicFolder: path18.join(
-          path18.relative(process.cwd(), pathToForestryConfig),
+        publicFolder: path20.join(
+          path20.relative(process.cwd(), pathToForestryConfig),
           config2.publicFolder
         ),
         collections,
@@ -7278,8 +7754,8 @@ var createPackageJSON = async () => {
 };
 var createGitignore = async ({ baseDir }) => {
   logger.info(logText("No .gitignore found, creating one"));
-  fs18.outputFileSync(
-    path18.join(baseDir, ".gitignore"),
+  fs19.outputFileSync(
+    path20.join(baseDir, ".gitignore"),
     "node_modules\ntina/__generated__\n"
   );
 };
@@ -7288,11 +7764,11 @@ var updateGitIgnore = async ({
   items
 }) => {
   logger.info(logText(`Adding ${items.join(",")} to .gitignore`));
-  const gitignoreContent = fs18.readFileSync(path18.join(baseDir, ".gitignore")).toString();
+  const gitignoreContent = fs19.readFileSync(path20.join(baseDir, ".gitignore")).toString();
   const newGitignoreContent = [...gitignoreContent.split("\n"), ...items].join(
     "\n"
   );
-  await fs18.writeFile(path18.join(baseDir, ".gitignore"), newGitignoreContent);
+  await fs19.writeFile(path20.join(baseDir, ".gitignore"), newGitignoreContent);
 };
 var addDependencies = async (config2, env, params) => {
   const { packageManager } = config2;
@@ -7369,22 +7845,22 @@ var writeGeneratedFile = async ({
   content,
   typescript
 }) => {
-  const { exists, path: path20, parentPath } = generatedFile.resolve(typescript);
+  const { exists, path: path22, parentPath } = generatedFile.resolve(typescript);
   if (exists) {
     if (overwrite) {
-      logger.info(`Overwriting file at ${path20}... \u2705`);
-      fs18.outputFileSync(path20, content);
+      logger.info(`Overwriting file at ${path22}... \u2705`);
+      fs19.outputFileSync(path22, content);
     } else {
-      logger.info(`Not overwriting file at ${path20}.`);
+      logger.info(`Not overwriting file at ${path22}.`);
       logger.info(
-        logText(`Please add the following to ${path20}:
+        logText(`Please add the following to ${path22}:
 ${indentText(content)}}`)
       );
     }
   } else {
-    logger.info(`Adding file at ${path20}... \u2705`);
-    await fs18.ensureDir(parentPath);
-    fs18.outputFileSync(path20, content);
+    logger.info(`Adding file at ${path22}... \u2705`);
+    await fs19.ensureDir(parentPath);
+    fs19.outputFileSync(path22, content);
   }
 };
 var addConfigFile = async ({
@@ -7462,7 +7938,7 @@ var addContentFile = async ({
         return () => ({
           exists: env.sampleContentExists,
           path: env.sampleContentPath,
-          parentPath: path18.dirname(env.sampleContentPath)
+          parentPath: path20.dirname(env.sampleContentPath)
         });
       }
     },
@@ -7486,10 +7962,10 @@ ${titleText(" TinaCMS ")} backend initialized!`));
       return `${x.key}=${x.value || "***"}`;
     }).join("\n") + `
 TINA_PUBLIC_IS_LOCAL=true`;
-    const envFile = path18.join(process.cwd(), ".env");
-    if (!fs18.existsSync(envFile)) {
+    const envFile = path20.join(process.cwd(), ".env");
+    if (!fs19.existsSync(envFile)) {
       logger.info(`Adding .env file to your project... \u2705`);
-      fs18.writeFileSync(envFile, envFileText);
+      fs19.writeFileSync(envFile, envFileText);
     } else {
       logger.info(
         "Please add the following environment variables to your .env file"
@@ -7566,7 +8042,7 @@ var addReactiveFile = {
     baseDir,
     dataLayer
   }) => {
-    const packageJsonPath = path18.join(baseDir, "package.json");
+    const packageJsonPath = path20.join(baseDir, "package.json");
     await writeGeneratedFile({
       generatedFile,
       typescript: config2.typescript,
@@ -7579,7 +8055,7 @@ var addReactiveFile = {
       })
     });
     logger.info("Adding a nextjs example... \u2705");
-    const packageJson = JSON.parse(fs18.readFileSync(packageJsonPath).toString());
+    const packageJson = JSON.parse(fs19.readFileSync(packageJsonPath).toString());
     const scripts = packageJson.scripts || {};
     const updatedPackageJson = JSON.stringify(
       {
@@ -7592,15 +8068,15 @@ var addReactiveFile = {
       null,
       2
     );
-    fs18.writeFileSync(packageJsonPath, updatedPackageJson);
+    fs19.writeFileSync(packageJsonPath, updatedPackageJson);
   }
 };
 var updateAstroPackageJson = async ({ baseDir }) => {
-  const packageJsonPath = path18.join(baseDir, "package.json");
-  if (!fs18.existsSync(packageJsonPath)) {
+  const packageJsonPath = path20.join(baseDir, "package.json");
+  if (!fs19.existsSync(packageJsonPath)) {
     return;
   }
-  const packageJson = JSON.parse(fs18.readFileSync(packageJsonPath).toString());
+  const packageJson = JSON.parse(fs19.readFileSync(packageJsonPath).toString());
   const scripts = packageJson.scripts || {};
   const updatedPackageJson = JSON.stringify(
     {
@@ -7610,7 +8086,7 @@ var updateAstroPackageJson = async ({ baseDir }) => {
     null,
     2
   );
-  fs18.writeFileSync(packageJsonPath, updatedPackageJson);
+  fs19.writeFileSync(packageJsonPath, updatedPackageJson);
   logger.info("Updating package.json scripts for Astro... \u2705");
 };
 function execShellCommand(cmd) {
@@ -7810,8 +8286,8 @@ var SearchIndexCommand = class extends Command7 {
 import { Command as Command8, Option as Option8 } from "clipanion";
 
 // src/next/commands/doctor-command/doctor.ts
-import path19 from "path";
-import fs19 from "fs-extra";
+import path21 from "path";
+import fs20 from "fs-extra";
 import yaml3 from "js-yaml";
 var DEPENDENCY_TYPES = [
   "dependencies",
@@ -7826,7 +8302,7 @@ var LOCAL_REFERENCE_PREFIXES = [
   "portal:",
   "workspace:"
 ];
-function isTinaPackage(name2) {
+function isTinaPackage2(name2) {
   return name2 === "tinacms" || name2 === "create-tina-app" || name2.startsWith("@tinacms/") || name2.startsWith("tinacms-") || name2.startsWith("next-tinacms-");
 }
 function getTinaDependencies(packageJson) {
@@ -7835,7 +8311,7 @@ function getTinaDependencies(packageJson) {
     for (const [name2, declared] of Object.entries(
       packageJson[dependencyType] || {}
     )) {
-      if (!isTinaPackage(name2) || dependencies.has(name2)) continue;
+      if (!isTinaPackage2(name2) || dependencies.has(name2)) continue;
       dependencies.set(name2, { name: name2, declared, dependencyType });
     }
   }
@@ -7844,11 +8320,11 @@ function getTinaDependencies(packageJson) {
   );
 }
 async function readProjectPackageJson(rootPath) {
-  const packageJsonPath = path19.join(rootPath, "package.json");
-  if (!await fs19.pathExists(packageJsonPath)) {
+  const packageJsonPath = path21.join(rootPath, "package.json");
+  if (!await fs20.pathExists(packageJsonPath)) {
     throw new Error(`No package.json found at ${packageJsonPath}`);
   }
-  return fs19.readJSON(packageJsonPath);
+  return fs20.readJSON(packageJsonPath);
 }
 async function resolveInstalledVersions({
   rootPath,
@@ -7971,14 +8447,14 @@ function isLocalReference(version2) {
   );
 }
 async function readNodeModulesVersion(rootPath, packageName) {
-  const packageJsonPath = path19.join(
+  const packageJsonPath = path21.join(
     rootPath,
     "node_modules",
     ...packageName.split("/"),
     "package.json"
   );
-  if (!await fs19.pathExists(packageJsonPath)) return void 0;
-  const packageJson = await fs19.readJSON(packageJsonPath);
+  if (!await fs20.pathExists(packageJsonPath)) return void 0;
+  const packageJson = await fs20.readJSON(packageJsonPath);
   return typeof packageJson.version === "string" ? packageJson.version : void 0;
 }
 async function readLockfileVersions(rootPath) {
@@ -7994,54 +8470,54 @@ async function readLockfileVersions(rootPath) {
   return /* @__PURE__ */ new Map();
 }
 async function readPackageLockVersions(rootPath) {
-  const lockfilePath = path19.join(rootPath, "package-lock.json");
+  const lockfilePath = path21.join(rootPath, "package-lock.json");
   const versions = /* @__PURE__ */ new Map();
-  if (!await fs19.pathExists(lockfilePath)) return versions;
-  const lockfile = await fs19.readJSON(lockfilePath);
+  if (!await fs20.pathExists(lockfilePath)) return versions;
+  const lockfile = await fs20.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") {
+    if (isTinaPackage2(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") {
+    if (isTinaPackage2(name2) && typeof version2 === "string") {
       versions.set(name2, version2);
     }
   }
   return versions;
 }
 async function readPnpmLockVersions(rootPath) {
-  const lockfilePath = path19.join(rootPath, "pnpm-lock.yaml");
+  const lockfilePath = path21.join(rootPath, "pnpm-lock.yaml");
   const versions = /* @__PURE__ */ new Map();
-  if (!await fs19.pathExists(lockfilePath)) return versions;
-  const lockfile = yaml3.load(await fs19.readFile(lockfilePath, "utf8"));
+  if (!await fs20.pathExists(lockfilePath)) return versions;
+  const lockfile = yaml3.load(await fs20.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;
+      if (!isTinaPackage2(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)) {
+    if (parsed && isTinaPackage2(parsed.name) && !versions.has(parsed.name)) {
       versions.set(parsed.name, parsed.version);
     }
   }
   return versions;
 }
 async function readYarnLockVersions(rootPath) {
-  const lockfilePath = path19.join(rootPath, "yarn.lock");
+  const lockfilePath = path21.join(rootPath, "yarn.lock");
   const versions = /* @__PURE__ */ new Map();
-  if (!await fs19.pathExists(lockfilePath)) return versions;
-  const contents = await fs19.readFile(lockfilePath, "utf8");
+  if (!await fs20.pathExists(lockfilePath)) return versions;
+  const contents = await fs20.readFile(lockfilePath, "utf8");
   if (contents.includes("__metadata:")) {
     return readYarnBerryLockVersions(contents);
   }
@@ -8055,7 +8531,7 @@ async function readYarnLockVersions(rootPath) {
     const version2 = line.match(/^\s+version\s+"([^"]+)"/)?.[1];
     if (!version2) continue;
     for (const name2 of activeNames) {
-      if (isTinaPackage(name2) && !versions.has(name2)) {
+      if (isTinaPackage2(name2) && !versions.has(name2)) {
         versions.set(name2, version2);
       }
     }
@@ -8069,7 +8545,7 @@ function readYarnBerryLockVersions(contents) {
     if (descriptor === "__metadata") continue;
     const name2 = extractYarnBerryPackageName(descriptor);
     const version2 = getYarnBerryInstalledVersion(descriptor, value?.version);
-    if (name2 && isTinaPackage(name2) && version2) {
+    if (name2 && isTinaPackage2(name2) && version2) {
       versions.set(name2, version2);
     }
   }