@anvil-works/anvil-cli 0.7.0-canary.9 → 0.7.1

package/dist/index.js

@@ -7371,6 +7371,7 @@ var __webpack_exports__ = {};
         setConfig: ()=>setConfig,
         getAccountsForUrl: ()=>auth_getAccountsForUrl,
         AppIdWithContext: ()=>anvil_api_namespaceObject.AppIdWithContext,
+        inspectCredentialHelperCommand: ()=>inspectCredentialHelperCommand,
         executeCheckout: ()=>executeCheckout,
         validateCheckoutDestination: ()=>validateCheckoutDestination,
         DeviceAuthorizationResponse: ()=>oauth_login_namespaceObject.DeviceAuthorizationResponse,
@@ -7386,7 +7387,9 @@ var __webpack_exports__ = {};
         verifyAndStoreTokens: ()=>auth_verifyAndStoreTokens,
         formatValidationPath: ()=>formatValidationPath,
         resolveAnvilUrl: ()=>resolveAnvilUrl,
+        buildGitAuthDoctorReport: ()=>buildGitAuthDoctorReport,
         parseCheckoutInput: ()=>parseCheckoutInput,
+        formatGitAuthDoctorReport: ()=>formatGitAuthDoctorReport,
         resetConfig: ()=>resetConfig,
         FormTemplateValidationResult: ()=>validators_namespaceObject.FormTemplateValidationResult,
         createWatchDiagnostic: ()=>createWatchDiagnostic,
@@ -7400,6 +7403,7 @@ var __webpack_exports__ = {};
         CheckoutAppListItem: ()=>anvil_api_namespaceObject.CheckoutAppListItem,
         getConfig: ()=>config_getConfig,
         CheckoutExecutionDeps: ()=>checkout_namespaceObject.CheckoutExecutionDeps,
+        validateFormTemplateHtml: ()=>validateFormTemplateHtml,
         ValidateBranchSyncStatusOptions: ()=>validation_namespaceObject.ValidateBranchSyncStatusOptions,
         BranchSyncStatus: ()=>validation_namespaceObject.BranchSyncStatus,
         getLatestVersion: ()=>getLatestVersion,
@@ -7449,6 +7453,7 @@ var __webpack_exports__ = {};
         executeGitCredentialOperation: ()=>executeGitCredentialOperation,
         CheckoutResult: ()=>checkout_namespaceObject.CheckoutResult,
         ParsedCheckoutInput: ()=>checkout_namespaceObject.ParsedCheckoutInput,
+        parseCredentialHelperCommand: ()=>parseCredentialHelperCommand,
         clearInMemoryTokens: ()=>clearInMemoryTokens,
         getDefaultDestinationDirectory: ()=>getDefaultDestinationDirectory,
         lookupByCommit: ()=>lookupByCommit,
@@ -13693,7 +13698,7 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
     }
     function getCredentialHelperModulePath(options) {
         const currentModulePath = options?.currentModulePath ?? __filename;
-        if (isAnvilCliPackageFile(currentModulePath)) return currentModulePath;
+        if (isAnvilCliPackageFile(currentModulePath) && "cli.js" !== external_path_default().basename(currentModulePath)) return currentModulePath;
         return (options?.resolvePackageEntry ?? (()=>requireFromHere.resolve("@anvil-works/anvil-cli")))();
     }
     async function getRepositoryGitDir(repoPath, git = esm_default(repoPath)) {
@@ -13880,6 +13885,7 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
     function auth_setRepoContext(repoPath) {
         repoContext = repoPath;
     }
+    const inFlightRefreshes = new Map();
     async function auth_verifyAuth(authToken, anvilUrl = getDefaultAnvilUrl()) {
         try {
             const resp = await fetch(`${anvilUrl}/ide/api/_/user`, {
@@ -13933,53 +13939,91 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
     }
     async function auth_getValidAuthToken(anvilUrl = getDefaultAnvilUrl(), username) {
         const normalized = config_normalizeAnvilUrl(anvilUrl);
-        let tokens;
-        let repoAuth;
-        if (inMemoryAuth && authMatches(inMemoryAuth, normalized, username)) tokens = inMemoryAuth.tokens;
-        else {
-            repoAuth = repoContext ? await readAuthFromRepo(repoContext) : void 0;
-            tokens = repoAuth && authMatches(repoAuth, normalized, username) ? repoAuth.tokens : getTokensAutoSelect(normalized, username);
-        }
+        const source = await resolveTokenSource(normalized, username);
+        const tokens = getSourceTokens(source);
         if (!tokens.authToken && !tokens.refreshToken) throw createAuthError.required("Not logged in. Please log in first.");
         const isExpired = null !== tokens.authTokenExpiresAt && tokens.authTokenExpiresAt <= Math.floor(Date.now() / 1000) + 60;
-        if (tokens.refreshToken && isExpired) try {
+        if (tokens.refreshToken && isExpired) {
+            const refreshKey = getRefreshKey(normalized, username, source, tokens.refreshToken);
+            const existingRefresh = inFlightRefreshes.get(refreshKey);
+            if (existingRefresh) return existingRefresh;
+            const refreshPromise = refreshAndStoreAccessToken(normalized, username, source, tokens.refreshToken).finally(()=>{
+                inFlightRefreshes.delete(refreshKey);
+            });
+            inFlightRefreshes.set(refreshKey, refreshPromise);
+            return refreshPromise;
+        }
+        if (tokens.authToken) return tokens.authToken;
+        throw createAuthError.required("No valid token available");
+    }
+    async function resolveTokenSource(normalizedUrl, username) {
+        if (inMemoryAuth && authMatches(inMemoryAuth, normalizedUrl, username)) return {
+            type: "memory",
+            auth: inMemoryAuth
+        };
+        const repoAuth = repoContext ? await readAuthFromRepo(repoContext) : void 0;
+        if (repoAuth && authMatches(repoAuth, normalizedUrl, username)) return {
+            type: "repo",
+            auth: repoAuth,
+            repoPath: repoContext
+        };
+        const tokens = getTokensAutoSelect(normalizedUrl, username);
+        return {
+            type: "store",
+            tokens,
+            accountUsername: getStoreAccountUsername(normalizedUrl, username, tokens.refreshToken ?? void 0)
+        };
+    }
+    function getSourceTokens(source) {
+        return "store" === source.type ? source.tokens : source.auth.tokens;
+    }
+    function getStoreAccountUsername(normalizedUrl, username, refreshToken) {
+        if (username) return username;
+        const urlTokens = getUrlTokens(normalizedUrl);
+        if (!urlTokens) return;
+        const accounts = Object.keys(urlTokens);
+        if (1 === accounts.length) return accounts[0];
+        return refreshToken ? findAccountByRefreshToken(normalizedUrl, refreshToken) : void 0;
+    }
+    function getRefreshKey(normalizedUrl, username, source, refreshToken) {
+        switch(source.type){
+            case "memory":
+                return `memory:${normalizedUrl}:${source.auth.username}`;
+            case "repo":
+                return `repo:${source.repoPath}:${normalizedUrl}:${source.auth.username}`;
+            case "store":
+                return `store:${normalizedUrl}:${source.accountUsername ?? username ?? refreshToken}`;
+        }
+    }
+    async function refreshAndStoreAccessToken(normalizedUrl, username, source, refreshToken) {
+        try {
+            const tokens = getSourceTokens(source);
             const clientId = tokens.clientId ?? ANVIL_SYNC_CLIENT_ID;
-            const tokenData = await refreshAccessToken(tokens.refreshToken, normalized, clientId);
-            const newExpiresAt = Math.floor(Date.now() / 1000) + tokenData.expires_in;
+            const tokenData = await refreshAccessToken(refreshToken, normalizedUrl, clientId);
             const newTokens = {
                 authToken: tokenData.access_token,
                 refreshToken: tokenData.refresh_token,
-                authTokenExpiresAt: newExpiresAt,
+                authTokenExpiresAt: Math.floor(Date.now() / 1000) + tokenData.expires_in,
                 clientId
             };
-            if (inMemoryAuth) inMemoryAuth.tokens = newTokens;
-            else if (repoAuth) {
+            if ("memory" === source.type) source.auth.tokens = newTokens;
+            else if ("repo" === source.type) {
                 const encryptionKey = process.env["ANVIL_AUTH_FILE_ENCRYPTION_KEY"];
                 if (!encryptionKey) throw createAuthError.required("Cannot refresh repo auth without ANVIL_AUTH_FILE_ENCRYPTION_KEY.");
-                repoAuth.tokens = newTokens;
-                await writeAuthToFile(repoContext, repoAuth, encryptionKey);
+                source.auth.tokens = newTokens;
+                await writeAuthToFile(source.repoPath, source.auth, encryptionKey);
             } else {
-                let accountUsername = username;
-                if (!accountUsername) {
-                    const urlTokens = getUrlTokens(normalized);
-                    if (urlTokens) {
-                        const accounts = Object.keys(urlTokens);
-                        accountUsername = 1 === accounts.length ? accounts[0] : findAccountByRefreshToken(normalized, tokens.refreshToken);
-                    }
-                }
-                if (!accountUsername) {
-                    await clearTokensForAccount(normalized, username, tokens.refreshToken);
+                if (!source.accountUsername) {
+                    await clearTokensForAccount(normalizedUrl, username, refreshToken);
                     throw createAuthError.required("Cannot determine which account to refresh. Please log in again.");
                 }
-                setAccountTokens(normalized, accountUsername, newTokens);
+                setAccountTokens(normalizedUrl, source.accountUsername, newTokens);
             }
             return tokenData.access_token;
         } catch (e) {
-            await clearTokensForAccount(normalized, username, tokens.refreshToken);
+            await clearTokensForAccount(normalizedUrl, username, refreshToken);
             throw e;
         }
-        if (tokens.authToken) return tokens.authToken;
-        throw createAuthError.required("No valid token available");
     }
     async function clearTokensForAccount(url, username, refreshToken) {
         if (inMemoryAuth || repoContext && await readAuthFromRepo(repoContext)) return;
@@ -14309,6 +14353,324 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
         } catch (_e) {}
         return out;
     }
+    const promises_namespaceObject = require("fs/promises");
+    var promises_default = /*#__PURE__*/ __webpack_require__.n(promises_namespaceObject);
+    function normalizeLineEndings(content) {
+        return content.replace(/\r\n/g, "\n");
+    }
+    function pythonifyName(name) {
+        return name.replace(/[^A-z0-9]/g, "_").replace(/^[0-9]/, "_$&");
+    }
+    function extractPythonName(relativePath, skipParts = 1) {
+        const parts = relativePath.slice(0, -3).split("/");
+        const isPackage = relativePath.endsWith("__init__.py");
+        const relevantParts = isPackage ? parts.slice(skipParts, -1) : parts.slice(skipParts);
+        return relevantParts.map(pythonifyName).join(".");
+    }
+    function deepEqual(a, b) {
+        if (a === b) return true;
+        if (null == a || null == b) return false;
+        if (typeof a !== typeof b) return false;
+        if ("object" != typeof a) return a === b;
+        if (Array.isArray(a) !== Array.isArray(b)) return false;
+        if (Array.isArray(a)) {
+            if (a.length !== b.length) return false;
+            return a.every((item, index)=>deepEqual(item, b[index]));
+        }
+        const keysA = Object.keys(a);
+        const keysB = Object.keys(b);
+        if (keysA.length !== keysB.length) return false;
+        return keysA.every((key)=>deepEqual(a[key], b[key]));
+    }
+    function parseHtmlWithFrontmatter(htmlContent) {
+        const frontmatterPattern = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
+        const match = htmlContent.match(frontmatterPattern);
+        if (match) {
+            const yamlStr = match[1];
+            const html = match[2];
+            const frontmatter = yamlStr ? external_js_yaml_default().load(yamlStr) ?? {} : {};
+            return {
+                frontmatter,
+                html
+            };
+        }
+        return {
+            frontmatter: {},
+            html: htmlContent
+        };
+    }
+    const ANVIL_GITIGNORE_ENTRY = "/.anvil/";
+    async function ensureProjectGitignoreIgnoresAnvilDir(projectRoot) {
+        const rootGitignorePath = external_path_default().join(projectRoot, ".gitignore");
+        try {
+            const existing = await external_fs_.promises.readFile(rootGitignorePath, "utf8");
+            if (existing.includes(ANVIL_GITIGNORE_ENTRY)) return false;
+            const prefix = existing.endsWith("\n") || 0 === existing.length ? "" : "\n";
+            await external_fs_.promises.writeFile(rootGitignorePath, `${existing}${prefix}${ANVIL_GITIGNORE_ENTRY}\n`, "utf8");
+            return true;
+        } catch (error) {
+            if ("ENOENT" !== error.code) throw error;
+            await external_fs_.promises.writeFile(rootGitignorePath, `${ANVIL_GITIGNORE_ENTRY}\n`, "utf8");
+            return true;
+        }
+    }
+    const ANVIL_DEPS_DIR = ".anvil/deps";
+    const ANVIL_DEPS_MANIFEST = "manifest.json";
+    const DEPS_MANIFEST_VERSION = 1;
+    function formatFetchError(prefix, status, errorBody) {
+        if (!errorBody) return `${prefix}: ${status}`;
+        try {
+            const parsed = JSON.parse(errorBody);
+            if ("string" == typeof parsed.error && parsed.error.trim()) return `${prefix}: ${parsed.error} (${status})`;
+        } catch  {}
+        return `${prefix}: ${status} ${errorBody}`;
+    }
+    async function fetchAllDependencies(appId, anvilUrl = resolveAnvilUrl(), options = {}) {
+        const { commit, includeDocs = true, knownDependencies = [] } = options;
+        const token = await auth_getValidAuthToken(anvilUrl);
+        const body = {
+            include_docs: includeDocs,
+            known_dependencies: knownDependencies
+        };
+        if (commit) body.commit = commit;
+        const resp = await fetch(`${anvilUrl}/ide/api/_/apps/${appId}/resolved-dependencies`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${token}`,
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify(body)
+        });
+        if (!resp.ok) {
+            const errorBody = await resp.text();
+            throw new Error(formatFetchError("Failed to fetch dependencies", resp.status, errorBody));
+        }
+        return await resp.json();
+    }
+    async function refreshDependencyCache(projectRoot, appId, anvilUrl = resolveAnvilUrl(), options = {}) {
+        const includeDocs = options.includeDocs ?? true;
+        const knownDependencies = await getKnownDependenciesForCache(projectRoot, includeDocs);
+        const response = await fetchAllDependencies(appId, anvilUrl, {
+            commit: options.commit,
+            includeDocs,
+            knownDependencies
+        });
+        if (!response.resolved_dependencies.length) {
+            await clearDepsCache(projectRoot);
+            return {
+                response,
+                addedGitignoreEntry: false
+            };
+        }
+        const addedGitignoreEntry = await ensureProjectGitignoreIgnoresAnvilDir(projectRoot);
+        await writeAllDepsToCache(projectRoot, response, {
+            includeDocs
+        });
+        return {
+            response,
+            addedGitignoreEntry
+        };
+    }
+    function depsDir(projectRoot) {
+        return external_path_default().join(projectRoot, ANVIL_DEPS_DIR);
+    }
+    function depsManifestPath(projectRoot) {
+        return external_path_default().join(depsDir(projectRoot), ANVIL_DEPS_MANIFEST);
+    }
+    function isResolvedDependencyManifestEntry(value) {
+        if (!value || "object" != typeof value) return false;
+        const entry = value;
+        return "string" == typeof entry.app_id && entry.app_id.length > 0 && "string" == typeof entry.commit_id && entry.commit_id.length > 0 && (void 0 === entry.branch || "string" == typeof entry.branch);
+    }
+    function isCachedDependencyManifestEntry(value) {
+        if (!isResolvedDependencyManifestEntry(value)) return false;
+        const entry = value;
+        return "string" == typeof entry.package_name && entry.package_name.length > 0;
+    }
+    function isDepsCacheManifest(value) {
+        if (!value || "object" != typeof value) return false;
+        const manifest = value;
+        return manifest.version === DEPS_MANIFEST_VERSION && "boolean" == typeof manifest.includeDocs && Array.isArray(manifest.resolved_dependencies) && manifest.resolved_dependencies.every(isResolvedDependencyManifestEntry) && Array.isArray(manifest.cached_dependencies) && manifest.cached_dependencies.every(isCachedDependencyManifestEntry);
+    }
+    async function readDepsCacheManifest(projectRoot) {
+        try {
+            const raw = await promises_default().readFile(depsManifestPath(projectRoot), "utf-8");
+            const parsed = JSON.parse(raw);
+            return isDepsCacheManifest(parsed) ? parsed : void 0;
+        } catch  {
+            return;
+        }
+    }
+    async function getKnownDependenciesForCache(projectRoot, includeDocs) {
+        const manifest = await readDepsCacheManifest(projectRoot);
+        if (!manifest || manifest.includeDocs !== includeDocs) return [];
+        return manifest.resolved_dependencies.map(({ app_id, commit_id })=>({
+                app_id,
+                commit_id
+            }));
+    }
+    function getDependencyWatchSubscriptionsFromManifest(manifest) {
+        if (!manifest) return [];
+        const cachedByAppId = new Map(manifest.cached_dependencies.map((dep)=>[
+                dep.app_id,
+                dep
+            ]));
+        return manifest.resolved_dependencies.flatMap((dep)=>{
+            if (!dep.branch) return [];
+            return [
+                {
+                    appId: dep.app_id,
+                    branch: dep.branch,
+                    packageName: cachedByAppId.get(dep.app_id)?.package_name
+                }
+            ];
+        });
+    }
+    function normalizeAnvilYamlDependenciesFromContent(content) {
+        const parsed = external_js_yaml_default().load(content);
+        if (!parsed || "object" != typeof parsed || !Array.isArray(parsed.dependencies)) return [];
+        return normalizeAnvilYamlDependenciesValue(parsed.dependencies);
+    }
+    function normalizeAnvilYamlDependenciesValue(value) {
+        if (!Array.isArray(value)) return [];
+        return normalizeForComparison(value);
+    }
+    async function readAnvilYamlDependencies(projectRoot) {
+        try {
+            const content = await promises_default().readFile(external_path_default().join(projectRoot, "anvil.yaml"), "utf-8");
+            return normalizeAnvilYamlDependenciesFromContent(content);
+        } catch  {
+            return [];
+        }
+    }
+    function anvilYamlDependenciesEqual(left, right) {
+        return deepEqual(left, right);
+    }
+    function normalizeForComparison(value) {
+        if (Array.isArray(value)) return value.map(normalizeForComparison);
+        if (value && "object" == typeof value) return Object.fromEntries(Object.entries(value).sort(([left], [right])=>left.localeCompare(right)).map(([key, entryValue])=>[
+                key,
+                normalizeForComparison(entryValue)
+            ]));
+        return value;
+    }
+    function cachedManifestEntry(dep, packageName) {
+        return {
+            app_id: dep.app_id,
+            commit_id: dep.commit_id,
+            ...dep.branch ? {
+                branch: dep.branch
+            } : {},
+            package_name: packageName
+        };
+    }
+    function safeDependencyPath(filePath, kind) {
+        const normalizedPath = external_path_default().normalize(filePath);
+        if (external_path_default().isAbsolute(normalizedPath) || normalizedPath.startsWith("..")) throw new Error(`Invalid dependency ${kind} path: ${filePath}`);
+        return normalizedPath;
+    }
+    async function writeDepToCache(projectRoot, dep) {
+        const depDir = external_path_default().join(projectRoot, ANVIL_DEPS_DIR, dep.package_name);
+        await promises_default().rm(depDir, {
+            recursive: true,
+            force: true
+        });
+        await promises_default().mkdir(external_path_default().join(depDir, "client_code"), {
+            recursive: true
+        });
+        await promises_default().mkdir(external_path_default().join(depDir, "server_code"), {
+            recursive: true
+        });
+        await promises_default().writeFile(external_path_default().join(depDir, "anvil.yaml"), external_js_yaml_default().dump({
+            package_name: dep.package_name
+        }));
+        for (const mod of dep.modules ?? [])if (mod.is_package) {
+            const modDir = external_path_default().join(depDir, "client_code", mod.name);
+            await promises_default().mkdir(modDir, {
+                recursive: true
+            });
+            await promises_default().writeFile(external_path_default().join(modDir, "__init__.py"), mod.code);
+        } else await promises_default().writeFile(external_path_default().join(depDir, "client_code", `${mod.name}.py`), mod.code);
+        for (const form of dep.forms ?? []){
+            const { code, class_name, is_package, ...formTemplate } = form;
+            if (is_package) {
+                const formDir = external_path_default().join(depDir, "client_code", class_name);
+                await promises_default().mkdir(formDir, {
+                    recursive: true
+                });
+                await promises_default().writeFile(external_path_default().join(formDir, "__init__.py"), code);
+                await promises_default().writeFile(external_path_default().join(formDir, "form_template.yaml"), external_js_yaml_default().dump(formTemplate));
+            } else {
+                await promises_default().writeFile(external_path_default().join(depDir, "client_code", `${class_name}.py`), code);
+                await promises_default().writeFile(external_path_default().join(depDir, "client_code", `${class_name}.yaml`), external_js_yaml_default().dump(formTemplate));
+            }
+        }
+        for (const mod of dep.server_modules ?? [])if (mod.is_package) {
+            const modDir = external_path_default().join(depDir, "server_code", mod.name);
+            await promises_default().mkdir(modDir, {
+                recursive: true
+            });
+            await promises_default().writeFile(external_path_default().join(modDir, "__init__.py"), mod.code);
+        } else await promises_default().writeFile(external_path_default().join(depDir, "server_code", `${mod.name}.py`), mod.code);
+        for (const asset of dep.assets ?? []){
+            const targetPath = external_path_default().join(depDir, "theme", "assets", safeDependencyPath(asset.name, "asset"));
+            await promises_default().mkdir(external_path_default().dirname(targetPath), {
+                recursive: true
+            });
+            await promises_default().writeFile(targetPath, Buffer.from(asset.content, "base64"));
+        }
+        for (const doc of dep.docs ?? []){
+            const targetPath = external_path_default().join(depDir, safeDependencyPath(doc.path, "doc"));
+            await promises_default().mkdir(external_path_default().dirname(targetPath), {
+                recursive: true
+            });
+            await promises_default().writeFile(targetPath, doc.content);
+        }
+    }
+    async function writeAllDepsToCache(projectRoot, response, options = {}) {
+        const includeDocs = options.includeDocs ?? true;
+        const manifest = await readDepsCacheManifest(projectRoot);
+        const canReuseExistingCache = manifest?.includeDocs === includeDocs;
+        if (!canReuseExistingCache) await clearDepsCache(projectRoot);
+        const previousCached = canReuseExistingCache ? manifest.cached_dependencies : [];
+        const resolvedAppIds = new Set(response.resolved_dependencies.map((dep)=>dep.app_id));
+        for (const dep of previousCached)if (!resolvedAppIds.has(dep.app_id)) await promises_default().rm(external_path_default().join(projectRoot, ANVIL_DEPS_DIR, dep.package_name), {
+            recursive: true,
+            force: true
+        });
+        for (const dep of response.dependencies)await writeDepToCache(projectRoot, dep);
+        const returnedByAppId = new Map(response.dependencies.map((dep)=>[
+                dep.app_id,
+                dep
+            ]));
+        const previousByAppId = new Map(previousCached.map((dep)=>[
+                dep.app_id,
+                dep
+            ]));
+        const cachedDependencies = response.resolved_dependencies.map((dep)=>{
+            const returned = returnedByAppId.get(dep.app_id);
+            if (returned) return cachedManifestEntry(returned, returned.package_name);
+            const previous = previousByAppId.get(dep.app_id);
+            if (!previous) return;
+            return cachedManifestEntry(dep, previous.package_name);
+        }).filter((dep)=>void 0 !== dep);
+        const newManifest = {
+            version: DEPS_MANIFEST_VERSION,
+            includeDocs,
+            resolved_dependencies: response.resolved_dependencies,
+            cached_dependencies: cachedDependencies
+        };
+        await promises_default().mkdir(depsDir(projectRoot), {
+            recursive: true
+        });
+        await promises_default().writeFile(depsManifestPath(projectRoot), `${JSON.stringify(newManifest, null, 2)}\n`);
+    }
+    async function clearDepsCache(projectRoot) {
+        await promises_default().rm(depsDir(projectRoot), {
+            recursive: true,
+            force: true
+        });
+    }
     class git_GitService {
         git;
         repoPath;
@@ -14395,6 +14757,77 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
                 throw errors_createGitError.commandFailed("status", e.message);
             }
         }
+        async discardModeOnlyChanges(paths) {
+            const discarded = [];
+            for (const relativePath of paths)try {
+                const headMode = await this.getHeadFileMode(relativePath);
+                if ("100644" !== headMode && "100755" !== headMode) continue;
+                const contentUnchanged = await this.hasSameContentAsHead(relativePath);
+                if (!contentUnchanged) continue;
+                await this.restoreExecutableBit(relativePath, "100755" === headMode);
+                discarded.push(relativePath);
+            } catch (e) {
+                throw errors_createGitError.commandFailed("discard mode-only changes", e.message);
+            }
+            return discarded;
+        }
+        async discardStagedModeOnlyChanges(paths) {
+            const discarded = [];
+            for (const relativePath of paths)try {
+                const headMode = await this.getHeadFileMode(relativePath);
+                if ("100644" !== headMode && "100755" !== headMode) continue;
+                const indexContentUnchanged = await this.hasSameIndexContentAsHead(relativePath);
+                if (!indexContentUnchanged) continue;
+                await this.git.raw([
+                    "reset",
+                    "-q",
+                    "HEAD",
+                    "--",
+                    relativePath
+                ]);
+                await this.restoreExecutableBit(relativePath, "100755" === headMode);
+                discarded.push(relativePath);
+            } catch (e) {
+                throw errors_createGitError.commandFailed("discard staged mode-only changes", e.message);
+            }
+            return discarded;
+        }
+        async getHeadFileMode(relativePath) {
+            const output = await this.git.raw([
+                "ls-tree",
+                "HEAD",
+                "--",
+                relativePath
+            ]);
+            const match = output.match(/^(\d{6})\s/);
+            return match?.[1] ?? null;
+        }
+        async hasSameContentAsHead(relativePath) {
+            const headHash = (await this.git.revparse([
+                `HEAD:${relativePath}`
+            ])).trim();
+            const worktreeHash = (await this.git.raw([
+                "hash-object",
+                "--",
+                relativePath
+            ])).trim();
+            return headHash === worktreeHash;
+        }
+        async hasSameIndexContentAsHead(relativePath) {
+            const headHash = (await this.git.revparse([
+                `HEAD:${relativePath}`
+            ])).trim();
+            const indexHash = (await this.git.revparse([
+                `:${relativePath}`
+            ])).trim();
+            return headHash === indexHash;
+        }
+        async restoreExecutableBit(relativePath, executable) {
+            const filePath = external_path_default().join(this.repoPath, relativePath);
+            const stat = await external_fs_.promises.stat(filePath);
+            const mode = executable ? 73 | stat.mode : -74 & stat.mode;
+            if ((511 & stat.mode) !== (511 & mode)) await external_fs_.promises.chmod(filePath, mode);
+        }
         async hasUncommittedChanges() {
             const status = await this.getStatus();
             return !status.isClean;
@@ -14534,6 +14967,32 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
                 throw errors_createGitError.commandFailed("rebase --abort", e.message);
             }
         }
+        async isAncestor(ancestorRef, descendantRef) {
+            try {
+                const mergeBase = (await this.git.raw([
+                    "merge-base",
+                    ancestorRef,
+                    descendantRef
+                ])).trim();
+                const ancestorCommit = (await this.git.revparse([
+                    ancestorRef
+                ])).trim();
+                return mergeBase === ancestorCommit;
+            } catch  {
+                return false;
+            }
+        }
+        async mergeFastForward(ref) {
+            try {
+                await this.git.raw([
+                    "merge",
+                    "--ff-only",
+                    ref
+                ]);
+            } catch (e) {
+                throw errors_createGitError.commandFailed("merge --ff-only", e.message);
+            }
+        }
         async deleteRef(ref) {
             try {
                 await this.git.raw([
@@ -14578,11 +15037,12 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
             } catch (error) {}
         }
     }
-    async function getStagedFileChanges(git) {
+    async function getStagedFileChanges(git, gitService) {
         try {
             const status = await git.status();
             const renames = status.renamed || [];
             const stagedFiles = status.files.filter((f)=>" " !== f.index && "?" !== f.index);
+            const stagedModeOnlyPaths = new Set(gitService ? await gitService.discardStagedModeOnlyChanges(stagedFiles.filter((f)=>"R" !== f.index && "D" !== f.index).map((f)=>f.path)) : []);
             const stagedRenames = [];
             for (const f of stagedFiles)if ("R" === f.index) {
                 const rename = renames.find((r)=>r.to === f.path);
@@ -14595,19 +15055,23 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
             const stagedRenamedFromPaths = new Set(stagedRenames.map((r)=>r.from));
             const stagedRenamedToPaths = new Set(stagedRenames.map((r)=>r.path));
             const changes = [];
-            for (const f of stagedFiles)if ("R" !== f.index) {
-                if (!(stagedRenamedFromPaths.has(f.path) || stagedRenamedToPaths.has(f.path))) if ("D" === f.index) changes.push({
-                    path: f.path,
-                    type: "unlink"
-                });
-                else if ("A" === f.index || "?" === f.index) changes.push({
-                    path: f.path,
-                    type: "add"
-                });
-                else changes.push({
-                    path: f.path,
-                    type: "change"
-                });
+            for (const f of stagedFiles){
+                if ("R" !== f.index) {
+                    if (!stagedModeOnlyPaths.has(f.path)) {
+                        if (!(stagedRenamedFromPaths.has(f.path) || stagedRenamedToPaths.has(f.path))) if ("D" === f.index) changes.push({
+                            path: f.path,
+                            type: "unlink"
+                        });
+                        else if ("A" === f.index || "?" === f.index) changes.push({
+                            path: f.path,
+                            type: "add"
+                        });
+                        else changes.push({
+                            path: f.path,
+                            type: "change"
+                        });
+                    }
+                }
             }
             changes.push(...stagedRenames);
             return changes;
@@ -14615,50 +15079,6 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
             throw errors_createGitError.commandFailed("status", e.message);
         }
     }
-    function normalizeLineEndings(content) {
-        return content.replace(/\r\n/g, "\n");
-    }
-    function pythonifyName(name) {
-        return name.replace(/[^A-z0-9]/g, "_").replace(/^[0-9]/, "_$&");
-    }
-    function extractPythonName(relativePath, skipParts = 1) {
-        const parts = relativePath.slice(0, -3).split("/");
-        const isPackage = relativePath.endsWith("__init__.py");
-        const relevantParts = isPackage ? parts.slice(skipParts, -1) : parts.slice(skipParts);
-        return relevantParts.map(pythonifyName).join(".");
-    }
-    function deepEqual(a, b) {
-        if (a === b) return true;
-        if (null == a || null == b) return false;
-        if (typeof a !== typeof b) return false;
-        if ("object" != typeof a) return a === b;
-        if (Array.isArray(a) !== Array.isArray(b)) return false;
-        if (Array.isArray(a)) {
-            if (a.length !== b.length) return false;
-            return a.every((item, index)=>deepEqual(item, b[index]));
-        }
-        const keysA = Object.keys(a);
-        const keysB = Object.keys(b);
-        if (keysA.length !== keysB.length) return false;
-        return keysA.every((key)=>deepEqual(a[key], b[key]));
-    }
-    function parseHtmlWithFrontmatter(htmlContent) {
-        const frontmatterPattern = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
-        const match = htmlContent.match(frontmatterPattern);
-        if (match) {
-            const yamlStr = match[1];
-            const html = match[2];
-            const frontmatter = yamlStr ? external_js_yaml_default().load(yamlStr) ?? {} : {};
-            return {
-                frontmatter,
-                html
-            };
-        }
-        return {
-            frontmatter: {},
-            html: htmlContent
-        };
-    }
     const external_chokidar_namespaceObject = require("chokidar");
     var external_chokidar_default = /*#__PURE__*/ __webpack_require__.n(external_chokidar_namespaceObject);
     class FileWatcher extends Emitter {
@@ -14808,6 +15228,12 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
         editSession;
         username;
         environment;
+        dependencyWatchEnabled;
+        dependencySubscriptions;
+        activeDependencySubscriptions = new Map();
+        watchedPrimaryBranch = null;
+        nextSubscriptionId = 1;
+        pendingDependencySubscriptionById = new Map();
         reconnectAttempts = 0;
         connectAttempts = 0;
         reconnectTimer = null;
@@ -14830,6 +15256,8 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
             this.editSession = options.editSession;
             this.username = options.username;
             this.environment = options.environment;
+            this.dependencyWatchEnabled = options.dependencyWatch ?? true;
+            this.dependencySubscriptions = dedupeDependencySubscriptions(options.dependencySubscriptions ?? []);
             this.sessionId = Math.random().toString(36).substring(2, 10);
             this.reconnectDelayMs = this.RECONNECT_DELAY_BASE_MS;
         }
@@ -14855,6 +15283,9 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
                 const subscribeMsg = this.buildSubscribeMessage(this.currentBranch);
                 logger_logger.debug(`[WebSocket ${this.sessionId}]`, `Subscribing: ${JSON.stringify(subscribeMsg)}`);
                 this.ws?.send(JSON.stringify(subscribeMsg));
+                this.watchedPrimaryBranch = this.currentBranch;
+                this.activeDependencySubscriptions.clear();
+                this.subscribeToDependencies();
                 this.emit("connected", void 0);
             });
             this.ws.on("unexpected-response", (request, response)=>{
@@ -14877,6 +15308,7 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
                 try {
                     const msg = JSON.parse(data.toString());
                     logger_logger.debug(`[WebSocket ${this.sessionId}]`, `Message: ${JSON.stringify(msg)}`);
+                    this.handleDependencySubscriptionReply(msg);
                     this.handleMessage(msg);
                 } catch (error) {
                     logger_logger.error(external_chalk_default().red(`Failed to parse WebSocket message: ${error.message}`));
@@ -14927,7 +15359,9 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
                 if (!ref_update) return void logger_logger.debug("Ignoring REPO_UPDATE with no ref_update");
                 const { ref } = ref_update;
                 const commitHash = "string" == typeof commit ? commit : commit?.v;
+                const appId = this.getMessageAppId(msg);
                 this.emit("repo-update", {
+                    appId,
                     ref,
                     commitHash: commitHash || "unknown",
                     saveSeq: ref_update?.["save-seq"]
@@ -14942,11 +15376,26 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
         }
         updateBranch(branch) {
             this.currentBranch = branch;
-            if (this.ws?.readyState === external_ws_default().OPEN) this.ws.send(JSON.stringify(this.buildSubscribeMessage(branch)));
+            if (this.ws?.readyState === external_ws_default().OPEN) {
+                this.ws.send(JSON.stringify(this.buildSubscribeMessage(branch)));
+                this.watchedPrimaryBranch = branch;
+                this.subscribeToDependencies();
+            }
         }
         updateEnvironment(environment) {
             this.environment = environment;
         }
+        updateDependencySubscriptions(subscriptions) {
+            const previousSubscriptions = this.dependencySubscriptions;
+            this.dependencySubscriptions = dedupeDependencySubscriptions(subscriptions);
+            if (this.ws?.readyState === external_ws_default().OPEN) {
+                this.unsubscribeStaleDependencies(previousSubscriptions, this.dependencySubscriptions);
+                this.subscribeToDependencies();
+            }
+        }
+        getDependencySubscriptions() {
+            return this.dependencySubscriptions;
+        }
         getEditSession() {
             return this.editSession;
         }
@@ -14957,7 +15406,22 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
                 clearTimeout(this.reconnectTimer);
                 this.reconnectTimer = null;
             }
+            if (this.ws?.readyState === external_ws_default().OPEN) {
+                this.ws.send(JSON.stringify(this.buildUnsubscribeMessage(this.appId)));
+                this.unwatchDependencySubscriptions([
+                    ...this.activeDependencySubscriptions.values()
+                ]);
+            }
+            this.teardownSocket();
+        }
+        reconnect() {
+            if (this.isClosing) return;
             this.teardownSocket();
+            this.connect().catch((error)=>{
+                this.emit("error", {
+                    error: error instanceof Error ? error : new Error(String(error))
+                });
+            });
         }
         isConnected() {
             return this.ws?.readyState === external_ws_default().OPEN;
@@ -14990,6 +15454,72 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
                 } : {}
             };
         }
+        buildUnsubscribeMessage(appId) {
+            return {
+                cmd: "UNWATCH_APP",
+                app: appId
+            };
+        }
+        subscribeToDependencies() {
+            if (!this.dependencyWatchEnabled || this.ws?.readyState !== external_ws_default().OPEN) return;
+            for (const subscription of this.dependencySubscriptions){
+                const key = this.dependencySubscriptionKey(subscription);
+                if (this.activeDependencySubscriptions.has(key)) continue;
+                const id = this.nextSubscriptionId++;
+                this.pendingDependencySubscriptionById.set(id, subscription);
+                this.activeDependencySubscriptions.set(key, subscription);
+                const subscribeMsg = {
+                    id,
+                    cmd: "WATCH_APP",
+                    app: subscription.appId,
+                    only_branch: subscription.branch
+                };
+                logger_logger.debug(`[WebSocket ${this.sessionId}]`, `Subscribing dependency: ${JSON.stringify(subscribeMsg)}`);
+                logger_logger.verbose(external_chalk_default().gray(`Watching dependency ${subscription.packageName ?? subscription.appId} (${subscription.appId}, branch ${subscription.branch})`));
+                this.ws.send(JSON.stringify(subscribeMsg));
+            }
+        }
+        handleDependencySubscriptionReply(msg) {
+            if ("number" != typeof msg.id) return;
+            const subscription = this.pendingDependencySubscriptionById.get(msg.id);
+            if (!subscription) return;
+            this.pendingDependencySubscriptionById.delete(msg.id);
+            if (!msg.error) return;
+            this.activeDependencySubscriptions.delete(this.dependencySubscriptionKey(subscription));
+            logger_logger.warn(external_chalk_default().yellow(`Could not watch dependency ${subscription.packageName ?? subscription.appId} (${subscription.appId}, branch ${subscription.branch}): ${this.formatDependencySubscriptionError(msg.error)}`));
+        }
+        formatDependencySubscriptionError(error) {
+            if ("string" == typeof error) return error;
+            if (error && "object" == typeof error && "string" == typeof error.message) return error.message;
+            return JSON.stringify(error);
+        }
+        getMessageAppId(msg) {
+            if ("string" == typeof msg.app) return msg.app;
+            if ("string" == typeof msg.app_id) return msg.app_id;
+            if ("string" == typeof msg.ref_update?.app) return msg.ref_update.app;
+            if ("string" == typeof msg.ref_update?.app_id) return msg.ref_update.app_id;
+            return this.appId;
+        }
+        unsubscribeStaleDependencies(previousSubscriptions, nextSubscriptions) {
+            const nextAppIds = new Set(nextSubscriptions.map((subscription)=>subscription.appId));
+            const staleSubscriptions = previousSubscriptions.filter((subscription)=>!nextAppIds.has(subscription.appId));
+            this.unwatchDependencySubscriptions(staleSubscriptions);
+            const nextKeys = new Set(nextSubscriptions.map((subscription)=>this.dependencySubscriptionKey(subscription)));
+            for (const subscription of previousSubscriptions){
+                const key = this.dependencySubscriptionKey(subscription);
+                if (!nextKeys.has(key)) this.activeDependencySubscriptions.delete(key);
+            }
+        }
+        unwatchDependencySubscriptions(subscriptions) {
+            if (!this.dependencyWatchEnabled || this.ws?.readyState !== external_ws_default().OPEN) return;
+            const unwatchedAppIds = new Set();
+            for (const subscription of subscriptions)if (!unwatchedAppIds.has(subscription.appId)) {
+                unwatchedAppIds.add(subscription.appId);
+                logger_logger.verbose(external_chalk_default().gray(`Stopped watching dependency ${subscription.packageName ?? subscription.appId} (${subscription.appId})`));
+                this.ws.send(JSON.stringify(this.buildUnsubscribeMessage(subscription.appId)));
+            }
+            for (const subscription of subscriptions)this.activeDependencySubscriptions.delete(this.dependencySubscriptionKey(subscription));
+        }
         getConnectionContext() {
             return `app ${this.appId}, branch ${this.currentBranch}, session ${this.sessionId}`;
         }
@@ -15061,6 +15591,9 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
         }
         teardownSocket() {
             this.stopHeartbeat();
+            this.pendingDependencySubscriptionById.clear();
+            this.activeDependencySubscriptions.clear();
+            this.watchedPrimaryBranch = null;
             const socket = this.ws;
             this.ws = null;
             if (!socket) return;
@@ -15076,6 +15609,9 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
                 logger_logger.debug(`[WebSocket ${this.sessionId}]`, "Error closing WebSocket (ignoring):", e);
             }
         }
+        dependencySubscriptionKey(subscription) {
+            return `${subscription.appId}\0${subscription.branch}`;
+        }
     }
     function normalizeEnvironmentBinding(msg) {
         return {
@@ -15084,6 +15620,18 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
             tableMappingId: msg.tableMappingId ?? msg.table_mapping_id ?? null
         };
     }
+    function dedupeDependencySubscriptions(subscriptions) {
+        const seen = new Set();
+        const deduped = [];
+        for (const subscription of subscriptions){
+            const key = `${subscription.appId}\0${subscription.branch}`;
+            if (!seen.has(key)) {
+                seen.add(key);
+                deduped.push(subscription);
+            }
+        }
+        return deduped;
+    }
     async function detectRemoteChanges(gitService, oldCommitId, newCommitId) {
         try {
             const files = await gitService.diffNames(oldCommitId, newCommitId);
@@ -15134,7 +15682,11 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
             ...status.modified,
             ...status.notAdded,
             ...status.created,
-            ...status.deleted
+            ...status.deleted,
+            ...(status.renamed ?? []).flatMap((r)=>[
+                    r.from,
+                    r.to
+                ])
         ]);
     }
     function extractChangesFromStatus(status) {
@@ -15176,12 +15728,22 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
             result.localOnlyChanges.forEach((c)=>logger_logger.verbose(external_chalk_default().gray(`     ${c.path}`)));
         }
     }
-    async function deleteFilesRemovedOnAnvil(gitService, unstagedFiles, remotelyChangedFiles) {
+    async function deleteFilesRemovedOnAnvil(gitService, unstagedFiles, remotelyChangedFiles, options = {}) {
         const filesToRemove = [];
-        for (const file of unstagedFiles)if (remotelyChangedFiles.has(file)) try {
-            await gitService.show(`HEAD:${file}`);
-        } catch (e) {
-            filesToRemove.push(file);
+        const localChangesToPreserve = options.localChangesToPreserve ?? new Set();
+        for (const file of unstagedFiles)if (!localChangesToPreserve.has(file)) {
+            try {
+                await gitService.show(`HEAD:${file}`);
+                continue;
+            } catch (e) {}
+            if (options.oldCommitId) {
+                try {
+                    await gitService.show(`${options.oldCommitId}:${file}`);
+                    filesToRemove.push(file);
+                } catch (e) {}
+                continue;
+            }
+            if (remotelyChangedFiles.has(file)) filesToRemove.push(file);
         }
         if (filesToRemove.length > 0) try {
             await gitService.clean(filesToRemove);
@@ -15193,6 +15755,7 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
         return filesToRemove;
     }
     const external_crypto_namespaceObject = require("crypto");
+    const form_template_parser_namespaceObject = require("@anvil-works/form-template-parser");
     const BUILTIN_COMPONENT_TYPES = new Set([
         "Label",
         "RichText",
@@ -15223,59 +15786,156 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
         "CustomComponent",
         "LayoutSlot",
         "FlowPanel",
-        "HtmlTemplate"
-    ]);
-    const KNOWN_RUNTIME_SERVICE_SOURCES = new Set([
-        "/runtime/services/tables.yml",
-        "/runtime/services/google.yml",
-        "/runtime/services/uplink.yml",
-        "/runtime/services/stripe.yml",
-        "/runtime/services/segment.yml",
-        "/runtime/services/facebook.yml",
-        "/runtime/services/anvil/users.yml",
-        "/runtime/services/anvil/secrets.yml",
-        "/runtime/services/anvil/saml.yml",
-        "/runtime/services/anvil/microsoft.yml",
-        "/runtime/services/anvil/email.yml",
-        "/runtime/services/anvil/files.yml"
+        "HtmlTemplate",
+        "HtmlComponent"
     ]);
     const IDENTIFIER_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
-    const DEP_ID_RE = /^dep_[A-Za-z0-9]+$/;
-    const DB_ACCESS_LEVELS = new Set([
-        "none",
-        "search",
-        "full"
-    ]);
-    const DB_BASIC_COLUMN_TYPES = new Set([
-        "string",
-        "number",
-        "bool",
-        "date",
-        "datetime",
-        "media",
-        "simpleObject"
-    ]);
-    const DB_LINK_COLUMN_TYPES = new Set([
-        "link_single",
-        "link_multiple"
-    ]);
-    const DB_TABLE_INDEX_TYPES = new Set([
-        "b_tree",
-        "trigram",
-        "full_text"
-    ]);
-    const SCHEDULE_EVERY_VALUES = new Set([
-        "minute",
-        "hour",
-        "day",
-        "week",
-        "month"
+    const PYTHON_KEYWORDS = new Set([
+        "False",
+        "None",
+        "True",
+        "and",
+        "as",
+        "assert",
+        "async",
+        "await",
+        "break",
+        "class",
+        "continue",
+        "def",
+        "del",
+        "elif",
+        "else",
+        "except",
+        "finally",
+        "for",
+        "from",
+        "global",
+        "if",
+        "import",
+        "in",
+        "is",
+        "lambda",
+        "nonlocal",
+        "not",
+        "or",
+        "pass",
+        "raise",
+        "return",
+        "try",
+        "while",
+        "with",
+        "yield",
+        "match",
+        "case"
     ]);
-    const CLIENT_VERSIONS = new Set([
-        "2",
-        "3"
+    function isValidPythonIdentifier(value) {
+        return IDENTIFIER_RE.test(value) && !PYTHON_KEYWORDS.has(value);
+    }
+    function isParserGeneratedComponentName(name) {
+        if (!name.startsWith("$")) return false;
+        const suffix = name.slice(1);
+        return suffix.length > 0 && isValidPythonIdentifier(suffix);
+    }
+    function pushIssue(issues, path, message) {
+        issues.push({
+            path,
+            message
+        });
+    }
+    function validateComponentName(value, path, issues) {
+        if (void 0 === value || "string" != typeof value || 0 === value.length) return void pushIssue(issues, path, "must be a non-empty string");
+        if (isParserGeneratedComponentName(value)) return;
+        if (!IDENTIFIER_RE.test(value)) return void pushIssue(issues, path, "must be a valid identifier");
+        if (PYTHON_KEYWORDS.has(value)) pushIssue(issues, path, "must be a valid Python identifier (not a keyword)");
+    }
+    const componentTypeSpec_IDENTIFIER_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+    const DEP_ID_RE = /^dep_[A-Za-z0-9]+$/;
+    const componentTypeSpec_PYTHON_KEYWORDS = new Set([
+        "False",
+        "None",
+        "True",
+        "and",
+        "as",
+        "assert",
+        "async",
+        "await",
+        "break",
+        "class",
+        "continue",
+        "def",
+        "del",
+        "elif",
+        "else",
+        "except",
+        "finally",
+        "for",
+        "from",
+        "global",
+        "if",
+        "import",
+        "in",
+        "is",
+        "lambda",
+        "nonlocal",
+        "not",
+        "or",
+        "pass",
+        "raise",
+        "return",
+        "try",
+        "while",
+        "with",
+        "yield",
+        "match",
+        "case"
     ]);
-    const PYTHON_KEYWORDS = new Set([
+    const LEGACY_FORM_TYPE_REFERENCE_MESSAGE = "must be a valid form: reference (form:Module.Form, form:dep_xxx:Package.Form)";
+    const COMPONENT_TYPE_REFERENCE_MESSAGE = "must be a known Anvil component type (see componentIcons.ts), a form: reference, or a package-qualified form reference (Package.Form)";
+    function isValidIdentifierSegment(value) {
+        return value.length > 0 && componentTypeSpec_IDENTIFIER_RE.test(value) && !componentTypeSpec_PYTHON_KEYWORDS.has(value);
+    }
+    function isValidLegacyFormTypeReference(typeName) {
+        if (!typeName.startsWith("form:")) return false;
+        const rest = typeName.slice(5);
+        if (0 === rest.length) return false;
+        let classPath = rest;
+        if (rest.startsWith("dep_")) {
+            const splitIndex = rest.indexOf(":");
+            if (splitIndex <= 0) return false;
+            const depId = rest.slice(0, splitIndex);
+            if (!DEP_ID_RE.test(depId)) return false;
+            classPath = rest.slice(splitIndex + 1);
+        }
+        if (0 === classPath.length) return false;
+        return classPath.split(".").every((part)=>isValidIdentifierSegment(part));
+    }
+    function isValidPackageQualifiedComponentType(typeName) {
+        if (typeName.startsWith("anvil.")) return false;
+        if (!typeName.includes(".")) return false;
+        const parts = typeName.split(".");
+        if (parts.length < 2) return false;
+        return parts.every((part)=>isValidIdentifierSegment(part));
+    }
+    function componentTypeSpec_pushIssue(issues, path, message) {
+        issues.push({
+            path,
+            message
+        });
+    }
+    function validateComponentTypeSpec(value, path, issues, allowedSingleSegmentTypes) {
+        if ("string" != typeof value || 0 === value.length) return void componentTypeSpec_pushIssue(issues, path, "must be a non-empty string");
+        const typeName = value;
+        if (typeName.startsWith("form:")) {
+            if (!isValidLegacyFormTypeReference(typeName)) componentTypeSpec_pushIssue(issues, path, LEGACY_FORM_TYPE_REFERENCE_MESSAGE);
+            return;
+        }
+        if (isValidPackageQualifiedComponentType(typeName)) return;
+        if (!isValidIdentifierSegment(typeName)) return void componentTypeSpec_pushIssue(issues, path, "must be a valid identifier");
+        if (!allowedSingleSegmentTypes.has(typeName)) componentTypeSpec_pushIssue(issues, path, COMPONENT_TYPE_REFERENCE_MESSAGE);
+    }
+    const formTemplateValidation_IDENTIFIER_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+    const formTemplateValidation_PYTHON_KEYWORDS = new Set([
         "False",
         "None",
         "True",
@@ -15329,58 +15989,29 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
         "padding",
         "spacing"
     ]);
-    function isValidFormReference(typeName) {
-        if (!typeName.startsWith("form:")) return false;
-        const rest = typeName.slice(5);
-        if (0 === rest.length) return false;
-        let classPath = rest;
-        if (rest.startsWith("dep_")) {
-            const splitIndex = rest.indexOf(":");
-            if (splitIndex <= 0) return false;
-            const depId = rest.slice(0, splitIndex);
-            if (!DEP_ID_RE.test(depId)) return false;
-            classPath = rest.slice(splitIndex + 1);
-        }
-        if (0 === classPath.length) return false;
-        return classPath.split(".").every((part)=>IDENTIFIER_RE.test(part));
-    }
-    function isBuiltinComponentType(typeName) {
-        return BUILTIN_COMPONENT_TYPES.has(typeName);
-    }
     function isPlainObject(value) {
         return "object" == typeof value && null !== value && !Array.isArray(value);
     }
-    function pushIssue(issues, path, message) {
+    function formTemplateValidation_pushIssue(issues, path, message) {
         issues.push({
             path,
             message
         });
     }
-    function formatValidationPath(path) {
-        return path || "root";
-    }
     function validateIdentifier(value, path, issues) {
-        if ("string" != typeof value || 0 === value.length) return void pushIssue(issues, path, "must be a non-empty string");
-        if (!IDENTIFIER_RE.test(value)) return void pushIssue(issues, path, "must be a valid identifier");
-        if (PYTHON_KEYWORDS.has(value)) pushIssue(issues, path, "must be a valid Python identifier (not a keyword)");
+        if ("string" != typeof value || 0 === value.length) return void formTemplateValidation_pushIssue(issues, path, "must be a non-empty string");
+        if (!formTemplateValidation_IDENTIFIER_RE.test(value)) return void formTemplateValidation_pushIssue(issues, path, "must be a valid identifier");
+        if (formTemplateValidation_PYTHON_KEYWORDS.has(value)) formTemplateValidation_pushIssue(issues, path, "must be a valid Python identifier (not a keyword)");
     }
     function validateComponentType(value, path, issues) {
-        if ("string" != typeof value || 0 === value.length) return void pushIssue(issues, path, "must be a non-empty string");
-        const typeName = value;
-        if (typeName.startsWith("form:")) {
-            if (!isValidFormReference(typeName)) pushIssue(issues, path, "must be a valid form: reference (form:Module.Form, form:dep_xxx:Package.Form)");
-            return;
-        }
-        if (!IDENTIFIER_RE.test(typeName)) return void pushIssue(issues, path, "must be a valid identifier");
-        if (PYTHON_KEYWORDS.has(typeName)) return void pushIssue(issues, path, "must be a valid Python identifier (not a keyword)");
-        if (!isBuiltinComponentType(typeName)) pushIssue(issues, path, "must be a known Anvil component type (see componentIcons.ts) or a form: reference");
+        validateComponentTypeSpec(value, path, issues, BUILTIN_COMPONENT_TYPES);
     }
     function validatePropertiesObject(value, path, issues) {
-        if (void 0 !== value && !isPlainObject(value)) pushIssue(issues, path, "must be an object");
+        if (void 0 !== value && !isPlainObject(value)) formTemplateValidation_pushIssue(issues, path, "must be an object");
     }
     function validateEventBindingsObject(value, path, issues) {
         if (void 0 === value) return;
-        if (!isPlainObject(value)) return void pushIssue(issues, path, "must be an object");
+        if (!isPlainObject(value)) return void formTemplateValidation_pushIssue(issues, path, "must be an object");
         for (const [eventName, handlerName] of Object.entries(value)){
             validateIdentifier(eventName, `${path}.${eventName}.name`, issues);
             validateIdentifier(handlerName, `${path}.${eventName}`, issues);
@@ -15388,13 +16019,13 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
     }
     function validateDataBindings(value, path, issues) {
         if (void 0 === value) return;
-        if (!Array.isArray(value)) return void pushIssue(issues, path, "must be an array");
+        if (!Array.isArray(value)) return void formTemplateValidation_pushIssue(issues, path, "must be an array");
         value.forEach((binding, index)=>{
             const bindingPath = `${path}[${index}]`;
-            if (!isPlainObject(binding)) return void pushIssue(issues, bindingPath, "must be an object");
-            if ("string" != typeof binding.property || 0 === binding.property.length) pushIssue(issues, `${bindingPath}.property`, "must be a non-empty string");
-            if ("string" != typeof binding.code || 0 === binding.code.length) pushIssue(issues, `${bindingPath}.code`, "must be a non-empty string");
-            if (void 0 !== binding.writeback && "boolean" != typeof binding.writeback) pushIssue(issues, `${bindingPath}.writeback`, "must be a boolean");
+            if (!isPlainObject(binding)) return void formTemplateValidation_pushIssue(issues, bindingPath, "must be an object");
+            if ("string" != typeof binding.property || 0 === binding.property.length) formTemplateValidation_pushIssue(issues, `${bindingPath}.property`, "must be a non-empty string");
+            if ("string" != typeof binding.code || 0 === binding.code.length) formTemplateValidation_pushIssue(issues, `${bindingPath}.code`, "must be a non-empty string");
+            if (void 0 !== binding.writeback && "boolean" != typeof binding.writeback) formTemplateValidation_pushIssue(issues, `${bindingPath}.writeback`, "must be a boolean");
         });
     }
     function validateComponentArray(components, pathPrefix, issues, seenNames) {
@@ -15402,146 +16033,563 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
             const childPath = `${pathPrefix}[${index}]`;
             validateComponentNode(component, childPath, issues, seenNames);
             if (isPlainObject(component) && "string" == typeof component.name && component.name.length > 0) {
-                if (seenNames.has(component.name)) pushIssue(issues, `${childPath}.name`, "must be unique across form components");
+                if (seenNames.has(component.name)) formTemplateValidation_pushIssue(issues, `${childPath}.name`, "must be unique across form components");
                 seenNames.add(component.name);
             }
         });
     }
     function validateComponentNode(value, path, issues, seenNames) {
-        if (!isPlainObject(value)) return void pushIssue(issues, path, "must be an object");
+        if (!isPlainObject(value)) return void formTemplateValidation_pushIssue(issues, path, "must be an object");
         validateComponentType(value.type, `${path}.type`, issues);
-        if (void 0 === value.name || "string" != typeof value.name || 0 === value.name.length) pushIssue(issues, `${path}.name`, "must be a non-empty string");
-        else validateIdentifier(value.name, `${path}.name`, issues);
+        validateComponentName(value.name, `${path}.name`, issues);
         validatePropertiesObject(value.properties, `${path}.properties`, issues);
         validatePropertiesObject(value.layout_properties, `${path}.layout_properties`, issues);
         validateEventBindingsObject(value.event_bindings, `${path}.event_bindings`, issues);
         validateDataBindings(value.data_bindings, `${path}.data_bindings`, issues);
         if (void 0 !== value.components) if (Array.isArray(value.components)) validateComponentArray(value.components, `${path}.components`, issues, seenNames);
-        else pushIssue(issues, `${path}.components`, "must be an array");
+        else formTemplateValidation_pushIssue(issues, `${path}.components`, "must be an array");
     }
     function validatePropertyDefinition(value, path, issues) {
-        if (!isPlainObject(value)) return void pushIssue(issues, path, "must be an object");
+        if (!isPlainObject(value)) return void formTemplateValidation_pushIssue(issues, path, "must be an object");
         validateIdentifier(value.name, `${path}.name`, issues);
-        if ("string" != typeof value.type || !PROPERTY_TYPES.has(value.type)) pushIssue(issues, `${path}.type`, "must be a supported property type");
-        if (void 0 !== value.description && "string" != typeof value.description) pushIssue(issues, `${path}.description`, "must be a string");
-        if (void 0 !== value.default_binding_prop && "boolean" != typeof value.default_binding_prop) pushIssue(issues, `${path}.default_binding_prop`, "must be a boolean");
-        if (void 0 !== value.allow_binding_writeback && "boolean" != typeof value.allow_binding_writeback) pushIssue(issues, `${path}.allow_binding_writeback`, "must be a boolean");
+        if ("string" != typeof value.type || !PROPERTY_TYPES.has(value.type)) formTemplateValidation_pushIssue(issues, `${path}.type`, "must be a supported property type");
+        if (void 0 !== value.description && "string" != typeof value.description) formTemplateValidation_pushIssue(issues, `${path}.description`, "must be a string");
+        if (void 0 !== value.default_binding_prop && "boolean" != typeof value.default_binding_prop) formTemplateValidation_pushIssue(issues, `${path}.default_binding_prop`, "must be a boolean");
+        if (void 0 !== value.allow_binding_writeback && "boolean" != typeof value.allow_binding_writeback) formTemplateValidation_pushIssue(issues, `${path}.allow_binding_writeback`, "must be a boolean");
         if (void 0 !== value.binding_writeback_events) if (Array.isArray(value.binding_writeback_events)) value.binding_writeback_events.forEach((eventName, index)=>{
-            if ("string" != typeof eventName || 0 === eventName.length) pushIssue(issues, `${path}.binding_writeback_events[${index}]`, "must be a non-empty string");
+            if ("string" != typeof eventName || 0 === eventName.length) formTemplateValidation_pushIssue(issues, `${path}.binding_writeback_events[${index}]`, "must be a non-empty string");
         });
-        else pushIssue(issues, `${path}.binding_writeback_events`, "must be an array");
+        else formTemplateValidation_pushIssue(issues, `${path}.binding_writeback_events`, "must be an array");
         if ("enum" === value.type) {
-            if (!Array.isArray(value.options) || value.options.some((option)=>"string" != typeof option)) pushIssue(issues, `${path}.options`, "must be an array of strings for enum properties");
+            if (!Array.isArray(value.options) || value.options.some((option)=>"string" != typeof option)) formTemplateValidation_pushIssue(issues, `${path}.options`, "must be an array of strings for enum properties");
         }
     }
     function validateEventDefinition(value, path, issues) {
-        if (!isPlainObject(value)) return void pushIssue(issues, path, "must be an object");
+        if (!isPlainObject(value)) return void formTemplateValidation_pushIssue(issues, path, "must be an object");
         validateIdentifier(value.name, `${path}.name`, issues);
-        if (void 0 !== value.description && "string" != typeof value.description) pushIssue(issues, `${path}.description`, "must be a string");
-        if (void 0 !== value.default_event && "boolean" != typeof value.default_event) pushIssue(issues, `${path}.default_event`, "must be a boolean");
+        if (void 0 !== value.description && "string" != typeof value.description) formTemplateValidation_pushIssue(issues, `${path}.description`, "must be a string");
+        if (void 0 !== value.default_event && "boolean" != typeof value.default_event) formTemplateValidation_pushIssue(issues, `${path}.default_event`, "must be a boolean");
         if (void 0 !== value.parameters) if (Array.isArray(value.parameters)) value.parameters.forEach((parameter, index)=>{
-            if (!isPlainObject(parameter)) return void pushIssue(issues, `${path}.parameters[${index}]`, "must be an object");
+            if (!isPlainObject(parameter)) return void formTemplateValidation_pushIssue(issues, `${path}.parameters[${index}]`, "must be an object");
             validateIdentifier(parameter.name, `${path}.parameters[${index}].name`, issues);
-            if (void 0 !== parameter.description && "string" != typeof parameter.description) pushIssue(issues, `${path}.parameters[${index}].description`, "must be a string");
+            if (void 0 !== parameter.description && "string" != typeof parameter.description) formTemplateValidation_pushIssue(issues, `${path}.parameters[${index}].description`, "must be a string");
         });
-        else pushIssue(issues, `${path}.parameters`, "must be an array");
+        else formTemplateValidation_pushIssue(issues, `${path}.parameters`, "must be an array");
     }
     function validateSlotDefinition(value, path, issues, seenNames) {
-        if (!isPlainObject(value)) return void pushIssue(issues, path, "must be an object");
-        if ("number" != typeof value.index || !Number.isInteger(value.index) || value.index < 0) pushIssue(issues, `${path}.index`, "must be a non-negative integer");
+        if (!isPlainObject(value)) return void formTemplateValidation_pushIssue(issues, path, "must be an object");
+        if ("number" != typeof value.index || !Number.isInteger(value.index) || value.index < 0) formTemplateValidation_pushIssue(issues, `${path}.index`, "must be a non-negative integer");
         validatePropertiesObject(value.set_layout_properties, `${path}.set_layout_properties`, issues);
         if (isPlainObject(value.target)) {
-            if ("container" !== value.target.type && "slot" !== value.target.type) pushIssue(issues, `${path}.target.type`, "must be 'container' or 'slot'");
-            validateIdentifier(value.target.name, `${path}.target.name`, issues);
-        } else pushIssue(issues, `${path}.target`, "must be an object");
+            if ("container" !== value.target.type && "slot" !== value.target.type) formTemplateValidation_pushIssue(issues, `${path}.target.type`, "must be 'container' or 'slot'");
+            if ("container" !== value.target.type || "" !== value.target.name) validateIdentifier(value.target.name, `${path}.target.name`, issues);
+        } else formTemplateValidation_pushIssue(issues, `${path}.target`, "must be an object");
         if (void 0 !== value.template) validateComponentNode(value.template, `${path}.template`, issues, seenNames);
     }
+    function prefixedPath(pathPrefix, path) {
+        return pathPrefix.length > 0 ? `${pathPrefix}.${path}` : path;
+    }
+    function validateFormTemplateMetadata(value, options = {}) {
+        const issues = [];
+        if (!isPlainObject(value)) {
+            formTemplateValidation_pushIssue(issues, options.pathPrefix ?? "", "must be a YAML object");
+            return issues;
+        }
+        const pathPrefix = options.pathPrefix ?? "";
+        const path = (suffix)=>prefixedPath(pathPrefix, suffix);
+        if (void 0 !== value.custom_component && "boolean" != typeof value.custom_component) formTemplateValidation_pushIssue(issues, path("custom_component"), "must be a boolean");
+        if (void 0 !== value.custom_component_container && "boolean" != typeof value.custom_component_container) formTemplateValidation_pushIssue(issues, path("custom_component_container"), "must be a boolean");
+        if (true === value.custom_component_container && true !== value.custom_component) formTemplateValidation_pushIssue(issues, path("custom_component_container"), "requires custom_component: true");
+        const properties = value.properties;
+        if (void 0 !== properties) if (Array.isArray(properties)) {
+            const seenNames = new Set();
+            let defaultBindingPropCount = 0;
+            properties.forEach((property, index)=>{
+                validatePropertyDefinition(property, path(`properties[${index}]`), issues);
+                if (!isPlainObject(property) || "string" != typeof property.name) return;
+                if (seenNames.has(property.name)) formTemplateValidation_pushIssue(issues, path(`properties[${index}].name`), "must be unique");
+                seenNames.add(property.name);
+                if (property.default_binding_prop) defaultBindingPropCount++;
+            });
+            if (defaultBindingPropCount > 1) formTemplateValidation_pushIssue(issues, path("properties"), "can only define one default_binding_prop");
+        } else formTemplateValidation_pushIssue(issues, path("properties"), "must be an array");
+        const events = value.events;
+        const eventNames = new Set();
+        if (void 0 !== events) if (Array.isArray(events)) {
+            let defaultEventCount = 0;
+            events.forEach((event, index)=>{
+                validateEventDefinition(event, path(`events[${index}]`), issues);
+                if (!isPlainObject(event) || "string" != typeof event.name) return;
+                if (eventNames.has(event.name)) formTemplateValidation_pushIssue(issues, path(`events[${index}].name`), "must be unique");
+                eventNames.add(event.name);
+                if (event.default_event) defaultEventCount++;
+            });
+            if (defaultEventCount > 1) formTemplateValidation_pushIssue(issues, path("events"), "can only define one default_event");
+        } else formTemplateValidation_pushIssue(issues, path("events"), "must be an array");
+        if (Array.isArray(properties)) properties.forEach((property, index)=>{
+            if (!isPlainObject(property) || !Array.isArray(property.binding_writeback_events)) return;
+            property.binding_writeback_events.forEach((eventName, eventIndex)=>{
+                if ("string" == typeof eventName && !eventNames.has(eventName)) formTemplateValidation_pushIssue(issues, path(`properties[${index}].binding_writeback_events[${eventIndex}]`), "must reference a defined event");
+            });
+        });
+        if (void 0 !== value.slots) {
+            const slotsPath = path("slots");
+            if (isPlainObject(value.slots)) if ("empty-marker" === options.slotsPolicy) {
+                if (Object.keys(value.slots).length > 0) formTemplateValidation_pushIssue(issues, slotsPath, "must be empty when defined in frontmatter");
+            } else {
+                const componentNames = options.componentNames ?? new Set();
+                for (const [slotName, slotDef] of Object.entries(value.slots)){
+                    validateIdentifier(slotName, path(`slots.${slotName}.name`), issues);
+                    validateSlotDefinition(slotDef, path(`slots.${slotName}`), issues, componentNames);
+                }
+            }
+            else formTemplateValidation_pushIssue(issues, slotsPath, "must be an object");
+        }
+        if (void 0 !== value.toolbox_item && !isPlainObject(value.toolbox_item)) formTemplateValidation_pushIssue(issues, path("toolbox_item"), "must be an object");
+        if (void 0 !== value.layout_metadata && !isPlainObject(value.layout_metadata)) formTemplateValidation_pushIssue(issues, path("layout_metadata"), "must be an object");
+        if (void 0 !== value.item_type) if (isPlainObject(value.item_type)) {
+            if ("number" != typeof value.item_type.table_id) formTemplateValidation_pushIssue(issues, path("item_type.table_id"), "must be a number");
+        } else formTemplateValidation_pushIssue(issues, path("item_type"), "must be an object");
+        return issues;
+    }
     function validateFormTemplateData(value) {
         const issues = [];
         const componentNames = new Set();
         if (!isPlainObject(value)) {
-            pushIssue(issues, "", "must be a YAML object");
+            formTemplateValidation_pushIssue(issues, "", "must be a YAML object");
             return issues;
         }
         const hasContainer = void 0 !== value.container;
         const hasLayout = void 0 !== value.layout;
         const hasComponents = void 0 !== value.components;
         const hasComponentsBySlot = void 0 !== value.components_by_slot;
-        if (hasContainer && hasLayout) pushIssue(issues, "", "cannot define both container and layout");
-        if (!hasContainer && !hasLayout) pushIssue(issues, "", "must define either container or layout");
-        if (void 0 !== value.is_package && "boolean" != typeof value.is_package) pushIssue(issues, "is_package", "must be a boolean");
+        if (hasContainer && hasLayout) formTemplateValidation_pushIssue(issues, "", "cannot define both container and layout");
+        if (!hasContainer && !hasLayout) formTemplateValidation_pushIssue(issues, "", "must define either container or layout");
+        if (void 0 !== value.is_package && "boolean" != typeof value.is_package) formTemplateValidation_pushIssue(issues, "is_package", "must be a boolean");
         if (hasContainer) if (isPlainObject(value.container)) {
             validateComponentType(value.container.type, "container.type", issues);
             validatePropertiesObject(value.container.properties, "container.properties", issues);
             validatePropertiesObject(value.container.layout_properties, "container.layout_properties", issues);
             validateEventBindingsObject(value.container.event_bindings, "container.event_bindings", issues);
             validateDataBindings(value.container.data_bindings, "container.data_bindings", issues);
-        } else pushIssue(issues, "container", "must be an object");
+        } else formTemplateValidation_pushIssue(issues, "container", "must be an object");
         if (hasLayout) if (isPlainObject(value.layout)) {
             validateComponentType(value.layout.type, "layout.type", issues);
             validatePropertiesObject(value.layout.properties, "layout.properties", issues);
             validateEventBindingsObject(value.layout.event_bindings, "layout.event_bindings", issues);
             validateEventBindingsObject(value.layout.form_event_bindings, "layout.form_event_bindings", issues);
             validateDataBindings(value.layout.data_bindings, "layout.data_bindings", issues);
-        } else pushIssue(issues, "layout", "must be an object");
-        if (hasComponents && hasLayout) pushIssue(issues, "components", "can only be used with container-based forms");
-        else if (hasComponents && !hasContainer) pushIssue(issues, "components", "can only be used with container-based forms");
+        } else formTemplateValidation_pushIssue(issues, "layout", "must be an object");
+        if (hasComponents && hasLayout) formTemplateValidation_pushIssue(issues, "components", "can only be used with container-based forms");
+        else if (hasComponents && !hasContainer) formTemplateValidation_pushIssue(issues, "components", "can only be used with container-based forms");
         else if (hasComponents) if (Array.isArray(value.components)) validateComponentArray(value.components, "components", issues, componentNames);
-        else pushIssue(issues, "components", "must be an array");
-        if (hasComponentsBySlot && hasContainer) pushIssue(issues, "components_by_slot", "can only be used with layout-based forms");
-        else if (hasComponentsBySlot && !hasLayout) pushIssue(issues, "components_by_slot", "can only be used with layout-based forms");
+        else formTemplateValidation_pushIssue(issues, "components", "must be an array");
+        if (hasComponentsBySlot && hasContainer) formTemplateValidation_pushIssue(issues, "components_by_slot", "can only be used with layout-based forms");
+        else if (hasComponentsBySlot && !hasLayout) formTemplateValidation_pushIssue(issues, "components_by_slot", "can only be used with layout-based forms");
         else if (hasComponentsBySlot) if (isPlainObject(value.components_by_slot)) for (const [slotName, slotComponents] of Object.entries(value.components_by_slot)){
             if (!Array.isArray(slotComponents)) {
-                pushIssue(issues, `components_by_slot.${slotName}`, "must be an array");
+                formTemplateValidation_pushIssue(issues, `components_by_slot.${slotName}`, "must be an array");
                 continue;
             }
             validateComponentArray(slotComponents, `components_by_slot.${slotName}`, issues, componentNames);
         }
-        else pushIssue(issues, "components_by_slot", "must be an object");
-        if (void 0 !== value.custom_component && "boolean" != typeof value.custom_component) pushIssue(issues, "custom_component", "must be a boolean");
-        if (void 0 !== value.custom_component_container && "boolean" != typeof value.custom_component_container) pushIssue(issues, "custom_component_container", "must be a boolean");
-        if (true === value.custom_component_container && true !== value.custom_component) pushIssue(issues, "custom_component_container", "requires custom_component: true");
-        const properties = value.properties;
-        if (void 0 !== properties) if (Array.isArray(properties)) {
-            const seenNames = new Set();
-            let defaultBindingPropCount = 0;
-            properties.forEach((property, index)=>{
-                validatePropertyDefinition(property, `properties[${index}]`, issues);
-                if (!isPlainObject(property) || "string" != typeof property.name) return;
-                if (seenNames.has(property.name)) pushIssue(issues, `properties[${index}].name`, "must be unique");
-                seenNames.add(property.name);
-                if (property.default_binding_prop) defaultBindingPropCount++;
-            });
-            if (defaultBindingPropCount > 1) pushIssue(issues, "properties", "can only define one default_binding_prop");
-        } else pushIssue(issues, "properties", "must be an array");
-        const events = value.events;
-        const eventNames = new Set();
-        if (void 0 !== events) if (Array.isArray(events)) {
-            let defaultEventCount = 0;
-            events.forEach((event, index)=>{
-                validateEventDefinition(event, `events[${index}]`, issues);
-                if (!isPlainObject(event) || "string" != typeof event.name) return;
-                if (eventNames.has(event.name)) pushIssue(issues, `events[${index}].name`, "must be unique");
-                eventNames.add(event.name);
-                if (event.default_event) defaultEventCount++;
-            });
-            if (defaultEventCount > 1) pushIssue(issues, "events", "can only define one default_event");
-        } else pushIssue(issues, "events", "must be an array");
-        if (Array.isArray(properties)) properties.forEach((property, index)=>{
-            if (!isPlainObject(property) || !Array.isArray(property.binding_writeback_events)) return;
-            property.binding_writeback_events.forEach((eventName, eventIndex)=>{
-                if ("string" == typeof eventName && !eventNames.has(eventName)) pushIssue(issues, `properties[${index}].binding_writeback_events[${eventIndex}]`, "must reference a defined event");
+        else formTemplateValidation_pushIssue(issues, "components_by_slot", "must be an object");
+        issues.push(...validateFormTemplateMetadata(value, {
+            componentNames
+        }));
+        return issues;
+    }
+    const KNOWN_RUNTIME_SERVICE_SOURCES = new Set([
+        "/runtime/services/tables.yml",
+        "/runtime/services/google.yml",
+        "/runtime/services/uplink.yml",
+        "/runtime/services/stripe.yml",
+        "/runtime/services/segment.yml",
+        "/runtime/services/facebook.yml",
+        "/runtime/services/anvil/users.yml",
+        "/runtime/services/anvil/secrets.yml",
+        "/runtime/services/anvil/saml.yml",
+        "/runtime/services/anvil/microsoft.yml",
+        "/runtime/services/anvil/email.yml",
+        "/runtime/services/anvil/files.yml"
+    ]);
+    const FRONTMATTER_ALLOWED_KEYS = new Set([
+        "custom_component",
+        "custom_component_container",
+        "properties",
+        "events",
+        "toolbox_item",
+        "layout_metadata",
+        "item_type",
+        "slots"
+    ]);
+    const FRONTMATTER_DISALLOWED_KEYS = new Set([
+        "container",
+        "components",
+        "layout",
+        "components_by_slot",
+        "code",
+        "class_name",
+        "is_package",
+        "save_as_html",
+        "serialized_html"
+    ]);
+    function validateFormTemplateHtml_isPlainObject(value) {
+        return "object" == typeof value && null !== value && !Array.isArray(value);
+    }
+    function validateFormTemplateHtml_pushIssue(issues, issuePath, message) {
+        issues.push({
+            path: issuePath,
+            message
+        });
+    }
+    function splitHtmlFormTemplateFrontmatter(htmlContent) {
+        const match = htmlContent.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+        if (!match) return {
+            frontmatter: null,
+            body: htmlContent
+        };
+        return {
+            frontmatter: match[1],
+            body: htmlContent.slice(match[0].length)
+        };
+    }
+    function validateHtmlFrontmatter(frontmatterYaml) {
+        const issues = [];
+        if (0 === frontmatterYaml.trim().length) {
+            validateFormTemplateHtml_pushIssue(issues, "frontmatter", "must not be empty; omit frontmatter entirely when unused");
+            return issues;
+        }
+        let data;
+        try {
+            data = external_js_yaml_namespaceObject.load(frontmatterYaml);
+        } catch (error) {
+            validateFormTemplateHtml_pushIssue(issues, "frontmatter", error instanceof Error ? error.message : String(error));
+            return issues;
+        }
+        if (!validateFormTemplateHtml_isPlainObject(data)) {
+            validateFormTemplateHtml_pushIssue(issues, "frontmatter", "must be a YAML object");
+            return issues;
+        }
+        for (const key of Object.keys(data))if (FRONTMATTER_DISALLOWED_KEYS.has(key)) validateFormTemplateHtml_pushIssue(issues, `frontmatter.${key}`, "belongs in the HTML body, not frontmatter");
+        else if (!FRONTMATTER_ALLOWED_KEYS.has(key)) validateFormTemplateHtml_pushIssue(issues, `frontmatter.${key}`, "is not an allowed frontmatter field");
+        issues.push(...validateFormTemplateMetadata(data, {
+            pathPrefix: "frontmatter",
+            slotsPolicy: "empty-marker"
+        }));
+        return issues;
+    }
+    function validateParsedHtmlTemplate(parsed) {
+        return validateFormTemplateData(parsed);
+    }
+    function validateFormTemplateHtml(htmlContent) {
+        const { frontmatter, body } = splitHtmlFormTemplateFrontmatter(htmlContent);
+        if (null !== frontmatter) {
+            const frontmatterIssues = validateHtmlFrontmatter(frontmatter);
+            if (frontmatterIssues.length > 0) return {
+                ok: false,
+                message: "form_template.html is invalid for Anvil",
+                issues: frontmatterIssues
+            };
+        }
+        let parsed;
+        try {
+            parsed = (0, form_template_parser_namespaceObject.parseSerializedHtml)(body);
+        } catch (error) {
+            return {
+                ok: false,
+                message: "form_template.html could not be parsed",
+                issues: [
+                    {
+                        path: "",
+                        message: error instanceof Error ? error.message : String(error)
+                    }
+                ]
+            };
+        }
+        const issues = validateParsedHtmlTemplate(parsed);
+        if (issues.length > 0) return {
+            ok: false,
+            message: "form_template.html is invalid for Anvil",
+            issues
+        };
+        return {
+            ok: true
+        };
+    }
+    const PYTHON_VALIDATOR_SCRIPT = String.raw`
+import ast
+import json
+import sys
+
+
+def issue_path(error):
+    if getattr(error, "lineno", None) is None:
+        return "root"
+    if getattr(error, "offset", None) is None:
+        return f"line {error.lineno}"
+    return f"line {error.lineno}, column {error.offset}"
+
+
+def base_name(node):
+    if isinstance(node, ast.Name):
+        return node.id
+    if isinstance(node, ast.Attribute):
+        return node.attr
+    return None
+
+
+def imports_template_from_anvil_designer(node, template_name):
+    if node.level < 1:
+        return False
+    if node.module not in ("_anvil_designer", None):
+        return False
+    return any(alias.name == template_name for alias in node.names)
+
+
+file_path = sys.argv[1]
+class_name = sys.argv[2]
+template_name = f"{class_name}Template" if class_name else ""
+source = sys.stdin.read()
+issues = []
+
+try:
+    compile(source, file_path, "exec")
+except SyntaxError as error:
+    issues.append({"path": issue_path(error), "message": error.msg})
+    print(json.dumps({"issues": issues}))
+    sys.exit(0)
+
+if class_name:
+    tree = ast.parse(source, filename=file_path)
+    has_template_import = False
+    has_form_class = False
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ImportFrom) and imports_template_from_anvil_designer(node, template_name):
+            has_template_import = True
+        elif isinstance(node, ast.ClassDef) and node.name == class_name:
+            if any(base_name(base) == template_name for base in node.bases):
+                has_form_class = True
+
+    if not has_template_import:
+        issues.append({
+            "path": "root",
+            "message": f"missing {chr(96)}from ._anvil_designer import {template_name}{chr(96)}",
+        })
+    if not has_form_class:
+        issues.append({
+            "path": "root",
+            "message": f"missing class {chr(96)}{class_name}{chr(96)} inheriting from {chr(96)}{template_name}{chr(96)}",
+        })
+
+print(json.dumps({"issues": issues}))
+`;
+    function findPythonInterpreter(env = process.env, probe = external_child_process_namespaceObject.spawnSync) {
+        const candidates = [
+            ..."string" == typeof env.ANVIL_PYTHON && env.ANVIL_PYTHON.length > 0 ? [
+                {
+                    command: env.ANVIL_PYTHON,
+                    args: []
+                }
+            ] : [],
+            {
+                command: "uv",
+                args: [
+                    "run",
+                    "--isolated",
+                    "--no-python-downloads",
+                    "python"
+                ]
+            },
+            {
+                command: "python3",
+                args: []
+            },
+            {
+                command: "python",
+                args: []
+            }
+        ];
+        for (const candidate of candidates){
+            const result = probe(candidate.command, [
+                ...candidate.args,
+                "--version"
+            ], {
+                encoding: "utf8"
             });
+            if (!result.error && 0 === result.status) return candidate;
+        }
+        return null;
+    }
+    function isClientFormPython(filePath) {
+        if ("__init__.py" === external_path_default().basename(filePath)) {
+            const formDir = external_path_default().dirname(filePath);
+            return external_fs_.existsSync(external_path_default().join(formDir, "form_template.html")) || external_fs_.existsSync(external_path_default().join(formDir, "form_template.yaml"));
+        }
+        const parsed = external_path_default().parse(filePath);
+        return external_fs_.existsSync(external_path_default().join(parsed.dir, `${parsed.name}.html`)) || external_fs_.existsSync(external_path_default().join(parsed.dir, `${parsed.name}.yaml`));
+    }
+    function expectedFormClassName(filePath) {
+        if (!isClientFormPython(filePath)) return null;
+        if ("__init__.py" === external_path_default().basename(filePath)) return external_path_default().basename(external_path_default().dirname(filePath));
+        return external_path_default().basename(filePath, ".py");
+    }
+    function isUnderDirectory(filePath, directoryPath) {
+        const relativePath = external_path_default().relative(directoryPath, filePath);
+        return relativePath.length > 0 && !relativePath.startsWith("..") && !external_path_default().isAbsolute(relativePath);
+    }
+    function validatePython(filePath, fileContent, appRoot) {
+        const interpreter = findPythonInterpreter();
+        if (!interpreter) return {
+            ok: false,
+            message: "Python file could not be validated",
+            issues: [
+                {
+                    path: "root",
+                    message: "Python validation requires uv, python3, or python on PATH, or ANVIL_PYTHON to be set"
+                }
+            ]
+        };
+        const absolutePath = external_path_default().resolve(filePath);
+        const clientCodeRoot = appRoot ? external_path_default().join(appRoot, "client_code") : null;
+        const formClassName = clientCodeRoot && isUnderDirectory(absolutePath, clientCodeRoot) ? expectedFormClassName(absolutePath) : null;
+        const result = (0, external_child_process_namespaceObject.spawnSync)(interpreter.command, [
+            ...interpreter.args,
+            "-c",
+            PYTHON_VALIDATOR_SCRIPT,
+            filePath,
+            formClassName ?? ""
+        ], {
+            encoding: "utf8",
+            input: fileContent,
+            maxBuffer: 1048576
+        });
+        if (result.error || 0 !== result.status) return {
+            ok: false,
+            message: "Python file could not be validated",
+            issues: [
+                {
+                    path: "root",
+                    message: result.error?.message ?? (result.stderr.trim() || "Python validator failed")
+                }
+            ]
+        };
+        let parsed;
+        try {
+            parsed = JSON.parse(result.stdout);
+        } catch (error) {
+            return {
+                ok: false,
+                message: "Python file could not be validated",
+                issues: [
+                    {
+                        path: "root",
+                        message: error instanceof Error ? error.message : String(error)
+                    }
+                ]
+            };
+        }
+        const issues = parsed.issues ?? [];
+        if (issues.length > 0) return {
+            ok: false,
+            message: "Python file is invalid for Anvil",
+            issues
+        };
+        return {
+            ok: true
+        };
+    }
+    const validators_IDENTIFIER_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+    const DB_ACCESS_LEVELS = new Set([
+        "none",
+        "search",
+        "full"
+    ]);
+    const DB_BASIC_COLUMN_TYPES = new Set([
+        "string",
+        "number",
+        "bool",
+        "date",
+        "datetime",
+        "media",
+        "simpleObject"
+    ]);
+    const DB_LINK_COLUMN_TYPES = new Set([
+        "link_single",
+        "link_multiple"
+    ]);
+    const DB_TABLE_INDEX_TYPES = new Set([
+        "b_tree",
+        "trigram",
+        "full_text"
+    ]);
+    const SCHEDULE_EVERY_VALUES = new Set([
+        "minute",
+        "hour",
+        "day",
+        "week",
+        "month"
+    ]);
+    const CLIENT_VERSIONS = new Set([
+        "2",
+        "3"
+    ]);
+    const validators_PYTHON_KEYWORDS = new Set([
+        "False",
+        "None",
+        "True",
+        "and",
+        "as",
+        "assert",
+        "async",
+        "await",
+        "break",
+        "class",
+        "continue",
+        "def",
+        "del",
+        "elif",
+        "else",
+        "except",
+        "finally",
+        "for",
+        "from",
+        "global",
+        "if",
+        "import",
+        "in",
+        "is",
+        "lambda",
+        "nonlocal",
+        "not",
+        "or",
+        "pass",
+        "raise",
+        "return",
+        "try",
+        "while",
+        "with",
+        "yield",
+        "match",
+        "case"
+    ]);
+    function validators_isPlainObject(value) {
+        return "object" == typeof value && null !== value && !Array.isArray(value);
+    }
+    function validators_pushIssue(issues, path, message) {
+        issues.push({
+            path,
+            message
         });
-        if (void 0 !== value.slots) if (isPlainObject(value.slots)) for (const [slotName, slotDef] of Object.entries(value.slots)){
-            validateIdentifier(slotName, `slots.${slotName}.name`, issues);
-            validateSlotDefinition(slotDef, `slots.${slotName}`, issues, componentNames);
-        }
-        else pushIssue(issues, "slots", "must be an object");
-        if (void 0 !== value.item_type) if (isPlainObject(value.item_type)) {
-            if ("number" != typeof value.item_type.table_id) pushIssue(issues, "item_type.table_id", "must be a number");
-        } else pushIssue(issues, "item_type", "must be an object");
-        return issues;
+    }
+    function formatValidationPath(path) {
+        return path || "root";
+    }
+    function validators_validateIdentifier(value, path, issues) {
+        if ("string" != typeof value || 0 === value.length) return void validators_pushIssue(issues, path, "must be a non-empty string");
+        if (!validators_IDENTIFIER_RE.test(value)) return void validators_pushIssue(issues, path, "must be a valid identifier");
+        if (validators_PYTHON_KEYWORDS.has(value)) validators_pushIssue(issues, path, "must be a valid Python identifier (not a keyword)");
     }
     function validateFormTemplate(yamlContent) {
         try {
@@ -15568,7 +16616,7 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
             };
         }
     }
-    const serviceConfigObject = external_valibot_namespaceObject.custom((input)=>isPlainObject(input), "must be an object");
+    const serviceConfigObject = external_valibot_namespaceObject.custom((input)=>validators_isPlainObject(input), "must be an object");
     const AnvilServiceEntrySchema = external_valibot_namespaceObject.looseObject({
         source: external_valibot_namespaceObject.pipe(external_valibot_namespaceObject.string(), external_valibot_namespaceObject.nonEmpty()),
         client_config: external_valibot_namespaceObject.optional(serviceConfigObject),
@@ -15596,14 +16644,14 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
     function validateRuntimeOptions(value, path) {
         const issues = [];
         if (void 0 === value) return issues;
-        if (!isPlainObject(value)) return issues;
+        if (!validators_isPlainObject(value)) return issues;
         if (void 0 !== value.client_version) {
-            if ("string" != typeof value.client_version || !CLIENT_VERSIONS.has(value.client_version)) pushIssue(issues, `${path}.client_version`, 'must be "2" or "3"');
+            if ("string" != typeof value.client_version || !CLIENT_VERSIONS.has(value.client_version)) validators_pushIssue(issues, `${path}.client_version`, 'must be "2" or "3"');
         }
         if (void 0 !== value.server_spec && null !== value.server_spec) {
-            if (!isPlainObject(value.server_spec)) return issues;
-            if ("requirements" in value.server_spec) pushIssue(issues, `${path}.server_spec.requirements`, "is not a valid anvil.yaml field; requirements come from server_code/requirements.txt");
-            if (void 0 !== value.server_spec.base && "string" != typeof value.server_spec.base) pushIssue(issues, `${path}.server_spec.base`, "must be a string");
+            if (!validators_isPlainObject(value.server_spec)) return issues;
+            if ("requirements" in value.server_spec) validators_pushIssue(issues, `${path}.server_spec.requirements`, "is not a valid anvil.yaml field; requirements come from server_code/requirements.txt");
+            if (void 0 !== value.server_spec.base && "string" != typeof value.server_spec.base) validators_pushIssue(issues, `${path}.server_spec.base`, "must be a string");
         }
         return issues;
     }
@@ -15611,27 +16659,27 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
         const issues = [];
         if (void 0 === value) return issues;
         if (null === value) {
-            pushIssue(issues, path, "must be an object, an empty array, or omitted");
+            validators_pushIssue(issues, path, "must be an object, an empty array, or omitted");
             return issues;
         }
         if (Array.isArray(value)) {
             if (0 === value.length) return issues;
-            pushIssue(issues, path, "must be an object mapping table names to schemas, or an empty array");
+            validators_pushIssue(issues, path, "must be an object mapping table names to schemas, or an empty array");
             return issues;
         }
-        if (!isPlainObject(value)) {
-            pushIssue(issues, path, "must be an object mapping table names to schemas");
+        if (!validators_isPlainObject(value)) {
+            validators_pushIssue(issues, path, "must be an object mapping table names to schemas");
             return issues;
         }
         for (const tableName of Object.keys(value)){
             const tablePath = `${path}.${tableName}`;
-            if (!IDENTIFIER_RE.test(tableName)) {
-                pushIssue(issues, tablePath, "must be a valid Python identifier");
+            if (!validators_IDENTIFIER_RE.test(tableName)) {
+                validators_pushIssue(issues, tablePath, "must be a valid Python identifier");
                 continue;
             }
             const table = value[tableName];
-            if (!isPlainObject(table)) {
-                pushIssue(issues, tablePath, "must be an object");
+            if (!validators_isPlainObject(table)) {
+                validators_pushIssue(issues, tablePath, "must be an object");
                 continue;
             }
             for (const req of [
@@ -15639,61 +16687,61 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
                 "server",
                 "title",
                 "columns"
-            ])if (void 0 === table[req]) pushIssue(issues, `${tablePath}.${req}`, "is required");
+            ])if (void 0 === table[req]) validators_pushIssue(issues, `${tablePath}.${req}`, "is required");
             if (void 0 !== table.client) {
-                if ("string" != typeof table.client || !DB_ACCESS_LEVELS.has(table.client)) pushIssue(issues, `${tablePath}.client`, 'must be "none", "search", or "full"');
+                if ("string" != typeof table.client || !DB_ACCESS_LEVELS.has(table.client)) validators_pushIssue(issues, `${tablePath}.client`, 'must be "none", "search", or "full"');
             }
             if (void 0 !== table.server) {
-                if ("string" != typeof table.server || !DB_ACCESS_LEVELS.has(table.server)) pushIssue(issues, `${tablePath}.server`, 'must be "none", "search", or "full"');
+                if ("string" != typeof table.server || !DB_ACCESS_LEVELS.has(table.server)) validators_pushIssue(issues, `${tablePath}.server`, 'must be "none", "search", or "full"');
             }
             if (void 0 !== table.title) {
-                if ("string" != typeof table.title || 0 === table.title.length) pushIssue(issues, `${tablePath}.title`, "must be a non-empty string");
+                if ("string" != typeof table.title || 0 === table.title.length) validators_pushIssue(issues, `${tablePath}.title`, "must be a non-empty string");
             }
             if (void 0 !== table.columns) if (Array.isArray(table.columns)) table.columns.forEach((column, index)=>{
                 validateDbSchemaColumn(column, `${tablePath}.columns[${index}]`, issues);
             });
-            else pushIssue(issues, `${tablePath}.columns`, "must be an array");
+            else validators_pushIssue(issues, `${tablePath}.columns`, "must be an array");
             if (void 0 !== table.indexes) if (Array.isArray(table.indexes)) table.indexes.forEach((indexEntry, index)=>{
                 validateDbTableIndex(indexEntry, `${tablePath}.indexes[${index}]`, issues);
             });
-            else pushIssue(issues, `${tablePath}.indexes`, "must be an array");
+            else validators_pushIssue(issues, `${tablePath}.indexes`, "must be an array");
         }
         return issues;
     }
     function validateDbTableIndex(value, path, issues) {
-        if (!isPlainObject(value)) return void pushIssue(issues, path, "must be an object");
-        if (!Array.isArray(value.columns) || value.columns.some((c)=>"string" != typeof c)) pushIssue(issues, `${path}.columns`, "must be an array of strings");
-        if (void 0 === value.type) pushIssue(issues, `${path}.type`, "is required");
-        else if ("string" != typeof value.type || !DB_TABLE_INDEX_TYPES.has(value.type)) pushIssue(issues, `${path}.type`, 'must be "b_tree", "trigram", or "full_text"');
+        if (!validators_isPlainObject(value)) return void validators_pushIssue(issues, path, "must be an object");
+        if (!Array.isArray(value.columns) || value.columns.some((c)=>"string" != typeof c)) validators_pushIssue(issues, `${path}.columns`, "must be an array of strings");
+        if (void 0 === value.type) validators_pushIssue(issues, `${path}.type`, "is required");
+        else if ("string" != typeof value.type || !DB_TABLE_INDEX_TYPES.has(value.type)) validators_pushIssue(issues, `${path}.type`, 'must be "b_tree", "trigram", or "full_text"');
     }
     function validateDbSchemaColumn(value, path, issues) {
-        if (!isPlainObject(value)) return void pushIssue(issues, path, "must be an object");
-        if (void 0 === value.name || "string" != typeof value.name || 0 === value.name.length) pushIssue(issues, `${path}.name`, "must be a non-empty string");
-        else if (!IDENTIFIER_RE.test(value.name)) pushIssue(issues, `${path}.name`, "must be a valid Python identifier");
-        if (void 0 === value.type) return void pushIssue(issues, `${path}.type`, "is required");
-        if ("string" != typeof value.type) return void pushIssue(issues, `${path}.type`, "must be a string");
+        if (!validators_isPlainObject(value)) return void validators_pushIssue(issues, path, "must be an object");
+        if (void 0 === value.name || "string" != typeof value.name || 0 === value.name.length) validators_pushIssue(issues, `${path}.name`, "must be a non-empty string");
+        else if (!validators_IDENTIFIER_RE.test(value.name)) validators_pushIssue(issues, `${path}.name`, "must be a valid Python identifier");
+        if (void 0 === value.type) return void validators_pushIssue(issues, `${path}.type`, "is required");
+        if ("string" != typeof value.type) return void validators_pushIssue(issues, `${path}.type`, "must be a string");
         const colType = value.type;
         if (DB_LINK_COLUMN_TYPES.has(colType)) {
-            if (void 0 === value.target || "string" != typeof value.target || 0 === value.target.length) pushIssue(issues, `${path}.target`, "must be a non-empty string (target table python name)");
-            else if (!IDENTIFIER_RE.test(value.target)) pushIssue(issues, `${path}.target`, "must be a valid Python identifier");
-        } else if (!DB_BASIC_COLUMN_TYPES.has(colType)) pushIssue(issues, `${path}.type`, `must be a basic column type (${[
+            if (void 0 === value.target || "string" != typeof value.target || 0 === value.target.length) validators_pushIssue(issues, `${path}.target`, "must be a non-empty string (target table python name)");
+            else if (!validators_IDENTIFIER_RE.test(value.target)) validators_pushIssue(issues, `${path}.target`, "must be a valid Python identifier");
+        } else if (!DB_BASIC_COLUMN_TYPES.has(colType)) validators_pushIssue(issues, `${path}.type`, `must be a basic column type (${[
             ...DB_BASIC_COLUMN_TYPES
         ].join(", ")}) or ${[
             ...DB_LINK_COLUMN_TYPES
         ].join(", ")}`);
-        if (void 0 !== value.client_hidden && "boolean" != typeof value.client_hidden) pushIssue(issues, `${path}.client_hidden`, "must be a boolean");
-        if (void 0 !== value.admin_ui && null !== value.admin_ui) if (isPlainObject(value.admin_ui)) {
+        if (void 0 !== value.client_hidden && "boolean" != typeof value.client_hidden) validators_pushIssue(issues, `${path}.client_hidden`, "must be a boolean");
+        if (void 0 !== value.admin_ui && null !== value.admin_ui) if (validators_isPlainObject(value.admin_ui)) {
             const ui = value.admin_ui;
-            if (void 0 !== ui.width && "number" != typeof ui.width) pushIssue(issues, `${path}.admin_ui.width`, "must be a number");
-            if (void 0 !== ui.order && "number" != typeof ui.order) pushIssue(issues, `${path}.admin_ui.order`, "must be a number");
-        } else pushIssue(issues, `${path}.admin_ui`, "must be an object or null");
+            if (void 0 !== ui.width && "number" != typeof ui.width) validators_pushIssue(issues, `${path}.admin_ui.width`, "must be a number");
+            if (void 0 !== ui.order && "number" != typeof ui.order) validators_pushIssue(issues, `${path}.admin_ui.order`, "must be a number");
+        } else validators_pushIssue(issues, `${path}.admin_ui`, "must be an object or null");
         if (void 0 !== value.indexes) {
-            if (!Array.isArray(value.indexes)) return void pushIssue(issues, `${path}.indexes`, "must be an array");
+            if (!Array.isArray(value.indexes)) return void validators_pushIssue(issues, `${path}.indexes`, "must be an array");
             value.indexes.forEach((entry, i)=>{
                 const idxPath = `${path}.indexes[${i}]`;
-                if (!isPlainObject(entry)) return void pushIssue(issues, idxPath, "must be an object");
-                if (void 0 === entry.type) pushIssue(issues, `${idxPath}.type`, "is required");
-                else if ("string" != typeof entry.type || !DB_TABLE_INDEX_TYPES.has(entry.type)) pushIssue(issues, `${idxPath}.type`, 'must be "b_tree", "trigram", or "full_text"');
+                if (!validators_isPlainObject(entry)) return void validators_pushIssue(issues, idxPath, "must be an object");
+                if (void 0 === entry.type) validators_pushIssue(issues, `${idxPath}.type`, "is required");
+                else if ("string" != typeof entry.type || !DB_TABLE_INDEX_TYPES.has(entry.type)) validators_pushIssue(issues, `${idxPath}.type`, 'must be "b_tree", "trigram", or "full_text"');
             });
         }
     }
@@ -15702,8 +16750,8 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
         if (void 0 === services) return issues;
         if (!Array.isArray(services)) return issues;
         services.forEach((service, index)=>{
-            if (!isPlainObject(service) || "string" != typeof service.source) return;
-            if (!KNOWN_RUNTIME_SERVICE_SOURCES.has(service.source)) pushIssue(issues, `${path}[${index}].source`, "must be a known runtime service source path");
+            if (!validators_isPlainObject(service) || "string" != typeof service.source) return;
+            if (!KNOWN_RUNTIME_SERVICE_SOURCES.has(service.source)) validators_pushIssue(issues, `${path}[${index}].source`, "must be a known runtime service source path");
         });
         return issues;
     }
@@ -15711,9 +16759,9 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
         const issues = [];
         if (void 0 === services || !Array.isArray(services)) return issues;
         services.forEach((service, index)=>{
-            if (!isPlainObject(service) || "/runtime/services/anvil/users.yml" !== service.source) return;
-            if (!isPlainObject(service.client_config)) return;
-            if (true === service.client_config.allow_remember_me && void 0 === service.client_config.remember_me_days) pushIssue(issues, `${path}[${index}].client_config.remember_me_days`, "must be set if allow_remember_me is true");
+            if (!validators_isPlainObject(service) || "/runtime/services/anvil/users.yml" !== service.source) return;
+            if (!validators_isPlainObject(service.client_config)) return;
+            if (true === service.client_config.allow_remember_me && void 0 === service.client_config.remember_me_days) validators_pushIssue(issues, `${path}[${index}].client_config.remember_me_days`, "must be set if allow_remember_me is true");
         });
         return issues;
     }
@@ -15721,25 +16769,25 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
         const issues = [];
         if (void 0 === value) return issues;
         if (!Array.isArray(value)) {
-            pushIssue(issues, path, "must be an array");
+            validators_pushIssue(issues, path, "must be an array");
             return issues;
         }
         value.forEach((task, index)=>{
             const taskPath = `${path}[${index}]`;
-            if (!isPlainObject(task)) return void pushIssue(issues, taskPath, "must be an object");
-            if ("string" != typeof task.job_id || 0 === task.job_id.length) pushIssue(issues, `${taskPath}.job_id`, "must be a non-empty string");
-            validateIdentifier(task.task_name, `${taskPath}.task_name`, issues);
-            if (!isPlainObject(task.time_spec)) return void pushIssue(issues, `${taskPath}.time_spec`, "must be an object");
+            if (!validators_isPlainObject(task)) return void validators_pushIssue(issues, taskPath, "must be an object");
+            if ("string" != typeof task.job_id || 0 === task.job_id.length) validators_pushIssue(issues, `${taskPath}.job_id`, "must be a non-empty string");
+            validators_validateIdentifier(task.task_name, `${taskPath}.task_name`, issues);
+            if (!validators_isPlainObject(task.time_spec)) return void validators_pushIssue(issues, `${taskPath}.time_spec`, "must be an object");
             const timeSpec = task.time_spec;
-            if ("string" != typeof timeSpec.every || !SCHEDULE_EVERY_VALUES.has(timeSpec.every)) pushIssue(issues, `${taskPath}.time_spec.every`, 'must be one of "minute", "hour", "day", "week", or "month"');
+            if ("string" != typeof timeSpec.every || !SCHEDULE_EVERY_VALUES.has(timeSpec.every)) validators_pushIssue(issues, `${taskPath}.time_spec.every`, 'must be one of "minute", "hour", "day", "week", or "month"');
             const interval = timeSpec.n;
-            if (void 0 !== interval && ("number" != typeof interval || !Number.isInteger(interval) || interval <= 0)) pushIssue(issues, `${taskPath}.time_spec.n`, "must be a positive integer");
-            if (void 0 !== timeSpec.at) if (isPlainObject(timeSpec.at)) {
+            if (void 0 !== interval && ("number" != typeof interval || !Number.isInteger(interval) || interval <= 0)) validators_pushIssue(issues, `${taskPath}.time_spec.n`, "must be a positive integer");
+            if (void 0 !== timeSpec.at) if (validators_isPlainObject(timeSpec.at)) {
                 const at = timeSpec.at;
-                if (void 0 !== at.minute && !Number.isInteger(at.minute)) pushIssue(issues, `${taskPath}.time_spec.at.minute`, "must be an integer");
-                if (void 0 !== at.hour && !Number.isInteger(at.hour)) pushIssue(issues, `${taskPath}.time_spec.at.hour`, "must be an integer");
-                if (void 0 !== at.day && !Number.isInteger(at.day)) pushIssue(issues, `${taskPath}.time_spec.at.day`, "must be an integer");
-            } else pushIssue(issues, `${taskPath}.time_spec.at`, "must be an object");
+                if (void 0 !== at.minute && !Number.isInteger(at.minute)) validators_pushIssue(issues, `${taskPath}.time_spec.at.minute`, "must be an integer");
+                if (void 0 !== at.hour && !Number.isInteger(at.hour)) validators_pushIssue(issues, `${taskPath}.time_spec.at.hour`, "must be an integer");
+                if (void 0 !== at.day && !Number.isInteger(at.day)) validators_pushIssue(issues, `${taskPath}.time_spec.at.day`, "must be an integer");
+            } else validators_pushIssue(issues, `${taskPath}.time_spec.at`, "must be an object");
         });
         return issues;
     }
@@ -15751,13 +16799,13 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
         dependencies: external_valibot_namespaceObject.optional(external_valibot_namespaceObject.array(external_valibot_namespaceObject.any())),
         runtime_options: RuntimeOptionsSchema,
         services: external_valibot_namespaceObject.optional(external_valibot_namespaceObject.array(AnvilServiceEntrySchema)),
-        startup: external_valibot_namespaceObject.optional(external_valibot_namespaceObject.looseObject({
+        startup: external_valibot_namespaceObject.optional(external_valibot_namespaceObject.nullable(external_valibot_namespaceObject.looseObject({
             type: external_valibot_namespaceObject.picklist([
                 "module",
                 "form"
             ]),
             module: external_valibot_namespaceObject.optional(external_valibot_namespaceObject.string())
-        })),
+        }))),
         startup_form: external_valibot_namespaceObject.optional(external_valibot_namespaceObject.nullable(external_valibot_namespaceObject.string())),
         db_schema: external_valibot_namespaceObject.optional(external_valibot_namespaceObject.any()),
         scheduled_tasks: external_valibot_namespaceObject.optional(external_valibot_namespaceObject.any()),
@@ -15848,6 +16896,14 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
             const startIndex = normalizedPath.lastIndexOf(clientCodePrefix);
             const relativeToClientCode = normalizedPath.slice(startIndex + clientCodePrefix.length);
             if (relativeToClientCode.endsWith(".yaml")) return "form_template.yaml";
+            if (relativeToClientCode.endsWith(".html")) return "form_template.html";
+            if (relativeToClientCode.endsWith(".py")) return "python";
+        }
+        const serverCodePrefix = "server_code/";
+        if (normalizedPath.startsWith(serverCodePrefix) || normalizedPath.includes(`/${serverCodePrefix}`)) {
+            const startIndex = normalizedPath.lastIndexOf(serverCodePrefix);
+            const relativeToServerCode = normalizedPath.slice(startIndex + serverCodePrefix.length);
+            if (relativeToServerCode.endsWith(".py")) return "python";
         }
         return null;
     }
@@ -15867,7 +16923,7 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
             currentDir = parentDir;
         }
     }
-    function validatePath(filePath, yamlContent) {
+    function validatePath(filePath, fileContent) {
         const target = inferValidationTarget(filePath);
         const existingPath = resolveExistingPath(filePath);
         const appRoot = findAnvilAppRoot(filePath);
@@ -15894,7 +16950,7 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
                     }
                 ]
             };
-            const result = validateAnvilYaml(yamlContent);
+            const result = validateAnvilYaml(fileContent);
             return result.ok ? {
                 ok: true,
                 target
@@ -15920,7 +16976,62 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
                     ]
                 };
             }
-            const result = validateFormTemplate(yamlContent);
+            const result = validateFormTemplate(fileContent);
+            return result.ok ? {
+                ok: true,
+                target
+            } : {
+                ...result,
+                target
+            };
+        }
+        if ("form_template.html" === target) {
+            if (existingPath && appRoot) {
+                const clientCodeRoot = external_path_default().join(appRoot, "client_code");
+                const relativeToClientCode = external_path_default().relative(clientCodeRoot, existingPath);
+                const isInsideClientCode = relativeToClientCode.length > 0 && !relativeToClientCode.startsWith("..") && !external_path_default().isAbsolute(relativeToClientCode);
+                if (!isInsideClientCode || !existingPath.endsWith(".html")) return {
+                    ok: false,
+                    target,
+                    message: "File is not a client_code HTML form",
+                    issues: [
+                        {
+                            path: "",
+                            message: `expected a .html file under ${clientCodeRoot}`
+                        }
+                    ]
+                };
+            }
+            const result = validateFormTemplateHtml(fileContent);
+            return result.ok ? {
+                ok: true,
+                target
+            } : {
+                ...result,
+                target
+            };
+        }
+        if ("python" === target) {
+            if (existingPath && appRoot) {
+                const clientCodeRoot = external_path_default().join(appRoot, "client_code");
+                const serverCodeRoot = external_path_default().join(appRoot, "server_code");
+                const relativeToClientCode = external_path_default().relative(clientCodeRoot, existingPath);
+                const relativeToServerCode = external_path_default().relative(serverCodeRoot, existingPath);
+                const isInsideClientCode = relativeToClientCode.length > 0 && !relativeToClientCode.startsWith("..") && !external_path_default().isAbsolute(relativeToClientCode);
+                const isInsideServerCode = relativeToServerCode.length > 0 && !relativeToServerCode.startsWith("..") && !external_path_default().isAbsolute(relativeToServerCode);
+                if (!isInsideClientCode && !isInsideServerCode || !existingPath.endsWith(".py")) return {
+                    ok: false,
+                    target,
+                    message: "File is not an Anvil app Python file",
+                    issues: [
+                        {
+                            path: "",
+                            message: `expected a .py file under ${clientCodeRoot} or ${serverCodeRoot}`
+                        }
+                    ]
+                };
+            }
+            const result = validatePython(filePath, fileContent, appRoot);
             return result.ok ? {
                 ok: true,
                 target
@@ -15936,7 +17047,7 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
             issues: [
                 {
                     path: "",
-                    message: "supported paths are anvil.yaml, client_code/**/form_template.yaml, and client_code/**/*.yaml"
+                    message: "supported paths are anvil.yaml, client_code/**/form_template.yaml, client_code/**/*.yaml, client_code/**/*.html, client_code/**/*.py, and server_code/**/*.py"
                 }
             ]
         };
@@ -15975,9 +17086,13 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
         };
         return null;
     }
+    function formatValidationFailure(fileName, validationResult) {
+        const issueSummary = validationResult.issues.map((issue)=>`  - ${formatValidationPath(issue.path)}: ${issue.message}`).join("\n");
+        return issueSummary ? `${fileName} validation failed: ${validationResult.message}\n${issueSummary}` : `${fileName} validation failed: ${validationResult.message}`;
+    }
     async function loadFormTemplateData(relativePath, templateInfo, context) {
         const { repoPath, stagedOnly = false } = context;
-        const { kind, format } = templateInfo;
+        const { format } = templateInfo;
         try {
             const content = await readFileContent(repoPath, relativePath, stagedOnly);
             if ("yaml" === format) {
@@ -15990,26 +17105,12 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
                         reason: issueSummary ? `${validationResult.message}. ${issueSummary}` : validationResult.message
                     };
                 }
-                const parsed = external_js_yaml_default().load(content);
-                const template = {
-                    ...parsed,
-                    is_package: "package" === kind
-                };
-                return {
-                    ok: true,
-                    data: {
-                        template
-                    }
-                };
             }
-            const { frontmatter, html } = parseHtmlWithFrontmatter(content);
-            const template = frontmatter ?? {};
             return {
                 ok: true,
-                data: {
-                    template,
-                    html
-                }
+                source: (0, form_template_parser_namespaceObject.parseFormTemplateSource)(content, {
+                    format
+                })
             };
         } catch (error) {
             return {
@@ -16716,20 +17817,6 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
             ]
         });
     }
-    function buildFormDataFromTemplate(template, html, options) {
-        const { class_name: _templateClassName, code: _templateCode, is_package: _templateIsPackage, ...templateRest } = template && "object" == typeof template ? template : {};
-        const formData = {
-            ...templateRest,
-            class_name: options.className,
-            code: options.code,
-            is_package: options.isPackage
-        };
-        if (void 0 !== html) {
-            formData.save_as_html = true;
-            formData.serialized_html = html;
-        }
-        return formData;
-    }
     async function buildFormTemplateData(relativePath, templateInfo, context) {
         const { repoPath, stagedOnly = false } = context;
         const { kind } = templateInfo;
@@ -16753,10 +17840,7 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
                 reason: "package" === kind ? "Form __init__.py file not found - cannot save template without code" : "Form .py file not found - cannot save template without code"
             }
         };
-        const templateData = loadResult.data.template ?? {};
-        const html = loadResult.data.html;
-        const templateObject = templateData && "object" == typeof templateData && !Array.isArray(templateData) ? templateData : {};
-        const formData = buildFormDataFromTemplate(templateObject, html, {
+        const formData = (0, form_template_parser_namespaceObject.buildFormTemplateSavePayload)(loadResult.source, {
             className,
             code: codeContent,
             isPackage: "package" === kind
@@ -16941,7 +18025,7 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
             }
         };
         const validationResult = validateAnvilYaml(yamlContent);
-        if (!validationResult.ok) throw new Error("anvil.yaml validation failed - see errors above");
+        if (!validationResult.ok) throw new Error(formatValidationFailure("anvil.yaml", validationResult));
         const changes = [];
         for (const [key, value] of Object.entries(parsedYaml))if (!previousYaml || !deepEqual(previousYaml[key], value)) changes.push({
             key,
@@ -17048,6 +18132,12 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
         }
     }
     function authDiagnostic(error) {
+        if ("token_refresh_failed" === error.type && error.message?.includes("invalid_grant")) return {
+            code: error.type,
+            recoverability: "requires_user_action",
+            requiresUserAction: true,
+            suggestedAction: "Your Anvil session auth has expired or was invalidated. Run anvil login or restart the agent/watch session, then retry."
+        };
         return {
             code: error.type,
             recoverability: "requires_user_action",
@@ -17110,6 +18200,7 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
     class SaveProcessor extends Emitter {
         hasPendingChanges = false;
         debounceTimer = null;
+        saveLoopPromise = null;
         saveSequence = 0;
         SAVE_DEBOUNCE_MS = 1000;
         MAX_RETRIES = 3;
@@ -17133,6 +18224,7 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
             if (this.debounceTimer) clearTimeout(this.debounceTimer);
             if (isFirstChange) logger_logger.progress("sync", "Change detected");
             this.debounceTimer = setTimeout(()=>{
+                this.debounceTimer = null;
                 this.processSaveBatchWithEvents().catch((error)=>{
                     logger_logger.error(`Save failed: ${errors_getErrorMessage(error)}`);
                 });
@@ -17157,6 +18249,18 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
             }
         }
         async processSaveBatchWithEvents() {
+            if (this.saveLoopPromise) return this.saveLoopPromise;
+            this.saveLoopPromise = this.drainSaveQueue();
+            try {
+                await this.saveLoopPromise;
+            } finally{
+                this.saveLoopPromise = null;
+            }
+        }
+        async drainSaveQueue() {
+            while(this.hasPendingChanges && !this.config.isCleanedUp() && !this.config.isPaused())await this.processOneSaveBatchWithEvents();
+        }
+        async processOneSaveBatchWithEvents() {
             if (this.config.isCleanedUp()) return;
             logger_logger.progressUpdate("sync", "Processing");
             if (!this.hasPendingChanges) return void logger_logger.progressEnd("sync");
@@ -17174,6 +18278,7 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
                     newCommitId: this.config.getCommitId(),
                     fileCount
                 });
+                if (result.anvilYamlDependenciesChanged) this.emit("anvil-yaml-dependencies-changed", void 0);
                 this.emit("save-complete", {
                     newCommitId: this.config.getCommitId(),
                     fileCount
@@ -17264,13 +18369,14 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
         }
         async getStagedChanges() {
             try {
-                return await getStagedFileChanges(this.config.gitService.getGit());
+                return await getStagedFileChanges(this.config.gitService.getGit(), this.config.gitService);
             } catch (e) {
                 logger_logger.error(external_chalk_default().red(`Error getting staged changes: ${errors_getErrorMessage(e)}`));
                 return [];
             }
         }
         async getUnstagedChanges(status) {
+            const modeOnlyChanges = new Set(await this.config.gitService.discardModeOnlyChanges(status.modified));
             const renames = status.renamed;
             const stagedRenamedFromPaths = new Set(renames.map((r)=>r.from));
             const stagedRenamedToPaths = new Set(renames.map((r)=>r.to));
@@ -17290,7 +18396,7 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
             const allRenamedFromPaths = new Set(allRenames.map((r)=>r.from));
             const allRenamedToPaths = new Set(allRenames.map((r)=>r.to));
             return [
-                ...status.modified.map((f)=>({
+                ...status.modified.filter((f)=>!modeOnlyChanges.has(f)).map((f)=>({
                         path: f,
                         type: "change"
                     })),
@@ -17361,11 +18467,15 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
         async processBatchedChanges(changes) {
             const saveArray = [];
             const originalFilePaths = [];
+            let anvilYamlDependenciesChanged = false;
             const deduplicatedChanges = deduplicateFormChanges(changes);
             for (const change of deduplicatedChanges){
                 if ("anvil.yaml" === change.path) {
                     const previousAnvilYaml = await this.getHeadAnvilYaml();
                     const anvilChanges = await getAnvilYamlChanges(this.config.repoPath, previousAnvilYaml);
+                    const previousDependencies = normalizeAnvilYamlDependenciesValue(previousAnvilYaml?.dependencies);
+                    const currentDependencies = await readAnvilYamlDependencies(this.config.repoPath);
+                    if (!anvilYamlDependenciesEqual(previousDependencies, currentDependencies)) anvilYamlDependenciesChanged = true;
                     if (0 === anvilChanges.length) {
                         logger_logger.verbose(external_chalk_default().gray("  Ignoring anvil.yaml: No changes detected"));
                         continue;
@@ -17417,7 +18527,8 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
             }
             await this.sendSavesToAnvil(saveArray, originalFilePaths);
             return {
-                skipped: false
+                skipped: false,
+                anvilYamlDependenciesChanged
             };
         }
         logSaveResult(change, savePath, content) {
@@ -17493,7 +18604,7 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
                 await this.handleConflict(json_resp, originalFilePaths, retryCount);
                 return;
             }
-            if (200 === resp.status) return void await this.handleSuccess(json_resp);
+            if (200 === resp.status) return void await this.handleSuccess(json_resp, originalFilePaths);
             logger_logger.error(`Unexpected response status: ${resp.status}`);
             throw {
                 type: "server_error",
@@ -17596,13 +18707,20 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
                 reason: "Unknown conflict"
             };
         }
-        async handleSuccess(json_resp) {
+        async handleSuccess(json_resp, originalFilePaths) {
             const version = json_resp.version;
-            this.config.setCommitId(version);
+            const oldCommitId = json_resp.previous_commit ?? null;
+            const commitIdBeforePostSaveSync = this.config.getCommitId();
+            this.emit("saved", {
+                oldCommitId,
+                newCommitId: version,
+                branch: this.config.getCurrentBranch()
+            });
             if (this.postSaveCallback) {
                 logger_logger.progressUpdate("sync", "Syncing back");
-                await this.postSaveCallback();
+                await this.postSaveCallback(new Set(originalFilePaths));
             }
+            if (this.config.getCommitId() === commitIdBeforePostSaveSync) this.config.setCommitId(version);
         }
         async rerouteChanges(changes) {
             logger_logger.verbose(external_chalk_default().blue(`Re-routing ${changes.length} local change(s)...`));
@@ -17656,76 +18774,114 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
     }
     class SyncManager extends Emitter {
         config;
-        syncInProgress = false;
+        syncQueue = Promise.resolve();
         constructor(config){
             super();
             this.config = config;
         }
         async syncRemoteChanges(knownLocalChanges) {
-            if (this.syncInProgress) {
-                logger_logger.debug("Sync already in progress, skipping");
+            const runSync = ()=>this.performSyncRemoteChanges(knownLocalChanges);
+            const queuedSync = this.syncQueue.then(runSync, runSync);
+            this.syncQueue = queuedSync.catch(()=>{});
+            return queuedSync;
+        }
+        async performSyncRemoteChanges(knownLocalChanges) {
+            const oldCommitId = this.config.getCommitId();
+            let locallyChangedFiles;
+            let initialStatus;
+            if (knownLocalChanges) locallyChangedFiles = knownLocalChanges;
+            else {
+                initialStatus = await this.config.gitService.getStatus();
+                locallyChangedFiles = buildLocalChangesSet(initialStatus);
+            }
+            let syncMode;
+            if (!knownLocalChanges && initialStatus && this.isCleanForFastForward(initialStatus)) syncMode = await this.fetchAndMoveCleanTreeToAnvilHead(oldCommitId, locallyChangedFiles);
+            else {
+                await this.fetchAndResetFromAnvil(locallyChangedFiles);
+                syncMode = "preservation";
+            }
+            if ("clean-move" === syncMode) return {
+                localOnlyChanges: [],
+                conflicts: []
+            };
+            const newCommitId = await this.config.gitService.getCommitId();
+            this.config.setCommitId(newCommitId);
+            const remoteChangedFiles = await detectRemoteChanges(this.config.gitService, oldCommitId, newCommitId);
+            const statusAfter = await this.config.gitService.getStatus();
+            const newChanges = extractChangesFromStatus(statusAfter);
+            if (0 === newChanges.length) {
+                logger_logger.verbose(external_chalk_default().gray("   No local changes - working directory is clean"));
                 return {
                     localOnlyChanges: [],
                     conflicts: []
                 };
             }
-            this.syncInProgress = true;
-            try {
-                const oldCommitId = this.config.getCommitId();
-                let locallyChangedFiles;
-                if (knownLocalChanges) locallyChangedFiles = knownLocalChanges;
+            const result = categorizeChanges(newChanges, locallyChangedFiles, remoteChangedFiles);
+            await acceptRemoteChanges(this.config.gitService, result.remoteOnlyChanges);
+            logConflictResolution(result);
+            return {
+                localOnlyChanges: result.localOnlyChanges,
+                conflicts: result.conflicts
+            };
+        }
+        async fetchAndResetFromAnvil(localChangesToPreserve = new Set()) {
+            const oldCommitId = this.config.getCommitId();
+            await this.withFetchedAnvilRef((tempRef)=>this.resetToFetchedAnvilRef(tempRef, oldCommitId, localChangesToPreserve));
+        }
+        async fetchAndMoveCleanTreeToAnvilHead(oldCommitId, locallyChangedFiles) {
+            return this.withFetchedAnvilRef(async (tempRef)=>{
+                const localHead = await this.config.gitService.getCommitId();
+                if (await this.config.gitService.isAncestor(localHead, tempRef)) await this.config.gitService.mergeFastForward(tempRef);
                 else {
-                    const status = await this.config.gitService.getStatus();
-                    locallyChangedFiles = buildLocalChangesSet(status);
+                    const statusBeforeHardReset = await this.config.gitService.getStatus();
+                    if (!this.isCleanForFastForward(statusBeforeHardReset)) {
+                        for (const filePath of buildLocalChangesSet(statusBeforeHardReset))locallyChangedFiles.add(filePath);
+                        await this.resetToFetchedAnvilRef(tempRef, oldCommitId, locallyChangedFiles);
+                        return "preservation";
+                    }
+                    await this.config.gitService.reset(tempRef, "hard");
                 }
-                await this.fetchAndResetFromAnvil();
                 const newCommitId = await this.config.gitService.getCommitId();
                 this.config.setCommitId(newCommitId);
-                const remoteChangedFiles = await detectRemoteChanges(this.config.gitService, oldCommitId, newCommitId);
-                const statusAfter = await this.config.gitService.getStatus();
-                const newChanges = extractChangesFromStatus(statusAfter);
-                if (0 === newChanges.length) {
-                    logger_logger.verbose(external_chalk_default().gray("   No local changes - working directory is clean"));
-                    return {
-                        localOnlyChanges: [],
-                        conflicts: []
-                    };
-                }
-                const result = categorizeChanges(newChanges, locallyChangedFiles, remoteChangedFiles);
-                await acceptRemoteChanges(this.config.gitService, result.remoteOnlyChanges);
-                logConflictResolution(result);
-                return {
-                    localOnlyChanges: result.localOnlyChanges,
-                    conflicts: result.conflicts
-                };
-            } finally{
-                this.syncInProgress = false;
-            }
+                await this.config.editorYaml.reload();
+                return "clean-move";
+            });
         }
-        async fetchAndResetFromAnvil() {
+        async withFetchedAnvilRef(callback) {
             const validToken = await auth_getValidAuthToken(this.config.anvilUrl, this.config.username);
             this.config.setAuthToken(validToken);
             const httpUrl = anvil_api_getGitFetchUrl(this.config.appId, this.config.getAuthToken(), this.config.anvilUrl);
             const currentBranch = this.config.getCurrentBranch();
             const tempRef = `anvil-sync-temp-${Date.now()}`;
-            const oldCommitId = this.config.getCommitId();
-            await this.config.gitService.fetch(httpUrl, `+${currentBranch}:${tempRef}`);
+            try {
+                await this.config.gitService.fetch(httpUrl, `+${currentBranch}:${tempRef}`);
+                return await callback(tempRef);
+            } finally{
+                await this.config.gitService.deleteRef(`refs/heads/${tempRef}`);
+            }
+        }
+        async resetToFetchedAnvilRef(tempRef, oldCommitId, localChangesToPreserve) {
             await this.config.gitService.reset(tempRef, "mixed");
-            await this.config.gitService.deleteRef(`refs/heads/${tempRef}`);
             const newCommitId = await this.config.gitService.getCommitId();
             await this.config.gitService.checkout([
                 ".anvil_editor.yaml",
                 "anvil.yaml"
             ]);
             await this.config.editorYaml.reload();
-            await this.deleteFilesRemovedOnAnvilLocally(oldCommitId, newCommitId);
+            await this.deleteFilesRemovedOnAnvilLocally(oldCommitId, newCommitId, localChangesToPreserve);
             await this.discardFormattingOnlyYamlChanges();
         }
-        async deleteFilesRemovedOnAnvilLocally(oldCommitId, newCommitId) {
+        isCleanForFastForward(status) {
+            return status.isClean && 0 === status.modified.length && 0 === status.notAdded.length && 0 === status.created.length && 0 === status.deleted.length && 0 === status.staged.length && 0 === status.renamed.length;
+        }
+        async deleteFilesRemovedOnAnvilLocally(oldCommitId, newCommitId, localChangesToPreserve) {
             try {
                 const status = await this.config.gitService.getStatus();
                 const remotelyChangedFiles = await detectRemoteChanges(this.config.gitService, oldCommitId, newCommitId);
-                await deleteFilesRemovedOnAnvil(this.config.gitService, status.notAdded, remotelyChangedFiles);
+                await deleteFilesRemovedOnAnvil(this.config.gitService, status.notAdded, remotelyChangedFiles, {
+                    oldCommitId,
+                    localChangesToPreserve
+                });
             } catch (e) {
                 logger_logger.verbose(external_chalk_default().gray(`  Failed to check git status: ${errors_getErrorMessage(e)}`));
             }
@@ -17838,6 +18994,10 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
         environment;
         envBranchChangeMode;
         isSwitchingForEnvironment = false;
+        environmentSwitchTargetBranch = null;
+        dependencyWatchEnabled;
+        isRefreshingDependencies = false;
+        hasPendingDependencyRefresh = false;
         pendingEnvironmentBranchSwitch = null;
         BRANCH_CHANGE_SETTLE_MS = 2000;
         LOCAL_CHANGE_POLL_MS = 2000;
@@ -17855,6 +19015,7 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
             this.stagedOnly = options.stagedOnly ?? false;
             this.environment = options.environment;
             this.envBranchChangeMode = options.envBranchChangeMode ?? "manual";
+            this.dependencyWatchEnabled = options.dependencyWatch ?? true;
             this.editSession = "anvil-sync-" + Math.random().toString(36).substring(2, 15);
             this.gitService = new git_GitService(this.repoPath);
             this.editorYaml = new EditorYamlManager(this.repoPath);
@@ -17874,6 +19035,7 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
         async initialize() {
             await this.editorYaml.load();
             this.initializeProcessors();
+            if (this.dependencyWatchEnabled) await this.refreshDependencies("startup");
             try {
                 await this.connectWebSocket();
             } catch (error) {
@@ -17893,7 +19055,7 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
                 getAuthToken: ()=>this.authToken,
                 setAuthToken: (token)=>{
                     this.authToken = token;
-                    this.wsClient?.updateAuthToken(token);
+                    this.wsClient?.updateAuthToken?.(token);
                 },
                 getCurrentBranch: ()=>this.currentBranch,
                 getCommitId: ()=>this.commitId,
@@ -17913,7 +19075,7 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
                 getAuthToken: ()=>this.authToken,
                 setAuthToken: (token)=>{
                     this.authToken = token;
-                    this.wsClient?.updateAuthToken(token);
+                    this.wsClient?.updateAuthToken?.(token);
                 },
                 getCurrentBranch: ()=>this.currentBranch,
                 getCommitId: ()=>this.commitId,
@@ -17926,15 +19088,25 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
                 isPaused: ()=>this.isPausedForUserInput
             });
             this.saveProcessor.setSyncCallback((filePaths)=>this.syncManager.syncRemoteChanges(filePaths));
-            this.saveProcessor.setPostSaveCallback(()=>this.syncManager.fetchAndResetFromAnvil());
+            this.saveProcessor.setPostSaveCallback((filePaths)=>this.syncAfterSave(filePaths));
             this.saveProcessor.on("save-started", (data)=>this.emit("save-started", data));
             this.saveProcessor.on("save-succeeded", (data)=>this.emit("save-succeeded", data));
             this.saveProcessor.on("save-failed", (data)=>this.emit("save-failed", data));
             this.saveProcessor.on("save-complete", (data)=>this.emit("save-complete", data));
+            this.saveProcessor.on("saved", (data)=>this.emit("saved", data));
+            this.saveProcessor.on("anvil-yaml-dependencies-changed", ()=>{
+                this.queueDependencyRefresh("anvil.yaml dependencies changed");
+            });
             this.saveProcessor.on("validation-failed", (data)=>this.emit("validation-failed", data));
             this.saveProcessor.on("sync-conflict", (data)=>this.emit("sync-conflict", data));
             this.saveProcessor.on("max-retries-exceeded", (data)=>this.emit("max-retries-exceeded", data));
         }
+        async syncAfterSave(savedFilePaths) {
+            const status = await this.gitService.getStatus();
+            const locallyChangedFiles = buildLocalChangesSet(status);
+            if (!this.stagedOnly) for (const filePath of savedFilePaths)locallyChangedFiles.add(filePath);
+            return this.syncManager.syncRemoteChanges(locallyChangedFiles);
+        }
         async connectWebSocket() {
             this.wsClient = new WebSocketClient({
                 appId: this.appId,
@@ -17943,7 +19115,9 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
                 currentBranch: this.currentBranch,
                 editSession: this.editSession,
                 username: this.username,
-                environment: this.environment
+                environment: this.environment,
+                dependencyWatch: this.dependencyWatchEnabled,
+                dependencySubscriptions: this.dependencyWatchEnabled ? await this.getDependencyWatchSubscriptions() : []
             });
             this.wsClient.on("env-state", ({ envs })=>{
                 for (const env of envs)this.handleEnvironmentBinding(env, "snapshot");
@@ -17951,7 +19125,8 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
             this.wsClient.on("env-update", (env)=>{
                 this.handleEnvironmentBinding(env, "update");
             });
-            this.wsClient.on("repo-update", async ({ ref, commitHash, saveSeq })=>{
+            this.wsClient.on("repo-update", async ({ appId, ref, commitHash, saveSeq })=>{
+                if (appId !== this.appId) return void await this.handleDependencyRepoUpdate(appId, ref, commitHash);
                 if (saveSeq?.session === this.editSession) return void logger_logger.debug("Ignoring update from our own session");
                 const branchName = ref.replace(/^refs\/heads\//, "");
                 if (branchName !== this.currentBranch) return void logger_logger.debug(`Ignoring update to different branch: ${branchName} (current: ${this.currentBranch})`);
@@ -17973,6 +19148,55 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
             });
             await this.wsClient.connect();
         }
+        async handleDependencyRepoUpdate(appId, ref, commitHash) {
+            if (!this.dependencyWatchEnabled) return;
+            const branchName = ref.replace(/^refs\/heads\//, "");
+            const subscription = this.wsClient?.getDependencySubscriptions().find((candidate)=>candidate.appId === appId && candidate.branch === branchName);
+            if (!subscription) return void logger_logger.debug(`Ignoring update for unwatched dependency app ${appId} on ${branchName}`);
+            logger_logger.verbose(external_chalk_default().cyan("Dependency update detected: ") + external_chalk_default().bold(subscription.packageName ?? appId) + external_chalk_default().gray(` (${branchName}, ${commitHash.substring(0, 8)})`));
+            await this.queueDependencyRefresh(`dependency ${appId} updated`);
+        }
+        async queueDependencyRefresh(reason) {
+            if (!this.dependencyWatchEnabled || this.isCleanedUp) return;
+            if (this.isRefreshingDependencies) {
+                this.hasPendingDependencyRefresh = true;
+                return;
+            }
+            this.isRefreshingDependencies = true;
+            try {
+                do {
+                    this.hasPendingDependencyRefresh = false;
+                    await this.refreshDependencies(reason);
+                }while (this.hasPendingDependencyRefresh && !this.isCleanedUp);
+            } finally{
+                this.isRefreshingDependencies = false;
+            }
+        }
+        async refreshDependencies(reason) {
+            if (!this.dependencyWatchEnabled || this.isCleanedUp) return;
+            logger_logger.progress("dependency-refresh", "startup" === reason ? "Fetching dependencies" : "Refreshing dependencies");
+            try {
+                const previousSubscriptions = this.wsClient?.getDependencySubscriptions() ?? [];
+                const { response, addedGitignoreEntry } = await refreshDependencyCache(this.repoPath, this.appId, this.anvilUrl, {
+                    includeDocs: true
+                });
+                if (addedGitignoreEntry) logger_logger.info("Added /.anvil/ to .gitignore");
+                const nextSubscriptions = await this.getDependencyWatchSubscriptions();
+                this.reconcileDependencySubscriptions(previousSubscriptions, nextSubscriptions);
+                logger_logger.progressEnd("dependency-refresh", response.dependencies.length ? `Fetched ${response.dependencies.length} dependencies` : "Dependencies already up to date");
+            } catch (error) {
+                logger_logger.progressEnd("dependency-refresh", "Failed");
+                logger_logger.warn(external_chalk_default().yellow(`Failed to refresh dependencies: ${errors_getErrorMessage(error)}`));
+            }
+        }
+        async getDependencyWatchSubscriptions() {
+            return getDependencyWatchSubscriptionsFromManifest(await readDepsCacheManifest(this.repoPath));
+        }
+        reconcileDependencySubscriptions(previousSubscriptions, nextSubscriptions) {
+            if (dependencySubscriptionsEqual(previousSubscriptions, nextSubscriptions)) return;
+            this.wsClient?.updateDependencySubscriptions(nextSubscriptions);
+            if (this.wsClient?.isConnected() && previousSubscriptions.length > 0) this.wsClient.reconnect();
+        }
         async handleEnvironmentBinding(env, source) {
             if (!this.environment?.envPid || env.envPid !== this.environment.envPid) return;
             this.environment = {
@@ -17995,6 +19219,7 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
         async switchToEnvironmentBranch(targetBranch, source) {
             if (this.isCleanedUp) return;
             this.isSwitchingForEnvironment = true;
+            this.environmentSwitchTargetBranch = targetBranch;
             const oldPausedState = this.isPausedForUserInput;
             try {
                 const status = await this.gitService.getStatus();
@@ -18019,6 +19244,8 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
                     ]);
                 }
                 logger_logger.verbose(external_chalk_default().cyan(`Environment branch ${"snapshot" === source ? "snapshot" : "update"}: `) + external_chalk_default().bold(`${this.currentBranch} -> ${targetBranch}`));
+                this.authToken = await auth_getValidAuthToken(this.anvilUrl, this.username);
+                this.wsClient?.updateAuthToken?.(this.authToken);
                 const fetchUrl = anvil_api_getGitFetchUrl(this.appId, this.authToken, this.anvilUrl);
                 const envRemoteRef = environment_environmentRemoteRefForBranch(targetBranch);
                 await this.gitService.fetch(fetchUrl, environment_environmentFetchRefSpecForBranch(targetBranch));
@@ -18034,6 +19261,7 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
                 this.lastBranchChangeTime = Date.now();
                 this.fileWatcher?.setCurrentBranch(targetBranch);
                 this.wsClient?.updateBranch(targetBranch);
+                this.queueDependencyRefresh("branch changed");
                 await this.initializeLocalChangeFingerprint();
                 this.emit("branch-changed", {
                     oldBranch,
@@ -18053,6 +19281,7 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
             } finally{
                 this.isPausedForUserInput = oldPausedState;
                 this.isSwitchingForEnvironment = false;
+                this.environmentSwitchTargetBranch = null;
             }
             const pendingSwitch = this.pendingEnvironmentBranchSwitch;
             this.pendingEnvironmentBranchSwitch = null;
@@ -18104,7 +19333,13 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
             });
         }
         async syncRemoteChanges(knownLocalChanges) {
-            return this.syncManager.syncRemoteChanges(knownLocalChanges);
+            const previousDependencies = this.dependencyWatchEnabled ? await readAnvilYamlDependencies(this.repoPath) : void 0;
+            const result = await this.syncManager.syncRemoteChanges(knownLocalChanges);
+            if (this.dependencyWatchEnabled && void 0 !== previousDependencies) {
+                const currentDependencies = await readAnvilYamlDependencies(this.repoPath);
+                if (!anvilYamlDependenciesEqual(previousDependencies, currentDependencies)) await this.queueDependencyRefresh("anvil.yaml dependencies changed");
+            }
+            return result;
         }
         cleanup() {
             this.isCleanedUp = true;
@@ -18134,15 +19369,7 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
                 getCurrentBranch: async ()=>this.gitService.getCurrentBranch()
             });
             this.fileWatcher.on("branch-change", ({ newBranch })=>{
-                const oldBranch = this.currentBranch;
-                logger_logger.verbose(external_chalk_default().gray("   Pausing sync for 2 seconds to allow branch to settle..."));
-                this.currentBranch = newBranch;
-                this.lastBranchChangeTime = Date.now();
-                this.wsClient?.updateBranch(newBranch);
-                this.emit("branch-changed", {
-                    oldBranch,
-                    newBranch
-                });
+                this.handleFileWatcherBranchChange(newBranch);
             });
             this.fileWatcher.on("index-change", ()=>{
                 this.saveProcessor?.queueSave();
@@ -18159,6 +19386,23 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
             this.startLocalChangeFallbackPolling();
             await new Promise(()=>{});
         }
+        handleFileWatcherBranchChange(newBranch) {
+            if (this.isSwitchingForEnvironment && newBranch === this.environmentSwitchTargetBranch) return void logger_logger.debug(`Ignoring FileWatcher branch-change during environment switch: ${newBranch}`);
+            const oldBranch = this.currentBranch;
+            logger_logger.verbose(external_chalk_default().gray("   Pausing sync for 2 seconds to allow branch to settle..."));
+            this.currentBranch = newBranch;
+            this.lastBranchChangeTime = Date.now();
+            this.wsClient?.updateBranch(newBranch);
+            this.queueDependencyRefresh("branch changed");
+            this.emit("external-branch-changed", {
+                oldBranch,
+                newBranch
+            });
+            this.emit("branch-changed", {
+                oldBranch,
+                newBranch
+            });
+        }
         startWatchingInBackground(onError) {
             this.startWatching().catch((error)=>{
                 this.cleanup();
@@ -18284,6 +19528,12 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
             return false;
         }
     }
+    function dependencySubscriptionsEqual(left, right) {
+        return subscriptionKeys(left).join("\n") === subscriptionKeys(right).join("\n");
+    }
+    function subscriptionKeys(subscriptions) {
+        return subscriptions.map((subscription)=>`${subscription.appId}\0${subscription.branch}`).sort();
+    }
     async function validation_validateAnvilApp(repoPath) {
         const anvilYamlPath = external_path_default().join(repoPath, "anvil.yaml");
         if (!external_fs_.existsSync(anvilYamlPath)) throw createValidationError.missingYaml(repoPath);
@@ -18501,6 +19751,367 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
     }
     require("inquirer");
     require("ora");
+    const defaultGitAuthDoctorDeps = {
+        getAppAuthBinding: git_auth_getAppAuthBinding,
+        getAccountsForUrl: auth_getAccountsForUrl,
+        hasTokensForUrl: auth_hasTokensForUrl,
+        runCredentialFill: runGitCredentialFill
+    };
+    function getHighestStatus(statuses) {
+        if (statuses.includes("error")) return "error";
+        if (statuses.includes("warning")) return "warning";
+        return "ok";
+    }
+    function finding(status, code, message) {
+        return {
+            status,
+            code,
+            message
+        };
+    }
+    function redactSecrets(value) {
+        return value.replace(/^password=.*$/gim, "password=<redacted>").replace(/(https?:\/\/git:)[^@\s]+@/g, "$1<redacted>@").replace(/(access[_-]?token=)[^&\s]+/gi, "$1<redacted>").replace(/(refresh[_-]?token=)[^&\s]+/gi, "$1<redacted>");
+    }
+    function splitShellCommand(command) {
+        const tokens = [];
+        let current = "";
+        let state = "normal";
+        for(let i = 0; i < command.length; i++){
+            const ch = command[i];
+            if ("single" === state) {
+                if ("'" === ch) state = "normal";
+                else current += ch;
+                continue;
+            }
+            if ("double" === state) {
+                if ("\"" === ch) state = "normal";
+                else if ("\\" === ch && i + 1 < command.length && [
+                    "$",
+                    "`",
+                    "\"",
+                    "\\",
+                    "\n"
+                ].includes(command[i + 1])) current += command[++i];
+                else current += ch;
+                continue;
+            }
+            if (/\s/.test(ch)) {
+                if (current) {
+                    tokens.push(current);
+                    current = "";
+                }
+            } else if ("'" === ch) state = "single";
+            else if ("\"" === ch) state = "double";
+            else if ("\\" === ch && i + 1 < command.length) current += command[++i];
+            else current += ch;
+        }
+        if ("normal" !== state) throw new Error("Unterminated quote in helper command");
+        if (current) tokens.push(current);
+        return tokens;
+    }
+    function parseCredentialHelperCommand(command) {
+        const trimmed = command.trim();
+        if (!trimmed || !trimmed.startsWith("!")) return {};
+        const tokens = splitShellCommand(trimmed.slice(1).trim());
+        return {
+            execPath: tokens[0],
+            helperPath: tokens[1]
+        };
+    }
+    function readHelperModulePath(helperPath) {
+        try {
+            const helperSource = external_fs_default().readFileSync(helperPath, "utf8");
+            const match = helperSource.match(/executeGitCredentialOperation\s*}\s*=\s*require\((["'])(.*?)\1\)/);
+            return match?.[2];
+        } catch  {
+            return;
+        }
+    }
+    function inspectCredentialHelperCommand(raw) {
+        const details = {
+            raw
+        };
+        try {
+            const parsed = parseCredentialHelperCommand(raw);
+            details.execPath = parsed.execPath;
+            details.helperPath = parsed.helperPath;
+        } catch (e) {
+            details.parseError = e.message;
+            return details;
+        }
+        if (details.execPath) details.execExists = external_fs_default().existsSync(details.execPath);
+        if (details.helperPath) {
+            details.helperExists = external_fs_default().existsSync(details.helperPath);
+            if (details.helperExists) {
+                try {
+                    const stat = external_fs_default().statSync(details.helperPath);
+                    details.helperExecutable = (73 & stat.mode) !== 0;
+                } catch  {
+                    details.helperExecutable = false;
+                }
+                details.modulePath = readHelperModulePath(details.helperPath);
+                if (details.modulePath) details.moduleExists = external_fs_default().existsSync(details.modulePath);
+            }
+        }
+        return details;
+    }
+    function detectAnvilRemote(remote) {
+        const fetchUrl = remote.refs.fetch;
+        const out = {
+            name: remote.name,
+            fetchUrl
+        };
+        if (!fetchUrl) return out;
+        const httpMatch = fetchUrl.match(/^(https?):\/\/(?:[^@/?#]+@)?([^/?#]+)\/git\/([A-Z0-9]+)\.git(?:[?#].*)?$/);
+        if (httpMatch) {
+            const [, protocol, host, appId] = httpMatch;
+            return {
+                ...out,
+                appId,
+                anvilUrl: config_normalizeAnvilUrl(`${protocol}://${host}`),
+                transport: "https"
+            };
+        }
+        const sshMatch = fetchUrl.match(/^ssh:\/\/(?:([^@]+)@)?([^:\/]+)(?::\d+)?\/(?:git\/)?([A-Z0-9]+)\.git(?:[?#].*)?$/);
+        if (sshMatch) {
+            const [, , host, appId] = sshMatch;
+            return {
+                ...out,
+                appId,
+                anvilUrl: config_normalizeAnvilUrl(host),
+                transport: "ssh"
+            };
+        }
+        return out;
+    }
+    async function getLocalConfigValues(repoPath, key) {
+        try {
+            const output = await esm_default(repoPath).raw([
+                "config",
+                "--local",
+                "--get-all",
+                key
+            ]);
+            const values = output.split(/\r?\n/);
+            if ("" === values[values.length - 1]) values.pop();
+            return values;
+        } catch  {
+            return [];
+        }
+    }
+    function buildCredentialInput(anvilUrl, appId) {
+        const url = new URL(anvilUrl);
+        return `protocol=${url.protocol.replace(/:$/, "")}\nhost=${url.host}\npath=git/${appId}.git\n\n`;
+    }
+    async function runGitCredentialFill(repoPath, input) {
+        return new Promise((resolve)=>{
+            const child = (0, external_child_process_namespaceObject.spawn)("git", [
+                "credential",
+                "fill"
+            ], {
+                cwd: repoPath,
+                env: {
+                    ...process.env,
+                    GIT_TERMINAL_PROMPT: "0"
+                },
+                stdio: [
+                    "pipe",
+                    "pipe",
+                    "pipe"
+                ]
+            });
+            let stdout = "";
+            let stderr = "";
+            child.stdout.setEncoding("utf8");
+            child.stderr.setEncoding("utf8");
+            child.stdout.on("data", (chunk)=>{
+                stdout += chunk;
+            });
+            child.stderr.on("data", (chunk)=>{
+                stderr += chunk;
+            });
+            child.on("error", (error)=>{
+                resolve({
+                    exitCode: null,
+                    stdout: redactSecrets(stdout),
+                    stderr: redactSecrets(stderr),
+                    error: redactSecrets(error.message)
+                });
+            });
+            child.on("close", (code)=>{
+                resolve({
+                    exitCode: code,
+                    stdout: redactSecrets(stdout),
+                    stderr: redactSecrets(stderr)
+                });
+            });
+            child.stdin.end(input);
+        });
+    }
+    async function buildAppReport(repoPath, remote, deps) {
+        const appId = remote.appId;
+        const anvilUrl = remote.anvilUrl;
+        const url = new URL(anvilUrl);
+        const credentialScope = `${url.protocol}//${url.host}`;
+        const helperConfigKey = `credential.${credentialScope}.helper`;
+        const helperValues = await getLocalConfigValues(repoPath, helperConfigKey);
+        const nonEmptyHelperValues = helperValues.filter((value)=>"" !== value.trim());
+        const helperDetails = nonEmptyHelperValues.map(inspectCredentialHelperCommand);
+        const findings = [];
+        if (0 === helperValues.length) findings.push(finding("error", "missing_helper_config", `No local ${helperConfigKey} entries found.`));
+        else if (0 === nonEmptyHelperValues.length) findings.push(finding("error", "missing_helper_command", `${helperConfigKey} only resets helpers; no Anvil helper command is configured.`));
+        for (const helper of helperDetails){
+            if (helper.parseError) findings.push(finding("error", "helper_parse_failed", `Could not parse helper command: ${helper.parseError}`));
+            if (helper.execPath && false === helper.execExists) findings.push(finding("error", "helper_exec_missing", `Credential helper Node executable does not exist: ${helper.execPath}`));
+            if (helper.helperPath) {
+                if (false === helper.helperExists) findings.push(finding("error", "helper_file_missing", `Credential helper script does not exist: ${helper.helperPath}`));
+                else if (false === helper.helperExecutable) findings.push(finding("warning", "helper_not_executable", `Credential helper script is not executable: ${helper.helperPath}`));
+            } else findings.push(finding("error", "helper_path_missing", "Credential helper command does not include a helper script path."));
+            if (helper.modulePath && false === helper.moduleExists) findings.push(finding("error", "helper_module_missing", `Generated helper points at a missing module: ${helper.modulePath}`));
+            if (helper.modulePath && "cli.js" === external_path_default().basename(helper.modulePath)) findings.push(finding("error", "helper_module_cli_entry", `Generated helper points at the CLI entry instead of the API entry: ${helper.modulePath}`));
+        }
+        const binding = await deps.getAppAuthBinding(repoPath, appId);
+        if (!binding.url) findings.push(finding("warning", "missing_app_binding_url", `No anvil.auth.${appId}.url binding is configured.`));
+        if (!binding.username) findings.push(finding("warning", "missing_app_binding_username", `No anvil.auth.${appId}.username binding is configured.`));
+        const authUrl = binding.url ? config_normalizeAnvilUrl(binding.url) : anvilUrl;
+        let accounts = [];
+        let authUsername = binding.username;
+        let hasUsableAuth = false;
+        try {
+            accounts = await deps.getAccountsForUrl(authUrl);
+            if (authUsername || 1 !== accounts.length) {
+                if (!authUsername && accounts.length > 1) findings.push(finding("error", "multiple_accounts_without_binding", `Multiple accounts are logged in for ${authUrl}; bind one with anvil checkout --user.`));
+            } else authUsername = accounts[0];
+            hasUsableAuth = authUsername ? await deps.hasTokensForUrl(authUrl, authUsername) : accounts.length <= 1 && await deps.hasTokensForUrl(authUrl);
+            if (!hasUsableAuth) findings.push(finding("error", "missing_usable_auth", authUsername ? `No usable auth tokens found for ${authUrl} as ${authUsername}.` : `No usable auth tokens found for ${authUrl}.`));
+        } catch (e) {
+            findings.push(finding("error", "auth_lookup_failed", `Auth lookup failed: ${redactSecrets(e.message)}`));
+        }
+        const fillResult = await deps.runCredentialFill(repoPath, buildCredentialInput(anvilUrl, appId));
+        const credentialSimulation = {
+            status: 0 === fillResult.exitCode && /^password=/im.test(fillResult.stdout) ? "ok" : "error",
+            exitCode: fillResult.exitCode,
+            stdout: redactSecrets(fillResult.stdout),
+            stderr: redactSecrets(fillResult.stderr),
+            error: fillResult.error ? redactSecrets(fillResult.error) : void 0
+        };
+        if ("ok" !== credentialSimulation.status) findings.push(finding("error", "credential_fill_failed", credentialSimulation.error || credentialSimulation.stderr.trim() || "git credential fill did not return a password."));
+        const report = {
+            appId,
+            anvilUrl,
+            remoteName: remote.name,
+            remoteUrl: remote.fetchUrl,
+            credentialScope,
+            helperConfigKey,
+            helperValues,
+            helperDetails,
+            binding: {
+                url: binding.url,
+                username: binding.username,
+                hasUrl: !!binding.url,
+                hasUsername: !!binding.username
+            },
+            auth: {
+                url: authUrl,
+                username: authUsername,
+                accounts,
+                hasUsableAuth
+            },
+            credentialSimulation,
+            findings
+        };
+        return report;
+    }
+    async function buildGitAuthDoctorReport(repoPathInput = process.cwd(), options = {}) {
+        const deps = options.deps ?? defaultGitAuthDoctorDeps;
+        const inputPath = external_path_default().resolve(repoPathInput);
+        const git = esm_default(inputPath);
+        const repoPath = (await git.raw([
+            "rev-parse",
+            "--show-toplevel"
+        ])).trim();
+        const rawGitDir = (await git.raw([
+            "rev-parse",
+            "--git-dir"
+        ])).trim();
+        const gitDir = external_path_default().isAbsolute(rawGitDir) ? rawGitDir : external_path_default().resolve(inputPath, rawGitDir);
+        auth_setRepoContext(repoPath);
+        const remotes = (await git.getRemotes(true)).map(detectAnvilRemote);
+        const anvilRemotes = remotes.filter((remote)=>remote.appId && remote.anvilUrl && "https" === remote.transport);
+        const findings = [];
+        if (0 === anvilRemotes.length) findings.push(finding("error", "missing_anvil_https_remote", "No HTTPS Anvil git remotes were detected."));
+        const apps = await Promise.all(anvilRemotes.map((remote)=>buildAppReport(repoPath, remote, deps)));
+        const status = getHighestStatus([
+            ...findings.map((item)=>item.status),
+            ...apps.flatMap((app)=>app.findings.map((item)=>item.status))
+        ]);
+        return {
+            repoPath,
+            gitDir,
+            remotes,
+            apps,
+            findings,
+            status
+        };
+    }
+    function formatStatus(status) {
+        if ("ok" === status) return external_chalk_default().green("[ok]");
+        if ("warning" === status) return external_chalk_default().yellow("[warn]");
+        return external_chalk_default().red("[error]");
+    }
+    function formatGitAuthDoctorReport(report) {
+        const lines = [];
+        lines.push(external_chalk_default().bold("Git auth doctor"));
+        lines.push(`Repository: ${report.repoPath}`);
+        lines.push(`Git dir: ${report.gitDir}`);
+        lines.push(`Overall: ${formatStatus(report.status)}`);
+        lines.push("");
+        lines.push(external_chalk_default().bold("Detected remotes:"));
+        if (0 === report.remotes.length) lines.push("  (none)");
+        else for (const remote of report.remotes){
+            const appText = remote.appId && remote.anvilUrl ? ` -> ${remote.appId} on ${remote.anvilUrl}` : "";
+            lines.push(`  - ${remote.name}: ${remote.fetchUrl || "(no fetch URL)"}${appText}`);
+        }
+        for (const app of report.apps){
+            lines.push("");
+            lines.push(external_chalk_default().bold(`App ${app.appId} (${app.remoteName})`));
+            lines.push(`  URL: ${app.anvilUrl}`);
+            lines.push(`  Credential scope: ${app.credentialScope}`);
+            lines.push(`  Helper config: ${app.helperConfigKey}`);
+            if (0 === app.helperValues.length) lines.push("    (none)");
+            else for (const value of app.helperValues)lines.push(`    - ${value || "(reset helper list)"}`);
+            for (const helper of app.helperDetails){
+                lines.push(`  Helper command: ${helper.raw}`);
+                lines.push(`    Node: ${helper.execPath || "(missing)"} ${false === helper.execExists ? "[missing]" : ""}`.trimEnd());
+                lines.push(`    Script: ${helper.helperPath || "(missing)"} ${false === helper.helperExists ? "[missing]" : ""}`.trimEnd());
+                if (helper.modulePath) lines.push(`    Module: ${helper.modulePath} ${false === helper.moduleExists ? "[missing]" : ""}`.trimEnd());
+            }
+            lines.push(`  Binding URL: ${app.binding.url || "(missing)"}`);
+            lines.push(`  Binding user: ${app.binding.username || "(missing)"}`);
+            lines.push(`  Auth tokens: ${app.auth.hasUsableAuth ? "available" : "not available"}${app.auth.username ? ` for ${app.auth.username}` : ""}`);
+            if (app.credentialSimulation) {
+                lines.push(`  Credential fill: ${formatStatus(app.credentialSimulation.status)} exit=${app.credentialSimulation.exitCode}`);
+                if (app.credentialSimulation.stdout.trim()) {
+                    lines.push("    stdout:");
+                    for (const line of app.credentialSimulation.stdout.trim().split(/\r?\n/))lines.push(`      ${line}`);
+                }
+                if (app.credentialSimulation.stderr.trim()) {
+                    lines.push("    stderr:");
+                    for (const line of app.credentialSimulation.stderr.trim().split(/\r?\n/))lines.push(`      ${line}`);
+                }
+            }
+            if (app.findings.length > 0) {
+                lines.push("  Findings:");
+                for (const item of app.findings)lines.push(`    ${formatStatus(item.status)} ${item.code}: ${item.message}`);
+            }
+        }
+        if (report.findings.length > 0) {
+            lines.push("");
+            lines.push(external_chalk_default().bold("Repository findings:"));
+            for (const item of report.findings)lines.push(`  ${formatStatus(item.status)} ${item.code}: ${item.message}`);
+        }
+        return lines.join("\n");
+    }
     const gitCredential_defaultDeps = {
         getValidAuthToken: auth_getValidAuthToken,
         getAccountsForUrl: auth_getAccountsForUrl,
@@ -18803,7 +20414,8 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
                 authToken,
                 currentBranch,
                 commitId,
-                username
+                username,
+                dependencyWatch: false
             });
             await session.initialize();
             await session.syncRemoteChanges();
@@ -18900,7 +20512,8 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
             stagedOnly,
             username,
             environment,
-            envBranchChangeMode: options.envBranchChangeMode ?? "manual"
+            envBranchChangeMode: options.envBranchChangeMode ?? "manual",
+            dependencyWatch: options.dependencyWatch ?? true
         });
         session.on("branch-changed", (data)=>{
             logger_logger.debug("Event: branch-changed", data);
@@ -18956,6 +20569,7 @@ exports.ValidationIssue = __webpack_exports__.ValidationIssue;
 exports.ValidationTarget = __webpack_exports__.ValidationTarget;
 exports.WatchSession = __webpack_exports__.WatchSession;
 exports.branchFromEnvironmentVersion = __webpack_exports__.branchFromEnvironmentVersion;
+exports.buildGitAuthDoctorReport = __webpack_exports__.buildGitAuthDoctorReport;
 exports.checkUncommittedChanges = __webpack_exports__.checkUncommittedChanges;
 exports.clearInMemoryTokens = __webpack_exports__.clearInMemoryTokens;
 exports.createWatchDiagnostic = __webpack_exports__.createWatchDiagnostic;
@@ -18967,6 +20581,7 @@ exports.executeCheckout = __webpack_exports__.executeCheckout;
 exports.executeGitCredentialOperation = __webpack_exports__.executeGitCredentialOperation;
 exports.filterCandidates = __webpack_exports__.filterCandidates;
 exports.formatCandidateLabel = __webpack_exports__.formatCandidateLabel;
+exports.formatGitAuthDoctorReport = __webpack_exports__.formatGitAuthDoctorReport;
 exports.formatValidationPath = __webpack_exports__.formatValidationPath;
 exports.getAccountsForUrl = __webpack_exports__.getAccountsForUrl;
 exports.getAllConfig = __webpack_exports__.getAllConfig;
@@ -18982,6 +20597,7 @@ exports.getSettableConfigKeys = __webpack_exports__.getSettableConfigKeys;
 exports.getValidAuthToken = __webpack_exports__.getValidAuthToken;
 exports.getWebSocketUrl = __webpack_exports__.getWebSocketUrl;
 exports.hasTokensForUrl = __webpack_exports__.hasTokensForUrl;
+exports.inspectCredentialHelperCommand = __webpack_exports__.inspectCredentialHelperCommand;
 exports.isCommandAvailable = __webpack_exports__.isCommandAvailable;
 exports.isDirectoryNonEmpty = __webpack_exports__.isDirectoryNonEmpty;
 exports.isPathInsideGitRepo = __webpack_exports__.isPathInsideGitRepo;
@@ -18992,6 +20608,7 @@ exports.lookupRemoteInfoForAppId = __webpack_exports__.lookupRemoteInfoForAppId;
 exports.normalizeAnvilUrl = __webpack_exports__.normalizeAnvilUrl;
 exports.parseCheckoutInput = __webpack_exports__.parseCheckoutInput;
 exports.parseConfigSetValue = __webpack_exports__.parseConfigSetValue;
+exports.parseCredentialHelperCommand = __webpack_exports__.parseCredentialHelperCommand;
 exports.pollDeviceAuthorization = __webpack_exports__.pollDeviceAuthorization;
 exports.preferredEditors = __webpack_exports__.preferredEditors;
 exports.readEnvironmentPid = __webpack_exports__.readEnvironmentPid;
@@ -19011,6 +20628,7 @@ exports.validateAppId = __webpack_exports__.validateAppId;
 exports.validateBranchSyncStatus = __webpack_exports__.validateBranchSyncStatus;
 exports.validateCheckoutDestination = __webpack_exports__.validateCheckoutDestination;
 exports.validateFormTemplate = __webpack_exports__.validateFormTemplate;
+exports.validateFormTemplateHtml = __webpack_exports__.validateFormTemplateHtml;
 exports.validatePath = __webpack_exports__.validatePath;
 exports.verifyAndStoreTokens = __webpack_exports__.verifyAndStoreTokens;
 exports.verifyAuth = __webpack_exports__.verifyAuth;
@@ -19043,6 +20661,7 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "ValidationTarget",
     "WatchSession",
     "branchFromEnvironmentVersion",
+    "buildGitAuthDoctorReport",
     "checkUncommittedChanges",
     "clearInMemoryTokens",
     "createWatchDiagnostic",
@@ -19054,6 +20673,7 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "executeGitCredentialOperation",
     "filterCandidates",
     "formatCandidateLabel",
+    "formatGitAuthDoctorReport",
     "formatValidationPath",
     "getAccountsForUrl",
     "getAllConfig",
@@ -19069,6 +20689,7 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "getValidAuthToken",
     "getWebSocketUrl",
     "hasTokensForUrl",
+    "inspectCredentialHelperCommand",
     "isCommandAvailable",
     "isDirectoryNonEmpty",
     "isPathInsideGitRepo",
@@ -19079,6 +20700,7 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "normalizeAnvilUrl",
     "parseCheckoutInput",
     "parseConfigSetValue",
+    "parseCredentialHelperCommand",
     "pollDeviceAuthorization",
     "preferredEditors",
     "readEnvironmentPid",
@@ -19098,6 +20720,7 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "validateBranchSyncStatus",
     "validateCheckoutDestination",
     "validateFormTemplate",
+    "validateFormTemplateHtml",
     "validatePath",
     "verifyAndStoreTokens",
     "verifyAuth",