@nuasite/cli 0.53.0 → 0.54.0

package/dist/index.js

@@ -47,6 +47,39 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
+// ../cms-core/src/asset-paths.ts
+function assetBaseDir(file) {
+  const lastSlash = file.lastIndexOf("/");
+  return lastSlash >= 0 ? file.slice(0, lastSlash) : "";
+}
+function normalizeSegments(base, rel) {
+  const out = base.slice();
+  for (const seg of rel.replace(/^\/+/, "").split("/")) {
+    if (seg === "" || seg === ".")
+      continue;
+    if (seg === "..") {
+      if (out.length === 0)
+        return null;
+      out.pop();
+      continue;
+    }
+    out.push(seg);
+  }
+  return out.join("/");
+}
+function resolveAssetCandidates(baseDir, rel) {
+  if (rel.startsWith("/")) {
+    const fromRoot = normalizeSegments([], rel);
+    if (fromRoot === null || fromRoot === "")
+      return [];
+    return [`public/${fromRoot}`, fromRoot];
+  }
+  if (baseDir === undefined)
+    return [];
+  const joined = normalizeSegments(baseDir.split("/").filter(Boolean), rel);
+  return joined === null ? [] : [joined];
+}
+
 // ../../node_modules/yaml/dist/nodes/identity.js
 var require_identity = __commonJS((exports) => {
   var ALIAS = Symbol.for("yaml.alias");
@@ -7011,6 +7044,497 @@ var require_dist = __commonJS((exports) => {
   exports.visitAsync = visit.visitAsync;
 });
 
+// ../cms-core/src/check-entries.ts
+import path from "path";
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
+}
+async function collectEntryFiles(fs, collection, base) {
+  const pattern = collection.loaderPattern ?? "**/*.{md,mdx,json,yaml,yml}";
+  const files = await fs.glob(`${base}/${pattern}`);
+  return files.filter((file) => !path.basename(file).startsWith("_")).sort();
+}
+function parseEntry(file, raw) {
+  const extension = path.extname(file);
+  if (DATA_EXTENSIONS.has(extension)) {
+    try {
+      const parsed = extension === ".json" ? JSON.parse(raw) : import_yaml.default.parse(raw);
+      return { frontmatter: isPlainObject(parsed) ? parsed : {} };
+    } catch (error) {
+      return { error: error instanceof Error ? error.message.split(`
+`)[0] : String(error) };
+    }
+  }
+  const trimmed = raw.trimStart();
+  if (!trimmed.startsWith("---"))
+    return { frontmatter: {} };
+  const lines = trimmed.split(`
+`);
+  const end = lines.findIndex((line, index) => index > 0 && line.trimEnd() === "---");
+  if (end === -1)
+    return { error: "frontmatter is never closed (missing the second `---`)" };
+  try {
+    const parsed = import_yaml.default.parse(lines.slice(1, end).join(`
+`).trim());
+    return { frontmatter: isPlainObject(parsed) ? parsed : {} };
+  } catch (error) {
+    return { error: error instanceof Error ? error.message.split(`
+`)[0] : String(error) };
+  }
+}
+function collectionKind(collection, loaderPattern) {
+  const extensions = collection.entries.map((entry) => path.extname(entry.file));
+  if (extensions.length > 0)
+    return extensions.some((extension) => extension === ".md" || extension === ".mdx") ? "markdown" : "data";
+  return loaderPattern === undefined || /\bmdx?\b/.test(loaderPattern) ? "markdown" : "data";
+}
+async function loadCollections(fs, config) {
+  const loaded = new Map;
+  for (const [name, collection] of config) {
+    const base = normalizeBase(collection.loaderBase ?? `src/content/${name}`);
+    if (!await fs.exists(base)) {
+      loaded.set(name, { name, base, exists: false, entries: [] });
+      continue;
+    }
+    const entries = [];
+    for (const file of await collectEntryFiles(fs, collection, base)) {
+      const parsed = parseEntry(file, await fs.readFile(file));
+      entries.push({
+        file,
+        stem: entryStem(file),
+        ..."error" in parsed ? { parseError: parsed.error } : { frontmatter: parsed.frontmatter }
+      });
+    }
+    loaded.set(name, { name, base, exists: true, entries });
+  }
+  return loaded;
+}
+var import_yaml, DATA_EXTENSIONS, normalizeBase = (base) => path.normalize(base).replace(/^\.\//, "").replace(/\/+$/, ""), entryStem = (file) => path.basename(file).replace(/\.(md|mdx|json|ya?ml)$/, "");
+var init_check_entries = __esm(() => {
+  import_yaml = __toESM(require_dist(), 1);
+  DATA_EXTENSIONS = new Set([".json", ".yaml", ".yml"]);
+});
+
+// ../cms-core/src/schema-port.ts
+function describeIssue(issue) {
+  if (issue.path.length === 0)
+    return { message: issue.message };
+  const field = issue.path.join(".");
+  return { field, message: `${field}: ${issue.message}` };
+}
+function schemaFor(schemas, collection) {
+  return Object.hasOwn(schemas, collection) ? schemas[collection] : undefined;
+}
+
+// ../cms-core/src/check-live.ts
+async function checkAgainstSchemas(input) {
+  const findings = [];
+  for (const collection of input.collections.values()) {
+    const schema = schemaFor(input.schemas, collection.name);
+    if (!schema)
+      continue;
+    for (const entry of collection.entries) {
+      if (entry.frontmatter === undefined)
+        continue;
+      let result;
+      try {
+        result = await schema.safeParse(entry.frontmatter);
+      } catch (error) {
+        findings.push({
+          severity: "error",
+          code: "entry/schema-rejected",
+          file: entry.file,
+          message: `The collection schema threw while validating this entry: ${error instanceof Error ? error.message : String(error)}`
+        });
+        continue;
+      }
+      if (result.success)
+        continue;
+      for (const issue of result.issues) {
+        findings.push({ severity: "error", code: "entry/schema-rejected", file: entry.file, ...describeIssue(issue) });
+      }
+    }
+  }
+  return findings;
+}
+var init_check_live = () => {};
+
+// ../cms-core/src/schema-probe.ts
+function mutated(point, mutation) {
+  let copy;
+  try {
+    copy = structuredClone(point.record);
+  } catch {
+    return null;
+  }
+  let parent = copy;
+  for (const segment of point.path.slice(0, -1)) {
+    if (!isContainer(parent))
+      return null;
+    parent = parent[segment];
+  }
+  const last = point.path.at(-1);
+  if (last === undefined || !isContainer(parent))
+    return null;
+  if ("remove" in mutation)
+    delete parent[last];
+  else
+    parent[last] = mutation.set;
+  return copy;
+}
+async function probe(schema, point, mutation) {
+  const value = mutated(point, mutation);
+  if (value === null)
+    return "unknown";
+  try {
+    const result = await schema.safeParse(value);
+    if (result.success)
+      return "accepted";
+    const here = result.issues.some((issue) => point.path.every((segment, index) => issue.path[index] === segment));
+    return here ? "rejected-here" : "rejected-elsewhere";
+  } catch {
+    return "unknown";
+  }
+}
+async function governsPath(schema, point) {
+  for (const value of GOVERNANCE_PROBES) {
+    if (await probe(schema, point, { set: value }) === "rejected-here")
+      return true;
+  }
+  return false;
+}
+async function acceptsMissing(schema, point) {
+  return await probe(schema, point, { remove: true }) === "accepted";
+}
+async function rejectsValueAt(schema, point, value) {
+  return await probe(schema, point, { set: value }) === "rejected-here";
+}
+async function firstAcceptedEntry(schema, entries) {
+  for (const entry of entries) {
+    if (!entry.frontmatter)
+      continue;
+    try {
+      const result = await schema.safeParse(entry.frontmatter);
+      if (result.success)
+        return entry.frontmatter;
+    } catch {}
+  }
+  return;
+}
+var pointAt = (seed, field) => ({ record: seed, path: [field] }), GOVERNANCE_PROBES, isContainer = (value) => typeof value === "object" && value !== null;
+var init_schema_probe = __esm(() => {
+  GOVERNANCE_PROBES = [{ __nuaProbe: true }, ["__nua_probe__"], 918273.456, null];
+});
+
+// ../cms-core/src/check-shape.ts
+async function requiredDrift(name, field, seed, schemas) {
+  const schema = schemaFor(schemas, name);
+  if (!schema || !field.required || field.layout?.hidden)
+    return null;
+  const point = pointAt(seed, field.name);
+  if (!await acceptsMissing(schema, point))
+    return null;
+  if (!await governsPath(schema, point))
+    return null;
+  return {
+    severity: "warning",
+    code: "cms/required-drift",
+    file: CONFIG_FILE,
+    field: `${name}.${field.name}`,
+    message: `The editor treats "${name}.${field.name}" as required and refuses to save it blank, but the schema accepts an entry without it.`,
+    hint: "Either the schema should require it, or the config should show the parser that it is optional. Wrapping a field schema in a helper call (`field.image(z.string().optional())`) or reaching it through an import hides the `.optional()` from the parser, which then reads the field as required \u2014 put the wrapper outside, as `field.image(z.string()).optional()`."
+  };
+}
+async function degradedField(name, field, seed, input) {
+  const schema = schemaFor(input.schemas, name);
+  if (!schema || field.type !== undefined || field.layout?.hidden)
+    return null;
+  if (anyEntryHasValue(input.collections.get(name)?.entries ?? [], field.name))
+    return null;
+  const point = pointAt(seed, field.name);
+  for (const text of TEXT_PROBES) {
+    if (!await rejectsValueAt(schema, point, text))
+      return null;
+  }
+  return {
+    severity: "error",
+    code: "cms/field-degraded",
+    file: CONFIG_FILE,
+    field: `${name}.${field.name}`,
+    message: `The editor will render "${name}.${field.name}" as a plain text input \u2014 the parser pinned no type and no entry supplies one \u2014 and the schema rejects text there.`,
+    hint: "Write the field's type chain inline in the content config (`n.number()`, `n.date()`, `n.enum([\u2026])`). A type reached through an import, a helper with arguments, or a modifier applied after the object is built is invisible to the parser, which then leaves the editor guessing."
+  };
+}
+async function checkFieldShapes(input) {
+  const findings = [];
+  for (const [name, collection] of input.config) {
+    const schema = schemaFor(input.schemas, name);
+    if (!schema || collection.fields.length === 0)
+      continue;
+    const seed = await firstAcceptedEntry(schema, input.collections.get(name)?.entries ?? []);
+    if (!seed)
+      continue;
+    for (const field of collection.fields) {
+      const drift = await requiredDrift(name, field, seed, input.schemas);
+      if (drift)
+        findings.push(drift);
+      const degraded = await degradedField(name, field, seed, input);
+      if (degraded)
+        findings.push(degraded);
+    }
+  }
+  return findings;
+}
+var CONFIG_FILE = "src/content.config.ts", TEXT_PROBES, anyEntryHasValue = (entries, field) => entries.some((entry) => entry.frontmatter !== undefined && entry.frontmatter[field] !== undefined);
+var init_check_shape = __esm(() => {
+  init_schema_probe();
+  TEXT_PROBES = ["", "nua", "https://nua.test/probe", "2024-01-02", "123"];
+});
+
+// ../cms-types/src/field-values.ts
+function isBlankFieldValue(value) {
+  return value === undefined || value === null || value === "";
+}
+function defaultValueForNewEntry(field, today = () => new Date) {
+  if (field.defaultValue !== undefined)
+    return field.defaultValue;
+  switch (field.type) {
+    case "boolean":
+      return false;
+    case "number":
+      return 0;
+    case "array":
+      return [];
+    case "date":
+      return today().toISOString().split("T")[0];
+    default:
+      return "";
+  }
+}
+function newRepeaterItem(fields, today) {
+  const item = {};
+  for (const field of fields) {
+    if (!field.required || field.hidden)
+      continue;
+    item[field.name] = defaultValueForNewEntry(field, today);
+  }
+  return item;
+}
+function blankRequiredFields(fields, frontmatter) {
+  return fields.filter((field) => field.required && !(field.hidden ?? field.layout?.hidden) && isBlankFieldValue(frontmatter[field.name])).map((field) => field.name);
+}
+// ../cms-types/src/index.ts
+function isFieldType(value) {
+  return FIELD_TYPES.includes(value);
+}
+var FIELD_TYPES;
+var init_src = __esm(() => {
+  FIELD_TYPES = [
+    "text",
+    "textarea",
+    "markdown",
+    "date",
+    "datetime",
+    "time",
+    "year",
+    "month",
+    "boolean",
+    "number",
+    "image",
+    "file",
+    "url",
+    "email",
+    "tel",
+    "color",
+    "select",
+    "array",
+    "object",
+    "reference"
+  ];
+});
+
+// ../cms-core/src/editor-write-model.ts
+function newEntryFrontmatter(fields, today) {
+  const frontmatter = {};
+  for (const field of fields) {
+    if (field.name === "title" || field.hidden)
+      continue;
+    frontmatter[field.name] = defaultValueForNewEntry(field, today);
+  }
+  return frontmatter;
+}
+function applyCreateRouteFields(frontmatter, kind, today = () => new Date) {
+  const title = "Untitled";
+  if (kind === "data")
+    return { title, ...frontmatter };
+  return { title, date: today().toISOString().split("T")[0], ...frontmatter };
+}
+function omitEmptyOnCreate(frontmatter) {
+  const out = {};
+  for (const [key, value] of Object.entries(frontmatter)) {
+    if (value !== undefined && value !== "")
+      out[key] = value;
+  }
+  return out;
+}
+var init_editor_write_model = __esm(() => {
+  init_src();
+  init_src();
+});
+
+// ../cms-core/src/check-write.ts
+async function parseWrite(schema, value) {
+  try {
+    const result = await schema.safeParse(value);
+    return { issues: result.success ? [] : result.issues };
+  } catch (error) {
+    return { threw: errorText(error) };
+  }
+}
+function valueAt(record, path2) {
+  let current = record;
+  for (const segment of path2) {
+    if (Array.isArray(current)) {
+      const index = typeof segment === "number" ? segment : Number(segment);
+      if (!Number.isInteger(index) || index < 0 || index >= current.length)
+        return { present: false };
+      current = current[index];
+      continue;
+    }
+    if (!isPlainObject(current) || !Object.hasOwn(current, String(segment)))
+      return { present: false };
+    current = current[String(segment)];
+  }
+  return current === undefined ? { present: false } : { present: true, value: current };
+}
+function hintFor(action, found) {
+  if (action === "create") {
+    if (!found.present) {
+      return "The create form leaves an untouched field out of the write entirely. `.optional()` or `.default(\u2026)` accepts a missing key; `.nullable()` does not \u2014 it accepts `null`, not absence.";
+    }
+    return `The create form starts this field at ${JSON.stringify(found.value)} and nothing makes the editor change it before saving. Either the schema accepts that value, or mark the field \`hidden\` so the write omits it and let \`.default(\u2026)\` supply one.`;
+  }
+  if (!found.present) {
+    return 'The appended item does not carry this key \u2014 "+ Add" seeds only the item fields the config declares required. Declaring it required there is what makes the editor seed it; if it is not required, `.optional()` or `.default(\u2026)` says so to the schema, and `.nullable()` does not \u2014 it accepts `null`, not absence.';
+  }
+  return `The appended item carries ${JSON.stringify(found.value)} for this key, and it is written the moment "+ Add" is clicked. \`.default(\u2026)\` on the inner field is the way out: the parser then reads the field as optional, so the item leaves the key out and the schema supplies the value itself.`;
+}
+function rejectionFinding(action, issue, kind, written) {
+  const { field, message } = describeIssue(issue);
+  const finding = {
+    severity: "error",
+    code: "cms/empty-write",
+    file: CONFIG_FILE2,
+    message: `${action} produces a write the schema rejects. ${message}`
+  };
+  if (field !== undefined)
+    finding.field = field;
+  finding.hint = hintFor(kind, valueAt(written, issue.path));
+  return finding;
+}
+function blankItemsFor(field, current, today) {
+  const itemFields = field.fields ?? [];
+  if (itemFields.length > 0) {
+    return [newRepeaterItem(itemFields.map((item) => ({ ...toWriteModelField(item), required: item.required })), today)];
+  }
+  if (current.length === 0)
+    return [{}, { name: "" }];
+  const first = current[0];
+  const template = isPlainObject(first) ? Object.fromEntries(Object.keys(first).map((key) => [key, ""])) : {};
+  return [{}, template];
+}
+async function checkEditorWrites(input) {
+  const findings = [];
+  const seen = new Set;
+  const report = (key, finding) => {
+    const identity = `${key} ${finding.field ?? ""}`;
+    if (seen.has(identity))
+      return;
+    seen.add(identity);
+    findings.push(finding);
+  };
+  for (const [name, collection] of input.config) {
+    const schema = schemaFor(input.schemas, name);
+    if (!schema)
+      continue;
+    const createKey = `${name} create`;
+    if (collection.fields.length === 0) {
+      report(createKey, {
+        severity: "warning",
+        code: "cms/empty-write-unchecked",
+        file: CONFIG_FILE2,
+        field: name,
+        message: `Could not check what creating a new entry in "${name}" writes: its schema is not readable from the content config, so there are no fields to predict the write from.`,
+        hint: "Write the field types inline in the content config rather than importing the shape from another module \u2014 the prediction reads the config source, and a schema assembled elsewhere leaves it nothing to read."
+      });
+      continue;
+    }
+    const loaded = input.collections.get(name);
+    const entries = loaded?.entries ?? [];
+    const kind = loaded ? collectionKind(loaded, collection.loaderPattern) : "markdown";
+    const created = applyCreateRouteFields(omitEmptyOnCreate(newEntryFrontmatter(collection.fields.map(toWriteModelField), input.today)), kind, input.today);
+    const guarded = new Set(blankRequiredFields(collection.fields, created));
+    const createAction = `Creating a new entry in "${name}"`;
+    const createVerdict = await parseWrite(schema, created);
+    if ("threw" in createVerdict) {
+      report(createKey, throwFinding(createAction, createVerdict.threw));
+    } else {
+      for (const issue of createVerdict.issues) {
+        const top = issue.path[0];
+        if (typeof top === "string" && guarded.has(top))
+          continue;
+        report(createKey, rejectionFinding(createAction, issue, "create", created));
+      }
+    }
+    const repeaters = collection.fields.filter((field) => field.type === "array" && field.itemType === "object");
+    if (repeaters.length === 0)
+      continue;
+    const seed = await firstAcceptedEntry(schema, entries);
+    for (const field of repeaters) {
+      const key = `${name} add:${field.name}`;
+      if (!seed) {
+        const hasEntries = entries.some((entry) => entry.frontmatter !== undefined);
+        const reason = hasEntries ? "no existing entry passes the schema, so there is no valid record to add an item to" : "the collection has no entry to add an item to";
+        report(key, {
+          severity: "warning",
+          code: "cms/empty-write-unchecked",
+          file: CONFIG_FILE2,
+          field: field.name,
+          message: `Could not check what "+ Add" on "${name}.${field.name}" writes: ${reason}.`,
+          hint: hasEntries ? `Fix the \`entry/schema-rejected\` findings in "${name}" and run this again \u2014 the prediction needs one entry the schema accepts.` : `Add one entry to "${name}" and run this again.`
+        });
+        continue;
+      }
+      const current = seed[field.name];
+      const existing = Array.isArray(current) ? current : [];
+      const action = `Clicking "+ Add" on "${name}.${field.name}"`;
+      for (const item of blankItemsFor(field, existing, input.today)) {
+        const written = { ...seed, [field.name]: [...existing, item] };
+        const verdict = await parseWrite(schema, written);
+        if ("threw" in verdict) {
+          report(key, throwFinding(action, verdict.threw));
+          continue;
+        }
+        for (const issue of verdict.issues)
+          report(key, rejectionFinding(action, issue, "add", written));
+      }
+    }
+  }
+  return findings;
+}
+var CONFIG_FILE2 = "src/content.config.ts", toWriteModelField = (field) => ({ name: field.name, type: field.type, hidden: field.layout?.hidden }), errorText = (error) => error instanceof Error ? error.message : String(error), throwFinding = (action, threw) => ({
+  severity: "error",
+  code: "cms/empty-write",
+  file: CONFIG_FILE2,
+  message: `${action} produces a write the schema throws on: ${threw}`,
+  hint: "A schema that throws instead of returning an issue is usually a refinement reading a field this write does not carry. Guard it against a missing value \u2014 `astro sync` runs the same schema over the same record."
+});
+var init_check_write = __esm(() => {
+  init_check_entries();
+  init_editor_write_model();
+  init_schema_probe();
+});
+
 // ../../node_modules/@babel/parser/lib/index.js
 var require_lib = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", {
@@ -21794,40 +22318,16 @@ var require_lib = __commonJS((exports) => {
   exports.tokTypes = tokTypes;
 });
 
-// ../cms-types/src/index.ts
-function isFieldType(value) {
-  return FIELD_TYPES.includes(value);
-}
-var FIELD_TYPES;
-var init_src = __esm(() => {
-  FIELD_TYPES = [
-    "text",
-    "textarea",
-    "markdown",
-    "date",
-    "datetime",
-    "time",
-    "year",
-    "month",
-    "boolean",
-    "number",
-    "image",
-    "file",
-    "url",
-    "email",
-    "tel",
-    "color",
-    "select",
-    "array",
-    "object",
-    "reference"
-  ];
-});
-
 // ../cms-core/src/content-config-ast.ts
 function resolveExpression(node, bindings, visited = new Set) {
   let current = node;
-  while (current.type === "Identifier") {
+  for (;; ) {
+    if (current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSNonNullExpression" || current.type === "TSTypeAssertion") {
+      current = current.expression;
+      continue;
+    }
+    if (current.type !== "Identifier")
+      return current;
     if (visited.has(current.name))
       return current;
     visited.add(current.name);
@@ -21836,7 +22336,80 @@ function resolveExpression(node, bindings, visited = new Set) {
       return current;
     current = next;
   }
-  return current;
+}
+function isAstNode(value) {
+  return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+}
+function walkNodes(node, visit) {
+  visit(node);
+  const children = Object.values(node);
+  for (const child of children) {
+    if (Array.isArray(child)) {
+      for (const item of child) {
+        if (isAstNode(item))
+          walkNodes(item, visit);
+      }
+    } else if (isAstNode(child)) {
+      walkNodes(child, visit);
+    }
+  }
+}
+function declaredPatternNames(node, record) {
+  switch (node.type) {
+    case "Identifier":
+      record(node.name);
+      return;
+    case "ObjectPattern":
+      for (const prop of node.properties)
+        declaredPatternNames(prop.type === "RestElement" ? prop.argument : prop.value, record);
+      return;
+    case "ArrayPattern":
+      for (const el of node.elements) {
+        if (el)
+          declaredPatternNames(el, record);
+      }
+      return;
+    case "AssignmentPattern":
+      declaredPatternNames(node.left, record);
+      return;
+    case "RestElement":
+      declaredPatternNames(node.argument, record);
+      return;
+  }
+}
+function shadowedNames(ast) {
+  const seen = new Set;
+  const shadowed = new Set;
+  const record = (name) => {
+    if (seen.has(name))
+      shadowed.add(name);
+    seen.add(name);
+  };
+  walkNodes(ast, (node) => {
+    switch (node.type) {
+      case "VariableDeclarator":
+        declaredPatternNames(node.id, record);
+        return;
+      case "FunctionDeclaration":
+      case "FunctionExpression":
+      case "ArrowFunctionExpression":
+        for (const param of node.params)
+          declaredPatternNames(param, record);
+        if (node.type !== "ArrowFunctionExpression" && node.id)
+          record(node.id.name);
+        return;
+      case "ClassDeclaration":
+        if (node.id)
+          record(node.id.name);
+        return;
+      case "ImportSpecifier":
+      case "ImportDefaultSpecifier":
+      case "ImportNamespaceSpecifier":
+        record(node.local.name);
+        return;
+    }
+  });
+  return shadowed;
 }
 function parseSource(source) {
   try {
@@ -21916,6 +22489,8 @@ function parseConfigSource(source, _sourcePath) {
       }
     }
   }
+  for (const name of shadowedNames(ast))
+    bindings.delete(name);
   const collectionObjects = new Map(inlineCollections);
   for (const [varName, collectionName] of exportMap) {
     const decl = collectionDecls.get(varName);
@@ -21974,6 +22549,7 @@ function parseConfigSource(source, _sourcePath) {
     result.set(collectionName, {
       name: collectionName,
       fields: parseSchemaFields(schemaObject, bindings),
+      ...hasSkippedMembers(schemaObject) ? { partialFields: true } : {},
       loaderPattern,
       loaderBase,
       layout,
@@ -22032,6 +22608,15 @@ function parseLayoutSection(node) {
     return null;
   return collapsed ? { title, fields, collapsed } : { title, fields };
 }
+function readEnumOptions(node) {
+  const options = [];
+  for (const el of node.elements) {
+    if (el?.type !== "StringLiteral")
+      return null;
+    options.push(el.value);
+  }
+  return options.length > 0 ? options : null;
+}
 function stringArray(node) {
   const out = [];
   for (const el of node.elements) {
@@ -22218,7 +22803,10 @@ function parseSchemaFields(schemaObject, bindings) {
   }
   return fields;
 }
-function analyzeFieldExpression(node, field, bindings) {
+function hasSkippedMembers(schemaObject) {
+  return schemaObject.properties.some((prop) => prop.type !== "ObjectProperty" || !propertyKeyName(prop.key));
+}
+function analyzeFieldExpression(node, field, bindings, helpers = new Set) {
   let current = resolveExpression(node, bindings);
   while (current) {
     if (current.type !== "CallExpression")
@@ -22227,10 +22815,30 @@ function analyzeFieldExpression(node, field, bindings) {
       analyzeBaseCall(current, field, bindings);
       return;
     }
+    if (current.callee.type === "Identifier") {
+      const returned = sameFileHelperReturn(current, bindings, helpers);
+      if (returned)
+        analyzeFieldExpression(returned, field, bindings, helpers);
+      return;
+    }
     if (current.callee.type !== "MemberExpression")
       return;
     const property = current.callee.property;
     const methodName = property.type === "Identifier" ? property.name : "";
+    if (methodName === "array") {
+      const item = { name: "__item__", required: true };
+      analyzeFieldExpression(current.callee.object, item, bindings, helpers);
+      if (item.reference) {
+        field.reference = { target: item.reference.target, isArray: true };
+        return;
+      }
+      field.type = "array";
+      if (item.type)
+        field.itemType = item.type;
+      if (item.fields)
+        field.fields = item.fields;
+      return;
+    }
     if (WRAPPER_METHODS.has(methodName)) {
       field.required = false;
     } else if (methodName === "orderBy") {
@@ -22241,6 +22849,25 @@ function analyzeFieldExpression(node, field, bindings) {
     current = resolveExpression(current.callee.object, bindings);
   }
 }
+function sameFileHelperReturn(call, bindings, seen) {
+  if (call.callee.type !== "Identifier" || call.arguments.length > 0)
+    return null;
+  if (seen.has(call.callee.name))
+    return null;
+  seen.add(call.callee.name);
+  const fn = resolveExpression(call.callee, bindings);
+  if (fn.type !== "ArrowFunctionExpression" && fn.type !== "FunctionExpression")
+    return null;
+  if (fn.params.length > 0)
+    return null;
+  if (fn.body.type !== "BlockStatement")
+    return fn.body;
+  for (const stmt of fn.body.body) {
+    if (stmt.type === "ReturnStatement" && stmt.argument)
+      return stmt.argument;
+  }
+  return null;
+}
 function isBaseCall(node) {
   const callee = node.callee;
   if (callee.type === "Identifier") {
@@ -22287,18 +22914,16 @@ function analyzeBaseCall(node, field, bindings) {
     }
     return;
   }
+  if ((ns === "z" || ns === "n") && fn === "boolean") {
+    field.type = "boolean";
+    return;
+  }
   if ((ns === "z" || ns === "n") && fn === "enum") {
-    const arg = node.arguments[0];
-    if (arg?.type === "ArrayExpression") {
-      const options = [];
-      for (const el of arg.elements) {
-        if (el?.type === "StringLiteral")
-          options.push(el.value);
-      }
-      if (options.length > 0) {
-        field.type = "select";
-        field.options = options;
-      }
+    const arg = node.arguments[0] ? resolveExpression(node.arguments[0], bindings) : undefined;
+    const options = arg?.type === "ArrayExpression" ? readEnumOptions(arg) : null;
+    if (options) {
+      field.type = "select";
+      field.options = options;
     }
     const hintsArg = node.arguments[1];
     if (hintsArg?.type === "ObjectExpression") {
@@ -22459,11 +23084,44 @@ var init_content_config_ast = __esm(() => {
   WRAPPER_METHODS = new Set(["optional", "nullable", "nullish", "default"]);
 });
 
-// ../cms-core/src/check.ts
-import path from "path";
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
+// ../cms-core/src/shared.ts
+function pathSegmentValue(raw) {
+  if (typeof raw === "string")
+    return raw;
+  if (typeof raw === "number" || typeof raw === "boolean")
+    return String(raw);
+  if (raw instanceof Date)
+    return raw.toISOString().slice(0, 10);
+  return;
+}
+function computePathnameFromSpec(spec, data) {
+  const segments = [];
+  for (const seg of spec) {
+    if ("literal" in seg) {
+      segments.push(seg.literal);
+      continue;
+    }
+    const value = pathSegmentValue(data[seg.field]);
+    if (value === undefined)
+      return;
+    segments.push(seg.map && Object.hasOwn(seg.map, value) ? seg.map[value] : value);
+  }
+  const path2 = ("/" + segments.join("/")).replace(/\/{2,}/g, "/").replace(/\/+$/, "");
+  return path2 === "" ? "/" : path2;
+}
+function resolvePathnameFromSpec(def, data) {
+  if (!def.pathname)
+    return;
+  return computePathnameFromSpec(def.pathname, data ?? {});
 }
+function slugifyHref(text) {
+  return "/" + text.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_]+/g, "-").replace(/^-+|-+$/g, "");
+}
+var init_shared = __esm(() => {
+  init_src();
+});
+
+// ../cms-core/src/check.ts
 function typeMismatch(field, value) {
   switch (field.type) {
     case "number":
@@ -22505,40 +23163,86 @@ function typeMismatch(field, value) {
       return null;
   }
 }
-async function collectEntryFiles(fs, collection, base) {
-  const pattern = collection.loaderPattern ?? "**/*.{md,mdx,json,yaml,yml}";
-  const files = await fs.glob(`${base}/${pattern}`);
-  return files.filter((file) => !path.basename(file).startsWith("_")).sort();
+function projectAssetPath(value) {
+  if (value === "" || value.startsWith("//"))
+    return null;
+  if (/^[a-z][a-z\d+\-.]*:/i.test(value))
+    return null;
+  if (/^[~@#]/.test(value))
+    return null;
+  const withoutQuery = value.split(/[?#]/)[0] ?? "";
+  return withoutQuery === "" ? null : withoutQuery;
 }
-function parseEntry(file, raw) {
-  const extension = path.extname(file);
-  if (DATA_EXTENSIONS.has(extension)) {
-    try {
-      const parsed = extension === ".json" ? JSON.parse(raw) : import_yaml.default.parse(raw);
-      return { frontmatter: isPlainObject(parsed) ? parsed : {} };
-    } catch (error) {
-      return { error: error instanceof Error ? error.message.split(`
-`)[0] : String(error) };
+async function checkAssets(fs, fields, data, file, prefix, findings) {
+  for (const field of fields) {
+    const value = data[field.name];
+    if (value === undefined || value === null)
+      continue;
+    const label = prefix === "" ? field.name : `${prefix}.${field.name}`;
+    if (field.type === "object" && field.fields && isPlainObject(value)) {
+      await checkAssets(fs, field.fields, value, file, label, findings);
+      continue;
+    }
+    if (field.type === "array" && field.itemType === "object" && field.fields && Array.isArray(value)) {
+      for (const [index, item] of value.entries()) {
+        if (isPlainObject(item))
+          await checkAssets(fs, field.fields, item, file, `${label}[${index}]`, findings);
+      }
+      continue;
     }
+    if (field.type !== "image" || typeof value !== "string")
+      continue;
+    const assetPath = projectAssetPath(value);
+    if (assetPath === null)
+      continue;
+    const candidates = resolveAssetCandidates(assetBaseDir(file), assetPath);
+    if (candidates.length === 0)
+      continue;
+    let found = false;
+    for (const candidate of candidates) {
+      if (await fs.exists(candidate)) {
+        found = true;
+        break;
+      }
+    }
+    if (found)
+      continue;
+    findings.push({
+      severity: "warning",
+      code: "entry/missing-asset",
+      file,
+      field: label,
+      message: `${label}: "${value}" points at no file (tried ${candidates.join(", ")}).`
+    });
   }
-  const trimmed = raw.trimStart();
-  if (!trimmed.startsWith("---"))
-    return { frontmatter: {} };
-  const lines = trimmed.split(`
-`);
-  const end = lines.findIndex((line, index) => index > 0 && line.trimEnd() === "---");
-  if (end === -1)
-    return { error: "frontmatter is never closed (missing the second `---`)" };
-  try {
-    const parsed = import_yaml.default.parse(lines.slice(1, end).join(`
-`).trim());
-    return { frontmatter: isPlainObject(parsed) ? parsed : {} };
-  } catch (error) {
-    return { error: error instanceof Error ? error.message.split(`
-`)[0] : String(error) };
+}
+function pathnameCollisions(collection, entries) {
+  if (!collection.pathname)
+    return [];
+  const findings = [];
+  const firstAt = new Map;
+  for (const entry of entries) {
+    if (!entry.frontmatter)
+      continue;
+    const pathname = computePathnameFromSpec(collection.pathname, entry.frontmatter);
+    if (pathname === undefined)
+      continue;
+    const first = firstAt.get(pathname);
+    if (!first) {
+      firstAt.set(pathname, entry);
+      continue;
+    }
+    findings.push({
+      severity: "warning",
+      code: "entry/pathname-collision",
+      file: entry.file,
+      field: collection.name,
+      message: `The pathname rule maps this entry and ${first.file} to ${pathname} \u2014 they collide on one page.`
+    });
   }
+  return findings;
 }
-async function checkContent(fs) {
+async function checkContent(fs, options = {}) {
   const findings = [];
   const config = await parseContentConfig(fs, new Map);
   if (config.size === 0) {
@@ -22550,51 +23254,47 @@ async function checkContent(fs) {
     });
     return { findings, collections: 0, entries: 0 };
   }
-  const bases = new Map;
-  const files = new Map;
+  const collections = await loadCollections(fs, config);
   const stems = new Map;
-  for (const [name, collection] of config) {
-    const base = normalizeBase(collection.loaderBase ?? `src/content/${name}`);
-    bases.set(name, base);
-    if (!await fs.exists(base)) {
+  for (const [name, loaded] of collections) {
+    stems.set(name, new Set(loaded.entries.map((entry) => entry.stem)));
+    if (!loaded.exists) {
       findings.push({
         severity: "error",
         code: "config/missing-dir",
         file: "src/content.config.ts",
         field: name,
-        message: `Collection "${name}" loads from ${base}/, which does not exist.`
+        message: `Collection "${name}" loads from ${loaded.base}/, which does not exist.`
       });
-      files.set(name, []);
-      stems.set(name, new Set);
       continue;
     }
-    const collectionFiles = await collectEntryFiles(fs, collection, base);
-    files.set(name, collectionFiles);
-    stems.set(name, new Set(collectionFiles.map(entryStem)));
-    if (collectionFiles.length === 0) {
+    if (loaded.entries.length === 0) {
       findings.push({
         severity: "warning",
         code: "config/empty-collection",
-        file: base,
+        file: loaded.base,
         field: name,
-        message: `Collection "${name}" matched no entries under ${base}/.`
+        message: `Collection "${name}" matched no entries under ${loaded.base}/.`
       });
     }
   }
   let entries = 0;
   for (const [name, collection] of config) {
     const typedFields = collection.fields.filter((field) => field.type !== undefined || field.required || field.reference);
-    for (const file of files.get(name) ?? []) {
+    const declared = new Set(collection.fields.map((field) => field.name));
+    const loadedEntries = collections.get(name)?.entries ?? [];
+    const schemaJudgesEntries = options.schemas !== undefined && schemaFor(options.schemas, name) !== undefined;
+    for (const entry of loadedEntries) {
       entries++;
-      const parsed = parseEntry(file, await fs.readFile(file));
-      if ("error" in parsed) {
-        findings.push({ severity: "error", code: "entry/syntax", file, message: `Frontmatter does not parse: ${parsed.error}` });
+      const file = entry.file;
+      if (entry.frontmatter === undefined) {
+        findings.push({ severity: "error", code: "entry/syntax", file, message: `Frontmatter does not parse: ${entry.parseError}` });
         continue;
       }
       for (const field of typedFields) {
-        const value = parsed.frontmatter[field.name];
+        const value = entry.frontmatter[field.name];
         if (value === undefined || value === null) {
-          if (field.required) {
+          if (field.required && !schemaJudgesEntries) {
             findings.push({
               severity: "error",
               code: "entry/missing-required",
@@ -22605,7 +23305,7 @@ async function checkContent(fs) {
           }
           continue;
         }
-        const mismatch = field.type === undefined ? null : typeMismatch(field, value);
+        const mismatch = field.type === undefined || schemaJudgesEntries ? null : typeMismatch(field, value);
         if (mismatch) {
           findings.push({ severity: "error", code: "entry/field-type", file, field: field.name, message: `${field.name}: ${mismatch}` });
           continue;
@@ -22629,7 +23329,26 @@ async function checkContent(fs) {
           });
         }
       }
+      await checkAssets(fs, collection.fields, entry.frontmatter, file, "", findings);
+      if (declared.size > 0 && !collection.partialFields) {
+        for (const key of Object.keys(entry.frontmatter)) {
+          if (declared.has(key))
+            continue;
+          findings.push({
+            severity: "warning",
+            code: "entry/unknown-key",
+            file,
+            field: key,
+            message: `"${key}" is not a field of "${name}" \u2014 nothing reads it.`
+          });
+        }
+      }
     }
+    findings.push(...pathnameCollisions(collection, loadedEntries));
+  }
+  if (options.schemas) {
+    const input = { config, collections, schemas: options.schemas };
+    findings.push(...await checkAgainstSchemas(input), ...await checkEditorWrites(input), ...await checkFieldShapes(input));
   }
   return { findings, collections: config.size, entries };
 }
@@ -22647,15 +23366,19 @@ function formatCheckReport(report) {
   const lines = [];
   for (const [file, findings] of byFile) {
     lines.push(file);
+    let lastHint;
     for (const finding of findings) {
       const at = finding.line === undefined ? "" : `${finding.line}:${finding.column ?? 0}`;
       lines.push(`  ${at.padEnd(8)}${(finding.severity === "error" ? "error" : "warn").padEnd(6)} ${finding.message}  [${finding.code}]`);
+      if (finding.hint !== undefined && finding.hint !== lastHint)
+        lines.push(`  ${" ".repeat(14)}\u2192 ${finding.hint}`);
+      lastHint = finding.hint;
     }
   }
   return lines.join(`
 `);
 }
-var import_yaml, DATA_EXTENSIONS, normalizeBase = (base) => path.normalize(base).replace(/^\.\//, "").replace(/\/+$/, ""), entryStem = (file) => path.basename(file).replace(/\.(md|mdx|json|ya?ml)$/, ""), typeName = (value) => {
+var typeName = (value) => {
   if (value === null)
     return "null";
   if (Array.isArray(value))
@@ -22665,45 +23388,14 @@ var import_yaml, DATA_EXTENSIONS, normalizeBase = (base) => path.normalize(base)
   return typeof value;
 };
 var init_check = __esm(() => {
+  init_check_entries();
+  init_check_live();
+  init_check_shape();
+  init_check_write();
   init_content_config_ast();
-  import_yaml = __toESM(require_dist(), 1);
-  DATA_EXTENSIONS = new Set([".json", ".yaml", ".yml"]);
+  init_shared();
 });
 
-// ../cms-core/src/shared.ts
-function pathSegmentValue(raw) {
-  if (typeof raw === "string")
-    return raw;
-  if (typeof raw === "number" || typeof raw === "boolean")
-    return String(raw);
-  if (raw instanceof Date)
-    return raw.toISOString().slice(0, 10);
-  return;
-}
-function computePathnameFromSpec(spec, data) {
-  const segments = [];
-  for (const seg of spec) {
-    if ("literal" in seg) {
-      segments.push(seg.literal);
-      continue;
-    }
-    const value = pathSegmentValue(data[seg.field]);
-    if (value === undefined)
-      return;
-    segments.push(seg.map && Object.hasOwn(seg.map, value) ? seg.map[value] : value);
-  }
-  const path2 = ("/" + segments.join("/")).replace(/\/{2,}/g, "/").replace(/\/+$/, "");
-  return path2 === "" ? "/" : path2;
-}
-function resolvePathnameFromSpec(def, data) {
-  if (!def.pathname)
-    return;
-  return computePathnameFromSpec(def.pathname, data ?? {});
-}
-function slugifyHref(text) {
-  return "/" + text.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_]+/g, "-").replace(/^-+|-+$/g, "");
-}
-
 // ../cms-core/src/collection-scanner.ts
 import path2 from "path";
 function normalizeFieldName(name) {
@@ -23496,6 +24188,7 @@ function warnOnPathnameCollisions(collections) {
 var import_yaml2, DATE_PATTERN, URL_PATTERN, IMAGE_EXTENSIONS, MAX_SELECT_OPTIONS = 10, TEXTAREA_MIN_LENGTH = 200, SIDEBAR_FIELD_NAMES, DIRECTIVE_PATTERN, FREE_TEXT_FIELD_NAMES, PUBLISH_TOGGLE_NAMES, PUBLISH_DATE_NAMES, TITLE_FALLBACK_FIELDS, FRONTMATTER_PATTERN, MAX_NESTED_FIELD_DEPTH = 16, HREF_SUFFIXES, WHOLE_DIRECTORY_PATTERN;
 var init_collection_scanner = __esm(() => {
   init_content_config_ast();
+  init_shared();
   import_yaml2 = __toESM(require_dist(), 1);
   DATE_PATTERN = /^\d{4}-\d{2}-\d{2}/;
   URL_PATTERN = /^(https?:\/\/|\/)/;
@@ -23575,12 +24268,16 @@ var import_yaml3;
 var init_entry_ops = __esm(() => {
   init_collection_scanner();
   init_content_config_ast();
+  init_editor_write_model();
   init_local();
+  init_shared();
   import_yaml3 = __toESM(require_dist(), 1);
 });
 
 // ../cms-core/src/handlers/page-ops.ts
-var init_page_ops = () => {};
+var init_page_ops = __esm(() => {
+  init_shared();
+});
 // ../cms-core/src/core.ts
 var init_core = __esm(() => {
   init_collection_scanner();
@@ -23817,14 +24514,21 @@ var init_project_config_ast = __esm(() => {
 // ../cms-core/src/index.ts
 var init_src2 = __esm(() => {
   init_check();
+  init_check_entries();
+  init_check_live();
+  init_check_shape();
+  init_check_write();
   init_collection_scanner();
   init_component_registry();
   init_content_config_ast();
   init_core();
+  init_editor_write_model();
   init_node_fs();
   init_entry_ops();
   init_media();
   init_project_config_ast();
+  init_schema_probe();
+  init_shared();
 });
 
 // ../../node_modules/@astrojs/compiler/dist/chunk-W5DTLHV4.js
@@ -24621,45 +25325,307 @@ var init_check_code = __esm(() => {
   IGNORED = ["node_modules", "dist", ".astro", ".git", ".output", ".vercel", ".netlify"];
 });
 
+// src/live-schema.ts
+import { existsSync, realpathSync } from "fs";
+import path5 from "path";
+function reasonOf(error, fallback = "unknown error") {
+  try {
+    if (typeof error === "string" && error !== "")
+      return error;
+    if (error instanceof Error && error.message !== "")
+      return error.message;
+    if (isRecord(error) && typeof error.message === "string" && error.message !== "")
+      return error.message;
+  } catch {}
+  return fallback;
+}
+function findConfig(projectRoot) {
+  for (const name of CONFIG_NAMES) {
+    const candidate = path5.join(projectRoot, name);
+    if (existsSync(candidate))
+      return candidate;
+  }
+  return null;
+}
+function projectAstroDir(projectRoot) {
+  let dir = projectRoot;
+  while (true) {
+    const candidate = path5.join(dir, "node_modules", "astro");
+    if (existsSync(path5.join(candidate, "package.json")))
+      return candidate;
+    const parent = path5.dirname(dir);
+    if (parent === dir)
+      return null;
+    dir = parent;
+  }
+}
+function zodEntryOf(module) {
+  if (!isRecord(module))
+    return null;
+  const namespace = module.z;
+  if (!isRecord(namespace))
+    return null;
+  const string = namespace.string;
+  const object = namespace.object;
+  const union = namespace.union;
+  const any = namespace.any;
+  if (typeof string !== "function" || typeof object !== "function" || typeof union !== "function" || typeof any !== "function")
+    return null;
+  return {
+    namespace,
+    any: () => Reflect.apply(any, namespace, []),
+    reference: () => {
+      const text = () => Reflect.apply(string, namespace, []);
+      const lookup = (key) => Reflect.apply(object, namespace, [{ [key]: text(), collection: text() }]);
+      return Reflect.apply(union, namespace, [[text(), lookup("id"), lookup("slug")]]);
+    }
+  };
+}
+function installContentStub(zodPath, zod) {
+  Bun.plugin({
+    name: "astro-content-stub",
+    setup(build) {
+      build.module("astro:content", () => ({
+        loader: "object",
+        exports: {
+          defineCollection: (collection) => collection,
+          reference: () => zod.reference(),
+          z: zod.namespace
+        }
+      }));
+    }
+  });
+  stubbedZod = zodPath;
+}
+function parseMethod(schema) {
+  if (!isRecord(schema))
+    return null;
+  for (const name of ["safeParseAsync", "safeParse"]) {
+    const method = schema[name];
+    if (typeof method === "function")
+      return (value) => Reflect.apply(method, schema, [value]);
+  }
+  return null;
+}
+function dedupe(issues) {
+  const seen = new Set;
+  const unique = [];
+  for (const issue of issues) {
+    const key = `${issue.path.join("\x00")}\x01${issue.message}`;
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    unique.push(issue);
+  }
+  return unique;
+}
+function unionIssues(raw) {
+  return asArray(raw.errors ?? raw.unionErrors).flatMap((branch) => asArray(isRecord(branch) ? branch.issues ?? branch.errors : branch).flatMap(toIssues));
+}
+function toIssues(raw) {
+  if (!isRecord(raw))
+    return [{ path: [], message: reasonOf(raw, "invalid value") }];
+  const base = asArray(raw.path).map((segment) => typeof segment === "number" ? segment : String(segment));
+  const branches = raw.code === "invalid_union" ? unionIssues(raw) : [];
+  if (branches.length > 0)
+    return dedupe(branches.map((issue) => ({ path: [...base, ...issue.path], message: issue.message })));
+  return [{ path: base, message: typeof raw.message === "string" ? raw.message : "invalid value" }];
+}
+function normalizeIssues(error) {
+  const raw = isRecord(error) ? asArray(error.issues ?? error.errors) : [];
+  if (raw.length > 0)
+    return raw.flatMap(toIssues);
+  return [{ path: [], message: reasonOf(error, "the schema rejected this value without saying why") }];
+}
+function liveSchema(parse3) {
+  return {
+    async safeParse(value) {
+      try {
+        const result = await parse3(value);
+        if (!isRecord(result))
+          return { success: false, issues: [{ path: [], message: "the schema returned no parse result" }] };
+        if (result.success === true)
+          return { success: true };
+        return { success: false, issues: normalizeIssues(result.error) };
+      } catch (error) {
+        return { success: false, issues: [{ path: [], message: reasonOf(error, "the schema threw while parsing this entry") }] };
+      }
+    }
+  };
+}
+async function collectSchemas(module, zod, configName) {
+  const collections = isRecord(module) ? module.collections : undefined;
+  if (!isRecord(collections))
+    return { skipped: `${configName} does not export a \`collections\` object.` };
+  const schemas = {};
+  for (const [name, definition] of Object.entries(collections)) {
+    if (!isRecord(definition))
+      continue;
+    const factory = definition.schema;
+    if (factory === undefined)
+      continue;
+    let resolved;
+    try {
+      resolved = typeof factory === "function" ? await Reflect.apply(factory, definition, [{ image: () => zod.any() }]) : factory;
+    } catch (error) {
+      return { skipped: `The schema of collection "${name}" in ${configName} threw while being built: ${reasonOf(error)}` };
+    }
+    const parse3 = parseMethod(resolved);
+    if (!parse3) {
+      return { skipped: `The schema of collection "${name}" in ${configName} has no safeParse method \u2014 is it a zod schema?` };
+    }
+    schemas[name] = liveSchema(parse3);
+  }
+  return { schemas };
+}
+async function loadLiveSchemas(projectRoot) {
+  const root = path5.resolve(projectRoot);
+  const configPath = findConfig(root);
+  if (!configPath) {
+    return { skipped: `No content config in ${root} \u2014 expected src/content.config.ts or src/content/config.ts.` };
+  }
+  const configName = path5.relative(root, configPath);
+  const astroDir = projectAstroDir(root);
+  if (!astroDir) {
+    return { skipped: `No node_modules/astro above ${root} \u2014 install the project's dependencies and run this again.` };
+  }
+  let zodPath;
+  try {
+    zodPath = realOf(Bun.resolveSync("astro/zod", root));
+  } catch (error) {
+    return { skipped: `Could not resolve astro/zod from ${root}: ${reasonOf(error)}` };
+  }
+  if (!contains(astroDir, zodPath)) {
+    return {
+      skipped: `astro/zod resolved to ${zodPath}, outside the project's own ${astroDir} \u2014 reinstall the project's dependencies and run this again.`
+    };
+  }
+  let zodModule;
+  try {
+    zodModule = await import(zodPath);
+  } catch (error) {
+    return { skipped: `Loading astro/zod from ${root} failed: ${reasonOf(error)}` };
+  }
+  let zod;
+  try {
+    zod = zodEntryOf(zodModule);
+  } catch {
+    zod = null;
+  }
+  if (!zod) {
+    return { skipped: `astro/zod in ${root} does not export a usable \`z\` \u2014 the installed Astro version may be unsupported.` };
+  }
+  if (stubbedZod === null) {
+    try {
+      installContentStub(zodPath, zod);
+    } catch (error) {
+      return { skipped: `Installing the astro:content stub failed: ${reasonOf(error)}` };
+    }
+  } else if (stubbedZod !== zodPath) {
+    return {
+      skipped: `Live schemas were already loaded against ${stubbedZod}; the astro:content stub is process-global, so ${root} needs a run of its own.`
+    };
+  }
+  let module;
+  try {
+    module = await import(configPath);
+  } catch (error) {
+    return { skipped: `${configName} failed to load: ${reasonOf(error)}` };
+  }
+  try {
+    return await collectSchemas(module, zod, configName);
+  } catch (error) {
+    return { skipped: `Reading the collections in ${configName} failed: ${reasonOf(error)}` };
+  }
+}
+var CONFIG_NAMES, isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value), asArray = (value) => Array.isArray(value) ? value : [], realOf = (target) => {
+  try {
+    return realpathSync(target);
+  } catch {
+    return target;
+  }
+}, contains = (dir, file) => {
+  const relative = path5.relative(realOf(dir), realOf(file));
+  return relative !== "" && !relative.startsWith("..") && !path5.isAbsolute(relative);
+}, stubbedZod = null;
+var init_live_schema = __esm(() => {
+  CONFIG_NAMES = [
+    "src/content.config.mjs",
+    "src/content.config.js",
+    "src/content.config.mts",
+    "src/content.config.ts",
+    "src/content/config.ts",
+    "src/content/config.js",
+    "src/content/config.mjs",
+    "src/content/config.mts"
+  ];
+});
+
 // src/check.ts
 var exports_check = {};
 __export(exports_check, {
+  parseCheckArgs: () => parseCheckArgs,
   check: () => check,
   astroRoots: () => astroRoots
 });
-import { existsSync, readdirSync } from "fs";
-import path5 from "path";
+import { existsSync as existsSync2, readdirSync } from "fs";
+import path6 from "path";
+function parseCheckArgs(args, cwd) {
+  const contentOnly = args.includes("--content-only");
+  return {
+    cwd,
+    json: args.includes("--json"),
+    strict: args.includes("--strict"),
+    contentOnly,
+    live: !contentOnly && !args.includes("--no-live")
+  };
+}
 function astroRoots(cwd) {
   if (hasAstroConfig(cwd))
     return ["."];
-  const packagesDir = path5.join(cwd, "packages");
-  if (!existsSync(packagesDir))
+  const packagesDir = path6.join(cwd, "packages");
+  if (!existsSync2(packagesDir))
     return [];
-  return readdirSync(packagesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort().filter((name) => hasAstroConfig(path5.join(packagesDir, name))).map((name) => path5.join("packages", name));
+  return readdirSync(packagesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort().filter((name) => hasAstroConfig(path6.join(packagesDir, name))).map((name) => path6.join("packages", name));
 }
 function prefixed(report, root) {
   if (root === ".")
     return report;
   return {
     ...report,
-    findings: report.findings.map((finding) => ({ ...finding, file: path5.join(root, finding.file) }))
+    findings: report.findings.map((finding) => ({ ...finding, file: path6.join(root, finding.file) }))
   };
 }
+async function liveSchemasFor(options, roots) {
+  if (options.contentOnly) {
+    return { skipped: "--content-only was passed, and reading the real schemas means executing the project's content config." };
+  }
+  if (!options.live)
+    return { skipped: "--no-live was passed." };
+  const first = roots[0];
+  if (roots.length !== 1 || first === undefined) {
+    const where = roots.join(", ");
+    return { skipped: `They need exactly one Astro project; this run covers ${roots.length} (${where}). Check each one from its own directory.` };
+  }
+  return loadLiveSchemas(path6.join(options.cwd, first));
+}
 async function check(options) {
   const roots = astroRoots(options.cwd);
   if (roots.length === 0) {
     console.error(`No astro.config.* found in ${options.cwd} or its packages/*. Run this in an Astro project.`);
     return 1;
   }
+  const live = await liveSchemasFor(options, roots);
+  const schemas = "schemas" in live ? live.schemas : undefined;
   const reports = await Promise.all(roots.map(async (root) => {
-    const absolute = path5.join(options.cwd, root);
-    const content = prefixed(await checkContent(createNodeFs(absolute)), root);
+    const absolute = path6.join(options.cwd, root);
+    const content = prefixed(await checkContent(createNodeFs(absolute), schemas ? { schemas } : {}), root);
     if (options.contentOnly)
       return { ...content, files: 0 };
     const code = await checkCode(absolute);
     return {
       ...content,
-      findings: [...content.findings, ...code.findings.map((finding) => ({ ...finding, file: path5.join(root, finding.file) }))],
+      findings: [...content.findings, ...code.findings.map((finding) => ({ ...finding, file: path6.join(root, finding.file) }))],
       files: code.files
     };
   }));
@@ -24672,7 +25638,7 @@ async function check(options) {
   const errors = report.findings.filter((finding) => finding.severity === "error").length;
   const warnings = report.findings.length - errors;
   if (options.json) {
-    console.log(JSON.stringify({ ...report, roots }, null, 2));
+    console.log(JSON.stringify({ ...report, roots, liveSchemas: "schemas" in live ? "ran" : live.skipped }, null, 2));
   } else {
     const formatted = formatCheckReport(report);
     if (formatted)
@@ -24682,23 +25648,26 @@ async function check(options) {
     const code = options.contentOnly ? "" : `, ${sourceFiles} source file(s)`;
     const counts = `${report.collections} collection(s), ${report.entries} entries${code}${where}`;
     console.log(errors === 0 && warnings === 0 ? `${counts} \u2014 no problems found` : `${counts} \u2014 ${errors} error(s), ${warnings} warning(s)`);
+    if ("skipped" in live)
+      console.log(`Live schema rules did not run: ${live.skipped}`);
   }
   return errors > 0 || options.strict && warnings > 0 ? 1 : 0;
 }
-var ASTRO_CONFIG_NAMES, hasAstroConfig = (dir) => ASTRO_CONFIG_NAMES.some((name) => existsSync(path5.join(dir, name)));
+var ASTRO_CONFIG_NAMES, hasAstroConfig = (dir) => ASTRO_CONFIG_NAMES.some((name) => existsSync2(path6.join(dir, name)));
 var init_check2 = __esm(() => {
   init_src2();
   init_check_code();
+  init_live_schema();
   ASTRO_CONFIG_NAMES = ["astro.config.ts", "astro.config.mts", "astro.config.mjs", "astro.config.js"];
 });
 
 // src/utils.ts
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 import { join } from "path";
 function findAstroConfig(cwd = process.cwd()) {
-  for (const name of CONFIG_NAMES) {
+  for (const name of CONFIG_NAMES2) {
     const p = join(cwd, name);
-    if (existsSync2(p))
+    if (existsSync3(p))
       return p;
   }
   return null;
@@ -24795,9 +25764,9 @@ function assembleConfig(imports, body) {
 `;
   return result;
 }
-var CONFIG_NAMES;
+var CONFIG_NAMES2;
 var init_utils = __esm(() => {
-  CONFIG_NAMES = [
+  CONFIG_NAMES2 = [
     "astro.config.ts",
     "astro.config.mts",
     "astro.config.mjs",
@@ -24815,7 +25784,7 @@ __export(exports_init, {
   detectNuaManagedImports: () => detectNuaManagedImports,
   cleanEmptyStructures: () => cleanEmptyStructures
 });
-import { existsSync as existsSync3, readFileSync, writeFileSync } from "fs";
+import { existsSync as existsSync4, readFileSync, writeFileSync } from "fs";
 import { basename, join as join2 } from "path";
 function detectNuaManagedImports(content) {
   const managed = new Map;
@@ -24959,7 +25928,7 @@ async function init({ cwd = process.cwd(), dryRun = false, yes = false } = {}) {
     process.exit(1);
   }
   const pkgPath = join2(cwd, "package.json");
-  if (!existsSync3(pkgPath)) {
+  if (!existsSync4(pkgPath)) {
     console.error("No package.json found.");
     process.exit(1);
   }
@@ -25037,7 +26006,7 @@ __export(exports_clean, {
   detectDisabledFeatures: () => detectDisabledFeatures,
   clean: () => clean
 });
-import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
 import { basename as basename2, join as join3 } from "path";
 function detectDisabledFeatures(content) {
   const disabled = new Set;
@@ -25146,7 +26115,7 @@ function transformPackageJson2(pkg, disabled, usedRuntimePackages = []) {
 }
 function scanForNuasiteUsage(cwd) {
   const srcDir = join3(cwd, "src");
-  if (!existsSync4(srcDir))
+  if (!existsSync5(srcDir))
     return [];
   const results = [];
   try {
@@ -25181,7 +26150,7 @@ async function clean({ cwd = process.cwd(), dryRun = false, yes = false } = {})
     return;
   }
   const pkgPath = join3(cwd, "package.json");
-  if (!existsSync4(pkgPath)) {
+  if (!existsSync5(pkgPath)) {
     console.error("No package.json found.");
     process.exit(1);
   }
@@ -25289,7 +26258,7 @@ var init_config = () => {};
 
 // ../cms/src/component-registry.ts
 import fs2 from "fs/promises";
-import path6 from "path";
+import path7 from "path";
 
 class ComponentRegistry {
   components = new Map;
@@ -25299,7 +26268,7 @@ class ComponentRegistry {
   }
   async scan() {
     for (const dir of this.componentDirs) {
-      const fullPath = path6.join(getProjectRoot(), dir);
+      const fullPath = path7.join(getProjectRoot(), dir);
       try {
         await this.scanDirectory(fullPath, dir);
       } catch {}
@@ -25314,8 +26283,8 @@ class ComponentRegistry {
   async scanDirectory(dir, relativePath) {
     const entries = await fs2.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path6.join(dir, entry.name);
-      const relPath = path6.join(relativePath, entry.name);
+      const fullPath = path7.join(dir, entry.name);
+      const relPath = path7.join(relativePath, entry.name);
       if (entry.isDirectory()) {
         await this.scanDirectory(fullPath, relPath);
       } else if (entry.isFile() && entry.name.endsWith(".astro")) {
@@ -25326,7 +26295,7 @@ class ComponentRegistry {
   async parseComponent(filePath, relativePath) {
     try {
       const content = await fs2.readFile(filePath, "utf-8");
-      const componentName = path6.basename(filePath, ".astro");
+      const componentName = path7.basename(filePath, ".astro");
       const props = await this.extractProps(content);
       const slots = this.extractSlots(content);
       const description = this.extractDescription(content);
@@ -25581,7 +26550,7 @@ function slugify2(text) {
 
 // ../cms/src/utils.ts
 import { createHash } from "crypto";
-import path7 from "path";
+import path8 from "path";
 function normalizePagePath(url) {
   let pathname;
   try {
@@ -25634,21 +26603,21 @@ function escapeReplacement(str) {
   return str.replace(/\$/g, "$$$$");
 }
 function resolveSourcePath(sourcePath) {
-  return path7.isAbsolute(sourcePath) ? sourcePath : path7.join(getProjectRoot(), sourcePath);
+  return path8.isAbsolute(sourcePath) ? sourcePath : path8.join(getProjectRoot(), sourcePath);
 }
 function resolveAndValidatePath(filePath) {
   const projectRoot = getProjectRoot();
-  const resolvedRoot = path7.resolve(projectRoot);
+  const resolvedRoot = path8.resolve(projectRoot);
   const isAbsoluteFs = filePath.startsWith(resolvedRoot);
   const normalizedPath = !isAbsoluteFs && filePath.startsWith("/") ? filePath.slice(1) : filePath;
-  const fullPath = path7.isAbsolute(normalizedPath) ? path7.resolve(normalizedPath) : path7.resolve(projectRoot, normalizedPath);
-  if (!fullPath.startsWith(resolvedRoot + path7.sep) && fullPath !== resolvedRoot) {
+  const fullPath = path8.isAbsolute(normalizedPath) ? path8.resolve(normalizedPath) : path8.resolve(projectRoot, normalizedPath);
+  if (!fullPath.startsWith(resolvedRoot + path8.sep) && fullPath !== resolvedRoot) {
     throw new Error(`Path traversal detected: ${filePath}`);
   }
   return fullPath;
 }
 async function acquireFileLock(filePath) {
-  const key = path7.resolve(filePath);
+  const key = path8.resolve(filePath);
   while (fileLocks.has(key)) {
     await fileLocks.get(key);
   }
@@ -25666,8 +26635,8 @@ function escapeHtml2(text) {
   return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 }
 function relativeImportPath2(fromFile, toFile) {
-  const fromDir = path7.dirname(fromFile);
-  let rel = path7.relative(fromDir, toFile).split(path7.sep).join("/");
+  const fromDir = path8.dirname(fromFile);
+  let rel = path8.relative(fromDir, toFile).split(path8.sep).join("/");
   if (!rel.startsWith("."))
     rel = `./${rel}`;
   return rel;
@@ -25680,7 +26649,7 @@ var init_utils2 = __esm(() => {
 
 // ../cms/src/handlers/component-ops.ts
 import fs3 from "fs/promises";
-import path8 from "path";
+import path9 from "path";
 async function handleInsertComponent(request, manifestWriter) {
   const { position, referenceComponentId, componentName, props, meta } = request;
   if (!meta?.url) {
@@ -25898,7 +26867,7 @@ function getComponentOccurrenceIndex(manifest, referenceComponent) {
 async function findComponentInvocationFile(projectRoot, pageUrl, manifest, referenceComponent) {
   if (referenceComponent.invocationSourcePath) {
     const filePath = normalizeFilePath(referenceComponent.invocationSourcePath);
-    const fullPath = path8.resolve(projectRoot, filePath);
+    const fullPath = path9.resolve(projectRoot, filePath);
     try {
       const content = await fs3.readFile(fullPath, "utf-8");
       const lines = content.split(`
@@ -25912,7 +26881,7 @@ async function findComponentInvocationFile(projectRoot, pageUrl, manifest, refer
   const candidates = getPageFileCandidates(pageUrl);
   const occurrenceIndex = getComponentOccurrenceIndex(manifest, referenceComponent);
   for (const candidate of candidates) {
-    const fullPath = path8.resolve(projectRoot, candidate);
+    const fullPath = path9.resolve(projectRoot, candidate);
     try {
       const content = await fs3.readFile(fullPath, "utf-8");
       const lines = content.split(`
@@ -25972,7 +26941,7 @@ function getIndentation(line) {
 function normalizeFilePath(p) {
   if (!p.startsWith("/"))
     return p;
-  const projectRoot = path8.resolve(getProjectRoot());
+  const projectRoot = path9.resolve(getProjectRoot());
   if (p.startsWith(projectRoot))
     return p;
   return p.slice(1);
@@ -26380,45 +27349,45 @@ var init_array_ops = __esm(() => {
 // ../cms/src/astro-image-paths.ts
 import { createHash as createHash2 } from "crypto";
 import fs5 from "fs/promises";
-import path9 from "path";
+import path10 from "path";
 function isHugoStyleEntry(entryAbsPath) {
-  return HUGO_INDEX_RE.test(path9.basename(entryAbsPath));
+  return HUGO_INDEX_RE.test(path10.basename(entryAbsPath));
 }
 function shortContentHash(buf) {
   return createHash2("sha256").update(buf).digest("hex").slice(0, 8);
 }
 async function pickAstroImageTarget(args) {
-  const entryDir = path9.dirname(args.entryAbsPath);
+  const entryDir = path10.dirname(args.entryAbsPath);
   const isHugoStyle = isHugoStyleEntry(args.entryAbsPath);
-  const safeFilename = path9.basename(args.originalFilename);
+  const safeFilename = path10.basename(args.originalFilename);
   if (!safeFilename || safeFilename === "." || safeFilename === "..") {
     throw new Error(`Invalid filename: ${args.originalFilename}`);
   }
   const baseName = isHugoStyle ? safeFilename : `${args.slug}-${safeFilename}`;
-  const baseAbs = path9.join(entryDir, baseName);
+  const baseAbs = path10.join(entryDir, baseName);
   if (await isFreeOrMatching(baseAbs, args.compareBuffer)) {
     return { absPath: baseAbs, relPath: `./${baseName}` };
   }
   const candidateAbs = await pickHashedSibling(entryDir, baseName, args.compareBuffer);
-  return { absPath: candidateAbs, relPath: `./${path9.basename(candidateAbs)}` };
+  return { absPath: candidateAbs, relPath: `./${path10.basename(candidateAbs)}` };
 }
 async function pickSiblingTarget(dir, filename, buf) {
-  const safe = path9.basename(filename);
+  const safe = path10.basename(filename);
   if (!safe || safe === "." || safe === "..") {
     throw new Error(`Invalid filename: ${filename}`);
   }
-  const baseAbs = path9.join(dir, safe);
+  const baseAbs = path10.join(dir, safe);
   if (await isFreeOrMatching(baseAbs, buf))
     return baseAbs;
   return pickHashedSibling(dir, safe, buf);
 }
 async function pickHashedSibling(dir, baseName, buf) {
   const hash = shortContentHash(buf);
-  const ext = path9.extname(baseName);
-  const stem = path9.basename(baseName, ext);
+  const ext = path10.extname(baseName);
+  const stem = path10.basename(baseName, ext);
   for (let attempt = 0;attempt < 5; attempt++) {
     const suffix = attempt === 0 ? hash : `${hash}-${attempt}`;
-    const candidateAbs = path9.join(dir, `${stem}-${suffix}${ext}`);
+    const candidateAbs = path10.join(dir, `${stem}-${suffix}${ext}`);
     if (await isFreeOrMatching(candidateAbs, buf))
       return candidateAbs;
   }
@@ -26442,7 +27411,7 @@ var init_astro_image_paths = __esm(() => {
 
 // ../cms/src/handlers/astro-image-upload.ts
 import fs6 from "fs/promises";
-import path10 from "path";
+import path11 from "path";
 async function tryAstroImageUpload(args) {
   const { collection, entry, field } = args.context;
   if (!collection || !entry || !field)
@@ -26464,12 +27433,12 @@ async function tryAstroImageUpload(args) {
     originalFilename: args.originalFilename,
     compareBuffer: args.fileBuffer
   });
-  await fs6.mkdir(path10.dirname(target.absPath), { recursive: true });
+  await fs6.mkdir(path11.dirname(target.absPath), { recursive: true });
   await fs6.writeFile(target.absPath, args.fileBuffer);
   return {
     success: true,
     url: target.relPath,
-    filename: path10.basename(target.absPath)
+    filename: path11.basename(target.absPath)
   };
 }
 var init_astro_image_upload = __esm(() => {
@@ -26661,7 +27630,7 @@ var require_he = __commonJS((exports, module) => {
     var has = function(object2, propertyName) {
       return hasOwnProperty2.call(object2, propertyName);
     };
-    var contains = function(array, value) {
+    var contains2 = function(array, value) {
       var index = -1;
       var length = array.length;
       while (++index < length) {
@@ -26696,7 +27665,7 @@ var require_he = __commonJS((exports, module) => {
         }
         return decodeMapNumeric[codePoint];
       }
-      if (strict && contains(invalidReferenceCodePoints, codePoint)) {
+      if (strict && contains2(invalidReferenceCodePoints, codePoint)) {
         parseError("disallowed character reference");
       }
       if (codePoint > 65535) {
@@ -30184,7 +31153,7 @@ var require_filters = __commonJS((exports) => {
   exports.filters = {
     contains: function(next, text, _a) {
       var adapter = _a.adapter;
-      return function contains(elem) {
+      return function contains2(elem) {
         return next(elem) && adapter.getText(elem).includes(text);
       };
     },
@@ -32297,7 +33266,7 @@ var init_snippet_utils = __esm(() => {
 
 // ../cms/src/handlers/source-writer.ts
 import fs8 from "fs/promises";
-import path11 from "path";
+import path12 from "path";
 async function handleUpdate(request, manifestWriter) {
   const { changes, meta } = request;
   const errors = [];
@@ -32334,7 +33303,7 @@ async function handleUpdate(request, manifestWriter) {
         }
         if (appliedCount > 0 && newContent !== currentContent) {
           for (const op of fileOps) {
-            await fs8.mkdir(path11.dirname(op.target), { recursive: true });
+            await fs8.mkdir(path12.dirname(op.target), { recursive: true });
             await fs8.writeFile(op.target, op.bytes);
           }
           await fs8.writeFile(fullPath, newContent, "utf-8");
@@ -32600,8 +33569,8 @@ async function tryRewriteAssetImport(content, importInfo, newSrc, absFilePath, o
   const resolved = await resolveNewSrcBytes(newSrc, originUrl);
   if (!resolved)
     return null;
-  const originalAssetAbs = path11.resolve(path11.dirname(absFilePath), importInfo.source);
-  const targetAbs = await pickSiblingTarget(path11.dirname(originalAssetAbs), resolved.filename, resolved.bytes);
+  const originalAssetAbs = path12.resolve(path12.dirname(absFilePath), importInfo.source);
+  const targetAbs = await pickSiblingTarget(path12.dirname(originalAssetAbs), resolved.filename, resolved.bytes);
   const newRelImport = relativeImportPath2(absFilePath, targetAbs);
   const newContent = content.slice(0, importInfo.sourceStart) + newRelImport + content.slice(importInfo.sourceEnd);
   return {
@@ -32611,8 +33580,8 @@ async function tryRewriteAssetImport(content, importInfo, newSrc, absFilePath, o
   };
 }
 async function resolveNewSrcBytes(newSrc, originUrl) {
-  const filenameFromPath = (p) => path11.basename(p.split("?")[0] ?? p);
-  const diskPath = newSrc.startsWith("/src/") ? path11.join(getProjectRoot(), newSrc.slice(1)) : newSrc.startsWith("/") && !newSrc.startsWith("//") ? path11.join(getProjectRoot(), "public", newSrc.replace(/^\/+/, "")) : null;
+  const filenameFromPath = (p) => path12.basename(p.split("?")[0] ?? p);
+  const diskPath = newSrc.startsWith("/src/") ? path12.join(getProjectRoot(), newSrc.slice(1)) : newSrc.startsWith("/") && !newSrc.startsWith("//") ? path12.join(getProjectRoot(), "public", newSrc.replace(/^\/+/, "")) : null;
   if (diskPath) {
     try {
       return { bytes: await fs8.readFile(diskPath), filename: filenameFromPath(newSrc) };
@@ -33160,7 +34129,7 @@ var init_source_writer = __esm(() => {
 });
 
 // ../cms/src/handlers/api-routes.ts
-import path12 from "path";
+import path13 from "path";
 function requireMedia(ctx) {
   if (!ctx.mediaAdapter) {
     sendError(ctx.res, "Media storage not configured", 501);
@@ -33323,7 +34292,7 @@ var init_api_routes = __esm(() => {
         sendJson(res, { success: false, error: `Invalid content path: ${body.filePath}` }, 400);
         return;
       }
-      const fullPath = path12.resolve(getProjectRoot(), body.filePath.replace(/^\//, ""));
+      const fullPath = path13.resolve(getProjectRoot(), body.filePath.replace(/^\//, ""));
       expectedDeletions.add(fullPath);
       const result = await core.deleteEntry(entry.collection, entry.slug);
       if (result.success) {
@@ -33430,7 +34399,7 @@ var init_api_routes = __esm(() => {
       const body = await parseJsonBody(req);
       const result = await core.deletePage(body);
       if (result.success && result.filePath) {
-        expectedDeletions.add(path12.resolve(getProjectRoot(), result.filePath));
+        expectedDeletions.add(path13.resolve(getProjectRoot(), result.filePath));
       }
       if (result.success && body.createRedirect && body.redirectTo) {
         await core.addRedirect({ source: body.pagePath, destination: body.redirectTo, statusCode: 307 });
@@ -33535,7 +34504,7 @@ var init_color_patterns = __esm(() => {
 
 // ../cms/src/tailwind-colors.ts
 import fs9 from "fs/promises";
-import path13 from "path";
+import path14 from "path";
 async function parseTailwindConfig(projectRoot = getProjectRoot()) {
   const cssFiles = [
     "src/styles/global.css",
@@ -33549,7 +34518,7 @@ async function parseTailwindConfig(projectRoot = getProjectRoot()) {
   ];
   let customColors = [];
   for (const cssFile of cssFiles) {
-    const fullPath = path13.join(projectRoot, cssFile);
+    const fullPath = path14.join(projectRoot, cssFile);
     try {
       const content = await fs9.readFile(fullPath, "utf-8");
       customColors = extractColorsFromCss(content);
@@ -33622,7 +34591,7 @@ async function parseTextStyles(projectRoot = getProjectRoot()) {
   ];
   let customTextStyles = {};
   for (const cssFile of cssFiles) {
-    const fullPath = path13.join(projectRoot, cssFile);
+    const fullPath = path14.join(projectRoot, cssFile);
     try {
       const content = await fs9.readFile(fullPath, "utf-8");
       customTextStyles = extractTextStylesFromCss(content);
@@ -34090,7 +35059,7 @@ var init_local_admin = __esm(() => {
 
 // ../cms/src/manifest-writer.ts
 import fs10 from "fs/promises";
-import path14 from "path";
+import path15 from "path";
 
 class ManifestWriter {
   globalManifest;
@@ -34161,10 +35130,10 @@ class ManifestWriter {
   }
   getPageManifestPath(pagePath) {
     if (pagePath === "/" || pagePath === "") {
-      return path14.join(this.outDir, "index.json");
+      return path15.join(this.outDir, "index.json");
     }
     const cleanPath = pagePath.replace(/^\//, "");
-    return path14.join(this.outDir, `${cleanPath}.json`);
+    return path15.join(this.outDir, `${cleanPath}.json`);
   }
   addPage(pagePath, entries, components, collection, seo) {
     this.pageManifests.set(pagePath, { entries, components, collection, seo });
@@ -34190,7 +35159,7 @@ class ManifestWriter {
   }
   async writePageManifest(pagePath, entries, components, collection, seo) {
     const manifestPath = this.getPageManifestPath(pagePath);
-    const manifestDir = path14.dirname(manifestPath);
+    const manifestDir = path15.dirname(manifestPath);
     await fs10.mkdir(manifestDir, { recursive: true });
     const metadata = {
       version: MANIFEST_VERSION,
@@ -34246,7 +35215,7 @@ class ManifestWriter {
       }
     }
     if (this.outDir) {
-      const globalManifestPath = path14.join(this.outDir, this.manifestFile);
+      const globalManifestPath = path15.join(this.outDir, this.manifestFile);
       const globalSettings = {
         componentDefinitions: this.componentDefinitions,
         pages
@@ -34858,7 +35827,7 @@ var init_field_types = __esm(() => {
 
 // ../cms/src/migrate-astro-image.ts
 import fs11 from "fs/promises";
-import path15 from "path";
+import path16 from "path";
 async function migrateAstroImages(options = {}) {
   const projectRoot = options.projectRoot ?? getProjectRoot();
   const dryRun = options.dryRun ?? false;
@@ -34870,7 +35839,7 @@ async function migrateAstroImages(options = {}) {
     if (astroFields.length === 0 || !def.entries)
       continue;
     for (const entry of def.entries) {
-      const entryAbs = path15.isAbsolute(entry.sourcePath) ? entry.sourcePath : path15.join(projectRoot, entry.sourcePath);
+      const entryAbs = path16.isAbsolute(entry.sourcePath) ? entry.sourcePath : path16.join(projectRoot, entry.sourcePath);
       let raw;
       try {
         raw = await fs11.readFile(entryAbs, "utf-8");
@@ -34885,7 +35854,7 @@ async function migrateAstroImages(options = {}) {
       }
       const [fullFm, fmStart, yamlBody, fmEnd] = fmMatch;
       const doc2 = import_yaml7.parseDocument(yamlBody);
-      let mutated = false;
+      let mutated2 = false;
       for (const field of astroFields) {
         const current = doc2.get(field.name);
         if (typeof current !== "string") {
@@ -34895,7 +35864,7 @@ async function migrateAstroImages(options = {}) {
         }
         if (!current.startsWith("/") || current.startsWith("//"))
           continue;
-        const sourceAbs = path15.join(projectRoot, "public", current.replace(/^\/+/, ""));
+        const sourceAbs = path16.join(projectRoot, "public", current.replace(/^\/+/, ""));
         let sourceBuf;
         try {
           sourceBuf = await fs11.readFile(sourceAbs);
@@ -34906,15 +35875,15 @@ async function migrateAstroImages(options = {}) {
         const target = await pickAstroImageTarget({
           entryAbsPath: entryAbs,
           slug: entry.slug,
-          originalFilename: path15.basename(current),
+          originalFilename: path16.basename(current),
           compareBuffer: sourceBuf
         });
         if (!dryRun) {
-          await fs11.mkdir(path15.dirname(target.absPath), { recursive: true });
+          await fs11.mkdir(path16.dirname(target.absPath), { recursive: true });
           await fs11.writeFile(target.absPath, sourceBuf);
         }
         doc2.set(field.name, target.relPath);
-        mutated = true;
+        mutated2 = true;
         migrations.push({
           entrySourcePath: entry.sourcePath,
           fieldName: field.name,
@@ -34924,7 +35893,7 @@ async function migrateAstroImages(options = {}) {
           copiedTo: target.absPath
         });
       }
-      if (mutated && !dryRun) {
+      if (mutated2 && !dryRun) {
         const newYaml = doc2.toString().replace(/\n$/, "");
         const newRaw = raw.replace(fullFm, `${fmStart}${newYaml}${fmEnd}`);
         await fs11.writeFile(entryAbs, newRaw, "utf-8");
@@ -34973,7 +35942,7 @@ var exports_migrate = {};
 __export(exports_migrate, {
   migrate: () => migrate
 });
-import path16 from "path";
+import path17 from "path";
 async function migrate(args) {
   if (args.target !== "astro-image") {
     console.error(`Unknown migrate target: ${args.target}`);
@@ -34992,7 +35961,7 @@ async function migrate(args) {
     for (const m2 of result.migrations) {
       console.log(`  ${m2.entrySourcePath}`);
       console.log(`    ${m2.fieldName}: ${m2.originalValue} \u2192 ${m2.newValue}`);
-      console.log(`      copy: ${path16.relative(process.cwd(), m2.copiedFrom)} \u2192 ${path16.relative(process.cwd(), m2.copiedTo)}`);
+      console.log(`      copy: ${path17.relative(process.cwd(), m2.copiedFrom)} \u2192 ${path17.relative(process.cwd(), m2.copiedTo)}`);
     }
   }
   if (result.skipped.length > 0) {
@@ -35034,7 +36003,7 @@ Commands:`);
   console.log("  build              Run astro build with the Nua defaults");
   console.log("  dev                Run astro dev with the Nua defaults");
   console.log("  preview            Run astro preview with the Nua defaults");
-  console.log("  check              Validate collections and parse the source (no build). --json, --strict, --content-only");
+  console.log("  check              Validate collections and parse the source (no build). --json, --strict, --content-only, --no-live");
   console.log("  init               Convert a standard Astro project to use Nua");
   console.log("  clean              Eject to a standard Astro project (remove @nuasite/* deps)");
   console.log("  migrate <target>   Run a content migration. Targets: astro-image");
@@ -35048,13 +36017,8 @@ if (command && ["build", "dev", "preview"].includes(command)) {
 } else {
   switch (command) {
     case "check": {
-      const { check: check2 } = await Promise.resolve().then(() => (init_check2(), exports_check));
-      process.exit(await check2({
-        cwd: process.cwd(),
-        json: args.includes("--json"),
-        strict: args.includes("--strict"),
-        contentOnly: args.includes("--content-only")
-      }));
+      const { check: check2, parseCheckArgs: parseCheckArgs2 } = await Promise.resolve().then(() => (init_check2(), exports_check));
+      process.exit(await check2(parseCheckArgs2(args, process.cwd())));
       break;
     }
     case "init": {