@nuasite/cli 0.52.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,14 +23366,19 @@ function formatCheckReport(report) {
   const lines = [];
   for (const [file, findings] of byFile) {
     lines.push(file);
+    let lastHint;
     for (const finding of findings) {
-      lines.push(`  ${finding.severity === "error" ? "error" : "warn "}  ${finding.message}  [${finding.code}]`);
+      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))
@@ -22664,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) {
@@ -23495,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?:\/\/|\/)/;
@@ -23574,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();
@@ -23816,80 +24514,1160 @@ 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
+import g from "crypto";
+import _ from "fs";
+import { TextDecoder as b, TextEncoder as v } from "util";
+var y, w, d = class {
+  constructor() {
+    this.argv = ["js"], this.env = {}, this.exit = (t) => {
+      t !== 0 && console.warn("exit code:", t);
+    }, this._exitPromise = new Promise((t) => {
+      this._resolveExitPromise = t;
+    }), this._pendingEvent = null, this._scheduledTimeouts = new Map, this._nextCallbackTimeoutID = 1;
+    let o = (t, e) => {
+      this.mem.setUint32(t + 0, e, true), this.mem.setUint32(t + 4, Math.floor(e / 4294967296), true);
+    }, n = (t) => {
+      let e = this.mem.getUint32(t + 0, true), s = this.mem.getInt32(t + 4, true);
+      return e + s * 4294967296;
+    }, r = (t) => {
+      let e = this.mem.getFloat64(t, true);
+      if (e === 0)
+        return;
+      if (!isNaN(e))
+        return e;
+      let s = this.mem.getUint32(t, true);
+      return this._values[s];
+    }, l = (t, e) => {
+      if (typeof e == "number" && e !== 0) {
+        if (isNaN(e)) {
+          this.mem.setUint32(t + 4, 2146959360, true), this.mem.setUint32(t, 0, true);
+          return;
+        }
+        this.mem.setFloat64(t, e, true);
+        return;
+      }
+      if (e === undefined) {
+        this.mem.setFloat64(t, 0, true);
+        return;
+      }
+      let i = this._ids.get(e);
+      i === undefined && (i = this._idPool.pop(), i === undefined && (i = this._values.length), this._values[i] = e, this._goRefCounts[i] = 0, this._ids.set(e, i)), this._goRefCounts[i]++;
+      let a = 0;
+      switch (typeof e) {
+        case "object":
+          e !== null && (a = 1);
+          break;
+        case "string":
+          a = 2;
+          break;
+        case "symbol":
+          a = 3;
+          break;
+        case "function":
+          a = 4;
+          break;
+      }
+      this.mem.setUint32(t + 4, 2146959360 | a, true), this.mem.setUint32(t, i, true);
+    }, c = (t) => {
+      let e = n(t + 0), s = n(t + 8);
+      return new Uint8Array(this._inst.exports.mem.buffer, e, s);
+    }, f = (t) => {
+      let e = n(t + 0), s = n(t + 8), i = new Array(s);
+      for (let a = 0;a < s; a++)
+        i[a] = r(e + a * 8);
+      return i;
+    }, u = (t) => {
+      let e = n(t + 0), s = n(t + 8);
+      return w.decode(new DataView(this._inst.exports.mem.buffer, e, s));
+    }, h = Date.now() - performance.now();
+    this.importObject = { gojs: { "runtime.wasmExit": (t) => {
+      t >>>= 0;
+      let e = this.mem.getInt32(t + 8, true);
+      this.exited = true, delete this._inst, delete this._values, delete this._goRefCounts, delete this._ids, delete this._idPool, this.exit(e);
+    }, "runtime.wasmWrite": (t) => {
+      t >>>= 0;
+      let e = n(t + 8), s = n(t + 16), i = this.mem.getInt32(t + 24, true);
+      _.writeSync(e, new Uint8Array(this._inst.exports.mem.buffer, s, i));
+    }, "runtime.resetMemoryDataView": (t) => {
+      t >>>= 0, this.mem = new DataView(this._inst.exports.mem.buffer);
+    }, "runtime.nanotime1": (t) => {
+      t >>>= 0, o(t + 8, (h + performance.now()) * 1e6);
+    }, "runtime.walltime": (t) => {
+      t >>>= 0;
+      let e = new Date().getTime();
+      o(t + 8, e / 1000), this.mem.setInt32(t + 16, e % 1000 * 1e6, true);
+    }, "runtime.scheduleTimeoutEvent": (t) => {
+      t >>>= 0;
+      let e = this._nextCallbackTimeoutID;
+      this._nextCallbackTimeoutID++, this._scheduledTimeouts.set(e, setTimeout(() => {
+        for (this._resume();this._scheduledTimeouts.has(e); )
+          console.warn("scheduleTimeoutEvent: missed timeout event"), this._resume();
+      }, n(t + 8) + 1)), this.mem.setInt32(t + 16, e, true);
+    }, "runtime.clearTimeoutEvent": (t) => {
+      t >>>= 0;
+      let e = this.mem.getInt32(t + 8, true);
+      clearTimeout(this._scheduledTimeouts.get(e)), this._scheduledTimeouts.delete(e);
+    }, "runtime.getRandomData": (t) => {
+      t >>>= 0, globalThis.crypto.getRandomValues(c(t + 8));
+    }, "syscall/js.finalizeRef": (t) => {
+      t >>>= 0;
+      let e = this.mem.getUint32(t + 8, true);
+      if (this._goRefCounts[e]--, this._goRefCounts[e] === 0) {
+        let s = this._values[e];
+        this._values[e] = null, this._ids.delete(s), this._idPool.push(e);
+      }
+    }, "syscall/js.stringVal": (t) => {
+      t >>>= 0, l(t + 24, u(t + 8));
+    }, "syscall/js.valueGet": (t) => {
+      t >>>= 0;
+      let e = Reflect.get(r(t + 8), u(t + 16));
+      t = this._inst.exports.getsp() >>> 0, l(t + 32, e);
+    }, "syscall/js.valueSet": (t) => {
+      t >>>= 0, Reflect.set(r(t + 8), u(t + 16), r(t + 32));
+    }, "syscall/js.valueDelete": (t) => {
+      t >>>= 0, Reflect.deleteProperty(r(t + 8), u(t + 16));
+    }, "syscall/js.valueIndex": (t) => {
+      t >>>= 0, l(t + 24, Reflect.get(r(t + 8), n(t + 16)));
+    }, "syscall/js.valueSetIndex": (t) => {
+      t >>>= 0, Reflect.set(r(t + 8), n(t + 16), r(t + 24));
+    }, "syscall/js.valueCall": (t) => {
+      t >>>= 0;
+      try {
+        let e = r(t + 8), s = Reflect.get(e, u(t + 16)), i = f(t + 32), a = Reflect.apply(s, e, i);
+        t = this._inst.exports.getsp() >>> 0, l(t + 56, a), this.mem.setUint8(t + 64, 1);
+      } catch (e) {
+        t = this._inst.exports.getsp() >>> 0, l(t + 56, e), this.mem.setUint8(t + 64, 0);
+      }
+    }, "syscall/js.valueInvoke": (t) => {
+      t >>>= 0;
+      try {
+        let e = r(t + 8), s = f(t + 16), i = Reflect.apply(e, undefined, s);
+        t = this._inst.exports.getsp() >>> 0, l(t + 40, i), this.mem.setUint8(t + 48, 1);
+      } catch (e) {
+        t = this._inst.exports.getsp() >>> 0, l(t + 40, e), this.mem.setUint8(t + 48, 0);
+      }
+    }, "syscall/js.valueNew": (t) => {
+      t >>>= 0;
+      try {
+        let e = r(t + 8), s = f(t + 16), i = Reflect.construct(e, s);
+        t = this._inst.exports.getsp() >>> 0, l(t + 40, i), this.mem.setUint8(t + 48, 1);
+      } catch (e) {
+        t = this._inst.exports.getsp() >>> 0, l(t + 40, e), this.mem.setUint8(t + 48, 0);
+      }
+    }, "syscall/js.valueLength": (t) => {
+      t >>>= 0, o(t + 16, Number.parseInt(r(t + 8).length));
+    }, "syscall/js.valuePrepareString": (t) => {
+      t >>>= 0;
+      let e = y.encode(String(r(t + 8)));
+      l(t + 16, e), o(t + 24, e.length);
+    }, "syscall/js.valueLoadString": (t) => {
+      t >>>= 0;
+      let e = r(t + 8);
+      c(t + 16).set(e);
+    }, "syscall/js.valueInstanceOf": (t) => {
+      t >>>= 0, this.mem.setUint8(t + 24, r(t + 8) instanceof r(t + 16) ? 1 : 0);
+    }, "syscall/js.copyBytesToGo": (t) => {
+      t >>>= 0;
+      let e = c(t + 8), s = r(t + 32);
+      if (!(s instanceof Uint8Array || s instanceof Uint8ClampedArray)) {
+        this.mem.setUint8(t + 48, 0);
+        return;
+      }
+      let i = s.subarray(0, e.length);
+      e.set(i), o(t + 40, i.length), this.mem.setUint8(t + 48, 1);
+    }, "syscall/js.copyBytesToJS": (t) => {
+      t >>>= 0;
+      let e = r(t + 8), s = c(t + 16);
+      if (!(e instanceof Uint8Array || e instanceof Uint8ClampedArray)) {
+        this.mem.setUint8(t + 48, 0);
+        return;
+      }
+      let i = s.subarray(0, e.length);
+      e.set(i), o(t + 40, i.length), this.mem.setUint8(t + 48, 1);
+    }, debug: (t) => {
+      console.log(t);
+    } } };
+  }
+  async run(o) {
+    if (!(o instanceof WebAssembly.Instance))
+      throw new Error("Go.run: WebAssembly.Instance expected");
+    this._inst = o, this.mem = new DataView(this._inst.exports.mem.buffer), this._values = [Number.NaN, 0, null, true, false, globalThis, this], this._goRefCounts = new Array(this._values.length).fill(Number.POSITIVE_INFINITY), this._ids = new Map([[0, 1], [null, 2], [true, 3], [false, 4], [globalThis, 5], [this, 6]]), this._idPool = [], this.exited = false;
+    let n = 4096, r = (h) => {
+      let t = n, e = y.encode(`${h}\x00`);
+      return new Uint8Array(this.mem.buffer, n, e.length).set(e), n += e.length, n % 8 !== 0 && (n += 8 - n % 8), t;
+    }, l = this.argv.length, c = [];
+    this.argv.forEach((h) => {
+      c.push(r(h));
+    }), c.push(0), Object.keys(this.env).sort().forEach((h) => {
+      c.push(r(`${h}=${this.env[h]}`));
+    }), c.push(0);
+    let u = n;
+    c.forEach((h) => {
+      this.mem.setUint32(n, h, true), this.mem.setUint32(n + 4, 0, true), n += 8;
+    }), this._inst.exports.run(l, u), this.exited && this._resolveExitPromise(), await this._exitPromise;
+  }
+  _resume() {
+    if (this.exited)
+      throw new Error("Go program has already exited");
+    this._inst.exports.resume(), this.exited && this._resolveExitPromise();
+  }
+  _makeFuncWrapper(o) {
+    let n = this;
+    return function() {
+      let r = { id: o, this: this, args: arguments };
+      return n._pendingEvent = r, n._resume(), r.result;
+    };
+  }
+};
+var init_chunk_W5DTLHV4 = __esm(() => {
+  globalThis.fs || Object.defineProperty(globalThis, "fs", { value: _ });
+  globalThis.process || Object.defineProperties(globalThis, "process", { value: process });
+  globalThis.crypto || Object.defineProperty(globalThis, "crypto", { value: g.webcrypto ? g.webcrypto : { getRandomValues(m) {
+    return g.randomFillSync(m);
+  } } });
+  globalThis.performance || Object.defineProperty(globalThis, "performance", { value: { now() {
+    let [m, o] = process.hrtime();
+    return m * 1000 + o / 1e6;
+  } } });
+  y = new v("utf-8");
+  w = new b("utf-8");
+});
+
+// ../../node_modules/@astrojs/compiler/dist/node/index.js
+import { promises as m } from "fs";
+import { fileURLToPath as f } from "url";
+var w2 = async (t, s) => i().then((r) => r.transform(t, s)), n, i = () => (n || (n = d2().catch((t) => {
+  throw n = undefined, t;
+})), n), y2 = async (t, s) => {
+  let r;
+  return r = await (async () => {
+    let o = await m.readFile(t).then((e) => e.buffer);
+    return WebAssembly.instantiate(new Uint8Array(o), s);
+  })(), r;
+}, d2 = async () => {
+  let t = new d, s = await y2(f(new URL("../astro.wasm", import.meta.url)), t.importObject);
+  t.run(s.instance);
+  let r = globalThis["@astrojs/compiler"];
+  return { transform: (a, o) => new Promise((e) => {
+    try {
+      e(r.transform(a, o || {}));
+    } catch (p) {
+      throw n = undefined, p;
+    }
+  }), parse: (a, o) => new Promise((e) => e(r.parse(a, o || {}))).catch((e) => {
+    throw n = undefined, e;
+  }).then((e) => ({ ...e, ast: JSON.parse(e.ast) })), convertToTSX: (a, o) => new Promise((e) => e(r.convertToTSX(a, o || {}))).catch((e) => {
+    throw n = undefined, e;
+  }).then((e) => ({ ...e, map: JSON.parse(e.map) })) };
+};
+var init_node = __esm(() => {
+  init_chunk_W5DTLHV4();
+});
+
+// ../../node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
+function decodeInteger(reader, relative) {
+  let value = 0;
+  let shift = 0;
+  let integer = 0;
+  do {
+    const c = reader.next();
+    integer = charToInt[c];
+    value |= (integer & 31) << shift;
+    shift += 5;
+  } while (integer & 32);
+  const shouldNegate = value & 1;
+  value >>>= 1;
+  if (shouldNegate) {
+    value = -2147483648 | -value;
+  }
+  return relative + value;
+}
+function hasMoreVlq(reader, max) {
+  if (reader.pos >= max)
+    return false;
+  return reader.peek() !== comma;
+}
+function decode(mappings) {
+  const { length } = mappings;
+  const reader = new StringReader(mappings);
+  const decoded = [];
+  let genColumn = 0;
+  let sourcesIndex = 0;
+  let sourceLine = 0;
+  let sourceColumn = 0;
+  let namesIndex = 0;
+  do {
+    const semi = reader.indexOf(";");
+    const line = [];
+    let sorted = true;
+    let lastCol = 0;
+    genColumn = 0;
+    while (reader.pos < semi) {
+      let seg;
+      genColumn = decodeInteger(reader, genColumn);
+      if (genColumn < lastCol)
+        sorted = false;
+      lastCol = genColumn;
+      if (hasMoreVlq(reader, semi)) {
+        sourcesIndex = decodeInteger(reader, sourcesIndex);
+        sourceLine = decodeInteger(reader, sourceLine);
+        sourceColumn = decodeInteger(reader, sourceColumn);
+        if (hasMoreVlq(reader, semi)) {
+          namesIndex = decodeInteger(reader, namesIndex);
+          seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex];
+        } else {
+          seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];
+        }
+      } else {
+        seg = [genColumn];
+      }
+      line.push(seg);
+      reader.pos++;
+    }
+    if (!sorted)
+      sort(line);
+    decoded.push(line);
+    reader.pos = semi + 1;
+  } while (reader.pos <= length);
+  return decoded;
+}
+function sort(line) {
+  line.sort(sortComparator);
+}
+function sortComparator(a, b2) {
+  return a[0] - b2[0];
+}
+var comma = 44, chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", intToChar, charToInt, bufLength, StringReader = class {
+  constructor(buffer) {
+    this.pos = 0;
+    this.buffer = buffer;
+  }
+  next() {
+    return this.buffer.charCodeAt(this.pos++);
+  }
+  peek() {
+    return this.buffer.charCodeAt(this.pos);
+  }
+  indexOf(char) {
+    const { buffer, pos } = this;
+    const idx = buffer.indexOf(char, pos);
+    return idx === -1 ? buffer.length : idx;
+  }
+};
+var init_sourcemap_codec = __esm(() => {
+  intToChar = new Uint8Array(64);
+  charToInt = new Uint8Array(128);
+  for (let i2 = 0;i2 < chars.length; i2++) {
+    const c = chars.charCodeAt(i2);
+    intToChar[i2] = c;
+    charToInt[c] = i2;
+  }
+  bufLength = 1024 * 16;
+});
+
+// ../../node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs
+function isAbsoluteUrl(input) {
+  return schemeRegex.test(input);
+}
+function isSchemeRelativeUrl(input) {
+  return input.startsWith("//");
+}
+function isAbsolutePath(input) {
+  return input.startsWith("/");
+}
+function isFileUrl(input) {
+  return input.startsWith("file:");
+}
+function isRelative(input) {
+  return /^[.?#]/.test(input);
+}
+function parseAbsoluteUrl(input) {
+  const match = urlRegex.exec(input);
+  return makeUrl(match[1], match[2] || "", match[3], match[4] || "", match[5] || "/", match[6] || "", match[7] || "");
+}
+function parseFileUrl(input) {
+  const match = fileRegex.exec(input);
+  const path4 = match[2];
+  return makeUrl("file:", "", match[1] || "", "", isAbsolutePath(path4) ? path4 : "/" + path4, match[3] || "", match[4] || "");
+}
+function makeUrl(scheme, user, host, port, path4, query, hash) {
+  return {
+    scheme,
+    user,
+    host,
+    port,
+    path: path4,
+    query,
+    hash,
+    type: 7
+  };
+}
+function parseUrl(input) {
+  if (isSchemeRelativeUrl(input)) {
+    const url2 = parseAbsoluteUrl("http:" + input);
+    url2.scheme = "";
+    url2.type = 6;
+    return url2;
+  }
+  if (isAbsolutePath(input)) {
+    const url2 = parseAbsoluteUrl("http://foo.com" + input);
+    url2.scheme = "";
+    url2.host = "";
+    url2.type = 5;
+    return url2;
+  }
+  if (isFileUrl(input))
+    return parseFileUrl(input);
+  if (isAbsoluteUrl(input))
+    return parseAbsoluteUrl(input);
+  const url = parseAbsoluteUrl("http://foo.com/" + input);
+  url.scheme = "";
+  url.host = "";
+  url.type = input ? input.startsWith("?") ? 3 : input.startsWith("#") ? 2 : 4 : 1;
+  return url;
+}
+function stripPathFilename(path4) {
+  if (path4.endsWith("/.."))
+    return path4;
+  const index = path4.lastIndexOf("/");
+  return path4.slice(0, index + 1);
+}
+function mergePaths(url, base) {
+  normalizePath(base, base.type);
+  if (url.path === "/") {
+    url.path = base.path;
+  } else {
+    url.path = stripPathFilename(base.path) + url.path;
+  }
+}
+function normalizePath(url, type) {
+  const rel = type <= 4;
+  const pieces = url.path.split("/");
+  let pointer = 1;
+  let positive = 0;
+  let addTrailingSlash = false;
+  for (let i2 = 1;i2 < pieces.length; i2++) {
+    const piece = pieces[i2];
+    if (!piece) {
+      addTrailingSlash = true;
+      continue;
+    }
+    addTrailingSlash = false;
+    if (piece === ".")
+      continue;
+    if (piece === "..") {
+      if (positive) {
+        addTrailingSlash = true;
+        positive--;
+        pointer--;
+      } else if (rel) {
+        pieces[pointer++] = piece;
+      }
+      continue;
+    }
+    pieces[pointer++] = piece;
+    positive++;
+  }
+  let path4 = "";
+  for (let i2 = 1;i2 < pointer; i2++) {
+    path4 += "/" + pieces[i2];
+  }
+  if (!path4 || addTrailingSlash && !path4.endsWith("/..")) {
+    path4 += "/";
+  }
+  url.path = path4;
+}
+function resolve(input, base) {
+  if (!input && !base)
+    return "";
+  const url = parseUrl(input);
+  let inputType = url.type;
+  if (base && inputType !== 7) {
+    const baseUrl = parseUrl(base);
+    const baseType = baseUrl.type;
+    switch (inputType) {
+      case 1:
+        url.hash = baseUrl.hash;
+      case 2:
+        url.query = baseUrl.query;
+      case 3:
+      case 4:
+        mergePaths(url, baseUrl);
+      case 5:
+        url.user = baseUrl.user;
+        url.host = baseUrl.host;
+        url.port = baseUrl.port;
+      case 6:
+        url.scheme = baseUrl.scheme;
+    }
+    if (baseType > inputType)
+      inputType = baseType;
+  }
+  normalizePath(url, inputType);
+  const queryHash = url.query + url.hash;
+  switch (inputType) {
+    case 2:
+    case 3:
+      return queryHash;
+    case 4: {
+      const path4 = url.path.slice(1);
+      if (!path4)
+        return queryHash || ".";
+      if (isRelative(base || input) && !isRelative(path4)) {
+        return "./" + path4 + queryHash;
+      }
+      return path4 + queryHash;
+    }
+    case 5:
+      return url.path + queryHash;
+    default:
+      return url.scheme + "//" + url.user + url.host + url.port + url.path + queryHash;
+  }
+}
+var schemeRegex, urlRegex, fileRegex;
+var init_resolve_uri = __esm(() => {
+  schemeRegex = /^[\w+.-]+:\/\//;
+  urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
+  fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
+});
+
+// ../../node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs
+function stripFilename(path4) {
+  if (!path4)
+    return "";
+  const index = path4.lastIndexOf("/");
+  return path4.slice(0, index + 1);
+}
+function resolver(mapUrl, sourceRoot) {
+  const from = stripFilename(mapUrl);
+  const prefix = sourceRoot ? sourceRoot + "/" : "";
+  return (source) => resolve(prefix + (source || ""), from);
+}
+function maybeSort(mappings, owned) {
+  const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
+  if (unsortedIndex === mappings.length)
+    return mappings;
+  if (!owned)
+    mappings = mappings.slice();
+  for (let i2 = unsortedIndex;i2 < mappings.length; i2 = nextUnsortedSegmentLine(mappings, i2 + 1)) {
+    mappings[i2] = sortSegments(mappings[i2], owned);
+  }
+  return mappings;
+}
+function nextUnsortedSegmentLine(mappings, start) {
+  for (let i2 = start;i2 < mappings.length; i2++) {
+    if (!isSorted(mappings[i2]))
+      return i2;
+  }
+  return mappings.length;
+}
+function isSorted(line) {
+  for (let j = 1;j < line.length; j++) {
+    if (line[j][COLUMN] < line[j - 1][COLUMN]) {
+      return false;
+    }
+  }
+  return true;
+}
+function sortSegments(line, owned) {
+  if (!owned)
+    line = line.slice();
+  return line.sort(sortComparator2);
+}
+function sortComparator2(a, b2) {
+  return a[COLUMN] - b2[COLUMN];
+}
+function binarySearch(haystack, needle, low, high) {
+  while (low <= high) {
+    const mid = low + (high - low >> 1);
+    const cmp = haystack[mid][COLUMN] - needle;
+    if (cmp === 0) {
+      found = true;
+      return mid;
+    }
+    if (cmp < 0) {
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+  found = false;
+  return low - 1;
+}
+function upperBound(haystack, needle, index) {
+  for (let i2 = index + 1;i2 < haystack.length; index = i2++) {
+    if (haystack[i2][COLUMN] !== needle)
+      break;
+  }
+  return index;
+}
+function lowerBound(haystack, needle, index) {
+  for (let i2 = index - 1;i2 >= 0; index = i2--) {
+    if (haystack[i2][COLUMN] !== needle)
+      break;
+  }
+  return index;
+}
+function memoizedState() {
+  return {
+    lastKey: -1,
+    lastNeedle: -1,
+    lastIndex: -1
+  };
+}
+function memoizedBinarySearch(haystack, needle, state, key) {
+  const { lastKey, lastNeedle, lastIndex } = state;
+  let low = 0;
+  let high = haystack.length - 1;
+  if (key === lastKey) {
+    if (needle === lastNeedle) {
+      found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
+      return lastIndex;
+    }
+    if (needle >= lastNeedle) {
+      low = lastIndex === -1 ? 0 : lastIndex;
+    } else {
+      high = lastIndex;
+    }
+  }
+  state.lastKey = key;
+  state.lastNeedle = needle;
+  return state.lastIndex = binarySearch(haystack, needle, low, high);
+}
+function parse2(map) {
+  return typeof map === "string" ? JSON.parse(map) : map;
+}
+function cast(map) {
+  return map;
+}
+function decodedMappings(map) {
+  var _a;
+  return (_a = cast(map))._decoded || (_a._decoded = decode(cast(map)._encoded));
+}
+function originalPositionFor(map, needle) {
+  let { line, column, bias } = needle;
+  line--;
+  if (line < 0)
+    throw new Error(LINE_GTR_ZERO);
+  if (column < 0)
+    throw new Error(COL_GTR_EQ_ZERO);
+  const decoded = decodedMappings(map);
+  if (line >= decoded.length)
+    return OMapping(null, null, null, null);
+  const segments = decoded[line];
+  const index = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
+  if (index === -1)
+    return OMapping(null, null, null, null);
+  const segment = segments[index];
+  if (segment.length === 1)
+    return OMapping(null, null, null, null);
+  const { names, resolvedSources } = map;
+  return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], segment.length === 5 ? names[segment[NAMES_INDEX]] : null);
+}
+function OMapping(source, line, column, name) {
+  return { source, line, column, name };
+}
+function traceSegmentInternal(segments, memo, line, column, bias) {
+  let index = memoizedBinarySearch(segments, column, memo, line);
+  if (found) {
+    index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
+  } else if (bias === LEAST_UPPER_BOUND)
+    index++;
+  if (index === -1 || index === segments.length)
+    return -1;
+  return index;
+}
+var COLUMN = 0, SOURCES_INDEX = 1, SOURCE_LINE = 2, SOURCE_COLUMN = 3, NAMES_INDEX = 4, found = false, LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)", COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)", LEAST_UPPER_BOUND = -1, GREATEST_LOWER_BOUND = 1, TraceMap = class {
+  constructor(map, mapUrl) {
+    const isString = typeof map === "string";
+    if (!isString && map._decodedMemo)
+      return map;
+    const parsed = parse2(map);
+    const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
+    this.version = version;
+    this.file = file;
+    this.names = names || [];
+    this.sourceRoot = sourceRoot;
+    this.sources = sources;
+    this.sourcesContent = sourcesContent;
+    this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || undefined;
+    const resolve2 = resolver(mapUrl, sourceRoot);
+    this.resolvedSources = sources.map(resolve2);
+    const { mappings } = parsed;
+    if (typeof mappings === "string") {
+      this._encoded = mappings;
+      this._decoded = undefined;
+    } else if (Array.isArray(mappings)) {
+      this._encoded = undefined;
+      this._decoded = maybeSort(mappings, isString);
+    } else if (parsed.sections) {
+      throw new Error(`TraceMap passed sectioned source map, please use FlattenMap export instead`);
+    } else {
+      throw new Error(`invalid source map: ${JSON.stringify(parsed)}`);
+    }
+    this._decodedMemo = memoizedState();
+    this._bySources = undefined;
+    this._bySourceMemos = undefined;
+  }
+};
+var init_trace_mapping = __esm(() => {
+  init_sourcemap_codec();
+  init_resolve_uri();
+});
+
+// src/check-code.ts
+var {Glob } = globalThis.Bun;
+import path4 from "path";
+function buildPosition(error) {
+  if (typeof error !== "object" || error === null || !("position" in error))
+    return null;
+  const position = error.position;
+  return typeof position === "object" && position !== null ? position : null;
+}
+function messageOf(error) {
+  const message = typeof error === "object" && error !== null && "message" in error ? error.message : undefined;
+  return String(typeof message === "string" ? message : error).split(`
+`)[0];
+}
+function toSource(map, position) {
+  if (!map || position?.line === undefined)
+    return {};
+  try {
+    const traced = originalPositionFor(new TraceMap(JSON.parse(map)), {
+      line: position.line,
+      column: position.column ?? 0
+    });
+    if (traced.line === null)
+      return {};
+    return { line: traced.line, column: traced.column + 1 };
+  } catch {
+    return {};
+  }
+}
+async function checkAstroFile(absolute, relative, source) {
+  let emitted;
+  try {
+    emitted = await w2(source, { filename: absolute, sourcemap: "both" });
+  } catch (error) {
+    return { severity: "error", code: "code/astro-parse", file: relative, message: messageOf(error) };
+  }
+  try {
+    new Bun.Transpiler({ loader: "ts" }).transformSync(emitted.code);
+    return null;
+  } catch (error) {
+    const position = buildPosition(error);
+    return {
+      severity: "error",
+      code: "code/syntax",
+      file: relative,
+      ...toSource(emitted.map, position),
+      message: messageOf(error)
+    };
+  }
+}
+function checkScriptFile(relative, source, loader) {
+  try {
+    new Bun.Transpiler({ loader }).transformSync(source);
+    return null;
+  } catch (error) {
+    const position = buildPosition(error);
+    return {
+      severity: "error",
+      code: "code/syntax",
+      file: relative,
+      line: position?.line,
+      column: position?.column === undefined ? undefined : position.column + 1,
+      message: messageOf(error)
+    };
+  }
+}
+async function checkCode(root) {
+  const findings = [];
+  let files = 0;
+  const paths = [];
+  for await (const relative of new Glob("**/*.{astro,ts,tsx,mts,cts}").scan({ cwd: root })) {
+    if (!isIgnored(relative))
+      paths.push(relative);
+  }
+  paths.sort();
+  for (const relative of paths) {
+    files++;
+    const absolute = path4.join(root, relative);
+    const source = await Bun.file(absolute).text();
+    const finding = relative.endsWith(".astro") ? await checkAstroFile(absolute, relative, source) : checkScriptFile(relative, source, relative.endsWith(".tsx") ? "tsx" : "ts");
+    if (finding)
+      findings.push(finding);
+  }
+  return { findings, files };
+}
+var IGNORED, isIgnored = (relative) => /\.d\.[mc]?ts$/.test(relative) || relative.split(path4.sep).some((segment) => IGNORED.includes(segment));
+var init_check_code = __esm(() => {
+  init_node();
+  init_trace_mapping();
+  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 path4 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 = path4.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(path4.join(packagesDir, name))).map((name) => path4.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: path4.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 reports = await Promise.all(roots.map(async (root) => prefixed(await checkContent(createNodeFs(path4.join(options.cwd, root))), root)));
+  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 = 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: path6.join(root, finding.file) }))],
+      files: code.files
+    };
+  }));
   const report = {
     findings: reports.flatMap((one) => one.findings),
     collections: reports.reduce((total, one) => total + one.collections, 0),
     entries: reports.reduce((total, one) => total + one.entries, 0)
   };
+  const sourceFiles = reports.reduce((total, one) => total + one.files, 0);
   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)
       console.log(formatted + `
 `);
     const where = roots.length === 1 && roots[0] === "." ? "" : ` in ${roots.join(", ")}`;
-    const counts = `${report.collections} collection(s), ${report.entries} entries${where}`;
+    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(path4.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;
@@ -23899,11 +25677,11 @@ function findMatchingClose(text, start) {
   const close = open === "{" ? "}" : open === "[" ? "]" : ")";
   let depth = 0;
   let inString = false;
-  for (let i = start;i < text.length; i++) {
-    const ch = text[i];
+  for (let i2 = start;i2 < text.length; i2++) {
+    const ch = text[i2];
     if (inString) {
       if (ch === "\\") {
-        i++;
+        i2++;
         continue;
       }
       if (ch === inString)
@@ -23919,7 +25697,7 @@ function findMatchingClose(text, start) {
     if (ch === close) {
       depth--;
       if (depth === 0)
-        return i;
+        return i2;
     }
   }
   return -1;
@@ -23941,20 +25719,20 @@ function removeProperty(body, propName) {
     return body;
   const propLineStart = match.index + 1;
   const afterMatch = match.index + match[0].length;
-  let i = afterMatch;
-  while (i < body.length && (body[i] === " " || body[i] === "\t"))
-    i++;
+  let i2 = afterMatch;
+  while (i2 < body.length && (body[i2] === " " || body[i2] === "\t"))
+    i2++;
   let valueEnd;
-  if (body[i] === "{" || body[i] === "[") {
-    valueEnd = findMatchingClose(body, i);
+  if (body[i2] === "{" || body[i2] === "[") {
+    valueEnd = findMatchingClose(body, i2);
     if (valueEnd === -1)
       return body;
     valueEnd++;
   } else {
-    while (i < body.length && body[i] !== "," && body[i] !== `
+    while (i2 < body.length && body[i2] !== "," && body[i2] !== `
 `)
-      i++;
-    valueEnd = i;
+      i2++;
+    valueEnd = i2;
   }
   let end = valueEnd;
   while (end < body.length && (body[end] === " " || body[end] === "\t"))
@@ -23986,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",
@@ -24006,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;
@@ -24131,7 +25909,7 @@ function transformPackageJson(pkg, nuaVersion) {
   if (!result.dependencies["@nuasite/nua"]) {
     result.dependencies["@nuasite/nua"] = nuaVersion;
   }
-  result.dependencies = Object.fromEntries(Object.entries(result.dependencies).sort(([a], [b]) => a.localeCompare(b)));
+  result.dependencies = Object.fromEntries(Object.entries(result.dependencies).sort(([a], [b2]) => a.localeCompare(b2)));
   return result;
 }
 async function init({ cwd = process.cwd(), dryRun = false, yes = false } = {}) {
@@ -24150,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);
   }
@@ -24228,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;
@@ -24241,9 +26019,9 @@ function detectDisabledFeatures(content) {
 }
 function prependToArrayProperty(lines, property, items) {
   const pattern = new RegExp(`\\b${property}\\s*:\\s*\\[`);
-  for (let i = 0;i < lines.length; i++) {
-    if (pattern.test(lines[i])) {
-      lines[i] = lines[i].replace(new RegExp(`(\\b${property}\\s*:\\s*\\[)`), `$1${items}, `);
+  for (let i2 = 0;i2 < lines.length; i2++) {
+    if (pattern.test(lines[i2])) {
+      lines[i2] = lines[i2].replace(new RegExp(`(\\b${property}\\s*:\\s*\\[)`), `$1${items}, `);
       return true;
     }
   }
@@ -24332,12 +26110,12 @@ function transformPackageJson2(pkg, disabled, usedRuntimePackages = []) {
       result.dependencies[name] = nuaVersion ?? "^0.16.0";
     }
   }
-  result.dependencies = Object.fromEntries(Object.entries(result.dependencies).sort(([a], [b]) => a.localeCompare(b)));
+  result.dependencies = Object.fromEntries(Object.entries(result.dependencies).sort(([a], [b2]) => a.localeCompare(b2)));
   return result;
 }
 function scanForNuasiteUsage(cwd) {
   const srcDir = join3(cwd, "src");
-  if (!existsSync4(srcDir))
+  if (!existsSync5(srcDir))
     return [];
   const results = [];
   try {
@@ -24372,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);
   }
@@ -24480,7 +26258,7 @@ var init_config = () => {};
 
 // ../cms/src/component-registry.ts
 import fs2 from "fs/promises";
-import path5 from "path";
+import path7 from "path";
 
 class ComponentRegistry {
   components = new Map;
@@ -24490,7 +26268,7 @@ class ComponentRegistry {
   }
   async scan() {
     for (const dir of this.componentDirs) {
-      const fullPath = path5.join(getProjectRoot(), dir);
+      const fullPath = path7.join(getProjectRoot(), dir);
       try {
         await this.scanDirectory(fullPath, dir);
       } catch {}
@@ -24505,8 +26283,8 @@ class ComponentRegistry {
   async scanDirectory(dir, relativePath) {
     const entries = await fs2.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path5.join(dir, entry.name);
-      const relPath = path5.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")) {
@@ -24517,7 +26295,7 @@ class ComponentRegistry {
   async parseComponent(filePath, relativePath) {
     try {
       const content = await fs2.readFile(filePath, "utf-8");
-      const componentName = path5.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);
@@ -24663,18 +26441,18 @@ ${propsContent}
       return null;
     const startIndex = match.index + match[0].length;
     let depth = 1;
-    let i = startIndex;
-    while (i < text.length && depth > 0) {
-      if (text[i] === "{") {
+    let i2 = startIndex;
+    while (i2 < text.length && depth > 0) {
+      if (text[i2] === "{") {
         depth++;
-      } else if (text[i] === "}") {
+      } else if (text[i2] === "}") {
         depth--;
       }
-      i++;
+      i2++;
     }
     if (depth !== 0)
       return null;
-    return text.substring(startIndex, i - 1);
+    return text.substring(startIndex, i2 - 1);
   }
   async extractProps(content) {
     const props = [];
@@ -24772,7 +26550,7 @@ function slugify2(text) {
 
 // ../cms/src/utils.ts
 import { createHash } from "crypto";
-import path6 from "path";
+import path8 from "path";
 function normalizePagePath(url) {
   let pathname;
   try {
@@ -24811,7 +26589,7 @@ function generateSourceFileHashes(entries) {
   }
   const hashes = {};
   for (const [filePath, fileEntries] of Object.entries(entriesByFile)) {
-    const sorted = fileEntries.sort((a, b) => (a.sourceLine || 0) - (b.sourceLine || 0));
+    const sorted = fileEntries.sort((a, b2) => (a.sourceLine || 0) - (b2.sourceLine || 0));
     const content = sorted.map((e) => `${e.sourceLine || 0}|${e.text}|${e.sourceSnippet || ""}`).join(`
 `);
     hashes[filePath] = sha256(content);
@@ -24825,27 +26603,27 @@ function escapeReplacement(str) {
   return str.replace(/\$/g, "$$$$");
 }
 function resolveSourcePath(sourcePath) {
-  return path6.isAbsolute(sourcePath) ? sourcePath : path6.join(getProjectRoot(), sourcePath);
+  return path8.isAbsolute(sourcePath) ? sourcePath : path8.join(getProjectRoot(), sourcePath);
 }
 function resolveAndValidatePath(filePath) {
   const projectRoot = getProjectRoot();
-  const resolvedRoot = path6.resolve(projectRoot);
+  const resolvedRoot = path8.resolve(projectRoot);
   const isAbsoluteFs = filePath.startsWith(resolvedRoot);
   const normalizedPath = !isAbsoluteFs && filePath.startsWith("/") ? filePath.slice(1) : filePath;
-  const fullPath = path6.isAbsolute(normalizedPath) ? path6.resolve(normalizedPath) : path6.resolve(projectRoot, normalizedPath);
-  if (!fullPath.startsWith(resolvedRoot + path6.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 = path6.resolve(filePath);
+  const key = path8.resolve(filePath);
   while (fileLocks.has(key)) {
     await fileLocks.get(key);
   }
   let release;
-  const lockPromise = new Promise((resolve) => {
-    release = resolve;
+  const lockPromise = new Promise((resolve2) => {
+    release = resolve2;
   });
   fileLocks.set(key, lockPromise);
   return () => {
@@ -24857,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 = path6.dirname(fromFile);
-  let rel = path6.relative(fromDir, toFile).split(path6.sep).join("/");
+  const fromDir = path8.dirname(fromFile);
+  let rel = path8.relative(fromDir, toFile).split(path8.sep).join("/");
   if (!rel.startsWith("."))
     rel = `./${rel}`;
   return rel;
@@ -24871,7 +26649,7 @@ var init_utils2 = __esm(() => {
 
 // ../cms/src/handlers/component-ops.ts
 import fs3 from "fs/promises";
-import path7 from "path";
+import path9 from "path";
 async function handleInsertComponent(request, manifestWriter) {
   const { position, referenceComponentId, componentName, props, meta } = request;
   if (!meta?.url) {
@@ -25012,12 +26790,12 @@ async function handleRemoveComponent(request, manifestWriter) {
 function findComponentBounds(lines, startLineIndex, componentName) {
   const startLine = startLineIndex;
   let tagClosed = false;
-  for (let i = startLineIndex;i < lines.length; i++) {
-    const currentLine = lines[i];
+  for (let i2 = startLineIndex;i2 < lines.length; i2++) {
+    const currentLine = lines[i2];
     const selfCloseIdx = currentLine.indexOf("/>");
     const openEndIdx = currentLine.indexOf(">");
     if (selfCloseIdx >= 0 && (openEndIdx < 0 || selfCloseIdx <= openEndIdx)) {
-      return { startLine, endLine: i };
+      return { startLine, endLine: i2 };
     }
     if (openEndIdx >= 0) {
       tagClosed = true;
@@ -25031,8 +26809,8 @@ function findComponentBounds(lines, startLineIndex, componentName) {
   const closingTag = `</${componentName}>`;
   let depth = 1;
   let endLine = startLineIndex;
-  for (let i = startLineIndex + 1;i < lines.length; i++) {
-    const currentLine = lines[i];
+  for (let i2 = startLineIndex + 1;i2 < lines.length; i2++) {
+    const currentLine = lines[i2];
     const openingMatches = currentLine.match(new RegExp(`<${escapedName}(?:\\s|>)`, "g"));
     if (openingMatches) {
       for (const match of openingMatches) {
@@ -25048,7 +26826,7 @@ function findComponentBounds(lines, startLineIndex, componentName) {
       depth -= closingMatches.length;
     }
     if (depth <= 0) {
-      endLine = i;
+      endLine = i2;
       break;
     }
   }
@@ -25089,7 +26867,7 @@ function getComponentOccurrenceIndex(manifest, referenceComponent) {
 async function findComponentInvocationFile(projectRoot, pageUrl, manifest, referenceComponent) {
   if (referenceComponent.invocationSourcePath) {
     const filePath = normalizeFilePath(referenceComponent.invocationSourcePath);
-    const fullPath = path7.resolve(projectRoot, filePath);
+    const fullPath = path9.resolve(projectRoot, filePath);
     try {
       const content = await fs3.readFile(fullPath, "utf-8");
       const lines = content.split(`
@@ -25103,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 = path7.resolve(projectRoot, candidate);
+    const fullPath = path9.resolve(projectRoot, candidate);
     try {
       const content = await fs3.readFile(fullPath, "utf-8");
       const lines = content.split(`
@@ -25119,22 +26897,22 @@ async function findComponentInvocationFile(projectRoot, pageUrl, manifest, refer
 function findComponentInvocationLine(lines, componentName, occurrenceIndex) {
   const pattern = new RegExp(`<${escapeRegex(componentName)}(?:\\s|>|/>|$)`);
   const startLine = findFrontmatterEnd(lines);
-  let found = 0;
-  for (let i = startLine;i < lines.length; i++) {
-    if (pattern.test(lines[i])) {
-      if (found === occurrenceIndex)
-        return i;
-      found++;
+  let found2 = 0;
+  for (let i2 = startLine;i2 < lines.length; i2++) {
+    if (pattern.test(lines[i2])) {
+      if (found2 === occurrenceIndex)
+        return i2;
+      found2++;
     }
   }
-  return found > 0 ? findComponentInvocationLine(lines, componentName, 0) : -1;
+  return found2 > 0 ? findComponentInvocationLine(lines, componentName, 0) : -1;
 }
 function findFrontmatterEnd(lines) {
   if (lines.length === 0 || lines[0].trim() !== "---")
     return 0;
-  for (let i = 1;i < lines.length; i++) {
-    if (lines[i].trim() === "---")
-      return i + 1;
+  for (let i2 = 1;i2 < lines.length; i2++) {
+    if (lines[i2].trim() === "---")
+      return i2 + 1;
   }
   return 0;
 }
@@ -25163,7 +26941,7 @@ function getIndentation(line) {
 function normalizeFilePath(p) {
   if (!p.startsWith("/"))
     return p;
-  const projectRoot = path7.resolve(getProjectRoot());
+  const projectRoot = path9.resolve(getProjectRoot());
   if (p.startsWith(projectRoot))
     return p;
   return p.slice(1);
@@ -25171,17 +26949,17 @@ function normalizeFilePath(p) {
 function ensureComponentImport(lines, componentName, componentFile, targetFile) {
   const importPattern = new RegExp(`import\\s+${escapeRegex(componentName)}\\s+from\\s+['"]`);
   const frontmatterEnd = findFrontmatterEnd(lines);
-  for (let i = 0;i < frontmatterEnd; i++) {
-    if (importPattern.test(lines[i])) {
+  for (let i2 = 0;i2 < frontmatterEnd; i2++) {
+    if (importPattern.test(lines[i2])) {
       return;
     }
   }
   const importStatement = `import ${componentName} from '${relativeImportPath2(targetFile, componentFile)}'`;
   if (frontmatterEnd > 0) {
     let insertAt = 1;
-    for (let i = 1;i < frontmatterEnd - 1; i++) {
-      if (/^\s*import\s/.test(lines[i])) {
-        insertAt = i + 1;
+    for (let i2 = 1;i2 < frontmatterEnd - 1; i2++) {
+      if (/^\s*import\s/.test(lines[i2])) {
+        insertAt = i2 + 1;
       }
     }
     lines.splice(insertAt, 0, importStatement);
@@ -25218,11 +26996,11 @@ function buildMapPattern(varName) {
 }
 function detectArrayPattern(lines, invocationLineIndex) {
   const searchStart = Math.max(0, invocationLineIndex - 5);
-  for (let i = invocationLineIndex;i >= searchStart; i--) {
-    const line = lines[i];
+  for (let i2 = invocationLineIndex;i2 >= searchStart; i2--) {
+    const line = lines[i2];
     const match = line.match(new RegExp(buildMapPattern()));
     if (match) {
-      return { arrayVarName: match[1], mapLineIndex: i };
+      return { arrayVarName: match[1], mapLineIndex: i2 };
     }
   }
   return null;
@@ -25284,10 +27062,10 @@ async function resolveArrayContext(component, manifest, pageUrl) {
     let mapLineIndex = -1;
     let occurrencesSeen = 0;
     const mapPattern = new RegExp(buildMapPattern(arrayVarName));
-    for (let i = fmEnd2;i < lines2.length; i++) {
-      if (mapPattern.test(lines2[i])) {
+    for (let i2 = fmEnd2;i2 < lines2.length; i2++) {
+      if (mapPattern.test(lines2[i2])) {
         if (occurrencesSeen === mapOccurrence) {
-          mapLineIndex = i;
+          mapLineIndex = i2;
           break;
         }
         occurrencesSeen++;
@@ -25301,7 +27079,7 @@ async function resolveArrayContext(component, manifest, pageUrl) {
     const elementBounds2 = findArrayDeclaration(frontmatterContent2, frontmatterStartLine2, arrayVarName);
     if (!elementBounds2 || elementBounds2.length === 0)
       return null;
-    const sameSourceComponents2 = Object.values(manifest.components).filter((c) => c.componentName === component.componentName && c.invocationSourcePath === component.invocationSourcePath).sort((a, b) => (a.invocationIndex ?? 0) - (b.invocationIndex ?? 0));
+    const sameSourceComponents2 = Object.values(manifest.components).filter((c) => c.componentName === component.componentName && c.invocationSourcePath === component.invocationSourcePath).sort((a, b2) => (a.invocationIndex ?? 0) - (b2.invocationIndex ?? 0));
     const arrayIndex2 = sameSourceComponents2.findIndex((c) => c.id === component.id);
     if (arrayIndex2 < 0 || arrayIndex2 >= elementBounds2.length)
       return null;
@@ -25348,7 +27126,7 @@ async function resolveArrayContext(component, manifest, pageUrl) {
     return null;
   }
   const occurrenceIndex = getComponentOccurrenceIndex(manifest, component);
-  const sameSourceComponents = Object.values(manifest.components).filter((c) => c.componentName === component.componentName && c.invocationSourcePath === component.invocationSourcePath).sort((a, b) => (a.invocationIndex ?? 0) - (b.invocationIndex ?? 0));
+  const sameSourceComponents = Object.values(manifest.components).filter((c) => c.componentName === component.componentName && c.invocationSourcePath === component.invocationSourcePath).sort((a, b2) => (a.invocationIndex ?? 0) - (b2.invocationIndex ?? 0));
   const arrayIndex = sameSourceComponents.findIndex((c) => c.id === component.id);
   if (arrayIndex < 0 || arrayIndex >= elementBounds.length) {
     return null;
@@ -25480,8 +27258,8 @@ async function handleAddArrayItem(request, manifestWriter) {
       const newElement = generateObjectLiteral(props);
       const indentation = getIndentation(freshLines[refBounds.startLine]);
       const indentedLines = newElement.split(`
-`).map((line, i) => {
-        if (i === 0)
+`).map((line, i2) => {
+        if (i2 === 0)
           return indentation + line;
         if (line.trim())
           return indentation + line;
@@ -25505,11 +27283,11 @@ async function handleAddArrayItem(request, manifestWriter) {
       const addedLineCount = indentedLines.split(`
 `).length;
       const closingSearchStart = lastEl.endLine + addedLineCount + 1;
-      for (let i = closingSearchStart;i < closingSearchStart + 5 && i < freshLines.length; i++) {
-        if (freshLines[i].trim().startsWith("]")) {
-          const prev = freshLines[i - 1];
+      for (let i2 = closingSearchStart;i2 < closingSearchStart + 5 && i2 < freshLines.length; i2++) {
+        if (freshLines[i2].trim().startsWith("]")) {
+          const prev = freshLines[i2 - 1];
           if (prev?.trimEnd().endsWith(",")) {
-            freshLines[i - 1] = prev.replace(/,(\s*)$/, "$1");
+            freshLines[i2 - 1] = prev.replace(/,(\s*)$/, "$1");
           }
           break;
         }
@@ -25571,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 path8 from "path";
+import path10 from "path";
 function isHugoStyleEntry(entryAbsPath) {
-  return HUGO_INDEX_RE.test(path8.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 = path8.dirname(args.entryAbsPath);
+  const entryDir = path10.dirname(args.entryAbsPath);
   const isHugoStyle = isHugoStyleEntry(args.entryAbsPath);
-  const safeFilename = path8.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 = path8.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: `./${path8.basename(candidateAbs)}` };
+  return { absPath: candidateAbs, relPath: `./${path10.basename(candidateAbs)}` };
 }
 async function pickSiblingTarget(dir, filename, buf) {
-  const safe = path8.basename(filename);
+  const safe = path10.basename(filename);
   if (!safe || safe === "." || safe === "..") {
     throw new Error(`Invalid filename: ${filename}`);
   }
-  const baseAbs = path8.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 = path8.extname(baseName);
-  const stem = path8.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 = path8.join(dir, `${stem}-${suffix}${ext}`);
+    const candidateAbs = path10.join(dir, `${stem}-${suffix}${ext}`);
     if (await isFreeOrMatching(candidateAbs, buf))
       return candidateAbs;
   }
@@ -25633,7 +27411,7 @@ var init_astro_image_paths = __esm(() => {
 
 // ../cms/src/handlers/astro-image-upload.ts
 import fs6 from "fs/promises";
-import path9 from "path";
+import path11 from "path";
 async function tryAstroImageUpload(args) {
   const { collection, entry, field } = args.context;
   if (!collection || !entry || !field)
@@ -25642,7 +27420,7 @@ async function tryAstroImageUpload(args) {
   const def = definitions[collection];
   if (!def)
     return null;
-  const fieldDef = def.fields.find((f) => f.name === field);
+  const fieldDef = def.fields.find((f2) => f2.name === field);
   if (!fieldDef?.astroImage)
     return null;
   const entryInfo = def.entries?.find((e) => e.slug === entry);
@@ -25655,12 +27433,12 @@ async function tryAstroImageUpload(args) {
     originalFilename: args.originalFilename,
     compareBuffer: args.fileBuffer
   });
-  await fs6.mkdir(path9.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: path9.basename(target.absPath)
+    filename: path11.basename(target.absPath)
   };
 }
 var init_astro_image_upload = __esm(() => {
@@ -25674,8 +27452,8 @@ async function handleCheckSlugExists(slug) {
   const normalizedSlug = slugify2(slug);
   if (!normalizedSlug)
     return { exists: false };
-  const found = await findPageFile(`/${normalizedSlug}`);
-  return found ? { exists: true, filePath: found } : { exists: false };
+  const found2 = await findPageFile(`/${normalizedSlug}`);
+  return found2 ? { exists: true, filePath: found2 } : { exists: false };
 }
 async function fileExists(fullPath) {
   try {
@@ -25707,7 +27485,7 @@ var init_page_ops2 = __esm(() => {
 
 // ../cms/src/handlers/request-utils.ts
 function readBody(req, maxSize = MAX_BODY_SIZE) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const chunks = [];
     let totalSize = 0;
     req.on("data", (chunk) => {
@@ -25719,7 +27497,7 @@ function readBody(req, maxSize = MAX_BODY_SIZE) {
       }
       chunks.push(chunk);
     });
-    req.on("end", () => resolve(Buffer.concat(chunks)));
+    req.on("end", () => resolve2(Buffer.concat(chunks)));
     req.on("error", reject);
   });
 }
@@ -25852,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) {
@@ -25887,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) {
@@ -25907,8 +27685,8 @@ var require_he = __commonJS((exports, module) => {
     var parseError = function(message) {
       throw Error("Parse error: " + message);
     };
-    var encode = function(string, options) {
-      options = merge(options, encode.options);
+    var encode2 = function(string, options) {
+      options = merge(options, encode2.options);
       var strict = options.strict;
       if (strict && regexInvalidRawCodePoint.test(string)) {
         parseError("forbidden code point");
@@ -25955,15 +27733,15 @@ var require_he = __commonJS((exports, module) => {
         return escapeCodePoint(codePoint);
       }).replace(regexBmpWhitelist, escapeBmpSymbol);
     };
-    encode.options = {
+    encode2.options = {
       allowUnsafeSymbols: false,
       encodeEverything: false,
       strict: false,
       useNamedReferences: false,
       decimal: false
     };
-    var decode = function(html, options) {
-      options = merge(options, decode.options);
+    var decode2 = function(html, options) {
+      options = merge(options, decode2.options);
       var strict = options.strict;
       if (strict && regexInvalidEntity.test(html)) {
         parseError("malformed character reference");
@@ -26018,7 +27796,7 @@ var require_he = __commonJS((exports, module) => {
         return $0;
       });
     };
-    decode.options = {
+    decode2.options = {
       isAttributeValue: false,
       strict: false
     };
@@ -26029,10 +27807,10 @@ var require_he = __commonJS((exports, module) => {
     };
     var he = {
       version: "1.2.0",
-      encode,
-      decode,
+      encode: encode2,
+      decode: decode2,
       escape,
-      unescape: decode
+      unescape: decode2
     };
     if (typeof define == "function" && typeof define.amd == "object" && define.amd) {
       define(function() {
@@ -26166,30 +27944,30 @@ var require_lib2 = __commonJS((exports) => {
 // ../../node_modules/domhandler/lib/node.js
 var require_node2 = __commonJS((exports) => {
   var __extends = exports && exports.__extends || function() {
-    var extendStatics = function(d, b) {
-      extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
-        d2.__proto__ = b2;
-      } || function(d2, b2) {
-        for (var p in b2)
-          if (Object.prototype.hasOwnProperty.call(b2, p))
-            d2[p] = b2[p];
+    var extendStatics = function(d3, b2) {
+      extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d4, b3) {
+        d4.__proto__ = b3;
+      } || function(d4, b3) {
+        for (var p in b3)
+          if (Object.prototype.hasOwnProperty.call(b3, p))
+            d4[p] = b3[p];
       };
-      return extendStatics(d, b);
+      return extendStatics(d3, b2);
     };
-    return function(d, b) {
-      if (typeof b !== "function" && b !== null)
-        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-      extendStatics(d, b);
+    return function(d3, b2) {
+      if (typeof b2 !== "function" && b2 !== null)
+        throw new TypeError("Class extends value " + String(b2) + " is not a constructor or null");
+      extendStatics(d3, b2);
       function __() {
-        this.constructor = d;
+        this.constructor = d3;
       }
-      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __);
+      d3.prototype = b2 === null ? Object.create(b2) : (__.prototype = b2.prototype, new __);
     };
   }();
   var __assign = exports && exports.__assign || function() {
     __assign = Object.assign || function(t) {
-      for (var s, i = 1, n = arguments.length;i < n; i++) {
-        s = arguments[i];
+      for (var s, i2 = 1, n2 = arguments.length;i2 < n2; i2++) {
+        s = arguments[i2];
         for (var p in s)
           if (Object.prototype.hasOwnProperty.call(s, p))
             t[p] = s[p];
@@ -26533,9 +28311,9 @@ var require_node2 = __commonJS((exports) => {
     var children = childs.map(function(child) {
       return cloneNode(child, true);
     });
-    for (var i = 1;i < children.length; i++) {
-      children[i].prev = children[i - 1];
-      children[i - 1].next = children[i];
+    for (var i2 = 1;i2 < children.length; i2++) {
+      children[i2].prev = children[i2 - 1];
+      children[i2 - 1].next = children[i2];
     }
     return children;
   }
@@ -26543,25 +28321,25 @@ var require_node2 = __commonJS((exports) => {
 
 // ../../node_modules/domhandler/lib/index.js
 var require_lib3 = __commonJS((exports) => {
-  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m2, k, k2) {
     if (k2 === undefined)
       k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+    var desc = Object.getOwnPropertyDescriptor(m2, k);
+    if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
       desc = { enumerable: true, get: function() {
-        return m[k];
+        return m2[k];
       } };
     }
     Object.defineProperty(o, k2, desc);
-  } : function(o, m, k, k2) {
+  } : function(o, m2, k, k2) {
     if (k2 === undefined)
       k2 = k;
-    o[k2] = m[k];
+    o[k2] = m2[k];
   });
-  var __exportStar = exports && exports.__exportStar || function(m, exports2) {
-    for (var p in m)
+  var __exportStar = exports && exports.__exportStar || function(m2, exports2) {
+    for (var p in m2)
       if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
-        __createBinding(exports2, m, p);
+        __createBinding(exports2, m2, p);
   };
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.DomHandler = undefined;
@@ -26775,25 +28553,25 @@ var require_decode_codepoint = __commonJS((exports) => {
 
 // ../../node_modules/dom-serializer/node_modules/entities/lib/decode.js
 var require_decode = __commonJS((exports) => {
-  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m2, k, k2) {
     if (k2 === undefined)
       k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+    var desc = Object.getOwnPropertyDescriptor(m2, k);
+    if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
       desc = { enumerable: true, get: function() {
-        return m[k];
+        return m2[k];
       } };
     }
     Object.defineProperty(o, k2, desc);
-  } : function(o, m, k, k2) {
+  } : function(o, m2, k, k2) {
     if (k2 === undefined)
       k2 = k;
-    o[k2] = m[k];
+    o[k2] = m2[k];
   });
-  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-  } : function(o, v) {
-    o["default"] = v;
+  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v2) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v2 });
+  } : function(o, v2) {
+    o["default"] = v2;
   });
   var __importStar = exports && exports.__importStar || function(mod) {
     if (mod && mod.__esModule)
@@ -27127,8 +28905,8 @@ var require_decode = __commonJS((exports) => {
 var require_encode_html = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   function restoreDiff(arr) {
-    for (var i = 1;i < arr.length; i++) {
-      arr[i][0] += arr[i - 1][0] + 1;
+    for (var i2 = 1;i2 < arr.length; i2++) {
+      arr[i2][0] += arr[i2 - 1][0] + 1;
     }
     return arr;
   }
@@ -27157,14 +28935,14 @@ var require_escape = __commonJS((exports) => {
     var lastIdx = 0;
     var match;
     while ((match = exports.xmlReplacer.exec(str)) !== null) {
-      var i = match.index;
-      var char = str.charCodeAt(i);
+      var i2 = match.index;
+      var char = str.charCodeAt(i2);
       var next = xmlCodeMap.get(char);
       if (next !== undefined) {
-        ret += str.substring(lastIdx, i) + next;
-        lastIdx = i + 1;
+        ret += str.substring(lastIdx, i2) + next;
+        lastIdx = i2 + 1;
       } else {
-        ret += "".concat(str.substring(lastIdx, i), "&#x").concat((0, exports.getCodePoint)(str, i).toString(16), ";");
+        ret += "".concat(str.substring(lastIdx, i2), "&#x").concat((0, exports.getCodePoint)(str, i2).toString(16), ";");
         lastIdx = exports.xmlReplacer.lastIndex += Number((char & 64512) === 55296);
       }
     }
@@ -27224,13 +29002,13 @@ var require_encode = __commonJS((exports) => {
     var lastIdx = 0;
     var match;
     while ((match = regExp.exec(str)) !== null) {
-      var i = match.index;
-      ret += str.substring(lastIdx, i);
-      var char = str.charCodeAt(i);
+      var i2 = match.index;
+      ret += str.substring(lastIdx, i2);
+      var char = str.charCodeAt(i2);
       var next = encode_html_js_1.default.get(char);
       if (typeof next === "object") {
-        if (i + 1 < str.length) {
-          var nextChar = str.charCodeAt(i + 1);
+        if (i2 + 1 < str.length) {
+          var nextChar = str.charCodeAt(i2 + 1);
           var value = typeof next.n === "number" ? next.n === nextChar ? next.o : undefined : next.n.get(nextChar);
           if (value !== undefined) {
             ret += value;
@@ -27242,9 +29020,9 @@ var require_encode = __commonJS((exports) => {
       }
       if (next !== undefined) {
         ret += next;
-        lastIdx = i + 1;
+        lastIdx = i2 + 1;
       } else {
-        var cp = (0, escape_js_1.getCodePoint)(str, i);
+        var cp = (0, escape_js_1.getCodePoint)(str, i2);
         ret += "&#x".concat(cp.toString(16), ";");
         lastIdx = regExp.lastIndex += Number(cp !== char);
       }
@@ -27273,7 +29051,7 @@ var require_lib4 = __commonJS((exports) => {
     EncodingMode2[EncodingMode2["Attribute"] = 3] = "Attribute";
     EncodingMode2[EncodingMode2["Text"] = 4] = "Text";
   })(EncodingMode = exports.EncodingMode || (exports.EncodingMode = {}));
-  function decode(data, options) {
+  function decode2(data, options) {
     if (options === undefined) {
       options = EntityLevel.XML;
     }
@@ -27284,7 +29062,7 @@ var require_lib4 = __commonJS((exports) => {
     }
     return (0, decode_js_1.decodeXML)(data);
   }
-  exports.decode = decode;
+  exports.decode = decode2;
   function decodeStrict(data, options) {
     var _a;
     if (options === undefined) {
@@ -27292,10 +29070,10 @@ var require_lib4 = __commonJS((exports) => {
     }
     var opts = typeof options === "number" ? { level: options } : options;
     (_a = opts.mode) !== null && _a !== undefined || (opts.mode = decode_js_1.DecodingMode.Strict);
-    return decode(data, opts);
+    return decode2(data, opts);
   }
   exports.decodeStrict = decodeStrict;
-  function encode(data, options) {
+  function encode2(data, options) {
     if (options === undefined) {
       options = EntityLevel.XML;
     }
@@ -27314,7 +29092,7 @@ var require_lib4 = __commonJS((exports) => {
     }
     return (0, escape_js_1.encodeXML)(data);
   }
-  exports.encode = encode;
+  exports.encode = encode2;
   var escape_js_2 = require_escape();
   Object.defineProperty(exports, "encodeXML", { enumerable: true, get: function() {
     return escape_js_2.encodeXML;
@@ -27494,8 +29272,8 @@ var require_foreignNames = __commonJS((exports) => {
 var require_lib5 = __commonJS((exports) => {
   var __assign = exports && exports.__assign || function() {
     __assign = Object.assign || function(t) {
-      for (var s, i = 1, n = arguments.length;i < n; i++) {
-        s = arguments[i];
+      for (var s, i2 = 1, n2 = arguments.length;i2 < n2; i2++) {
+        s = arguments[i2];
         for (var p in s)
           if (Object.prototype.hasOwnProperty.call(s, p))
             t[p] = s[p];
@@ -27504,25 +29282,25 @@ var require_lib5 = __commonJS((exports) => {
     };
     return __assign.apply(this, arguments);
   };
-  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m2, k, k2) {
     if (k2 === undefined)
       k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+    var desc = Object.getOwnPropertyDescriptor(m2, k);
+    if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
       desc = { enumerable: true, get: function() {
-        return m[k];
+        return m2[k];
       } };
     }
     Object.defineProperty(o, k2, desc);
-  } : function(o, m, k, k2) {
+  } : function(o, m2, k, k2) {
     if (k2 === undefined)
       k2 = k;
-    o[k2] = m[k];
+    o[k2] = m2[k];
   });
-  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-  } : function(o, v) {
-    o["default"] = v;
+  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v2) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v2 });
+  } : function(o, v2) {
+    o["default"] = v2;
   });
   var __importStar = exports && exports.__importStar || function(mod) {
     if (mod && mod.__esModule)
@@ -27558,7 +29336,7 @@ var require_lib5 = __commonJS((exports) => {
     var _a;
     if (!attributes)
       return;
-    var encode = ((_a = opts.encodeEntities) !== null && _a !== undefined ? _a : opts.decodeEntities) === false ? replaceQuotes : opts.xmlMode || opts.encodeEntities !== "utf8" ? entities_1.encodeXML : entities_1.escapeAttribute;
+    var encode2 = ((_a = opts.encodeEntities) !== null && _a !== undefined ? _a : opts.decodeEntities) === false ? replaceQuotes : opts.xmlMode || opts.encodeEntities !== "utf8" ? entities_1.encodeXML : entities_1.escapeAttribute;
     return Object.keys(attributes).map(function(key) {
       var _a2, _b;
       var value = (_a2 = attributes[key]) !== null && _a2 !== undefined ? _a2 : "";
@@ -27568,7 +29346,7 @@ var require_lib5 = __commonJS((exports) => {
       if (!opts.emptyAttrs && !opts.xmlMode && value === "") {
         return key;
       }
-      return "".concat(key, '="').concat(encode(value), '"');
+      return "".concat(key, '="').concat(encode2(value), '"');
     }).join(" ");
   }
   var singleTag = new Set([
@@ -27598,8 +29376,8 @@ var require_lib5 = __commonJS((exports) => {
     }
     var nodes = "length" in node ? node : [node];
     var output = "";
-    for (var i = 0;i < nodes.length; i++) {
-      output += renderNode(nodes[i], options);
+    for (var i2 = 0;i2 < nodes.length; i2++) {
+      output += renderNode(nodes[i2], options);
     }
     return output;
   }
@@ -27955,15 +29733,15 @@ var require_querying = __commonJS((exports) => {
       recurse = true;
     }
     var searchedNodes = Array.isArray(nodes) ? nodes : [nodes];
-    for (var i = 0;i < searchedNodes.length; i++) {
-      var node = searchedNodes[i];
+    for (var i2 = 0;i2 < searchedNodes.length; i2++) {
+      var node = searchedNodes[i2];
       if ((0, domhandler_1.isTag)(node) && test(node)) {
         return node;
       }
       if (recurse && (0, domhandler_1.hasChildren)(node) && node.children.length > 0) {
-        var found = findOne(test, node.children, true);
-        if (found)
-          return found;
+        var found2 = findOne(test, node.children, true);
+        if (found2)
+          return found2;
       }
     }
     return null;
@@ -28052,9 +29830,9 @@ var require_legacy = __commonJS((exports) => {
       return (0, domhandler_1.isTag)(elem) && elem.attribs[attrib] === value;
     };
   }
-  function combineFuncs(a, b) {
+  function combineFuncs(a, b2) {
     return function(elem) {
-      return a(elem) || b(elem);
+      return a(elem) || b2(elem);
     };
   }
   function compileTest(options) {
@@ -28185,11 +29963,11 @@ var require_helpers = __commonJS((exports) => {
     return DocumentPosition.PRECEDING;
   }
   function uniqueSort(nodes) {
-    nodes = nodes.filter(function(node, i, arr) {
-      return !arr.includes(node, i + 1);
+    nodes = nodes.filter(function(node, i2, arr) {
+      return !arr.includes(node, i2 + 1);
     });
-    nodes.sort(function(a, b) {
-      var relative = compareDocumentPosition(a, b);
+    nodes.sort(function(a, b2) {
+      var relative = compareDocumentPosition(a, b2);
       if (relative & DocumentPosition.PRECEDING) {
         return -1;
       } else if (relative & DocumentPosition.FOLLOWING) {
@@ -28340,25 +30118,25 @@ var require_feeds = __commonJS((exports) => {
 
 // ../../node_modules/domutils/lib/index.js
 var require_lib6 = __commonJS((exports) => {
-  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m2, k, k2) {
     if (k2 === undefined)
       k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+    var desc = Object.getOwnPropertyDescriptor(m2, k);
+    if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
       desc = { enumerable: true, get: function() {
-        return m[k];
+        return m2[k];
       } };
     }
     Object.defineProperty(o, k2, desc);
-  } : function(o, m, k, k2) {
+  } : function(o, m2, k, k2) {
     if (k2 === undefined)
       k2 = k;
-    o[k2] = m[k];
+    o[k2] = m2[k];
   });
-  var __exportStar = exports && exports.__exportStar || function(m, exports2) {
-    for (var p in m)
+  var __exportStar = exports && exports.__exportStar || function(m2, exports2) {
+    for (var p in m2)
       if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
-        __createBinding(exports2, m, p);
+        __createBinding(exports2, m2, p);
   };
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.hasChildren = exports.isDocument = exports.isComment = exports.isText = exports.isCDATA = exports.isTag = undefined;
@@ -28478,7 +30256,7 @@ var require_parse = __commonJS((exports) => {
   }
   exports.isTraversal = isTraversal;
   var stripQuotesFromPseudos = new Set(["contains", "icontains"]);
-  function funescape(_, escaped, escapedWhitespace) {
+  function funescape(_2, escaped, escapedWhitespace) {
     var high = parseInt(escaped, 16) - 65536;
     return high !== high || escapedWhitespace ? escaped : high < 0 ? String.fromCharCode(high + 65536) : String.fromCharCode(high >> 10 | 55296, high & 1023 | 56320);
   }
@@ -28491,7 +30269,7 @@ var require_parse = __commonJS((exports) => {
   function isWhitespace(c) {
     return c === 32 || c === 9 || c === 10 || c === 12 || c === 13;
   }
-  function parse2(selector) {
+  function parse3(selector) {
     var subselects = [];
     var endIndex = parseSelector(subselects, "".concat(selector), 0);
     if (endIndex < selector.length) {
@@ -28499,7 +30277,7 @@ var require_parse = __commonJS((exports) => {
     }
     return subselects;
   }
-  exports.parse = parse2;
+  exports.parse = parse3;
   function parseSelector(subselects, selector, selectorIndex) {
     var tokens = [];
     function getName(offset) {
@@ -28787,11 +30565,11 @@ var require_parse = __commonJS((exports) => {
 var require_stringify3 = __commonJS((exports) => {
   var __spreadArray = exports && exports.__spreadArray || function(to, from, pack) {
     if (pack || arguments.length === 2)
-      for (var i = 0, l = from.length, ar;i < l; i++) {
-        if (ar || !(i in from)) {
+      for (var i2 = 0, l = from.length, ar;i2 < l; i2++) {
+        if (ar || !(i2 in from)) {
           if (!ar)
-            ar = Array.prototype.slice.call(from, 0, i);
-          ar[i] = from[i];
+            ar = Array.prototype.slice.call(from, 0, i2);
+          ar[i2] = from[i2];
         }
       }
     return to.concat(ar || Array.prototype.slice.call(from));
@@ -28895,10 +30673,10 @@ var require_stringify3 = __commonJS((exports) => {
   function escapeName(str, charsToEscape) {
     var lastIdx = 0;
     var ret = "";
-    for (var i = 0;i < str.length; i++) {
-      if (charsToEscape.has(str.charCodeAt(i))) {
-        ret += "".concat(str.slice(lastIdx, i), "\\").concat(str.charAt(i));
-        lastIdx = i + 1;
+    for (var i2 = 0;i2 < str.length; i2++) {
+      if (charsToEscape.has(str.charCodeAt(i2))) {
+        ret += "".concat(str.slice(lastIdx, i2), "\\").concat(str.charAt(i2));
+        lastIdx = i2 + 1;
       }
     }
     return ret.length > 0 ? ret + str.slice(lastIdx) : str;
@@ -28907,25 +30685,25 @@ var require_stringify3 = __commonJS((exports) => {
 
 // ../../node_modules/css-what/lib/commonjs/index.js
 var require_commonjs = __commonJS((exports) => {
-  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m2, k, k2) {
     if (k2 === undefined)
       k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+    var desc = Object.getOwnPropertyDescriptor(m2, k);
+    if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
       desc = { enumerable: true, get: function() {
-        return m[k];
+        return m2[k];
       } };
     }
     Object.defineProperty(o, k2, desc);
-  } : function(o, m, k, k2) {
+  } : function(o, m2, k, k2) {
     if (k2 === undefined)
       k2 = k;
-    o[k2] = m[k];
+    o[k2] = m2[k];
   });
-  var __exportStar = exports && exports.__exportStar || function(m, exports2) {
-    for (var p in m)
+  var __exportStar = exports && exports.__exportStar || function(m2, exports2) {
+    for (var p in m2)
       if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
-        __createBinding(exports2, m, p);
+        __createBinding(exports2, m2, p);
   };
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.stringify = exports.parse = exports.isTraversal = undefined;
@@ -28968,11 +30746,11 @@ var require_sort = __commonJS((exports) => {
   ]);
   function sortByProcedure(arr) {
     var procs = arr.map(getProcedure);
-    for (var i = 1;i < arr.length; i++) {
-      var procNew = procs[i];
+    for (var i2 = 1;i2 < arr.length; i2++) {
+      var procNew = procs[i2];
       if (procNew < 0)
         continue;
-      for (var j = i - 1;j >= 0 && procNew < procs[j]; j--) {
+      for (var j = i2 - 1;j >= 0 && procNew < procs[j]; j--) {
         var token = arr[j + 1];
         arr[j + 1] = arr[j];
         arr[j] = token;
@@ -28999,8 +30777,8 @@ var require_sort = __commonJS((exports) => {
       } else if (token.name === "has" || token.name === "contains") {
         proc = 0;
       } else if (Array.isArray(token.data)) {
-        proc = Math.min.apply(Math, token.data.map(function(d) {
-          return Math.min.apply(Math, d.map(getProcedure));
+        proc = Math.min.apply(Math, token.data.map(function(d3) {
+          return Math.min.apply(Math, d3.map(getProcedure));
         }));
         if (proc < 0) {
           proc = 0;
@@ -29215,7 +30993,7 @@ var require_parse2 = __commonJS((exports) => {
   var whitespace = new Set([9, 10, 12, 13, 32]);
   var ZERO = 48;
   var NINE = 57;
-  function parse2(formula) {
+  function parse3(formula) {
     formula = formula.trim().toLowerCase();
     if (formula === "even") {
       return [2, 0];
@@ -29267,7 +31045,7 @@ var require_parse2 = __commonJS((exports) => {
       }
     }
   }
-  exports.parse = parse2;
+  exports.parse = parse3;
 });
 
 // ../../node_modules/nth-check/lib/compile.js
@@ -29280,53 +31058,53 @@ var require_compile = __commonJS((exports) => {
   var boolbase_1 = __importDefault(require_boolbase());
   function compile(parsed) {
     var a = parsed[0];
-    var b = parsed[1] - 1;
-    if (b < 0 && a <= 0)
+    var b2 = parsed[1] - 1;
+    if (b2 < 0 && a <= 0)
       return boolbase_1.default.falseFunc;
     if (a === -1)
       return function(index) {
-        return index <= b;
+        return index <= b2;
       };
     if (a === 0)
       return function(index) {
-        return index === b;
+        return index === b2;
       };
     if (a === 1)
-      return b < 0 ? boolbase_1.default.trueFunc : function(index) {
-        return index >= b;
+      return b2 < 0 ? boolbase_1.default.trueFunc : function(index) {
+        return index >= b2;
       };
     var absA = Math.abs(a);
-    var bMod = (b % absA + absA) % absA;
+    var bMod = (b2 % absA + absA) % absA;
     return a > 1 ? function(index) {
-      return index >= b && index % absA === bMod;
+      return index >= b2 && index % absA === bMod;
     } : function(index) {
-      return index <= b && index % absA === bMod;
+      return index <= b2 && index % absA === bMod;
     };
   }
   exports.compile = compile;
   function generate(parsed) {
     var a = parsed[0];
-    var b = parsed[1] - 1;
-    var n = 0;
+    var b2 = parsed[1] - 1;
+    var n2 = 0;
     if (a < 0) {
       var aPos_1 = -a;
-      var minValue_1 = (b % aPos_1 + aPos_1) % aPos_1;
+      var minValue_1 = (b2 % aPos_1 + aPos_1) % aPos_1;
       return function() {
-        var val = minValue_1 + aPos_1 * n++;
-        return val > b ? null : val;
+        var val = minValue_1 + aPos_1 * n2++;
+        return val > b2 ? null : val;
       };
     }
     if (a === 0)
-      return b < 0 ? function() {
+      return b2 < 0 ? function() {
         return null;
       } : function() {
-        return n++ === 0 ? b : null;
+        return n2++ === 0 ? b2 : null;
       };
-    if (b < 0) {
-      b += a * Math.ceil(-b / a);
+    if (b2 < 0) {
+      b2 += a * Math.ceil(-b2 / a);
     }
     return function() {
-      return a * n++ + b;
+      return a * n2++ + b2;
     };
   }
   exports.generate = generate;
@@ -29375,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);
       };
     },
@@ -29396,10 +31174,10 @@ var require_filters = __commonJS((exports) => {
       return function nthChild(elem) {
         var siblings = adapter.getSiblings(elem);
         var pos = 0;
-        for (var i = 0;i < siblings.length; i++) {
-          if (equals(elem, siblings[i]))
+        for (var i2 = 0;i2 < siblings.length; i2++) {
+          if (equals(elem, siblings[i2]))
             break;
-          if (adapter.isTag(siblings[i])) {
+          if (adapter.isTag(siblings[i2])) {
             pos++;
           }
         }
@@ -29416,10 +31194,10 @@ var require_filters = __commonJS((exports) => {
       return function nthLastChild(elem) {
         var siblings = adapter.getSiblings(elem);
         var pos = 0;
-        for (var i = siblings.length - 1;i >= 0; i--) {
-          if (equals(elem, siblings[i]))
+        for (var i2 = siblings.length - 1;i2 >= 0; i2--) {
+          if (equals(elem, siblings[i2]))
             break;
-          if (adapter.isTag(siblings[i])) {
+          if (adapter.isTag(siblings[i2])) {
             pos++;
           }
         }
@@ -29436,8 +31214,8 @@ var require_filters = __commonJS((exports) => {
       return function nthOfType(elem) {
         var siblings = adapter.getSiblings(elem);
         var pos = 0;
-        for (var i = 0;i < siblings.length; i++) {
-          var currentSibling = siblings[i];
+        for (var i2 = 0;i2 < siblings.length; i2++) {
+          var currentSibling = siblings[i2];
           if (equals(elem, currentSibling))
             break;
           if (adapter.isTag(currentSibling) && adapter.getName(currentSibling) === adapter.getName(elem)) {
@@ -29457,8 +31235,8 @@ var require_filters = __commonJS((exports) => {
       return function nthLastOfType(elem) {
         var siblings = adapter.getSiblings(elem);
         var pos = 0;
-        for (var i = siblings.length - 1;i >= 0; i--) {
-          var currentSibling = siblings[i];
+        for (var i2 = siblings.length - 1;i2 >= 0; i2--) {
+          var currentSibling = siblings[i2];
           if (equals(elem, currentSibling))
             break;
           if (adapter.isTag(currentSibling) && adapter.getName(currentSibling) === adapter.getName(elem)) {
@@ -29531,10 +31309,10 @@ var require_pseudos = __commonJS((exports) => {
     "last-child": function(elem, _a) {
       var { adapter, equals } = _a;
       var siblings = adapter.getSiblings(elem);
-      for (var i = siblings.length - 1;i >= 0; i--) {
-        if (equals(elem, siblings[i]))
+      for (var i2 = siblings.length - 1;i2 >= 0; i2--) {
+        if (equals(elem, siblings[i2]))
           return true;
-        if (adapter.isTag(siblings[i]))
+        if (adapter.isTag(siblings[i2]))
           break;
       }
       return false;
@@ -29543,8 +31321,8 @@ var require_pseudos = __commonJS((exports) => {
       var { adapter, equals } = _a;
       var siblings = adapter.getSiblings(elem);
       var elemName = adapter.getName(elem);
-      for (var i = 0;i < siblings.length; i++) {
-        var currentSibling = siblings[i];
+      for (var i2 = 0;i2 < siblings.length; i2++) {
+        var currentSibling = siblings[i2];
         if (equals(elem, currentSibling))
           return true;
         if (adapter.isTag(currentSibling) && adapter.getName(currentSibling) === elemName) {
@@ -29557,8 +31335,8 @@ var require_pseudos = __commonJS((exports) => {
       var { adapter, equals } = _a;
       var siblings = adapter.getSiblings(elem);
       var elemName = adapter.getName(elem);
-      for (var i = siblings.length - 1;i >= 0; i--) {
-        var currentSibling = siblings[i];
+      for (var i2 = siblings.length - 1;i2 >= 0; i2--) {
+        var currentSibling = siblings[i2];
         if (equals(elem, currentSibling))
           return true;
         if (adapter.isTag(currentSibling) && adapter.getName(currentSibling) === elemName) {
@@ -29629,11 +31407,11 @@ var require_aliases = __commonJS((exports) => {
 var require_subselects = __commonJS((exports) => {
   var __spreadArray = exports && exports.__spreadArray || function(to, from, pack) {
     if (pack || arguments.length === 2)
-      for (var i = 0, l = from.length, ar;i < l; i++) {
-        if (ar || !(i in from)) {
+      for (var i2 = 0, l = from.length, ar;i2 < l; i2++) {
+        if (ar || !(i2 in from)) {
           if (!ar)
-            ar = Array.prototype.slice.call(from, 0, i);
-          ar[i] = from[i];
+            ar = Array.prototype.slice.call(from, 0, i2);
+          ar[i2] = from[i2];
         }
       }
     return to.concat(ar || Array.prototype.slice.call(from));
@@ -29877,8 +31655,8 @@ var require_general = __commonJS((exports) => {
       case css_what_1.SelectorType.Sibling: {
         return function sibling(elem) {
           var siblings = adapter.getSiblings(elem);
-          for (var i = 0;i < siblings.length; i++) {
-            var currentSibling = siblings[i];
+          for (var i2 = 0;i2 < siblings.length; i2++) {
+            var currentSibling = siblings[i2];
             if (equals(elem, currentSibling))
               break;
             if (adapter.isTag(currentSibling) && next(currentSibling)) {
@@ -29898,8 +31676,8 @@ var require_general = __commonJS((exports) => {
         return function adjacent(elem) {
           var siblings = adapter.getSiblings(elem);
           var lastElement;
-          for (var i = 0;i < siblings.length; i++) {
-            var currentSibling = siblings[i];
+          for (var i2 = 0;i2 < siblings.length; i2++) {
+            var currentSibling = siblings[i2];
             if (equals(elem, currentSibling))
               break;
             if (adapter.isTag(currentSibling)) {
@@ -29922,25 +31700,25 @@ var require_general = __commonJS((exports) => {
 
 // ../../node_modules/css-select/lib/compile.js
 var require_compile2 = __commonJS((exports) => {
-  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m2, k, k2) {
     if (k2 === undefined)
       k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+    var desc = Object.getOwnPropertyDescriptor(m2, k);
+    if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
       desc = { enumerable: true, get: function() {
-        return m[k];
+        return m2[k];
       } };
     }
     Object.defineProperty(o, k2, desc);
-  } : function(o, m, k, k2) {
+  } : function(o, m2, k, k2) {
     if (k2 === undefined)
       k2 = k;
-    o[k2] = m[k];
+    o[k2] = m2[k];
   });
-  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-  } : function(o, v) {
-    o["default"] = v;
+  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v2) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v2 });
+  } : function(o, v2) {
+    o["default"] = v2;
   });
   var __importStar = exports && exports.__importStar || function(mod) {
     if (mod && mod.__esModule)
@@ -30039,40 +31817,40 @@ var require_compile2 = __commonJS((exports) => {
       return previous === boolbase_1.default.falseFunc ? boolbase_1.default.falseFunc : (0, general_js_1.compileGeneralSelector)(previous, rule, options, context, compileToken);
     }, (_a = options.rootFunc) !== null && _a !== undefined ? _a : boolbase_1.default.trueFunc);
   }
-  function reduceRules(a, b) {
-    if (b === boolbase_1.default.falseFunc || a === boolbase_1.default.trueFunc) {
+  function reduceRules(a, b2) {
+    if (b2 === boolbase_1.default.falseFunc || a === boolbase_1.default.trueFunc) {
       return a;
     }
-    if (a === boolbase_1.default.falseFunc || b === boolbase_1.default.trueFunc) {
-      return b;
+    if (a === boolbase_1.default.falseFunc || b2 === boolbase_1.default.trueFunc) {
+      return b2;
     }
     return function combine(elem) {
-      return a(elem) || b(elem);
+      return a(elem) || b2(elem);
     };
   }
 });
 
 // ../../node_modules/css-select/lib/index.js
 var require_lib8 = __commonJS((exports) => {
-  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m2, k, k2) {
     if (k2 === undefined)
       k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+    var desc = Object.getOwnPropertyDescriptor(m2, k);
+    if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
       desc = { enumerable: true, get: function() {
-        return m[k];
+        return m2[k];
       } };
     }
     Object.defineProperty(o, k2, desc);
-  } : function(o, m, k, k2) {
+  } : function(o, m2, k, k2) {
     if (k2 === undefined)
       k2 = k;
-    o[k2] = m[k];
+    o[k2] = m2[k];
   });
-  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-  } : function(o, v) {
-    o["default"] = v;
+  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v2) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v2 });
+  } : function(o, v2) {
+    o["default"] = v2;
   });
   var __importStar = exports && exports.__importStar || function(mod) {
     if (mod && mod.__esModule)
@@ -30095,8 +31873,8 @@ var require_lib8 = __commonJS((exports) => {
   var boolbase_1 = __importDefault(require_boolbase());
   var compile_js_1 = require_compile2();
   var subselects_js_1 = require_subselects();
-  var defaultEquals = function(a, b) {
-    return a === b;
+  var defaultEquals = function(a, b2) {
+    return a === b2;
   };
   var defaultOptions = {
     adapter: DomUtils,
@@ -30141,8 +31919,8 @@ var require_lib8 = __commonJS((exports) => {
   function appendNextSiblings(elem, adapter) {
     var elems = Array.isArray(elem) ? elem.slice(0) : [elem];
     var elemsLength = elems.length;
-    for (var i = 0;i < elemsLength; i++) {
-      var nextSiblings = (0, subselects_js_1.getNextSiblings)(elems[i], adapter);
+    for (var i2 = 0;i2 < elemsLength; i2++) {
+      var nextSiblings = (0, subselects_js_1.getNextSiblings)(elems[i2], adapter);
       elems.push.apply(elems, nextSiblings);
     }
     return elems;
@@ -30242,8 +32020,8 @@ var require_matcher = __commonJS((exports) => {
   }
   function findOne(test, elems) {
     let elem = null;
-    for (let i = 0, l = elems === null || elems === undefined ? undefined : elems.length;i < l && !elem; i++) {
-      const el = elems[i];
+    for (let i2 = 0, l = elems === null || elems === undefined ? undefined : elems.length;i2 < l && !elem; i2++) {
+      const el = elems[i2];
       if (test(el)) {
         elem = el;
       } else {
@@ -30257,12 +32035,12 @@ var require_matcher = __commonJS((exports) => {
   }
   function findAll(test, nodes) {
     let result = [];
-    for (let i = 0, j = nodes.length;i < j; i++) {
-      if (!isTag(nodes[i]))
+    for (let i2 = 0, j = nodes.length;i2 < j; i2++) {
+      if (!isTag(nodes[i2]))
         continue;
-      if (test(nodes[i]))
-        result.push(nodes[i]);
-      const childs = getChildren(nodes[i]);
+      if (test(nodes[i2]))
+        result.push(nodes[i2]);
+      const childs = getChildren(nodes[i2]);
       if (childs)
         result = result.concat(findAll(test, childs));
     }
@@ -30366,23 +32144,23 @@ var require_text = __commonJS((exports) => {
   }
   exports.default = TextNode;
   function trimText(text) {
-    let i = 0;
+    let i2 = 0;
     let startPos;
     let endPos;
-    while (i >= 0 && i < text.length) {
-      if (/\S/.test(text[i])) {
+    while (i2 >= 0 && i2 < text.length) {
+      if (/\S/.test(text[i2])) {
         if (startPos === undefined) {
-          startPos = i;
-          i = text.length;
+          startPos = i2;
+          i2 = text.length;
         } else {
-          endPos = i;
-          i = undefined;
+          endPos = i2;
+          i2 = undefined;
         }
       }
       if (startPos === undefined)
-        i++;
+        i2++;
       else
-        i--;
+        i2--;
     }
     if (startPos === undefined)
       startPos = 0;
@@ -30410,7 +32188,7 @@ var require_html = __commonJS((exports) => {
   var node_1 = __importDefault(require_node());
   var text_1 = __importDefault(require_text());
   var type_1 = __importDefault(require_type());
-  function decode(val) {
+  function decode2(val) {
     return JSON.parse(JSON.stringify(he_1.default.decode(val)));
   }
   var Htags = ["h1", "h2", "h3", "h4", "h5", "h6", "header", "hgroup"];
@@ -30560,14 +32338,14 @@ var require_html = __commonJS((exports) => {
       }, "");
     }
     get textContent() {
-      return decode(this.rawText);
+      return decode2(this.rawText);
     }
     set textContent(val) {
       const content = [new text_1.default(val, this)];
       this.childNodes = content;
     }
     get text() {
-      return decode(this.rawText);
+      return decode2(this.rawText);
     }
     get structuredText() {
       let currentBlock = [];
@@ -30618,7 +32396,7 @@ var require_html = __commonJS((exports) => {
       }).join("");
     }
     set innerHTML(content) {
-      const r = parse2(content, this._parseOptions);
+      const r = parse3(content, this._parseOptions);
       const nodes = r.childNodes.length ? r.childNodes : [new text_1.default(content, this)];
       resetParent(nodes, this);
       resetParent(this.childNodes, null);
@@ -30629,7 +32407,7 @@ var require_html = __commonJS((exports) => {
         content = [content];
       } else if (typeof content == "string") {
         options = Object.assign(Object.assign({}, this._parseOptions), options);
-        const r = parse2(content, options);
+        const r = parse3(content, options);
         content = r.childNodes.length ? r.childNodes : [new text_1.default(r.innerHTML, this)];
       }
       resetParent(this.childNodes, null);
@@ -30643,7 +32421,7 @@ var require_html = __commonJS((exports) => {
         if (node instanceof node_1.default) {
           return [node];
         } else if (typeof node == "string") {
-          const r = parse2(node, this._parseOptions);
+          const r = parse3(node, this._parseOptions);
           return r.childNodes.length ? r.childNodes : [new text_1.default(node, this)];
         }
         return [];
@@ -30659,15 +32437,15 @@ var require_html = __commonJS((exports) => {
       return this.toString();
     }
     trimRight(pattern) {
-      for (let i = 0;i < this.childNodes.length; i++) {
-        const childNode = this.childNodes[i];
+      for (let i2 = 0;i2 < this.childNodes.length; i2++) {
+        const childNode = this.childNodes[i2];
         if (childNode.nodeType === type_1.default.ELEMENT_NODE) {
           childNode.trimRight(pattern);
         } else {
           const index = childNode.rawText.search(pattern);
           if (index > -1) {
             childNode.rawText = childNode.rawText.substr(0, index);
-            this.childNodes.length = i + 1;
+            this.childNodes.length = i2 + 1;
           }
         }
       }
@@ -30800,8 +32578,8 @@ var require_html = __commonJS((exports) => {
       let old = null;
       function findOne(test, elems) {
         let elem = null;
-        for (let i = 0, l = elems.length;i < l && !elem; i++) {
-          const el2 = elems[i];
+        for (let i2 = 0, l = elems.length;i2 < l && !elem; i2++) {
+          const el2 = elems[i2];
           if (test(el2)) {
             elem = el2;
           } else {
@@ -30855,7 +32633,7 @@ var require_html = __commonJS((exports) => {
       const attrs = this.rawAttributes;
       for (const key in attrs) {
         const val = attrs[key] || "";
-        this._attrs[key.toLowerCase()] = decode(val);
+        this._attrs[key.toLowerCase()] = decode2(val);
       }
       return this._attrs;
     }
@@ -30864,7 +32642,7 @@ var require_html = __commonJS((exports) => {
       const attrs = this.rawAttributes;
       for (const key in attrs) {
         const val = attrs[key] || "";
-        ret_attrs[key] = decode(val);
+        ret_attrs[key] = decode2(val);
       }
       return ret_attrs;
     }
@@ -30924,7 +32702,7 @@ var require_html = __commonJS((exports) => {
       }
       attrs[key] = String(value);
       if (this._attrs) {
-        this._attrs[k2] = decode(attrs[key]);
+        this._attrs[k2] = decode2(attrs[key]);
       }
       this.rawAttrs = Object.keys(attrs).map((name) => {
         const val = this.quoteAttribute(attrs[name]);
@@ -30959,7 +32737,7 @@ var require_html = __commonJS((exports) => {
       if (arguments.length < 2) {
         throw new Error("2 arguments required");
       }
-      const p = parse2(html, this._parseOptions);
+      const p = parse3(html, this._parseOptions);
       if (where === "afterend") {
         this.after(...p.childNodes);
       } else if (where === "afterbegin") {
@@ -30998,11 +32776,11 @@ var require_html = __commonJS((exports) => {
     get nextSibling() {
       if (this.parentNode) {
         const children = this.parentNode.childNodes;
-        let i = 0;
-        while (i < children.length) {
-          const child = children[i++];
+        let i2 = 0;
+        while (i2 < children.length) {
+          const child = children[i2++];
           if (this === child)
-            return children[i] || null;
+            return children[i2] || null;
         }
         return null;
       }
@@ -31010,10 +32788,10 @@ var require_html = __commonJS((exports) => {
     get nextElementSibling() {
       if (this.parentNode) {
         const children = this.parentNode.childNodes;
-        let i = 0;
+        let i2 = 0;
         let find = false;
-        while (i < children.length) {
-          const child = children[i++];
+        while (i2 < children.length) {
+          const child = children[i2++];
           if (find) {
             if (child instanceof HTMLElement) {
               return child || null;
@@ -31028,11 +32806,11 @@ var require_html = __commonJS((exports) => {
     get previousSibling() {
       if (this.parentNode) {
         const children = this.parentNode.childNodes;
-        let i = children.length;
-        while (i > 0) {
-          const child = children[--i];
+        let i2 = children.length;
+        while (i2 > 0) {
+          const child = children[--i2];
           if (this === child)
-            return children[i - 1] || null;
+            return children[i2 - 1] || null;
         }
         return null;
       }
@@ -31040,10 +32818,10 @@ var require_html = __commonJS((exports) => {
     get previousElementSibling() {
       if (this.parentNode) {
         const children = this.parentNode.childNodes;
-        let i = children.length;
+        let i2 = children.length;
         let find = false;
-        while (i > 0) {
-          const child = children[--i];
+        while (i2 > 0) {
+          const child = children[--i2];
           if (find) {
             if (child instanceof HTMLElement) {
               return child || null;
@@ -31083,7 +32861,7 @@ var require_html = __commonJS((exports) => {
       return this.classList.toString();
     }
     clone() {
-      return parse2(this.toString(), this._parseOptions).firstChild;
+      return parse3(this.toString(), this._parseOptions).firstChild;
     }
   }
   exports.default = HTMLElement;
@@ -31260,13 +33038,13 @@ var require_html = __commonJS((exports) => {
               }
             }
             if (options.closeAllByClosing === true) {
-              let i;
-              for (i = stack.length - 2;i >= 0; i--) {
-                if (stack[i].rawTagName === tagName)
+              let i2;
+              for (i2 = stack.length - 2;i2 >= 0; i2--) {
+                if (stack[i2].rawTagName === tagName)
                   break;
               }
-              if (i >= 0) {
-                while (stack.length > i) {
+              if (i2 >= 0) {
+                while (stack.length > i2) {
                   currentParent.range[1] = createRange(-1, Math.max(lastTextPos, tagEndPos))[1];
                   stack.pop();
                   currentParent = (0, back_1.default)(stack);
@@ -31282,7 +33060,7 @@ var require_html = __commonJS((exports) => {
     return stack;
   }
   exports.base_parse = base_parse;
-  function parse2(data, options = {}) {
+  function parse3(data, options = {}) {
     const stack = base_parse(data, options);
     const [root] = stack;
     while (stack.length > 1) {
@@ -31309,7 +33087,7 @@ var require_html = __commonJS((exports) => {
     }
     return root;
   }
-  exports.parse = parse2;
+  exports.parse = parse3;
   function resolveInsertable(insertable) {
     return insertable.map((val) => {
       if (typeof val === "string") {
@@ -31368,41 +33146,18 @@ var require_dist2 = __commonJS((exports) => {
   var parse_1 = __importDefault(require_parse3());
   var valid_1 = __importDefault(require_valid());
   exports.valid = valid_1.default;
-  function parse2(data, options = {}) {
+  function parse3(data, options = {}) {
     return (0, parse_1.default)(data, options);
   }
-  exports.default = parse2;
-  exports.parse = parse2;
-  parse2.parse = parse_1.default;
-  parse2.HTMLElement = html_1.default;
-  parse2.CommentNode = comment_1.default;
-  parse2.valid = valid_1.default;
-  parse2.Node = node_1.default;
-  parse2.TextNode = text_1.default;
-  parse2.NodeType = type_1.default;
-});
-// ../../node_modules/@astrojs/compiler/dist/chunk-W5DTLHV4.js
-import g from "crypto";
-import _ from "fs";
-import { TextDecoder as b, TextEncoder as v } from "util";
-var y, w;
-var init_chunk_W5DTLHV4 = __esm(() => {
-  globalThis.fs || Object.defineProperty(globalThis, "fs", { value: _ });
-  globalThis.process || Object.defineProperties(globalThis, "process", { value: process });
-  globalThis.crypto || Object.defineProperty(globalThis, "crypto", { value: g.webcrypto ? g.webcrypto : { getRandomValues(m) {
-    return g.randomFillSync(m);
-  } } });
-  globalThis.performance || Object.defineProperty(globalThis, "performance", { value: { now() {
-    let [m, o] = process.hrtime();
-    return m * 1000 + o / 1e6;
-  } } });
-  y = new v("utf-8");
-  w = new b("utf-8");
-});
-
-// ../../node_modules/@astrojs/compiler/dist/node/index.js
-var init_node = __esm(() => {
-  init_chunk_W5DTLHV4();
+  exports.default = parse3;
+  exports.parse = parse3;
+  parse3.parse = parse_1.default;
+  parse3.HTMLElement = html_1.default;
+  parse3.CommentNode = comment_1.default;
+  parse3.valid = valid_1.default;
+  parse3.Node = node_1.default;
+  parse3.TextNode = text_1.default;
+  parse3.NodeType = type_1.default;
 });
 // ../cms/src/source-finder/cache.ts
 var parsedFileCache, directoryCache, markdownFileCache, declaredUrlIndexCache, dirtyFiles;
@@ -31489,9 +33244,9 @@ function extractAstroImageOriginalUrl(src) {
         return href;
     }
     if (url.pathname.startsWith("/@image/")) {
-      const f = url.searchParams.get("f");
-      if (f)
-        return f;
+      const f2 = url.searchParams.get("f");
+      if (f2)
+        return f2;
     }
   } catch {}
   return;
@@ -31511,7 +33266,7 @@ var init_snippet_utils = __esm(() => {
 
 // ../cms/src/handlers/source-writer.ts
 import fs8 from "fs/promises";
-import path10 from "path";
+import path12 from "path";
 async function handleUpdate(request, manifestWriter) {
   const { changes, meta } = request;
   const errors = [];
@@ -31548,7 +33303,7 @@ async function handleUpdate(request, manifestWriter) {
         }
         if (appliedCount > 0 && newContent !== currentContent) {
           for (const op of fileOps) {
-            await fs8.mkdir(path10.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");
@@ -31782,28 +33537,28 @@ function findFrontmatterAssetImport(content, varName) {
     return null;
   const fmStart = fmMatch[0].indexOf(fmMatch[1]);
   const importRe = /^\s*import\s+(?!type\b)([\s\S]+?)\s+from\s+(['"])([^'"]+)\2/gm;
-  let m;
-  while ((m = importRe.exec(fmMatch[1])) !== null) {
-    const source = m[3];
+  let m2;
+  while ((m2 = importRe.exec(fmMatch[1])) !== null) {
+    const source = m2[3];
     if (!source.startsWith(".") || !ASSET_IMPORT_EXT_RE.test(source))
       continue;
-    const tokens = m[1].replace(/[{}]/g, ",").split(",").map((s) => s.trim()).filter((t) => t && !t.startsWith("type "));
+    const tokens = m2[1].replace(/[{}]/g, ",").split(",").map((s) => s.trim()).filter((t) => t && !t.startsWith("type "));
     const matches = tokens.some((tok) => {
       const aliasMatch = tok.match(/^\S+\s+as\s+(\S+)$/);
       return (aliasMatch ? aliasMatch[1] : tok) === varName;
     });
     if (!matches)
       continue;
-    const matchStart = fmStart + m.index;
-    const sourceStart = matchStart + m[0].indexOf(m[2]) + 1;
+    const matchStart = fmStart + m2.index;
+    const sourceStart = matchStart + m2[0].indexOf(m2[2]) + 1;
     return { localName: varName, source, sourceStart, sourceEnd: sourceStart + source.length };
   }
   return null;
 }
 function inlineJsxLiteralReplace(content, lines, regionStart, exprMatch, newSrc) {
   let regionStartOffset = 0;
-  for (let i = 0;i < regionStart; i++)
-    regionStartOffset += lines[i].length + 1;
+  for (let i2 = 0;i2 < regionStart; i2++)
+    regionStartOffset += lines[i2].length + 1;
   const absIndex = regionStartOffset + exprMatch.index;
   return {
     content: content.slice(0, absIndex) + `src="${escapeReplacement(newSrc)}"` + content.slice(absIndex + exprMatch.length),
@@ -31814,8 +33569,8 @@ async function tryRewriteAssetImport(content, importInfo, newSrc, absFilePath, o
   const resolved = await resolveNewSrcBytes(newSrc, originUrl);
   if (!resolved)
     return null;
-  const originalAssetAbs = path10.resolve(path10.dirname(absFilePath), importInfo.source);
-  const targetAbs = await pickSiblingTarget(path10.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 {
@@ -31825,8 +33580,8 @@ async function tryRewriteAssetImport(content, importInfo, newSrc, absFilePath, o
   };
 }
 async function resolveNewSrcBytes(newSrc, originUrl) {
-  const filenameFromPath = (p) => path10.basename(p.split("?")[0] ?? p);
-  const diskPath = newSrc.startsWith("/src/") ? path10.join(getProjectRoot(), newSrc.slice(1)) : newSrc.startsWith("/") && !newSrc.startsWith("//") ? path10.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) };
@@ -31916,10 +33671,10 @@ function replaceClassInAttribute(content, oldClass, newClass, sourceLine) {
   }
   const lines = content.split(`
 `);
-  for (let i = 0;i < lines.length; i++) {
-    const result = replaceOnLine(lines[i]);
+  for (let i2 = 0;i2 < lines.length; i2++) {
+    const result = replaceOnLine(lines[i2]);
     if (result !== null) {
-      lines[i] = result;
+      lines[i2] = result;
       return { success: true, content: lines.join(`
 `) };
     }
@@ -31959,10 +33714,10 @@ function appendClassToAttribute(content, newClass, sourceLine) {
   }
   const lines = content.split(`
 `);
-  for (let i = 0;i < lines.length; i++) {
-    const result = doAppendOnLine(lines[i]);
+  for (let i2 = 0;i2 < lines.length; i2++) {
+    const result = doAppendOnLine(lines[i2]);
     if (result !== null) {
-      lines[i] = result;
+      lines[i2] = result;
       return { success: true, content: lines.join(`
 `) };
     }
@@ -32121,9 +33876,9 @@ function applyTextChangeWithPlaceholders(content, sourceSnippet, originalValue,
   }
   let updatedSnippet = sourceSnippet;
   let anyChange = false;
-  for (let i = 0;i < originalParts.length; i++) {
-    const oldPart = originalParts[i];
-    let newPart = newParts[i];
+  for (let i2 = 0;i2 < originalParts.length; i2++) {
+    const oldPart = originalParts[i2];
+    let newPart = newParts[i2];
     if (oldPart === newPart || oldPart.length === 0) {
       continue;
     }
@@ -32170,8 +33925,8 @@ function findTextInSnippet(snippet, decodedText) {
   const match = snippet.match(regex);
   if (match)
     return match[0];
-  const chars = [...decodedText].map((ch) => escapeRegex(ch));
-  const brAwarePattern = chars.join("(?:<br\\b[^>]*\\/?>)*");
+  const chars2 = [...decodedText].map((ch) => escapeRegex(ch));
+  const brAwarePattern = chars2.join("(?:<br\\b[^>]*\\/?>)*");
   const brRegex = new RegExp(brAwarePattern);
   const brMatch = snippet.match(brRegex);
   return brMatch && brMatch[0] !== decodedText ? brMatch[0] : null;
@@ -32215,19 +33970,19 @@ function findExpressionAttribute(text, attr) {
     return null;
   const braceStart = match.index + match[0].length - 1;
   let depth = 1;
-  let i = braceStart + 1;
-  while (i < text.length && depth > 0) {
-    if (text[i] === "{")
+  let i2 = braceStart + 1;
+  while (i2 < text.length && depth > 0) {
+    if (text[i2] === "{")
       depth++;
-    else if (text[i] === "}")
+    else if (text[i2] === "}")
       depth--;
-    i++;
+    i2++;
   }
   if (depth !== 0)
     return null;
   return {
     index: match.index,
-    length: i - match.index
+    length: i2 - match.index
   };
 }
 function findExpressionSrcAttribute(text) {
@@ -32323,16 +34078,16 @@ function tryBrNormalizedChange(sourceSnippet, resolvedOriginal, resolvedNewText)
   if (originalSegments.length !== newSegments.length)
     return null;
   const root = import_node_html_parser.parse(sourceSnippet, { blockTextElements: {} });
-  const outerElement = root.childNodes.find((n) => n.nodeType === import_node_html_parser.NodeType.ELEMENT_NODE);
+  const outerElement = root.childNodes.find((n2) => n2.nodeType === import_node_html_parser.NodeType.ELEMENT_NODE);
   if (!outerElement)
     return null;
   const groups = [[]];
-  for (let i = 0;i < outerElement.childNodes.length; i++) {
-    const child = outerElement.childNodes[i];
+  for (let i2 = 0;i2 < outerElement.childNodes.length; i2++) {
+    const child = outerElement.childNodes[i2];
     if (child.nodeType === import_node_html_parser.NodeType.ELEMENT_NODE && child.rawTagName === "br") {
       groups.push([]);
     } else if (child.nodeType === import_node_html_parser.NodeType.TEXT_NODE) {
-      groups[groups.length - 1].push({ node: child, index: i });
+      groups[groups.length - 1].push({ node: child, index: i2 });
     }
   }
   if (groups.length !== originalSegments.length)
@@ -32374,7 +34129,7 @@ var init_source_writer = __esm(() => {
 });
 
 // ../cms/src/handlers/api-routes.ts
-import path11 from "path";
+import path13 from "path";
 function requireMedia(ctx) {
   if (!ctx.mediaAdapter) {
     sendError(ctx.res, "Media storage not configured", 501);
@@ -32537,7 +34292,7 @@ var init_api_routes = __esm(() => {
         sendJson(res, { success: false, error: `Invalid content path: ${body.filePath}` }, 400);
         return;
       }
-      const fullPath = path11.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) {
@@ -32644,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(path11.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 });
@@ -32749,7 +34504,7 @@ var init_color_patterns = __esm(() => {
 
 // ../cms/src/tailwind-colors.ts
 import fs9 from "fs/promises";
-import path12 from "path";
+import path14 from "path";
 async function parseTailwindConfig(projectRoot = getProjectRoot()) {
   const cssFiles = [
     "src/styles/global.css",
@@ -32763,7 +34518,7 @@ async function parseTailwindConfig(projectRoot = getProjectRoot()) {
   ];
   let customColors = [];
   for (const cssFile of cssFiles) {
-    const fullPath = path12.join(projectRoot, cssFile);
+    const fullPath = path14.join(projectRoot, cssFile);
     try {
       const content = await fs9.readFile(fullPath, "utf-8");
       customColors = extractColorsFromCss(content);
@@ -32836,7 +34591,7 @@ async function parseTextStyles(projectRoot = getProjectRoot()) {
   ];
   let customTextStyles = {};
   for (const cssFile of cssFiles) {
-    const fullPath = path12.join(projectRoot, cssFile);
+    const fullPath = path14.join(projectRoot, cssFile);
     try {
       const content = await fs9.readFile(fullPath, "utf-8");
       customTextStyles = extractTextStylesFromCss(content);
@@ -33304,7 +35059,7 @@ var init_local_admin = __esm(() => {
 
 // ../cms/src/manifest-writer.ts
 import fs10 from "fs/promises";
-import path13 from "path";
+import path15 from "path";
 
 class ManifestWriter {
   globalManifest;
@@ -33375,10 +35130,10 @@ class ManifestWriter {
   }
   getPageManifestPath(pagePath) {
     if (pagePath === "/" || pagePath === "") {
-      return path13.join(this.outDir, "index.json");
+      return path15.join(this.outDir, "index.json");
     }
     const cleanPath = pagePath.replace(/^\//, "");
-    return path13.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 });
@@ -33404,7 +35159,7 @@ class ManifestWriter {
   }
   async writePageManifest(pagePath, entries, components, collection, seo) {
     const manifestPath = this.getPageManifestPath(pagePath);
-    const manifestDir = path13.dirname(manifestPath);
+    const manifestDir = path15.dirname(manifestPath);
     await fs10.mkdir(manifestDir, { recursive: true });
     const metadata = {
       version: MANIFEST_VERSION,
@@ -33460,7 +35215,7 @@ class ManifestWriter {
       }
     }
     if (this.outDir) {
-      const globalManifestPath = path13.join(this.outDir, this.manifestFile);
+      const globalManifestPath = path15.join(this.outDir, this.manifestFile);
       const globalSettings = {
         componentDefinitions: this.componentDefinitions,
         pages
@@ -33570,8 +35325,8 @@ function $constructor(name, initializer, params) {
     initializer(inst, def);
     const proto = _2.prototype;
     const keys = Object.keys(proto);
-    for (let i = 0;i < keys.length; i++) {
-      const k = keys[i];
+    for (let i2 = 0;i2 < keys.length; i2++) {
+      const k = keys[i2];
       if (!(k in inst)) {
         inst[k] = proto[k].bind(inst);
       }
@@ -33722,10 +35477,10 @@ function formatError(error, mapper = (issue) => issue.message) {
         fieldErrors._errors.push(mapper(issue));
       } else {
         let curr = fieldErrors;
-        let i = 0;
-        while (i < issue.path.length) {
-          const el = issue.path[i];
-          const terminal = i === issue.path.length - 1;
+        let i2 = 0;
+        while (i2 < issue.path.length) {
+          const el = issue.path[i2];
+          const terminal = i2 === issue.path.length - 1;
           if (!terminal) {
             curr[el] = curr[el] || { _errors: [] };
           } else {
@@ -33733,7 +35488,7 @@ function formatError(error, mapper = (issue) => issue.message) {
             curr[el]._errors.push(mapper(issue));
           }
           curr = curr[el];
-          i++;
+          i2++;
         }
       }
     }
@@ -33927,8 +35682,8 @@ class $ZodRegistry {
     if (p) {
       const pm = { ...this.get(p) ?? {} };
       delete pm.id;
-      const f = { ...pm, ...this._map.get(schema) };
-      return Object.keys(f).length ? f : undefined;
+      const f2 = { ...pm, ...this._map.get(schema) };
+      return Object.keys(f2).length ? f2 : undefined;
     }
     return this._map.get(schema);
   }
@@ -34072,7 +35827,7 @@ var init_field_types = __esm(() => {
 
 // ../cms/src/migrate-astro-image.ts
 import fs11 from "fs/promises";
-import path14 from "path";
+import path16 from "path";
 async function migrateAstroImages(options = {}) {
   const projectRoot = options.projectRoot ?? getProjectRoot();
   const dryRun = options.dryRun ?? false;
@@ -34080,11 +35835,11 @@ async function migrateAstroImages(options = {}) {
   const migrations = [];
   const skipped = [];
   for (const def of Object.values(collections)) {
-    const astroFields = def.fields.filter((f) => f.astroImage);
+    const astroFields = def.fields.filter((f2) => f2.astroImage);
     if (astroFields.length === 0 || !def.entries)
       continue;
     for (const entry of def.entries) {
-      const entryAbs = path14.isAbsolute(entry.sourcePath) ? entry.sourcePath : path14.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");
@@ -34099,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") {
@@ -34109,7 +35864,7 @@ async function migrateAstroImages(options = {}) {
         }
         if (!current.startsWith("/") || current.startsWith("//"))
           continue;
-        const sourceAbs = path14.join(projectRoot, "public", current.replace(/^\/+/, ""));
+        const sourceAbs = path16.join(projectRoot, "public", current.replace(/^\/+/, ""));
         let sourceBuf;
         try {
           sourceBuf = await fs11.readFile(sourceAbs);
@@ -34120,15 +35875,15 @@ async function migrateAstroImages(options = {}) {
         const target = await pickAstroImageTarget({
           entryAbsPath: entryAbs,
           slug: entry.slug,
-          originalFilename: path14.basename(current),
+          originalFilename: path16.basename(current),
           compareBuffer: sourceBuf
         });
         if (!dryRun) {
-          await fs11.mkdir(path14.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,
@@ -34138,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");
@@ -34187,7 +35942,7 @@ var exports_migrate = {};
 __export(exports_migrate, {
   migrate: () => migrate
 });
-import path15 from "path";
+import path17 from "path";
 async function migrate(args) {
   if (args.target !== "astro-image") {
     console.error(`Unknown migrate target: ${args.target}`);
@@ -34203,10 +35958,10 @@ async function migrate(args) {
   } else {
     console.log(`${result.migrations.length} field(s) to migrate:
 `);
-    for (const m of result.migrations) {
-      console.log(`  ${m.entrySourcePath}`);
-      console.log(`    ${m.fieldName}: ${m.originalValue} \u2192 ${m.newValue}`);
-      console.log(`      copy: ${path15.relative(process.cwd(), m.copiedFrom)} \u2192 ${path15.relative(process.cwd(), m.copiedTo)}`);
+    for (const m2 of result.migrations) {
+      console.log(`  ${m2.entrySourcePath}`);
+      console.log(`    ${m2.fieldName}: ${m2.originalValue} \u2192 ${m2.newValue}`);
+      console.log(`      copy: ${path17.relative(process.cwd(), m2.copiedFrom)} \u2192 ${path17.relative(process.cwd(), m2.copiedTo)}`);
     }
   }
   if (result.skipped.length > 0) {
@@ -34248,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 the content collections (no build). --json, --strict");
+  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");
@@ -34262,12 +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")
-      }));
+      const { check: check2, parseCheckArgs: parseCheckArgs2 } = await Promise.resolve().then(() => (init_check2(), exports_check));
+      process.exit(await check2(parseCheckArgs2(args, process.cwd())));
       break;
     }
     case "init": {