@anvil-works/anvil-cli 0.5.15 → 0.6.1-canary.0

package/dist/cli.js

@@ -33721,6 +33721,7 @@ var __webpack_exports__ = {};
     var commander = __webpack_require__("./node_modules/.pnpm/commander@14.0.2/node_modules/commander/index.js");
     const { program: esm_program, createCommand, createArgument, createOption, CommanderError, InvalidArgumentError, InvalidOptionArgumentError, Command, Argument, Option, Help } = commander;
     var external_fs_ = __webpack_require__("fs");
+    var external_fs_default = /*#__PURE__*/ __webpack_require__.n(external_fs_);
     const external_path_namespaceObject = require("path");
     var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
     var semver = __webpack_require__("./node_modules/.pnpm/semver@7.7.3/node_modules/semver/index.js");
@@ -41840,18 +41841,27 @@ var __webpack_exports__ = {};
         if (list.length > 1) return `(${list.join(` ${separator} `)})`;
         return list[0] ?? "never";
     }
-    function minValue(requirement, message$1) {
+    function getDotPath(issue) {
+        if (issue.path) {
+            let key = "";
+            for (const item of issue.path)if ("string" != typeof item.key && "number" != typeof item.key) return null;
+            else if (key) key += `.${item.key}`;
+            else key += item.key;
+            return key;
+        }
+        return null;
+    }
+    function dist_nonEmpty(message$1) {
         return {
             kind: "validation",
-            type: "min_value",
-            reference: minValue,
+            type: "non_empty",
+            reference: dist_nonEmpty,
             async: false,
-            expects: `>=${requirement instanceof Date ? requirement.toJSON() : /* @__PURE__ */ _stringify(requirement)}`,
-            requirement,
+            expects: "!0",
             message: message$1,
             "~run" (dataset, config$1) {
-                if (dataset.typed && !(dataset.value >= this.requirement)) _addIssue(this, "value", dataset, config$1, {
-                    received: dataset.value instanceof Date ? dataset.value.toJSON() : /* @__PURE__ */ _stringify(dataset.value)
+                if (dataset.typed && 0 === dataset.value.length) _addIssue(this, "length", dataset, config$1, {
+                    received: "0"
                 });
                 return dataset;
             }
@@ -41961,53 +41971,30 @@ var __webpack_exports__ = {};
             }
         };
     }
-    function nullable(wrapped, default_) {
-        return {
-            kind: "schema",
-            type: "nullable",
-            reference: nullable,
-            expects: `(${wrapped.expects} | null)`,
-            async: false,
-            wrapped,
-            default: default_,
-            get "~standard" () {
-                return /* @__PURE__ */ _getStandardProps(this);
-            },
-            "~run" (dataset, config$1) {
-                if (null === dataset.value) {
-                    if (void 0 !== this.default) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
-                    if (null === dataset.value) {
-                        dataset.typed = true;
-                        return dataset;
-                    }
-                }
-                return this.wrapped["~run"](dataset, config$1);
-            }
-        };
-    }
-    function dist_number(message$1) {
+    function custom(check$1, message$1) {
         return {
             kind: "schema",
-            type: "number",
-            reference: dist_number,
-            expects: "number",
+            type: "custom",
+            reference: custom,
+            expects: "unknown",
             async: false,
+            check: check$1,
             message: message$1,
             get "~standard" () {
                 return /* @__PURE__ */ _getStandardProps(this);
             },
             "~run" (dataset, config$1) {
-                if ("number" != typeof dataset.value || isNaN(dataset.value)) _addIssue(this, "type", dataset, config$1);
-                else dataset.typed = true;
+                if (this.check(dataset.value)) dataset.typed = true;
+                else _addIssue(this, "type", dataset, config$1);
                 return dataset;
             }
         };
     }
-    function dist_object(entries$1, message$1) {
+    function looseObject(entries$1, message$1) {
         return {
             kind: "schema",
-            type: "object",
-            reference: dist_object,
+            type: "loose_object",
+            reference: looseObject,
             expects: "Object",
             async: false,
             entries: entries$1,
@@ -42068,17 +42055,20 @@ var __webpack_exports__ = {};
                             if (config$1.abortEarly) break;
                         }
                     }
+                    if (!dataset.issues || !config$1.abortEarly) {
+                        for(const key in input)if (/* @__PURE__ */ _isValidObjectKey(input, key) && !(key in this.entries)) dataset.value[key] = input[key];
+                    }
                 } else _addIssue(this, "type", dataset, config$1);
                 return dataset;
             }
         };
     }
-    function optional(wrapped, default_) {
+    function nullable(wrapped, default_) {
         return {
             kind: "schema",
-            type: "optional",
-            reference: optional,
-            expects: `(${wrapped.expects} | undefined)`,
+            type: "nullable",
+            reference: nullable,
+            expects: `(${wrapped.expects} | null)`,
             async: false,
             wrapped,
             default: default_,
@@ -42086,9 +42076,9 @@ var __webpack_exports__ = {};
                 return /* @__PURE__ */ _getStandardProps(this);
             },
             "~run" (dataset, config$1) {
-                if (void 0 === dataset.value) {
+                if (null === dataset.value) {
                     if (void 0 !== this.default) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
-                    if (void 0 === dataset.value) {
+                    if (null === dataset.value) {
                         dataset.typed = true;
                         return dataset;
                     }
@@ -42097,151 +42087,81 @@ var __webpack_exports__ = {};
             }
         };
     }
-    function record(key, value$1, message$1) {
+    function dist_number(message$1) {
         return {
             kind: "schema",
-            type: "record",
-            reference: record,
-            expects: "Object",
+            type: "number",
+            reference: dist_number,
+            expects: "number",
             async: false,
-            key,
-            value: value$1,
             message: message$1,
             get "~standard" () {
                 return /* @__PURE__ */ _getStandardProps(this);
             },
             "~run" (dataset, config$1) {
-                const input = dataset.value;
-                if (input && "object" == typeof input) {
-                    dataset.typed = true;
-                    dataset.value = {};
-                    for(const entryKey in input)if (/* @__PURE__ */ _isValidObjectKey(input, entryKey)) {
-                        const entryValue = input[entryKey];
-                        const keyDataset = this.key["~run"]({
-                            value: entryKey
-                        }, config$1);
-                        if (keyDataset.issues) {
-                            const pathItem = {
-                                type: "object",
-                                origin: "key",
-                                input,
-                                key: entryKey,
-                                value: entryValue
-                            };
-                            for (const issue of keyDataset.issues){
-                                issue.path = [
-                                    pathItem
-                                ];
-                                dataset.issues?.push(issue);
-                            }
-                            if (!dataset.issues) dataset.issues = keyDataset.issues;
-                            if (config$1.abortEarly) {
-                                dataset.typed = false;
-                                break;
-                            }
-                        }
-                        const valueDataset = this.value["~run"]({
-                            value: entryValue
-                        }, config$1);
-                        if (valueDataset.issues) {
-                            const pathItem = {
-                                type: "object",
-                                origin: "value",
-                                input,
-                                key: entryKey,
-                                value: entryValue
-                            };
-                            for (const issue of valueDataset.issues){
-                                if (issue.path) issue.path.unshift(pathItem);
-                                else issue.path = [
-                                    pathItem
-                                ];
-                                dataset.issues?.push(issue);
-                            }
-                            if (!dataset.issues) dataset.issues = valueDataset.issues;
-                            if (config$1.abortEarly) {
-                                dataset.typed = false;
-                                break;
-                            }
-                        }
-                        if (!keyDataset.typed || !valueDataset.typed) dataset.typed = false;
-                        if (keyDataset.typed) dataset.value[keyDataset.value] = valueDataset.value;
-                    }
-                } else _addIssue(this, "type", dataset, config$1);
+                if ("number" != typeof dataset.value || isNaN(dataset.value)) _addIssue(this, "type", dataset, config$1);
+                else dataset.typed = true;
                 return dataset;
             }
         };
     }
-    function dist_string(message$1) {
+    function optional(wrapped, default_) {
         return {
             kind: "schema",
-            type: "string",
-            reference: dist_string,
-            expects: "string",
+            type: "optional",
+            reference: optional,
+            expects: `(${wrapped.expects} | undefined)`,
+            async: false,
+            wrapped,
+            default: default_,
+            get "~standard" () {
+                return /* @__PURE__ */ _getStandardProps(this);
+            },
+            "~run" (dataset, config$1) {
+                if (void 0 === dataset.value) {
+                    if (void 0 !== this.default) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
+                    if (void 0 === dataset.value) {
+                        dataset.typed = true;
+                        return dataset;
+                    }
+                }
+                return this.wrapped["~run"](dataset, config$1);
+            }
+        };
+    }
+    function picklist(options, message$1) {
+        return {
+            kind: "schema",
+            type: "picklist",
+            reference: picklist,
+            expects: /* @__PURE__ */ _joinExpects(options.map(_stringify), "|"),
             async: false,
+            options,
             message: message$1,
             get "~standard" () {
                 return /* @__PURE__ */ _getStandardProps(this);
             },
             "~run" (dataset, config$1) {
-                if ("string" == typeof dataset.value) dataset.typed = true;
+                if (this.options.includes(dataset.value)) dataset.typed = true;
                 else _addIssue(this, "type", dataset, config$1);
                 return dataset;
             }
         };
     }
-    function _subIssues(datasets) {
-        let issues;
-        if (datasets) for (const dataset of datasets)if (issues) issues.push(...dataset.issues);
-        else issues = dataset.issues;
-        return issues;
-    }
-    function union(options, message$1) {
+    function dist_string(message$1) {
         return {
             kind: "schema",
-            type: "union",
-            reference: union,
-            expects: /* @__PURE__ */ _joinExpects(options.map((option)=>option.expects), "|"),
+            type: "string",
+            reference: dist_string,
+            expects: "string",
             async: false,
-            options,
             message: message$1,
             get "~standard" () {
                 return /* @__PURE__ */ _getStandardProps(this);
             },
             "~run" (dataset, config$1) {
-                let validDataset;
-                let typedDatasets;
-                let untypedDatasets;
-                for (const schema of this.options){
-                    const optionDataset = schema["~run"]({
-                        value: dataset.value
-                    }, config$1);
-                    if (optionDataset.typed) if (optionDataset.issues) if (typedDatasets) typedDatasets.push(optionDataset);
-                    else typedDatasets = [
-                        optionDataset
-                    ];
-                    else {
-                        validDataset = optionDataset;
-                        break;
-                    }
-                    else if (untypedDatasets) untypedDatasets.push(optionDataset);
-                    else untypedDatasets = [
-                        optionDataset
-                    ];
-                }
-                if (validDataset) return validDataset;
-                if (typedDatasets) {
-                    if (1 === typedDatasets.length) return typedDatasets[0];
-                    _addIssue(this, "type", dataset, config$1, {
-                        issues: /* @__PURE__ */ _subIssues(typedDatasets)
-                    });
-                    dataset.typed = true;
-                } else {
-                    if (untypedDatasets?.length === 1) return untypedDatasets[0];
-                    _addIssue(this, "type", dataset, config$1, {
-                        issues: /* @__PURE__ */ _subIssues(untypedDatasets)
-                    });
-                }
+                if ("string" == typeof dataset.value) dataset.typed = true;
+                else _addIssue(this, "type", dataset, config$1);
                 return dataset;
             }
         };
@@ -42584,7 +42504,7 @@ var __webpack_exports__ = {};
             if (!preferredEditors.includes(normalized)) throw new Error(`✖ Error: preferredEditor must be one of: ${preferredEditors.join(", ")} (alias: code -> vscode)`);
             return normalized;
         }
-        if ("anvilUrl" === key) return value.trim().replace(/\/+$/, "");
+        if ("anvilUrl" === key) return normalizeAnvilUrl(value);
         return coerceConfigValue(key, value);
     }
     function getPreferredEditorCommand(preferredEditorValue) {
@@ -48029,91 +47949,753 @@ var __webpack_exports__ = {};
         return filesToRemove;
     }
     var external_crypto_ = __webpack_require__("crypto");
-    const FormTemplateSchema = dist_object({
-        is_package: optional(dist_boolean()),
-        container: optional(dist_object({
-            type: dist_string(),
-            properties: optional(any())
-        })),
-        components: optional(dist_array(any())),
-        layout: optional(dist_object({
-            type: dist_string(),
-            properties: optional(any())
-        })),
-        components_by_slot: optional(record(dist_string(), dist_array(any()))),
-        custom_component: optional(dist_boolean()),
-        custom_component_container: optional(dist_boolean()),
-        properties: optional(dist_array(any())),
-        events: optional(dist_array(any())),
-        toolbox_item: optional(any()),
-        layout_metadata: optional(any()),
-        slots: optional(any()),
-        item_type: optional(dist_object({
-            table_id: dist_number()
-        }))
-    });
+    const BUILTIN_COMPONENT_TYPES = new Set([
+        "Label",
+        "RichText",
+        "Link",
+        "Button",
+        "TextBox",
+        "TextArea",
+        "CheckBox",
+        "RadioButton",
+        "DropDown",
+        "DatePicker",
+        "Timer",
+        "Canvas",
+        "Image",
+        "YouTubeVideo",
+        "GoogleMap",
+        "Plot",
+        "FileLoader",
+        "Spacer",
+        "GridPanel",
+        "LinearPanel",
+        "XYPanel",
+        "ColumnPanel",
+        "HtmlPanel",
+        "RepeatingPanel",
+        "DataGrid",
+        "DataRowPanel",
+        "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"
+    ]);
+    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 CLIENT_VERSIONS = new Set([
+        "2",
+        "3"
+    ]);
+    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 PROPERTY_TYPES = new Set([
+        "string",
+        "number",
+        "color",
+        "boolean",
+        "text[]",
+        "enum",
+        "icon",
+        "form",
+        "object",
+        "uri",
+        "margin",
+        "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 validators_isPlainObject(value) {
+        return "object" == typeof value && null !== value && !Array.isArray(value);
+    }
+    function 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)");
+    }
+    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");
+    }
+    function validatePropertiesObject(value, path, issues) {
+        if (void 0 !== value && !validators_isPlainObject(value)) pushIssue(issues, path, "must be an object");
+    }
+    function validateEventBindingsObject(value, path, issues) {
+        if (void 0 === value) return;
+        if (!validators_isPlainObject(value)) return void 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);
+        }
+    }
+    function validateDataBindings(value, path, issues) {
+        if (void 0 === value) return;
+        if (!Array.isArray(value)) return void pushIssue(issues, path, "must be an array");
+        value.forEach((binding, index)=>{
+            const bindingPath = `${path}[${index}]`;
+            if (!validators_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");
+        });
+    }
+    function validateComponentArray(components, pathPrefix, issues, seenNames) {
+        components.forEach((component, index)=>{
+            const childPath = `${pathPrefix}[${index}]`;
+            validateComponentNode(component, childPath, issues, seenNames);
+            if (validators_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");
+                seenNames.add(component.name);
+            }
+        });
+    }
+    function validateComponentNode(value, path, issues, seenNames) {
+        if (!validators_isPlainObject(value)) return void 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);
+        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");
+    }
+    function validatePropertyDefinition(value, path, issues) {
+        if (!validators_isPlainObject(value)) return void 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 (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");
+        });
+        else 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");
+        }
+    }
+    function validateEventDefinition(value, path, issues) {
+        if (!validators_isPlainObject(value)) return void 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.parameters) if (Array.isArray(value.parameters)) value.parameters.forEach((parameter, index)=>{
+            if (!validators_isPlainObject(parameter)) return void 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");
+        });
+        else pushIssue(issues, `${path}.parameters`, "must be an array");
+    }
+    function validateSlotDefinition(value, path, issues, seenNames) {
+        if (!validators_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");
+        validatePropertiesObject(value.set_layout_properties, `${path}.set_layout_properties`, issues);
+        if (validators_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 (void 0 !== value.template) validateComponentNode(value.template, `${path}.template`, issues, seenNames);
+    }
+    function validateFormTemplateData(value) {
+        const issues = [];
+        const componentNames = new Set();
+        if (!validators_isPlainObject(value)) {
+            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) if (validators_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");
+        if (hasLayout) if (validators_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 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 if (hasComponentsBySlot) if (validators_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");
+                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 (!validators_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 (!validators_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 (!validators_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");
+            });
+        });
+        if (void 0 !== value.slots) if (validators_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 (validators_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 validateFormTemplate(yamlContent) {
         try {
             const data = js_yaml_load(yamlContent);
-            const result = safeParse(FormTemplateSchema, data);
-            if (!result.success) {
-                logger_logger.error("form_template.yaml: Validation failed");
-                for (const issue of result.issues)logger_logger.error(`  - ${issue.path?.map((p)=>p.key).join(".") || "root"}: ${issue.message}`);
-                return false;
-            }
-            return true;
+            const issues = validateFormTemplateData(data);
+            if (issues.length > 0) return {
+                ok: false,
+                message: "form_template.yaml is invalid for Anvil",
+                issues
+            };
+            return {
+                ok: true
+            };
         } catch (error) {
-            logger_logger.error(`form_template.yaml: YAML parse error: ${error}`);
-            return false;
+            return {
+                ok: false,
+                message: "form_template.yaml is not valid YAML",
+                issues: [
+                    {
+                        path: "",
+                        message: error instanceof Error ? error.message : String(error)
+                    }
+                ]
+            };
+        }
+    }
+    const serviceConfigObject = custom((input)=>validators_isPlainObject(input), "must be an object");
+    const AnvilServiceEntrySchema = looseObject({
+        source: pipe(dist_string(), dist_nonEmpty()),
+        client_config: optional(serviceConfigObject),
+        server_config: optional(serviceConfigObject)
+    });
+    const RuntimeOptionsSchema = looseObject({
+        version: dist_number(),
+        client_version: optional(picklist([
+            "2",
+            "3"
+        ])),
+        preview_v3: optional(dist_boolean()),
+        server_version: optional(dist_string()),
+        server_persist: optional(dist_boolean()),
+        legacy_features: optional(looseObject({
+            class_names: optional(dist_boolean()),
+            bootstrap3: optional(dist_boolean()),
+            __dict__: optional(dist_boolean()),
+            root_container: optional(dist_boolean())
+        })),
+        server_spec: optional(nullable(looseObject({
+            base: optional(dist_string())
+        })))
+    });
+    function validateRuntimeOptions(value, path) {
+        const issues = [];
+        if (void 0 === 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 (void 0 !== value.server_spec && null !== value.server_spec) {
+            if (!validators_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");
+        }
+        return issues;
+    }
+    function validateDbSchema(value, path) {
+        const issues = [];
+        if (void 0 === value) return issues;
+        if (null === value) {
+            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");
+            return issues;
+        }
+        if (!validators_isPlainObject(value)) {
+            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");
+                continue;
+            }
+            const table = value[tableName];
+            if (!validators_isPlainObject(table)) {
+                pushIssue(issues, tablePath, "must be an object");
+                continue;
+            }
+            for (const req of [
+                "client",
+                "server",
+                "title",
+                "columns"
+            ])if (void 0 === table[req]) 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 (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 (void 0 !== table.title) {
+                if ("string" != typeof table.title || 0 === table.title.length) 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");
+            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");
         }
+        return issues;
+    }
+    function validateDbTableIndex(value, path, issues) {
+        if (!validators_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"');
+    }
+    function validateDbSchemaColumn(value, path, issues) {
+        if (!validators_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");
+        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 (${[
+            ...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 (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 !== value.indexes) {
+            if (!Array.isArray(value.indexes)) return void pushIssue(issues, `${path}.indexes`, "must be an array");
+            value.indexes.forEach((entry, i)=>{
+                const idxPath = `${path}.indexes[${i}]`;
+                if (!validators_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"');
+            });
+        }
+    }
+    function validateKnownServiceSources(services, path) {
+        const issues = [];
+        if (void 0 === services) return issues;
+        if (!Array.isArray(services)) return issues;
+        services.forEach((service, index)=>{
+            if (!validators_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");
+        });
+        return issues;
     }
-    const AnvilYamlSchema = dist_object({
+    function validateServiceConfigs(services, path) {
+        const issues = [];
+        if (void 0 === services || !Array.isArray(services)) return issues;
+        services.forEach((service, index)=>{
+            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) pushIssue(issues, `${path}[${index}].client_config.remember_me_days`, "must be set if allow_remember_me is true");
+        });
+        return issues;
+    }
+    function validateScheduledTasks(value, path) {
+        const issues = [];
+        if (void 0 === value) return issues;
+        if (!Array.isArray(value)) {
+            pushIssue(issues, path, "must be an array");
+            return issues;
+        }
+        value.forEach((task, index)=>{
+            const taskPath = `${path}[${index}]`;
+            if (!validators_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 (!validators_isPlainObject(task.time_spec)) return void 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"');
+            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 (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");
+        });
+        return issues;
+    }
+    const AnvilYamlSchema = looseObject({
         name: dist_string(),
-        package_name: dist_string(),
+        package_name: optional(dist_string()),
         allow_embedding: optional(dist_boolean()),
         renamed: optional(dist_boolean()),
         dependencies: optional(dist_array(any())),
-        runtime_options: dist_object({
-            version: pipe(dist_number(), minValue(2)),
-            client_version: optional(dist_string()),
-            server_version: optional(dist_string()),
-            server_spec: optional(any())
-        }),
-        services: optional(dist_array(dist_object({
-            source: dist_string(),
-            client_config: optional(any()),
-            server_config: optional(any())
-        }))),
-        startup: optional(union([
-            dist_object({
-                module: dist_string(),
-                type: dist_string()
-            }),
-            any()
-        ])),
+        runtime_options: RuntimeOptionsSchema,
+        services: optional(dist_array(AnvilServiceEntrySchema)),
+        startup: optional(looseObject({
+            type: picklist([
+                "module",
+                "form"
+            ]),
+            module: optional(dist_string())
+        })),
         startup_form: optional(nullable(dist_string())),
         db_schema: optional(any()),
+        scheduled_tasks: optional(any()),
         secrets: optional(any()),
-        metadata: optional(any())
+        metadata: optional(looseObject({
+            title: optional(dist_string()),
+            description: optional(dist_string()),
+            logo_img: optional(dist_string())
+        })),
+        client_init_module: optional(dist_string())
     });
+    function formatValibotIssuePath(issue) {
+        return getDotPath(issue) ?? "";
+    }
     function validateAnvilYaml(yamlContent) {
-        if (yamlContent.includes("<<<<<<<") || yamlContent.includes(">>>>>>>")) {
-            logger_logger.error("anvil.yaml contains git merge conflict markers. Please resolve conflicts manually.");
-            return false;
-        }
+        if (yamlContent.includes("<<<<<<<") || yamlContent.includes(">>>>>>>")) return {
+            ok: false,
+            message: "anvil.yaml contains merge conflict markers",
+            issues: [
+                {
+                    path: "",
+                    message: "contains git merge conflict markers"
+                }
+            ]
+        };
         try {
             const data = js_yaml_load(yamlContent);
             const result = safeParse(AnvilYamlSchema, data);
-            if (!result.success) {
-                logger_logger.error("anvil.yaml: Validation failed");
-                for (const issue of result.issues)logger_logger.error(`  - ${issue.path?.map((p)=>p.key).join(".") || "root"}: ${issue.message}`);
-                return false;
-            }
-            return true;
+            if (!result.success) return {
+                ok: false,
+                message: "anvil.yaml is invalid for Anvil",
+                issues: result.issues.map((issue)=>({
+                        path: formatValibotIssuePath(issue),
+                        message: issue.message
+                    }))
+            };
+            const runtimeOptionIssues = validateRuntimeOptions(result.output.runtime_options, "runtime_options");
+            if (runtimeOptionIssues.length > 0) return {
+                ok: false,
+                message: "anvil.yaml is invalid for Anvil",
+                issues: runtimeOptionIssues
+            };
+            const serviceIssues = validateKnownServiceSources(result.output.services, "services");
+            if (serviceIssues.length > 0) return {
+                ok: false,
+                message: "anvil.yaml is invalid for Anvil",
+                issues: serviceIssues
+            };
+            const serviceConfigIssues = validateServiceConfigs(result.output.services, "services");
+            if (serviceConfigIssues.length > 0) return {
+                ok: false,
+                message: "anvil.yaml is invalid for Anvil",
+                issues: serviceConfigIssues
+            };
+            const scheduledTaskIssues = validateScheduledTasks(result.output.scheduled_tasks, "scheduled_tasks");
+            if (scheduledTaskIssues.length > 0) return {
+                ok: false,
+                message: "anvil.yaml is invalid for Anvil",
+                issues: scheduledTaskIssues
+            };
+            const dbIssues = validateDbSchema(result.output.db_schema, "db_schema");
+            if (dbIssues.length > 0) return {
+                ok: false,
+                message: "anvil.yaml is invalid for Anvil",
+                issues: dbIssues
+            };
+            return {
+                ok: true
+            };
         } catch (error) {
-            logger_logger.error(`anvil.yaml: YAML parse error: ${error}`);
-            return false;
+            return {
+                ok: false,
+                message: "anvil.yaml is not valid YAML",
+                issues: [
+                    {
+                        path: "",
+                        message: error instanceof Error ? error.message : String(error)
+                    }
+                ]
+            };
+        }
+    }
+    function inferValidationTarget(filePath) {
+        const normalizedPath = filePath.replace(/\\/g, "/");
+        if ("anvil.yaml" === normalizedPath || normalizedPath.endsWith("/anvil.yaml")) return "anvil.yaml";
+        const clientCodePrefix = "client_code/";
+        if (normalizedPath.startsWith(clientCodePrefix) || normalizedPath.includes(`/${clientCodePrefix}`)) {
+            const startIndex = normalizedPath.lastIndexOf(clientCodePrefix);
+            const relativeToClientCode = normalizedPath.slice(startIndex + clientCodePrefix.length);
+            if (relativeToClientCode.endsWith(".yaml")) return "form_template.yaml";
+        }
+        return null;
+    }
+    function resolveExistingPath(filePath) {
+        const absolutePath = external_path_default().resolve(filePath);
+        return external_fs_.existsSync(absolutePath) ? absolutePath : null;
+    }
+    function findAnvilAppRoot(filePath) {
+        const existingPath = resolveExistingPath(filePath);
+        if (!existingPath) return null;
+        let currentDir = external_fs_.statSync(existingPath).isDirectory() ? existingPath : external_path_default().dirname(existingPath);
+        let appRoot = null;
+        while(true){
+            if (external_fs_.existsSync(external_path_default().join(currentDir, "anvil.yaml"))) appRoot = currentDir;
+            const parentDir = external_path_default().dirname(currentDir);
+            if (parentDir === currentDir) return appRoot;
+            currentDir = parentDir;
+        }
+    }
+    function validatePath(filePath, yamlContent) {
+        const target = inferValidationTarget(filePath);
+        const existingPath = resolveExistingPath(filePath);
+        const appRoot = findAnvilAppRoot(filePath);
+        if (existingPath && !appRoot) return {
+            ok: false,
+            target: target ?? "unknown",
+            message: "File is not inside an Anvil app",
+            issues: [
+                {
+                    path: "",
+                    message: "could not find an anvil.yaml app root for this file"
+                }
+            ]
+        };
+        if ("anvil.yaml" === target) {
+            if (existingPath && appRoot && external_path_default().resolve(existingPath) !== external_path_default().join(appRoot, "anvil.yaml")) return {
+                ok: false,
+                target,
+                message: "File is not the app root anvil.yaml",
+                issues: [
+                    {
+                        path: "",
+                        message: `expected ${external_path_default().join(appRoot, "anvil.yaml")}`
+                    }
+                ]
+            };
+            const result = validateAnvilYaml(yamlContent);
+            return result.ok ? {
+                ok: true,
+                target
+            } : {
+                ...result,
+                target
+            };
+        }
+        if ("form_template.yaml" === 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(".yaml")) return {
+                    ok: false,
+                    target,
+                    message: "File is not a client_code YAML form",
+                    issues: [
+                        {
+                            path: "",
+                            message: `expected a .yaml file under ${clientCodeRoot}`
+                        }
+                    ]
+                };
+            }
+            const result = validateFormTemplate(yamlContent);
+            return result.ok ? {
+                ok: true,
+                target
+            } : {
+                ...result,
+                target
+            };
         }
+        return {
+            ok: false,
+            target: "unknown",
+            message: "No validator for this path",
+            issues: [
+                {
+                    path: "",
+                    message: "supported paths are anvil.yaml, client_code/**/form_template.yaml, and client_code/**/*.yaml"
+                }
+            ]
+        };
     }
     function normalizeClientCodePath(relativePath) {
         return relativePath.replace(/\\/g, "/");
@@ -48153,10 +48735,15 @@ var __webpack_exports__ = {};
         try {
             const content = await readFileContent(repoPath, relativePath, stagedOnly);
             if ("yaml" === format) {
-                if (!validateFormTemplate(content)) return {
-                    ok: false,
-                    reason: "package" === kind ? "Invalid form_template.yaml - validation failed" : "Invalid form yaml - validation failed"
-                };
+                const validationResult = validateFormTemplate(content);
+                if (!validationResult.ok) {
+                    const firstIssue = validationResult.issues[0];
+                    const issueSummary = firstIssue ? `${formatValidationPath(firstIssue.path)}: ${firstIssue.message}` : void 0;
+                    return {
+                        ok: false,
+                        reason: issueSummary ? `${validationResult.message}. ${issueSummary}` : validationResult.message
+                    };
+                }
                 const parsed = jsYaml.load(content);
                 const template = {
                     ...parsed,
@@ -48830,10 +49417,11 @@ var __webpack_exports__ = {};
         });
     }
     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,
-            ...template,
             is_package: options.isPackage
         };
         if (void 0 !== html) {
@@ -49043,7 +49631,8 @@ var __webpack_exports__ = {};
                 requirements: currentRequirements
             }
         };
-        if (!validateAnvilYaml(yamlContent)) throw new Error("anvil.yaml validation failed - see errors above");
+        const validationResult = validateAnvilYaml(yamlContent);
+        if (!validationResult.ok) throw new Error("anvil.yaml validation failed - see errors above");
         const changes = [];
         for (const [key, value] of Object.entries(parsedYaml))if (!previousYaml || !deepEqual(previousYaml[key], value)) changes.push({
             key,
@@ -49538,6 +50127,19 @@ var __webpack_exports__ = {};
             };
         }
     }
+    function stripNonSemanticYamlFields(yamlFile, parsed) {
+        const normalized = {
+            ...parsed ?? {}
+        };
+        delete normalized.is_package;
+        const normalizedPath = yamlFile.replace(/\\/g, "/");
+        const isFormTemplate = normalizedPath.startsWith("client_code/") && (normalizedPath.endsWith("/form_template.yaml") || /^client_code\/[^/]+\.ya?ml$/i.test(normalizedPath) && !normalizedPath.endsWith("anvil.yaml"));
+        if (isFormTemplate) {
+            delete normalized.class_name;
+            delete normalized.code;
+        }
+        return normalized;
+    }
     class SyncManager extends Emitter_Emitter {
         config;
         syncInProgress = false;
@@ -49658,8 +50260,8 @@ var __webpack_exports__ = {};
                 }
                 const workingParsed = js_yaml_load(workingContent);
                 const headParsed = js_yaml_load(headContent);
-                const { is_package: _w, ...workingForCompare } = workingParsed;
-                const { is_package: _h, ...headForCompare } = headParsed;
+                const workingForCompare = stripNonSemanticYamlFields(yamlFile, workingParsed);
+                const headForCompare = stripNonSemanticYamlFields(yamlFile, headParsed);
                 if (deepEqual(workingForCompare, headForCompare)) {
                     logger_logger.verbose(chalk_source.gray(`  Discarding formatting-only change: ${yamlFile}`));
                     await this.config.gitService.checkout([
@@ -51034,6 +51636,33 @@ var __webpack_exports__ = {};
     function getUsernameConfigKey(appId) {
         return `anvil.auth.${appId}.username`;
     }
+    function shellQuote(value) {
+        return `'${value.replace(/'/g, "'\\''")}'`;
+    }
+    function shellQuoteDouble(value) {
+        return `"${value.replace(/(["$`])/g, "\\$1")}"`;
+    }
+    function getDefaultCliPath(options) {
+        const servicesDir = options?.servicesDir ?? __dirname;
+        const pathExists = options?.pathExists ?? external_fs_default().existsSync;
+        const candidates = [
+            external_path_default().resolve(servicesDir, "..", "cli.js"),
+            external_path_default().resolve(servicesDir, "..", "cli.ts")
+        ];
+        return candidates.find((candidate)=>pathExists(candidate));
+    }
+    function getGitCredentialHelperCommand(options) {
+        const platform = options?.platform ?? process.platform;
+        const execPath = options?.execPath ?? process.execPath;
+        const cliPath = options?.cliPath ?? getDefaultCliPath() ?? process.argv[1];
+        if (!execPath || !cliPath) return "!anvil git-credential";
+        if ("win32" === platform) {
+            const resolvedExecPath = external_path_default().win32.resolve(execPath);
+            const resolvedCliPath = external_path_default().win32.resolve(cliPath);
+            return `!${shellQuoteDouble(resolvedExecPath)} ${shellQuoteDouble(resolvedCliPath)} git-credential`;
+        }
+        return `!${shellQuote(external_path_default().resolve(execPath))} ${shellQuote(external_path_default().resolve(cliPath))} git-credential`;
+    }
     async function getLocalConfigValue(repoPath, key) {
         try {
             const value = (await esm_default(repoPath).raw([
@@ -51102,7 +51731,7 @@ var __webpack_exports__ = {};
             "--local",
             "--add",
             `credential.${scope}.helper`,
-            "!anvil git-credential"
+            getGitCredentialHelperCommand()
         ]);
         await git.raw([
             "config",
@@ -53466,6 +54095,44 @@ var __webpack_exports__ = {};
         program.command("update").description("Update anvil to the latest version").alias("u").action(async ()=>{
             await handleUpdateCommand();
         });
+        program.command("validate").description("Validate YAML based on path (anvil.yaml or client_code/**/*.yaml)").argument("<file>", "Path to YAML file").action((file)=>{
+            let yamlContent;
+            try {
+                yamlContent = (0, external_fs_.readFileSync)(file, "utf8");
+            } catch (error) {
+                logger_logger.error(`Failed to read ${file}: ${error.message}`);
+                process.exitCode = 1;
+                return;
+            }
+            const result = validatePath(file, yamlContent);
+            if (result.ok) {
+                if (getGlobalOutputConfig().jsonMode) logJsonResult(true, {
+                    data: {
+                        file,
+                        type: result.target,
+                        valid: true
+                    }
+                });
+                else logger_logger.success(`${file} is valid (${result.target})`);
+                return;
+            }
+            if (getGlobalOutputConfig().jsonMode) logJsonResult(false, {
+                error: result.message,
+                data: {
+                    file,
+                    type: result.target,
+                    issues: result.issues
+                }
+            });
+            else {
+                logger_logger.error(`${file} failed validation: ${result.message}`);
+                for (const issue of result.issues){
+                    const issuePath = issue.path.length > 0 ? issue.path : "root";
+                    logger_logger.error(`  - ${issuePath}: ${issue.message}`);
+                }
+            }
+            process.exitCode = 1;
+        });
         if (watchCommand) {
             const watchOptions = watchCommand.options.map((opt)=>{
                 const flags = opt.flags;