@lupinum/ginko 0.4.0 → 0.6.0

package/dist/shared/{ginko.CrNRBkS5.mjs → ginko.B1-DoOea.mjs}

@@ -1,33 +1,10 @@
-import { m as msg, o as labelOf, i as isTranslatable, l as effectiveAlt, A as ALT_MAX, g as effectiveMax, j as parseMarkdown, r as effectiveProfile, c as bare, J as DEFAULT_LOCALE, E as isLocale, k as sha256, v as MAX_LOCALES, D as isCurrency, n as coreMessage, x as componentProblems, K as labelProblem, L as MAX_CENTS, M as MARKDOWN_PROFILES, h as effectiveMin, I as profileCovers } from './ginko.C-QjDn3O.mjs';
-import { b as workWeekOf, w as weekInfoOf } from './ginko.CQvxhyez.mjs';
+import { m as msg, u as labelOf, i as isTranslatable, q as effectiveAlt, A as ALT_MAX, v as ALT_INVISIBLE, g as effectiveMax, x as isShown, a as parseMarkdown, y as effectiveProfile, j as bare, z as fileRefUses, D as DEFAULT_LOCALE, C as isLocale, n as sha256, M as MAX_LOCALES, E as isCurrency, F as coreMessage, G as componentProblems, H as labelProblem, I as MAX_CENTS, J as MARKDOWN_PROFILES, l as effectiveMin, K as profileCovers } from './ginko.BNVC-g9n.mjs';
+import { r as roundedMb, C as CALENDAR_NAMES, h as holidaysOf, S as STORED_HOLIDAYS, l as limitOf, f as formatMb } from './ginko.D1PeQ3ds.mjs';
+import { f as firstDayShown, w as workWeekOf, a as startOfWeek, D as DEFAULT_WEEK, e as weekInfoOf } from './ginko.C-oz8wwI.mjs';
 
 const PREFILL_TOKENS = ["@today", "@workWeek", "@nextWorkWeek"];
 const isPrefillToken = (value) => PREFILL_TOKENS.includes(value);
 
-const MB = 1024 * 1024;
-const UPLOAD_TYPES = {
-  "image/jpeg": { label: "JPEG", kind: "image", limit: 20 * MB },
-  "image/png": { label: "PNG", kind: "image", limit: 20 * MB },
-  "image/webp": { label: "WebP", kind: "image", limit: 20 * MB },
-  "image/heic": { label: "HEIC", kind: "image", limit: 20 * MB },
-  "application/pdf": { label: "PDF", kind: "file", limit: 10 * MB }
-};
-function acceptOf(kind) {
-  return typesOf(kind).join(",");
-}
-function limitOf(kind) {
-  return Math.max(...typesOf(kind).map((type) => UPLOAD_TYPES[type].limit));
-}
-function formatMb(bytes) {
-  return `${roundedMb(bytes)}`.replace(".", ",");
-}
-function roundedMb(bytes) {
-  return Math.round(bytes / MB * 10) / 10;
-}
-function typesOf(kind) {
-  return Object.keys(UPLOAD_TYPES).filter((type) => UPLOAD_TYPES[type].kind === kind);
-}
-
 function staleOf(brick, data, today, week, planned = []) {
   const weekly = weeklyTask(brick);
   if (!weekly) return void 0;
@@ -43,6 +20,18 @@ function weeklyTask(brick) {
   }
   return void 0;
 }
+function weekStartField(brick) {
+  if (brick.plans) return brick.plans.field;
+  const weekly = weeklyTask(brick);
+  if (weekly) return weekly.field;
+  for (const task of brick.tasks ?? []) {
+    if (task.kind === "remove") continue;
+    for (const [field, token] of Object.entries(task.prefill ?? {})) {
+      if ((token === "@workWeek" || token === "@nextWorkWeek") && brick.fields[field]?.type === "date") return field;
+    }
+  }
+  return void 0;
+}
 function plannedWeeks(schema, singleKey, entriesOf) {
   const weeks = [];
   for (const [key, brick] of Object.entries(schema.bricks)) {
@@ -60,6 +49,32 @@ function plansThisWeek(schema, singleKey, task, entryBrick, data, thisWeek) {
   if (single?.kind !== "single" || plan?.kind !== "collection" || plan.retired || plan.plans?.brick !== singleKey) return false;
   return weeklyTask(single)?.task.id === task.id && data[plan.plans.field] === thisWeek;
 }
+function duePlan(brick, data, today) {
+  const plan = brick.planned;
+  if (!plan) return void 0;
+  const next = data[plan.next];
+  const from = data[plan.from];
+  return next !== void 0 && next !== null && typeof from === "string" && from <= today ? next : void 0;
+}
+function createAsks(brick, key, task) {
+  const field = Object.hasOwn(brick.fields, key) ? brick.fields[key] : void 0;
+  if (task?.fields && !task.fields.includes(key)) return false;
+  return !!field && field.type !== "slug" && key !== brick.planned?.next && key !== brick.planned?.from;
+}
+function liveFrom(schema, brickKey, data, changed, today) {
+  const brick = Object.hasOwn(schema.bricks, brickKey) ? schema.bricks[brickKey] : void 0;
+  if (!brick) return void 0;
+  if (brick.kind === "collection" && brick.plans) {
+    const start = data[brick.plans.field];
+    const first = typeof start === "string" ? firstDayShown(start, schema.week) : void 0;
+    return first && first > today ? first : void 0;
+  }
+  const plan = brick.planned;
+  if (!plan || !changed.length || !changed.every((root) => root === plan.next || root === plan.from)) return void 0;
+  const from = data[plan.from];
+  const next = data[plan.next];
+  return next !== void 0 && next !== null && typeof from === "string" && from > today ? from : void 0;
+}
 
 const replacements = { \u00E4: "ae", \u00F6: "oe", \u00FC: "ue", \u00DF: "ss", \u00C4: "ae", \u00D6: "oe", \u00DC: "ue" };
 function slugify(input) {
@@ -67,6 +82,13 @@ function slugify(input) {
   return slug || "eintrag";
 }
 const SLUG_PATTERN = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+function slugBases(locales, texts) {
+  const main = locales[0];
+  return Object.fromEntries(locales.map((locale) => {
+    const own = texts[locale] ?? "";
+    return [locale, locale === main ? slugify(own) : own ? slugify(own) : void 0];
+  }));
+}
 function uniqueSlug(base, taken) {
   if (!taken(base)) return base;
   for (let n = 2; ; n++) {
@@ -75,6 +97,7 @@ function uniqueSlug(base, taken) {
   }
 }
 
+const SHAPE_CODES = /* @__PURE__ */ new Set(["TYPE", "NOT_OBJECT", "NOT_LOCALIZED", "UNKNOWN_FIELD", "UNKNOWN_LOCALE", "UNKNOWN_BRICK"]);
 const datePattern = /^\d{4}-\d{2}-\d{2}$/;
 const timePattern = /^([01]\d|2[0-3]):[0-5]\d$/;
 const rowIdPattern = /^[A-Za-z0-9_-]{10}$/;
@@ -83,11 +106,18 @@ async function validate(schema, brickKey, data, opts) {
   if (!brick) return { errors: [issue("", "UNKNOWN_BRICK", "unknownBrick", { brick: brickKey })], warnings: [] };
   const texts = [];
   const issues = checkFields(brick.fields, data, "", { locales: schema.locales, main: schema.locales[0], texts, refs: opts.refs, fileAlt: opts.fileAlt });
-  for (const { field, text, path } of texts) {
-    const { problemMessages: problems } = await parseMarkdown(text, { profile: effectiveProfile(field), components: schema.components });
-    for (const problem of problems) issues.push(issue(path, "MARKDOWN", "markdown", { label: shown(field, schema.locales[0]), problem: bare(problem) }));
-  }
-  if (opts.mode !== "patch") return { errors: issues, warnings: [] };
+  for (const { field, text, path, locale } of texts) {
+    const { problemMessages: problems, value } = await parseMarkdown(text, { profile: effectiveProfile(field), components: schema.components });
+    const label = shown(field, schema.locales[0]);
+    for (const problem of problems) {
+      issues.push(problem.line === void 0 ? issue(path, "MARKDOWN", "markdown", { label, problem: bare(problem) }) : issue(path, "MARKDOWN", "markdownAt", { label, line: problem.line, problem: bare(problem) }));
+    }
+    if (opts.uploads) issues.push(...fileRefIssues(value.nodes, path, label, locale, schema, opts.uploads, opts.fileAlt));
+  }
+  const rules = ruleIssues(schema, brick, data);
+  if (opts.mode === "restore") return { errors: issues.filter((i) => SHAPE_CODES.has(i.code)), warnings: [...issues.filter((i) => !SHAPE_CODES.has(i.code)), ...rules.map((r) => r.issue)] };
+  if (opts.mode === "release") return { errors: issues, warnings: rules.map((r) => r.issue) };
+  if (opts.mode === "create") return { errors: [...issues, ...rules.map((r) => r.issue)], warnings: [] };
   const changed = opts.changed ?? /* @__PURE__ */ new Set();
   const errors = [];
   const warnings = [];
@@ -96,10 +126,59 @@ async function validate(schema, brickKey, data, opts) {
     if (related || issue2.code === "UNKNOWN_FIELD") errors.push(issue2);
     else warnings.push(issue2);
   }
+  for (const { issue: issue2, touches } of rules) {
+    if (touches.some((field) => [...changed].some((c) => c === field || c.startsWith(`${field}.`)))) errors.push(issue2);
+    else warnings.push(issue2);
+  }
   return { errors, warnings };
 }
+function ruleIssues(schema, brick, data) {
+  if (!isRecord$1(data)) return [];
+  const out = [];
+  const main = schema.locales[0];
+  const plan = brick.planned;
+  if (plan) {
+    const set = (key) => data[key] !== void 0 && data[key] !== null;
+    const missing = set(plan.next) && !set(plan.from) ? plan.from : set(plan.from) && !set(plan.next) ? plan.next : void 0;
+    const field = missing && Object.hasOwn(brick.fields, missing) ? brick.fields[missing] : void 0;
+    if (missing && field) out.push({ issue: issue(missing, "REQUIRED", "fieldMissing", { label: shown(field, main) }), touches: [plan.next, plan.from] });
+  }
+  for (const [name, field] of Object.entries(brick.fields)) {
+    if (field.type !== "time" || !field.after) continue;
+    const [start2, end] = [data[field.after], data[name]];
+    if (typeof start2 === "string" && typeof end === "string" && timePattern.test(start2) && timePattern.test(end) && end <= start2) {
+      out.push({ issue: issue(name, "TIME_ORDER", "timeOrder", { start: shown(brick.fields[field.after], main), end: shown(field, main) }), touches: [field.after, name] });
+    }
+  }
+  const week = weekStartField(brick);
+  const start = week ? data[week] : void 0;
+  if (week && isDate(start) && startOfWeek(start, schema.week ?? DEFAULT_WEEK) !== start) {
+    out.push({ issue: issue(week, "NOT_WEEK_START", "notWeekStart", { label: shown(brick.fields[week], main) }), touches: [week] });
+  }
+  return out;
+}
+function fileRefIssues(nodes, path, label, locale, schema, uploads, fileAlt) {
+  const out = [];
+  const refs = fileRefUses(nodes, schema.components);
+  if (refs.some((ref) => !uploads(ref.id))) out.push(issue(path, "FILE_REF_MISSING", "fileRefMissing", { label }));
+  if (refs.some((ref) => ref.kind !== "link" && uploads(ref.id) === "file")) out.push(issue(path, "FILE_REF_NOT_IMAGE", "fileRefPdf", { label }));
+  const library = new Map(refs.filter((ref) => ref.kind === "img").map((ref) => [ref.node, fileAlt?.(ref.id)]));
+  let described = true;
+  eachNode(nodes, (node) => {
+    if (node[0] === "img" && !effectiveAlt({ [locale]: node[1].alt }, library.get(node), locale)) described = false;
+  });
+  if (!described) out.push(issue(path, "ALT_REQUIRED", "markdownImageAltMissing", { label }));
+  return out;
+}
+function eachNode(nodes, fn) {
+  for (const node of nodes) {
+    if (!Array.isArray(node) || typeof node[0] !== "string" || !isRecord$1(node[1])) continue;
+    fn(node);
+    eachNode(node.slice(2), fn);
+  }
+}
 function checkFields(fields, data, path, ctx) {
-  if (!isRecord$2(data)) return [issue(path, "NOT_OBJECT", "notObject")];
+  if (!isRecord$1(data)) return [issue(path, "NOT_OBJECT", "notObject")];
   const issues = [];
   for (const key of Object.keys(data)) {
     if (key === "_id" && path) continue;
@@ -110,7 +189,7 @@ function checkFields(fields, data, path, ctx) {
     const at = join(path, key);
     const value = data[key];
     if (value === void 0 || value === null) {
-      if (!field.optional) issues.push(issue(at, "REQUIRED", "fieldMissing", { label: shown(field, ctx.main) }));
+      if (!field.optional && isShown(field, data)) issues.push(issue(at, "REQUIRED", "fieldMissing", { label: shown(field, ctx.main) }));
       continue;
     }
     issues.push(...checkField$1(field, value, at, ctx));
@@ -119,7 +198,7 @@ function checkFields(fields, data, path, ctx) {
 }
 function checkField$1(field, value, path, ctx) {
   if (isTranslatable(field)) {
-    if (!isRecord$2(value)) return [issue(path, "NOT_LOCALIZED", "notLocalized", { label: shown(field, ctx.main) })];
+    if (!isRecord$1(value)) return [issue(path, "NOT_LOCALIZED", "notLocalized", { label: shown(field, ctx.main) })];
     const out = [];
     for (const locale of Object.keys(value)) {
       if (!ctx.locales.includes(locale)) out.push(issue(join(path, locale), "UNKNOWN_LOCALE", "unknownLocale", { locale }));
@@ -131,14 +210,15 @@ function checkField$1(field, value, path, ctx) {
     for (const locale of ctx.locales) {
       const v = value[locale];
       if (v === void 0 || v === null || v === "") continue;
-      out.push(...checkScalar(field, v, join(path, locale), locale === ctx.main, ctx));
+      out.push(...checkScalar(field, v, join(path, locale), locale, ctx));
     }
     return out;
   }
-  return checkScalar(field, value, path, true, ctx);
+  return checkScalar(field, value, path, void 0, ctx);
 }
 const CONTROL = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/;
-function checkScalar(field, value, path, isMain, ctx) {
+function checkScalar(field, value, path, locale, ctx) {
+  const isMain = locale === void 0 || locale === ctx?.main;
   const label = shown(field, ctx?.main);
   const fail = (code, key, params) => [issue(path, code, key, { label, ...params })];
   switch (field.type) {
@@ -150,7 +230,7 @@ function checkScalar(field, value, path, isMain, ctx) {
       if (!field.optional && isMain && value.trim() === "") return fail("REQUIRED", "fieldEmpty");
       if (value.length > max) return fail("TOO_LONG", "tooLong", { max });
       if (CONTROL.test(value)) return fail("FORMAT", "controlChars");
-      if (field.type === "markdown") ctx?.texts?.push({ field, text: value, path });
+      if (field.type === "markdown") ctx?.texts?.push({ field, text: value, path, locale: locale ?? ctx.main });
       if (field.type === "text" && field.format && value !== "") {
         const ok = field.format === "url" ? /^https?:\/\/[^\s]+$/i.test(value) : field.format === "email" ? /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value) : /^\+?[0-9 ()/-]{5,30}$/.test(value) && (value.match(/[0-9]/g)?.length ?? 0) >= 5;
         if (!ok) return fail("FORMAT", "badFormat");
@@ -166,7 +246,7 @@ function checkScalar(field, value, path, isMain, ctx) {
       if (Math.abs(Math.round((value - field.min) / field.step) * field.step - (value - field.min)) > 1e-9) return fail("STEP", "badStep", { step: field.step });
       return [];
     case "money": {
-      if (!isRecord$2(value) || !Number.isSafeInteger(value.amount) || Object.keys(value).some((k) => k !== "amount")) return fail("TYPE", "notMoney");
+      if (!isRecord$1(value) || !Number.isSafeInteger(value.amount) || Object.keys(value).some((k) => k !== "amount")) return fail("TYPE", "notMoney");
       const cents = value.amount;
       if (cents < (field.min ?? 0) || cents > effectiveMax(field)) return fail("RANGE", "moneyOutOfRange");
       return [];
@@ -178,7 +258,7 @@ function checkScalar(field, value, path, isMain, ctx) {
     case "time":
       return typeof value === "string" && timePattern.test(value) ? [] : fail("TIME", "badTime");
     case "daterange":
-      if (!isRecord$2(value) || !isDate(value.from) || !isDate(value.to) || Object.keys(value).length !== 2) return fail("DATE", "badDateRange");
+      if (!isRecord$1(value) || !isDate(value.from) || !isDate(value.to) || Object.keys(value).length !== 2) return fail("DATE", "badDateRange");
       return value.from <= value.to ? [] : fail("DATE_ORDER", "dateRangeOrder");
     case "choice":
       return typeof value === "string" && field.options.some((o) => o.value === value) ? [] : fail("CHOICE", "badChoice");
@@ -205,7 +285,7 @@ function checkScalar(field, value, path, isMain, ctx) {
         const key = field.unique;
         const seen = /* @__PURE__ */ new Set();
         for (const row of value) {
-          const v = isRecord$2(row) ? row[key] : void 0;
+          const v = isRecord$1(row) ? row[key] : void 0;
           if (typeof v !== "string") continue;
           if (seen.has(v)) {
             out.push(issue(path, "DUPLICATE", "duplicateRowValue", { label, value: v }));
@@ -216,7 +296,7 @@ function checkScalar(field, value, path, isMain, ctx) {
       }
       const ids = /* @__PURE__ */ new Set();
       value.forEach((row, index) => {
-        const id = isRecord$2(row) && typeof row._id === "string" ? row._id : void 0;
+        const id = isRecord$1(row) && typeof row._id === "string" ? row._id : void 0;
         if (!id || !rowIdPattern.test(id)) {
           out.push(issue(join(path, String(index)), "ROW_ID", "badRowId", { label, row: index + 1 }));
           return;
@@ -231,12 +311,12 @@ function checkScalar(field, value, path, isMain, ctx) {
       return out;
     }
     case "image":
-      if (!isRecord$2(value) || typeof value.file !== "string" || !isRecord$2(value.alt) || Object.keys(value).some((k) => k !== "file" && k !== "alt")) return fail("TYPE", "notImage");
+      if (!isRecord$1(value) || typeof value.file !== "string" || !isRecord$1(value.alt) || Object.keys(value).some((k) => k !== "file" && k !== "alt")) return fail("TYPE", "notImage");
       for (const l of Object.keys(value.alt)) if (!ctx.locales.includes(l)) return [issue(join(path, `alt.${l}`), "UNKNOWN_LOCALE", "unknownLocale", { locale: l })];
       if (effectiveAlt(value.alt, ctx.fileAlt?.(value.file), ctx.main) === "") return [issue(join(path, "alt"), "ALT_REQUIRED", "altMissing", { label })];
-      return Object.entries(value.alt).filter(([, a]) => typeof a !== "string" || a.length > ALT_MAX).map(([l]) => issue(join(path, `alt.${l}`), "TOO_LONG", "altTooLong", { label }));
+      return Object.entries(value.alt).flatMap(([l, a]) => typeof a !== "string" || a.length > ALT_MAX ? [issue(join(path, `alt.${l}`), "TOO_LONG", "altTooLong", { label })] : ALT_INVISIBLE.test(a) ? [issue(join(path, `alt.${l}`), "FORMAT", "controlChars", { label })] : []);
     case "file":
-      return isRecord$2(value) && typeof value.file === "string" && Object.keys(value).length === 1 ? [] : fail("TYPE", "notFile");
+      return isRecord$1(value) && typeof value.file === "string" && Object.keys(value).length === 1 ? [] : fail("TYPE", "notFile");
   }
 }
 function checkValue(schema, field, value, path) {
@@ -259,7 +339,7 @@ function fileProblem(field, file) {
   return void 0;
 }
 const shown = (field, main) => labelOf(field.label, DEFAULT_LOCALE, main ?? DEFAULT_LOCALE);
-function isRecord$2(v) {
+function isRecord$1(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function join(path, key) {
@@ -271,12 +351,12 @@ function issue(path, code, key, params) {
 }
 
 const RESERVED_KEYS = /* @__PURE__ */ new Set([...Object.getOwnPropertyNames(Object.prototype), "prototype"]);
+const LINK_HEADS = /* @__PURE__ */ new Set(["page", "file"]);
 const UNSAFE_PATH = /\.\.|\/\/|[?#]/;
-const SCHEMA_KEYS = /* @__PURE__ */ new Set(["site", "name", "url", "timeZone", "locales", "currency", "week", "pages", "bricks", "migrations", "retired", "components", "agents"]);
+const SCHEMA_KEYS = /* @__PURE__ */ new Set(["site", "name", "url", "timeZone", "locales", "currency", "week", "holidays", "pages", "bricks", "migrations", "retired", "components", "agents"]);
 const COMPONENT_KEYS = /* @__PURE__ */ new Set(["kind", "label", "describe", "props", "slots", "children", "parents", "editor"]);
-const BRICK_KEYS = /* @__PURE__ */ new Set(["pos", "kind", "source", "label", "describe", "fields", "layout", "tasks", "max", "order", "route", "visible", "untranslated", "plans", "drafts", "retired"]);
-const FIELD_KEYS = /* @__PURE__ */ new Set(["pos", "type", "label", "hint", "unit", "optional", "default", "translate", "retired", "max", "min", "step", "format", "currency", "from", "accept", "maxBytes", "options", "of", "itemLabel", "unique", "profile", "to", "multiple", "showWhen", "group"]);
-const SITE_BUDGET = { siteBytes: 4 * 1024 * 1024, entries: 2e3, entryBytes: 256 * 1024 };
+const BRICK_KEYS = /* @__PURE__ */ new Set(["pos", "kind", "source", "label", "describe", "fields", "layout", "tasks", "max", "order", "route", "visible", "untranslated", "plans", "planned", "drafts", "status", "retired"]);
+const FIELD_KEYS = /* @__PURE__ */ new Set(["pos", "type", "label", "hint", "unit", "optional", "default", "translate", "retired", "max", "min", "step", "format", "currency", "from", "accept", "maxBytes", "options", "of", "itemLabel", "unique", "profile", "to", "multiple", "showWhen", "askAgainWhen", "group", "after"]);
 const SCHEMA_LIMITS = { bytes: 256 * 1024, bricks: 30, fieldsPerBrick: 60 };
 function serializeSchema(site) {
   const retired = site.retired ?? {};
@@ -299,6 +379,8 @@ function serializeSchema(site) {
     currency: site.currency,
     // Computed once here; the server, the Studio and the site all read `schema.week`.
     week: weekInfoOf(site.languages?.[site.locales[0]] ?? site.locales[0], site.firstDayOfWeek),
+    // Like `week`: resolved once, so the server and the Studio never run the site's code to know its holidays.
+    ...withHolidays(site),
     pages: Object.fromEntries(Object.entries(site.pages).map(([key, page]) => [key, typeof page === "string" ? { [site.locales[0]]: page } : page])),
     bricks,
     migrations,
@@ -307,6 +389,10 @@ function serializeSchema(site) {
     ...site.agents?.review !== void 0 ? { agents: { review: site.agents.review } } : {}
   }, [], []);
 }
+function withHolidays(site) {
+  const holidays = holidaysOf(site);
+  return holidays === void 0 ? {} : { holidays };
+}
 function storedField(field, locales) {
   return Object.fromEntries(Object.entries(field).flatMap(([key, value]) => {
     if (key === "of" && field.type === "list") return [[key, Object.fromEntries(Object.entries(field.of).map(([name, column]) => [name, storedField(column, locales)]))]];
@@ -334,14 +420,14 @@ function storedPrefill(prefill, fields, locales) {
 function storedValue(field, value, locales) {
   if (isTranslatable(field)) {
     if (typeof value === "string") return { [locales[0]]: value };
-    if (!isRecord$1(value) || Object.values(value).some((text) => typeof text !== "string")) return value;
+    if (!isRecord(value) || Object.values(value).some((text) => typeof text !== "string")) return value;
     const kept = Object.fromEntries(Object.entries(value).filter(([locale]) => locales.includes(locale)));
     return Object.hasOwn(kept, locales[0]) ? kept : void 0;
   }
   if (field.type !== "list" || !Array.isArray(value)) return value;
   const rows = [];
   for (const row of value) {
-    if (!isRecord$1(row)) {
+    if (!isRecord(row)) {
       rows.push(row);
       continue;
     }
@@ -356,7 +442,7 @@ function storedValue(field, value, locales) {
   }
   return rows;
 }
-const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const LOST = "$lost";
 function plain(value, path, ancestors) {
   switch (typeof value) {
@@ -405,6 +491,10 @@ function platformSchema(schema) {
 function ordered(record) {
   return Object.entries(record).sort(([a, x], [b, y]) => (x.pos ?? Number.MAX_SAFE_INTEGER) - (y.pos ?? Number.MAX_SAFE_INTEGER) || a.localeCompare(b));
 }
+function grantGroups(schema, grants) {
+  const held = new Set(grants);
+  return ordered(schema.bricks).filter(([, brick]) => !brick.retired).map(([key, brick]) => ({ brick: key, label: brick.label, tasks: (brick.tasks ?? []).filter((task) => held.has(`${key}.${task.id}`)).map((task) => task.label) })).filter((group) => group.tasks.length > 0);
+}
 function migrationFingerprint(brick, fills, compute) {
   return sha256(`${brick}
 ${fills}
@@ -430,7 +520,9 @@ const SITE_KEYS = {
   agents: true,
   components: true,
   migrations: true,
-  retired: true
+  retired: true,
+  country: true,
+  calendar: true
 };
 function checkSite(site, schema = serializeSchema(site)) {
   const problems = Object.keys(site).filter((key) => !Object.hasOwn(SITE_KEYS, key)).map((key) => `Unknown key \u201C${key}\u201D. Known keys: ${Object.keys(SITE_KEYS).join(", ")}.`);
@@ -438,6 +530,10 @@ function checkSite(site, schema = serializeSchema(site)) {
     if (!site.locales.includes(locale)) problems.push(`languages: locale \u201C${locale}\u201D is not in locales.`);
     if (!isLocale(language)) problems.push(`languages.${locale}: invalid language \u201C${String(language)}\u201D (expected a canonical language tag such as \u201Cde-AT\u201D or \u201Cen-US\u201D).`);
   }
+  if (site.country !== void 0 && !/^[A-Z]{2}$/.test(String(site.country))) problems.push(`country: invalid country \u201C${String(site.country)}\u201D (expected an ISO 3166-1 code such as \u201CAT\u201D or \u201CDE\u201D).`);
+  if (site.calendar !== void 0 && typeof site.calendar !== "function" && !CALENDAR_NAMES.includes(site.calendar)) {
+    problems.push(`calendar: unknown calendar \u201C${String(site.calendar)}\u201D (expected AT, DE, SG, none or a function (year) => holidays).`);
+  }
   const color = site.seo?.color;
   if (color !== void 0 && !/^#(?:[\da-f]{3}|[\da-f]{6})$/i.test(color)) problems.push(`seo.color: invalid colour \u201C${String(color)}\u201D (expected \u201C#rrggbb\u201D or \u201C#rgb\u201D).`);
   return [...problems, ...checkSchema(schema)];
@@ -471,6 +567,7 @@ function schemaProblems(schema) {
   if (!isSiteUrl(schema.url)) problems.push(`Invalid site url \u201C${String(schema.url)}\u201D (expected an absolute http(s) address such as \u201Chttps://linde.example\u201D).`);
   if (!isTimeZone(schema.timeZone)) problems.push(`Invalid time zone \u201C${String(schema.timeZone)}\u201D (expected for example \u201CEurope/Vienna\u201D).`);
   if (!isWeek(schema.week)) problems.push("week must be { firstDay: 1 to 7, weekend: [days 1 to 7] } (1 = Monday, 7 = Sunday).");
+  if (schema.holidays !== void 0 && !STORED_HOLIDAYS.includes(schema.holidays)) problems.push(`holidays must be one of ${STORED_HOLIDAYS.join(", ")}.`);
   if (!isCurrency(schema.currency)) problems.push(`Invalid currency \u201C${String(schema.currency)}\u201D (expected an ISO 4217 code such as \u201CEUR\u201D or \u201CJPY\u201D).`);
   const pageOwner = /* @__PURE__ */ new Map();
   for (const [key, paths] of Object.entries(schema.pages)) {
@@ -496,6 +593,7 @@ function schemaProblems(schema) {
   const routes = /* @__PURE__ */ new Map();
   for (const [key, brick] of Object.entries(schema.bricks)) {
     if (!/^[a-z][a-zA-Z0-9]{0,40}$/.test(key) || RESERVED_KEYS.has(key)) problems.push(`Invalid brick name \u201C${key}\u201D.`);
+    else if (LINK_HEADS.has(key)) problems.push(`The brick name \u201C${key}\u201D is reserved: \`$${key}.\u2026\` in a Markdown text means ${key === "page" ? "a page" : "a file of the Files library"}.`);
     unknown(key, brick, BRICK_KEYS);
     pushLabel(`${key}.label`, brick.label);
     if (brick.describe !== void 0) pushLabel(`${key}.describe`, brick.describe);
@@ -521,8 +619,11 @@ function schemaProblems(schema) {
         else if (!token) for (const p of checkValue(schema, field, value, path)) problems.push(`${p.path}: ${coreMessage("en", p.key, p.params)}`);
         else if (field.type !== "date") problems.push(`${path}: \u201C${value}\u201D needs a date field.`);
       }
+      if (task.kind === "create" && task.fields !== void 0) problems.push(...createFieldsProblems(`${key}.${task.id}.fields`, task, brick));
       if (task.needsApproval !== void 0 && typeof task.needsApproval !== "boolean") problems.push(`${key}.${task.id}: needsApproval must be true or false.`);
     }
+    if (brick.planned !== void 0) problems.push(...plannedProblems(key, brick));
+    if (brick.status !== void 0) problems.push(...statusProblems(key, brick, schema));
     if (brick.kind === "single" && "drafts" in brick) problems.push(`${key}: drafts are only allowed for collections.`);
     if (brick.kind === "single" && "plans" in brick) problems.push(`${key}: plans are only allowed for collections.`);
     if (brick.kind === "collection") {
@@ -634,6 +735,25 @@ function isWeek(week) {
   const { firstDay, weekend } = week;
   return isIsoDay(firstDay) && Array.isArray(weekend) && weekend.length <= 6 && weekend.every(isIsoDay);
 }
+function createFieldsProblems(path, task, brick) {
+  if (!Array.isArray(task.fields)) return [`${path}: must be a list of field names.`];
+  const fields = brick.fields;
+  const listed = task.fields;
+  const problems = [];
+  for (const name of listed) {
+    const field = Object.hasOwn(fields, name) ? fields[name] : void 0;
+    if (!field) problems.push(`${path}: \u201C${name}\u201D is not a field of this brick.`);
+    else if (field.type === "slug") problems.push(`${path}: \u201C${name}\u201D is the address and is made from \u201C${field.from}\u201D, so the task cannot ask for it.`);
+    else if (brick.planned && (name === brick.planned.next || name === brick.planned.from)) problems.push(`${path}: \u201C${name}\u201D is the plan of a planned change, so the task cannot ask for it.`);
+    else if (field.retired) problems.push(`${path}: \u201C${name}\u201D is retired, so the task cannot ask for it.`);
+  }
+  const prefilled = Object.keys(task.prefill ?? {});
+  for (const [name, field] of Object.entries(fields)) {
+    if (field.optional || field.default !== void 0 || field.type === "slug" || field.retired) continue;
+    if (!listed.includes(name) && !prefilled.includes(name)) problems.push(`${path}: \u201C${name}\u201D is required and has no default, so the task must ask for it.`);
+  }
+  return problems;
+}
 function plansProblems(key, plans, fields, schema) {
   if (typeof plans !== "object" || plans === null || Array.isArray(plans)) return [`${key}: plans must be an object with brick and field.`];
   const { brick, field } = plans;
@@ -650,6 +770,74 @@ function plansProblems(key, plans, fields, schema) {
   }
   return problems;
 }
+const HOURS_FIELDS = { week: "list", exceptions: "list", closedOn: "date", holidays: "choice" };
+const HOUR_PLAN_FIELDS = { week: "list", from: "date", yearly: "boolean" };
+function isHourPlans(brick) {
+  return brick.kind === "collection" && !brick.retired && Object.entries(HOUR_PLAN_FIELDS).every(([name, type]) => Object.hasOwn(brick.fields, name) && !brick.fields[name].retired && brick.fields[name].type === type);
+}
+function statusProblems(key, brick, schema) {
+  const status = brick.status;
+  const kinds = brick.kind === "collection" ? ["next", "count", "missing", "age"] : ["hours"];
+  const shape = brick.kind === "collection" ? "{ next }, { count: true }, { missing } or { age }" : "{ hours: true } or { hours: { plans } }";
+  if (typeof status !== "object" || status === null || Array.isArray(status)) return [`${key}: status must be ${shape}.`];
+  const entries = Object.entries(status);
+  if (entries.length !== 1 || !kinds.includes(entries[0][0])) return [`${key}: status must be ${shape}.`];
+  const [kind, value] = entries[0];
+  if (kind === "count") {
+    if (value !== true) return [`${key}: status.count must be true.`];
+    const vis = brick.visible;
+    return vis?.mode === "until" ? [] : [`${key}: status { count: true } needs visible: { mode: 'until' }.`];
+  }
+  if (kind === "hours") {
+    const problems = [];
+    if (value !== true) {
+      const plans = typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length === 1 ? value.plans : void 0;
+      if (typeof plans !== "string") return [`${key}: status.hours must be true or { plans: '<key of the hour plans>' }.`];
+      const target = Object.hasOwn(schema.bricks, plans) ? schema.bricks[plans] : void 0;
+      if (!target || target.retired) problems.push(`${key}: status.hours.plans names \u201C${plans}\u201D, which is not a live brick of the site.`);
+      else if (!isHourPlans(target)) problems.push(`${key}: status.hours.plans names \u201C${plans}\u201D, which is not a collection of hour plans (hourPlans(): a list \u201Cweek\u201D, a date \u201Cfrom\u201D and a switch \u201Cyearly\u201D).`);
+    }
+    for (const [name, type] of Object.entries(HOURS_FIELDS)) {
+      const field2 = Object.hasOwn(brick.fields, name) ? brick.fields[name] : void 0;
+      if (!field2 || field2.retired) problems.push(`${key}: status { hours } needs the live field \u201C${name}\u201D.`);
+      else if (field2.type !== type) problems.push(`${key}: status { hours } needs \u201C${name}\u201D to be a ${type} field.`);
+    }
+    return problems;
+  }
+  const field = typeof value === "string" && Object.hasOwn(brick.fields, value) ? brick.fields[value] : void 0;
+  if (!field) return [`${key}: status.${kind} names \u201C${String(value)}\u201D, which is not a field of the brick.`];
+  if (field.retired) return [`${key}: status.${kind} names the retired field \u201C${value}\u201D; remove the status or name another field.`];
+  if (kind === "missing") return field.optional && field.default === void 0 ? [] : [`${key}: status.missing needs an optional field without a default, \u201C${value}\u201D is not.`];
+  return field.type === "date" || field.type === "daterange" ? [] : [`${key}: status.${kind} needs a date or daterange field, \u201C${value}\u201D is a ${field.type} field.`];
+}
+function plannedProblems(key, brick) {
+  const planned = brick.planned;
+  if (typeof planned !== "object" || planned === null || Array.isArray(planned)) return [`${key}: planned must be an object with field, next and from.`];
+  const p = planned;
+  const problems = [];
+  for (const k of Object.keys(p)) if (!["field", "next", "from"].includes(k)) problems.push(`${key}.planned: unknown property \u201C${k}\u201D.`);
+  const named = (role) => {
+    const name = p[role];
+    const field2 = typeof name === "string" && Object.hasOwn(brick.fields, name) ? brick.fields[name] : void 0;
+    if (!field2 || field2.retired) problems.push(`${key}: planned.${role} names \u201C${String(name)}\u201D, which is not a field of the brick.`);
+    return field2;
+  };
+  const field = named("field");
+  const next = named("next");
+  const from = named("from");
+  if (!field || !next || !from) return problems;
+  const [f, n, d] = [p.field, p.next, p.from];
+  if ((/* @__PURE__ */ new Set([f, n, d])).size < 3) problems.push(`${key}: planned needs three different fields.`);
+  if (next.type !== field.type) problems.push(`${key}: planned.next \u201C${n}\u201D needs the type of \u201C${f}\u201D (${field.type}).`);
+  if (from.type !== "date") problems.push(`${key}: planned.from \u201C${d}\u201D must be a date field.`);
+  if (!next.optional || !from.optional) problems.push(`${key}: planned.next \u201C${n}\u201D and planned.from \u201C${d}\u201D must be optional.`);
+  for (const task of brick.tasks ?? []) {
+    if (task.kind === "edit" && task.fields.includes(f) && !(task.fields.includes(n) && task.fields.includes(d))) {
+      problems.push(`${key}.${task.id}: the task changes \u201C${f}\u201D, so it must also show its plan \u201C${n}\u201D and \u201C${d}\u201D.`);
+    }
+  }
+  return problems;
+}
 function mirrorProblem(target, source, siteCurrency) {
   if (source.type !== target.type) return `type ${source.type} instead of ${target.type}`;
   if (isTranslatable(source) !== isTranslatable(target)) return "different translatability";
@@ -734,6 +922,11 @@ function checkField(path, field, siblings, topLevel, schema) {
     if (keys !== "field,is" && keys !== "field,not") problems.push(`${path}.showWhen: needs \`field\` and one of \`is\` or \`not\`.`);
     else if (typeof when.field !== "string" || !Object.hasOwn(siblings, when.field) || when.field === path.split(".").pop()) problems.push(`${path}.showWhen: \u201C${String(when.field)}\u201D is not another field next to this one.`);
   }
+  if (field.type === "choices" && field.askAgainWhen !== void 0) {
+    const target = field.askAgainWhen;
+    const sibling = typeof target === "string" && Object.hasOwn(siblings, target) ? siblings[target] : void 0;
+    if (target === path.split(".").pop() || sibling?.type !== "text" && sibling?.type !== "longtext") problems.push(`${path}.askAgainWhen: must name a text field next to it.`);
+  }
   let numbersOk = true;
   for (const key of NUMBER_OPTIONS) {
     const value = field[key];
@@ -808,6 +1001,11 @@ function checkField(path, field, siblings, topLevel, schema) {
     case "file":
       if (!(field.maxBytes > 0 && field.maxBytes <= limitOf("file"))) problems.push(`${path}: maxBytes at most ${formatMb(limitOf("file"))} MB.`);
       break;
+    case "time":
+      if (field.after !== void 0 && (!topLevel || siblings[field.after]?.type !== "time" || field.after === path.split(".").pop())) {
+        problems.push(`${path}.after: \u201C${String(field.after)}\u201D is not another time field of the brick.`);
+      }
+      break;
     case "slug": {
       const source = siblings[field.from];
       if (!source || !["text", "longtext"].includes(source.type)) problems.push(`${path}: from must be a text field.`);
@@ -818,258 +1016,4 @@ function checkField(path, field, siblings, topLevel, schema) {
   return problems;
 }
 
-function trimSlash(path) {
-  return path.length > 1 ? path.replace(/\/+$/, "") : path;
-}
-function escapeRegex(text) {
-  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function compile(rule) {
-  const wildcard = rule.from.endsWith("*");
-  const base = trimSlash(wildcard ? rule.from.slice(0, -1).replace(/\/$/, "") : rule.from);
-  const params = [];
-  const source = base.split("/").map((segment) => {
-    const param = /^:([A-Za-z_]\w*)$/.exec(segment);
-    if (!param) return escapeRegex(segment);
-    params.push(param[1]);
-    return "([^/]+)";
-  }).join("/");
-  const tail = wildcard ? "(?:/(.*))?" : "";
-  return { rule, pattern: new RegExp(`^${source}${tail}$`), params, wildcard };
-}
-const compiledRules = /* @__PURE__ */ new WeakMap();
-const entryRules = /* @__PURE__ */ new WeakMap();
-function compiledFor(rules) {
-  let compiled = compiledRules.get(rules);
-  if (!compiled) compiledRules.set(rules, compiled = rules.map(compile));
-  return compiled;
-}
-function matchRedirect(rules, path) {
-  const queryStart = path.indexOf("?");
-  const pathPart = trimSlash(queryStart === -1 ? path : path.slice(0, queryStart));
-  const query = queryStart === -1 ? "" : path.slice(queryStart + 1);
-  for (const compiled of compiledFor(rules)) {
-    const match = compiled.pattern.exec(pathPart);
-    if (!match) continue;
-    const values = {};
-    compiled.params.forEach((name, index) => {
-      values[name] = match[index + 1] ?? "";
-    });
-    values.splat = compiled.wildcard ? match[match.length - 1] ?? "" : "";
-    let to = compiled.rule.to.replace(/:([A-Za-z_]\w*)/g, (token, name) => values[name] ?? token);
-    if (/^[/\\]/.test(to)) to = "/" + to.replace(/^[/\\]+/, "");
-    if (query) to += (to.includes("?") ? "&" : "?") + query;
-    return { to, status: compiled.rule.status ?? 301 };
-  }
-  return void 0;
-}
-function findRedirect(rules, bundle, path) {
-  if (!bundle) return matchRedirect(rules, path);
-  let fromEntries = entryRules.get(bundle);
-  if (!fromEntries) entryRules.set(bundle, fromEntries = entryRedirects(bundle));
-  return matchRedirect(rules, path) ?? matchRedirect(fromEntries, path);
-}
-function entryRedirects(bundle) {
-  const rules = [];
-  for (const brick of Object.values(bundle.bricks)) {
-    if (brick.kind !== "collection") continue;
-    for (const item of brick.items) {
-      const value = item.data.redirectFrom;
-      const oldPaths = Array.isArray(value) ? value.filter((path) => typeof path === "string") : typeof value === "string" ? [value] : [];
-      const url = item.urls?.[bundle.locale];
-      if (!url) continue;
-      for (const from of oldPaths) rules.push({ from, to: url, status: 301 });
-    }
-  }
-  return rules;
-}
-function redirectProblems(rules) {
-  const problems = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const { from, to } of rules) {
-    if (!from.startsWith("/")) problems.push(`"${from}": path must start with "/".`);
-    if (trimSlash(from) === trimSlash(to)) problems.push(`"${from}": redirect points to itself.`);
-    if (/^[/\\]?:/.test(to)) problems.push(`"${from}": "to" starts with a parameter (${to}). Start it with a fixed path such as "/new/:splat" so a visitor cannot choose the target host.`);
-    if (seen.has(from)) problems.push(`"${from}": defined more than once.`);
-    seen.add(from);
-  }
-  return problems;
-}
-
-const isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
-const isTree = (v) => isRecord(v) && Array.isArray(v.nodes);
-const isNode = (n) => Array.isArray(n) && typeof n[0] === "string" && isRecord(n[1]);
-function mapTrees(bundle, fn) {
-  const walk = (value, at, field) => {
-    if (isTree(value)) return fn(value, { ...at, field });
-    if (Array.isArray(value)) return value.map((v, i) => walk(v, at, `${field}.${i}`));
-    if (isRecord(value)) return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, walk(v, at, field ? `${field}.${k}` : k)]));
-    return value;
-  };
-  const data = (d, brick, id) => walk(d, { brick, id }, "");
-  const bricks = Object.fromEntries(Object.entries(bundle.bricks).map(([key, b]) => [key, b.kind === "single" ? { ...b, data: data(b.data, key, key) } : { ...b, items: b.items.map((item) => ({ ...item, data: data(item.data, key, item.id) })) }]));
-  return { ...bundle, bricks };
-}
-function find(bundle, brick, ref) {
-  const b = Object.hasOwn(bundle.bricks, brick) ? bundle.bricks[brick] : void 0;
-  if (b?.kind !== "collection") return void 0;
-  return b.items.find((i) => i.id === `${brick}/${ref}` || i.id === ref || i.data.slug === ref);
-}
-function routeTarget(bundle, schema, ref) {
-  const dot = ref.indexOf(".");
-  if (dot < 1) return void 0;
-  const head = ref.slice(0, dot);
-  const rest = ref.slice(dot + 1);
-  if (head === "page") return Object.hasOwn(schema.pages, rest) ? schema.pages[rest][bundle.locale] : void 0;
-  return find(bundle, head, rest)?.urls?.[bundle.locale];
-}
-function resolveRouteLinks(bundle, schema) {
-  const hasSnippets = Object.hasOwn(schema.bricks, "snippets") && schema.bricks.snippets.kind === "collection";
-  const snippetNodes = (name) => {
-    const body = hasSnippets ? find(bundle, "snippets", name)?.data.body : void 0;
-    return isTree(body) ? body.nodes : void 0;
-  };
-  const resolve = (nodes, nested) => nodes.flatMap((node) => {
-    if (!isNode(node)) return [node];
-    const [tag, props, ...children] = node;
-    if (tag === "snippet" && !nested) {
-      const inner = typeof props.name === "string" ? snippetNodes(props.name) : void 0;
-      return inner ? resolve(inner, true) : [[tag, { ...props, "data-broken": true }, ...children]];
-    }
-    let next = props;
-    const href = props.href;
-    if (tag === "a" && typeof href === "string" && href.startsWith("$")) {
-      const hash = href.indexOf("#");
-      const target = routeTarget(bundle, schema, hash === -1 ? href.slice(1) : href.slice(1, hash));
-      next = target === void 0 ? { ...props, "data-broken": true } : { ...props, href: target + (hash === -1 ? "" : href.slice(hash)) };
-    }
-    return [[tag, next, ...resolve(children, nested)]];
-  });
-  return mapTrees(bundle, (tree) => ({
-    ...tree,
-    nodes: resolve(tree.nodes, false),
-    ...tree.summary ? { summary: resolve(tree.summary, false) } : {}
-  }));
-}
-function eachNode(nodes, fn) {
-  for (const node of nodes) if (isNode(node)) {
-    fn(node);
-    eachNode(node.slice(2), fn);
-  }
-}
-const normal = (path) => path.length > 1 && path.endsWith("/") ? path.slice(0, -1) : path;
-function checkLinks(bundles, schema, options = {}) {
-  const config = options.linkCheck ?? {};
-  const levels = { broken: config.broken ?? "error", anchors: config.anchors ?? "warn", redirected: config.redirected ?? "warn" };
-  const rules = [...options.redirects ?? [], ...bundles.flatMap(entryRedirects)];
-  const known = /* @__PURE__ */ new Set();
-  const trees = /* @__PURE__ */ new Map();
-  for (const bundle of bundles) {
-    for (const pages of Object.values(schema.pages)) {
-      const p = pages[bundle.locale];
-      if (p) known.add(normal(p));
-    }
-    for (const b of Object.values(bundle.bricks)) {
-      if (b.kind !== "collection") continue;
-      for (const item of b.items) {
-        const url = item.urls?.[bundle.locale];
-        if (!url) continue;
-        known.add(normal(url));
-        const own = [];
-        mapTrees({ ...bundle, bricks: { x: { kind: "single", data: item.data, fallback: [] } } }, (t) => {
-          own.push(t);
-          return t;
-        });
-        trees.set(normal(url), own);
-      }
-    }
-  }
-  const hasId = (list, id) => list.some((t) => {
-    let found = false;
-    eachNode(t.nodes, (n) => {
-      if (/^h[1-6]$/.test(n[0]) && n[1].id === id) found = true;
-    });
-    return found;
-  });
-  const issues = [];
-  for (const bundle of bundles) {
-    mapTrees(bundle, (tree, at) => {
-      const add = (severity, href, key, params) => issues.push({ severity, locale: bundle.locale, brick: at.brick, id: at.id, field: at.field, href, ...msg(`links.${key}`, params) });
-      const broken = (href, key, params) => {
-        if (levels.broken !== "off") add(levels.broken, href, key, params);
-      };
-      eachNode([...tree.nodes, ...tree.summary ?? []], (node) => {
-        const [tag, props] = node;
-        if (tag === "snippet" && props["data-broken"]) return broken(`snippet:${String(props.name)}`, "snippetMissing", { name: String(props.name) });
-        const href = props.href;
-        if (tag !== "a" || typeof href !== "string") return;
-        if (props["data-broken"]) {
-          const head = href.slice(1).split(".")[0];
-          if (href.startsWith("$") && head !== "page" && Object.hasOwn(schema.bricks, head) && !Object.hasOwn(bundle.bricks, head)) return;
-          return broken(href, "linkBroken", { href });
-        }
-        const hash = href.indexOf("#");
-        const path = hash === -1 ? href : href.slice(0, hash);
-        const anchor = hash === -1 ? "" : href.slice(hash + 1);
-        let target;
-        if (path === "") target = [tree];
-        else if (path.startsWith("/") && !path.startsWith("//")) {
-          const clean = normal(path.split("?")[0]);
-          const moved = levels.redirected === "off" ? void 0 : matchRedirect(rules, clean);
-          if (moved) {
-            add(levels.redirected, href, "linkRedirected", { href, to: moved.to });
-            return;
-          }
-          if (!known.has(clean)) {
-            if (options.files && !options.files(clean)) broken(href, "pathUnknown", { path: clean });
-            return;
-          }
-          target = trees.get(clean);
-        } else return;
-        if (anchor && levels.anchors !== "off" && target && !hasId(target, anchor)) add(levels.anchors, href, "anchorMissing", { anchor });
-      });
-      return tree;
-    });
-  }
-  return issues;
-}
-function externalLinks(bundles) {
-  const out = [];
-  for (const bundle of bundles) {
-    mapTrees(bundle, (tree, at) => {
-      eachNode([...tree.nodes, ...tree.summary ?? []], ([tag, props]) => {
-        const href = props.href;
-        if (tag === "a" && typeof href === "string" && /^https?:\/\//.test(href)) out.push({ href, locale: bundle.locale, ...at });
-      });
-      return tree;
-    });
-  }
-  return out;
-}
-const MD_INLINE = /\]\(\s*<?([^)\s>]+)/g;
-const MD_DEFINITION = /^[ \t]{0,3}\[[^\]]+\]:[ \t]*<?(\S+?)>?(?:[ \t]+.*)?$/gm;
-const MD_SNIPPET = /::snippet\{[^}]*\bname="([^"]*)"/g;
-function linkTargets(fields, data) {
-  const out = /* @__PURE__ */ new Set();
-  const text = (value) => {
-    for (const markdown of typeof value === "string" ? [value] : isRecord(value) ? Object.values(value) : []) {
-      if (typeof markdown !== "string") continue;
-      for (const m of markdown.matchAll(MD_INLINE)) out.add(m[1]);
-      for (const m of markdown.matchAll(MD_DEFINITION)) out.add(m[1]);
-      for (const m of markdown.matchAll(MD_SNIPPET)) out.add(`snippet:${m[1]}`);
-    }
-  };
-  const walk = (inner, row) => {
-    for (const [name, field] of Object.entries(inner)) {
-      const value = row[name];
-      if (field.type === "markdown") text(value);
-      else if (field.type === "list" && Array.isArray(value)) {
-        for (const r of value) if (isRecord(r)) walk(field.of, r);
-      }
-    }
-  };
-  walk(fields, data);
-  return out;
-}
-
-export { platformSchema as A, BRICK_KEYS as B, slugify as C, staleOf as D, uniqueSlug as E, FIELD_KEYS as F, validate as G, weeklyTask as H, PREFILL_TOKENS as P, SCHEMA_KEYS as S, UPLOAD_TYPES as U, checkSite as a, redirectProblems as b, checkLinks as c, entryRedirects as d, externalLinks as e, SCHEMA_LIMITS as f, SITE_BUDGET as g, SLUG_PATTERN as h, acceptOf as i, checkSchema as j, fileProblem as k, findRedirect as l, formatMb as m, isDate as n, isPrefillToken as o, isTimeZone as p, limitOf as q, resolveRouteLinks as r, serializeSchema as s, linkTargets as t, mainLocale as u, matchRedirect as v, migrationFingerprint as w, ordered as x, plannedWeeks as y, plansThisWeek as z };
+export { weekStartField as A, BRICK_KEYS as B, weeklyTask as C, FIELD_KEYS as F, PREFILL_TOKENS as P, SCHEMA_KEYS as S, checkSchema as a, createAsks as b, checkSite as c, SCHEMA_LIMITS as d, SHAPE_CODES as e, SLUG_PATTERN as f, duePlan as g, fileProblem as h, grantGroups as i, isDate as j, isHourPlans as k, isPrefillToken as l, isTimeZone as m, liveFrom as n, ordered as o, platformSchema as p, mainLocale as q, migrationFingerprint as r, serializeSchema as s, plannedWeeks as t, plansThisWeek as u, validate as v, slugBases as w, slugify as x, staleOf as y, uniqueSlug as z };