@xtrable-ltd/nanoesis 0.1.0

package/dist/chunk-G2UEZTYC.js

@@ -0,0 +1,2541 @@
+// ../engine/src/slug.ts
+function slugify(input) {
+  return input.normalize("NFKD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+
+// ../engine/src/text.ts
+function humanize(name) {
+  const spaced = name.replace(/[_-]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").trim().replace(/\s+/g, " ");
+  if (spaced.length === 0) return "";
+  return spaced.charAt(0).toUpperCase() + spaced.slice(1);
+}
+
+// ../engine/src/mime.ts
+var CONTENT_TYPES = {
+  html: "text/html; charset=utf-8",
+  json: "application/json; charset=utf-8",
+  js: "text/javascript; charset=utf-8",
+  mjs: "text/javascript; charset=utf-8",
+  css: "text/css; charset=utf-8",
+  txt: "text/plain; charset=utf-8",
+  xml: "application/xml; charset=utf-8",
+  svg: "image/svg+xml",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  webp: "image/webp",
+  avif: "image/avif",
+  gif: "image/gif",
+  ico: "image/x-icon",
+  woff: "font/woff",
+  woff2: "font/woff2",
+  map: "application/json; charset=utf-8"
+};
+function contentTypeFor(path) {
+  const ext = path.slice(path.lastIndexOf(".") + 1).toLowerCase();
+  return CONTENT_TYPES[ext] ?? "application/octet-stream";
+}
+
+// ../engine/src/content/item.ts
+var ContentParseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ContentParseError";
+  }
+};
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFieldPrimitive(value) {
+  return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function isFlatRecord(value) {
+  return isPlainObject(value) && Object.values(value).every(isFieldPrimitive);
+}
+function parseFieldValue(key, value) {
+  if (isFieldPrimitive(value)) return value;
+  if (Array.isArray(value)) {
+    if (value.every(isFieldPrimitive)) return value;
+    if (value.every(isFlatRecord)) return value;
+    throw new ContentParseError(
+      `Field "${key}" array must hold only primitives or only flat records (no nesting).`
+    );
+  }
+  throw new ContentParseError(`Field "${key}" must be a primitive or an array, not a bare object.`);
+}
+function parseOptionalString(raw, key) {
+  const value = raw[key];
+  if (value === void 0) return void 0;
+  if (typeof value !== "string") {
+    throw new ContentParseError(`"${key}" must be a string when present.`);
+  }
+  return value;
+}
+function parseContentItem(raw) {
+  if (!isPlainObject(raw)) {
+    throw new ContentParseError("A content item must be a JSON object.");
+  }
+  if (typeof raw.title !== "string") {
+    throw new ContentParseError('A content item requires a string "title".');
+  }
+  let isPublished = false;
+  if (raw.isPublished !== void 0) {
+    if (typeof raw.isPublished !== "boolean") {
+      throw new ContentParseError(
+        `"isPublished" must be a boolean when present, got ${JSON.stringify(raw.isPublished)}.`
+      );
+    }
+    isPublished = raw.isPublished;
+  }
+  let fields = {};
+  if (raw.fields !== void 0) {
+    if (!isPlainObject(raw.fields)) {
+      throw new ContentParseError('"fields" must be an object.');
+    }
+    fields = Object.fromEntries(
+      Object.entries(raw.fields).map(([key, value]) => [key, parseFieldValue(key, value)])
+    );
+  }
+  const template = parseOptionalString(raw, "template");
+  const created = parseOptionalString(raw, "created");
+  const published = parseOptionalString(raw, "published");
+  const updated = parseOptionalString(raw, "updated");
+  return {
+    title: raw.title,
+    isPublished,
+    fields,
+    ...template !== void 0 && { template },
+    ...created !== void 0 && { created },
+    ...published !== void 0 && { published },
+    ...updated !== void 0 && { updated }
+  };
+}
+
+// ../engine/src/content/sort.ts
+function isPlainObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseSortFile(raw) {
+  if (!isPlainObject2(raw)) return { order: [] };
+  const order = Array.isArray(raw.order) ? raw.order.filter((entry) => typeof entry === "string") : [];
+  const name = typeof raw.name === "string" ? raw.name : void 0;
+  const defaultTemplate = typeof raw.defaultTemplate === "string" ? raw.defaultTemplate : void 0;
+  const collection = isPlainObject2(raw.collection) ? { recursive: raw.collection.recursive === true } : void 0;
+  return {
+    order,
+    ...name !== void 0 && { name },
+    ...defaultTemplate !== void 0 && { defaultTemplate },
+    ...collection !== void 0 && { collection }
+  };
+}
+
+// ../engine/src/store/blob-store.ts
+var InMemoryBlobStore = class {
+  blobs = /* @__PURE__ */ new Map();
+  constructor(initial) {
+    if (initial === void 0) return;
+    const encoder = new TextEncoder();
+    for (const [key, value] of Object.entries(initial)) {
+      this.blobs.set(key, copy(typeof value === "string" ? encoder.encode(value) : value));
+    }
+  }
+  async get(key) {
+    const value = this.blobs.get(key);
+    return value === void 0 ? void 0 : copy(value);
+  }
+  async put(key, bytes) {
+    this.blobs.set(key, copy(bytes));
+  }
+  async delete(key) {
+    this.blobs.delete(key);
+  }
+};
+function copy(bytes) {
+  return bytes.slice();
+}
+
+// ../engine/src/store/content-index.ts
+var RESERVED_PREFIX = ".nanoesis/";
+var INDEX_KEY = `${RESERVED_PREFIX}index.json`;
+var BACKUP_RING_SIZE = 3;
+function backupKey(slot) {
+  return `${RESERVED_PREFIX}index.bak.${slot}`;
+}
+function emptyIndex() {
+  return freezeIndex(0, []);
+}
+async function loadIndex(store) {
+  const live = parseIndex(await store.get(INDEX_KEY));
+  if (live !== void 0) return live;
+  let best;
+  for (let slot = 0; slot < BACKUP_RING_SIZE; slot += 1) {
+    const candidate = parseIndex(await store.get(backupKey(slot)));
+    if (candidate !== void 0 && (best === void 0 || candidate.version > best.version)) {
+      best = candidate;
+    }
+  }
+  return best ?? emptyIndex();
+}
+async function saveIndex(store, prev, nextKeys) {
+  await store.put(backupKey(prev.version % BACKUP_RING_SIZE), serialize(prev));
+  const next = freezeIndex(prev.version + 1, nextKeys);
+  await store.put(INDEX_KEY, serialize(next));
+  return next;
+}
+function freezeIndex(version, keys) {
+  const sorted = [...new Set(keys)].sort();
+  return { version, keys: sorted, checksum: checksumOf(version, sorted) };
+}
+function serialize(index) {
+  return new TextEncoder().encode(`${JSON.stringify(index, null, 2)}
+`);
+}
+function parseIndex(bytes) {
+  if (bytes === void 0) return void 0;
+  let raw;
+  try {
+    raw = JSON.parse(new TextDecoder().decode(bytes));
+  } catch {
+    return void 0;
+  }
+  if (typeof raw !== "object" || raw === null) return void 0;
+  const { version, keys, checksum } = raw;
+  if (typeof version !== "number" || typeof checksum !== "string" || !Array.isArray(keys)) {
+    return void 0;
+  }
+  const stringKeys = keys.filter((key) => typeof key === "string");
+  if (stringKeys.length !== keys.length) return void 0;
+  const rebuilt = freezeIndex(version, stringKeys);
+  return rebuilt.checksum === checksum ? rebuilt : void 0;
+}
+function checksumOf(version, sortedKeys) {
+  const text = `${version}
+${sortedKeys.join("\n")}`;
+  let hash = 2166136261;
+  for (let i = 0; i < text.length; i += 1) {
+    hash ^= text.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+
+// ../engine/src/store/indexed-store.ts
+var IndexedStore = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  index;
+  loading;
+  /** The index, loaded once on first need and cached (mutations replace the cached copy). */
+  async loaded() {
+    if (this.index !== void 0) return this.index;
+    this.loading ??= loadIndex(this.store);
+    this.index = await this.loading;
+    return this.index;
+  }
+  async list(dir) {
+    return childrenOf((await this.loaded()).keys, dir);
+  }
+  async readText(path) {
+    return new TextDecoder().decode(await this.readBytes(path));
+  }
+  async readBytes(path) {
+    const bytes = await this.store.get(path);
+    if (bytes === void 0) throw new Error(`No such file in content source: ${path}`);
+    return bytes;
+  }
+  async exists(path) {
+    return pathExists((await this.loaded()).keys, path);
+  }
+  /**
+   * Create or overwrite `key`. The index is rewritten only when `key` is new (an
+   * overwrite leaves the key set unchanged, so editing an item is a single `put`).
+   */
+  async write(key, bytes) {
+    const target = guarded(normalize(key));
+    await this.store.put(target, bytes);
+    const index = await this.loaded();
+    if (!index.keys.includes(target)) {
+      this.index = await saveIndex(this.store, index, [...index.keys, target]);
+    }
+  }
+  /**
+   * Delete a file, or a whole directory subtree (every key under `key/`). Idempotent: a
+   * path the index does not know is still deleted from the store (clearing an orphan),
+   * and deleting nothing is a no-op.
+   */
+  async delete(key) {
+    const target = guarded(normalize(key));
+    const index = await this.loaded();
+    const prefix = `${target}/`;
+    const removed = index.keys.filter((k) => k === target || k.startsWith(prefix));
+    if (removed.length === 0) {
+      await this.store.delete(target);
+      return;
+    }
+    await Promise.all(removed.map((k) => this.store.delete(k)));
+    const remaining = index.keys.filter((k) => k !== target && !k.startsWith(prefix));
+    this.index = await saveIndex(this.store, index, remaining);
+  }
+  /**
+   * Move/rename a file, or a whole directory subtree (every key under `from/` is remapped
+   * under `to/`). Clobbering an existing destination, or renaming a missing path, are
+   * returned as data (`ok: false`), not thrown (CLAUDE §2), the same contract the host's
+   * `/api/rename` enforces. (Mutating the reserved namespace is a programmer error and
+   * still throws.)
+   */
+  async rename(from, to) {
+    const source = guarded(normalize(from));
+    const dest = guarded(normalize(to));
+    if (source === dest) return { ok: true };
+    const index = await this.loaded();
+    const sourcePrefix = `${source}/`;
+    const affected = index.keys.filter((k) => k === source || k.startsWith(sourcePrefix));
+    if (affected.length === 0) return { ok: false, reason: "missing" };
+    const destPrefix = `${dest}/`;
+    if (index.keys.some((k) => k === dest || k.startsWith(destPrefix))) {
+      return { ok: false, reason: "exists" };
+    }
+    const moves = affected.map((k) => ({
+      from: k,
+      to: k === source ? dest : dest + k.slice(source.length)
+    }));
+    for (const move of moves) {
+      const bytes = await this.store.get(move.from);
+      if (bytes === void 0) continue;
+      await this.store.put(move.to, bytes);
+      await this.store.delete(move.from);
+    }
+    const movedFrom = new Set(moves.map((move) => move.from));
+    const next = index.keys.filter((k) => !movedFrom.has(k)).concat(moves.map((m) => m.to));
+    this.index = await saveIndex(this.store, index, next);
+    return { ok: true };
+  }
+};
+function guarded(key) {
+  if (key === "" || key.startsWith(RESERVED_PREFIX)) {
+    throw new Error(`Refusing to mutate a reserved key: ${key === "" ? "(root)" : key}`);
+  }
+  return key;
+}
+function normalize(path) {
+  return path.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "").replace(/\/+$/, "");
+}
+function childrenOf(keys, dir) {
+  const base = normalize(dir);
+  const prefix = base === "" ? "" : `${base}/`;
+  const entries = /* @__PURE__ */ new Map();
+  for (const key of keys) {
+    if (prefix !== "" && !key.startsWith(prefix)) continue;
+    const rest = key.slice(prefix.length);
+    if (rest === "") continue;
+    const slash = rest.indexOf("/");
+    if (slash === -1) entries.set(rest, "file");
+    else entries.set(rest.slice(0, slash), "dir");
+  }
+  return [...entries].map(([name, kind]) => ({ name, kind }));
+}
+function pathExists(keys, path) {
+  const target = normalize(path);
+  if (target === "") return true;
+  if (keys.includes(target)) return true;
+  const prefix = `${target}/`;
+  return keys.some((key) => key.startsWith(prefix));
+}
+
+// ../engine/src/content/source.ts
+function normalizePath(path) {
+  return path.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "").replace(/\/+$/, "");
+}
+var InMemoryContentSource = class {
+  files;
+  constructor(files) {
+    this.files = new Map(Object.entries(files).map(([key, value]) => [normalizePath(key), value]));
+  }
+  async readText(path) {
+    const value = this.files.get(normalizePath(path));
+    if (value === void 0) throw new Error(`No such file in content source: ${path}`);
+    return typeof value === "string" ? value : new TextDecoder().decode(value);
+  }
+  async readBytes(path) {
+    const value = this.files.get(normalizePath(path));
+    if (value === void 0) throw new Error(`No such file in content source: ${path}`);
+    return typeof value === "string" ? new TextEncoder().encode(value) : value;
+  }
+  async exists(path) {
+    const target = normalizePath(path);
+    if (target === "") return true;
+    if (this.files.has(target)) return true;
+    const prefix = `${target}/`;
+    for (const key of this.files.keys()) {
+      if (key.startsWith(prefix)) return true;
+    }
+    return false;
+  }
+  async list(dir) {
+    const base = normalizePath(dir);
+    const prefix = base === "" ? "" : `${base}/`;
+    const entries = /* @__PURE__ */ new Map();
+    for (const key of this.files.keys()) {
+      if (prefix !== "" && !key.startsWith(prefix)) continue;
+      const rest = key.slice(prefix.length);
+      if (rest === "") continue;
+      const slash = rest.indexOf("/");
+      if (slash === -1) entries.set(rest, "file");
+      else entries.set(rest.slice(0, slash), "dir");
+    }
+    return [...entries].map(([name, kind]) => ({ name, kind }));
+  }
+};
+
+// ../engine/src/url/redirects.ts
+var DEFAULT_STATUS = 301;
+var OUTPUT_PATH = "_redirects";
+function isRule(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const record = value;
+  return typeof record.from === "string" && typeof record.to === "string";
+}
+function parseRedirects(raw) {
+  if (!Array.isArray(raw)) return [];
+  const rules = [];
+  for (const entry of raw) {
+    if (!isRule(entry)) continue;
+    const status = entry.status;
+    rules.push(
+      typeof status === "number" && Number.isInteger(status) ? { from: entry.from, to: entry.to, status } : { from: entry.from, to: entry.to }
+    );
+  }
+  return rules;
+}
+function resolveTarget(from, exact) {
+  const seen = /* @__PURE__ */ new Set([from]);
+  let target = exact.get(from).to;
+  while (exact.has(target) && !seen.has(target)) {
+    seen.add(target);
+    target = exact.get(target).to;
+  }
+  return target;
+}
+function buildRedirects(rules, liveUrls) {
+  const exact = /* @__PURE__ */ new Map();
+  const wildcard = /* @__PURE__ */ new Map();
+  for (const rule of rules) {
+    (rule.from.includes("*") ? wildcard : exact).set(rule.from, rule);
+  }
+  const resolved = [];
+  for (const [from, rule] of exact) {
+    if (liveUrls.has(from)) continue;
+    const to = resolveTarget(from, exact);
+    if (to === from) continue;
+    resolved.push(rule.status !== void 0 ? { from, to, status: rule.status } : { from, to });
+  }
+  resolved.push(...wildcard.values());
+  if (resolved.length === 0) return void 0;
+  resolved.sort((a, b) => a.from.localeCompare(b.from) || a.to.localeCompare(b.to));
+  const contents = resolved.map((rule) => `${rule.from} ${rule.to} ${rule.status ?? DEFAULT_STATUS}
+`).join("");
+  return { path: OUTPUT_PATH, contents };
+}
+
+// ../engine/src/content/loader.ts
+var SORT_FILE = "_sort.json";
+var REDIRECTS_FILE = "_redirects.json";
+var SITE_CONFIG_FILE = "_site.json";
+var ASSETS_DIR = "assets";
+var ITEM_EXT = ".json";
+var DEFAULT_DIRS = {
+  content: "content",
+  templates: "templates",
+  components: "components",
+  /** Static passthrough, copied verbatim to the published root (DESIGN §8). The
+   *  engine never reads it; named here so hosts/editor share one source of truth. */
+  public: "public"
+};
+function join(...parts) {
+  return parts.filter((part) => part !== "").join("/");
+}
+function stripBom(text) {
+  return text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+}
+async function loadContentTree(source, contentDir = DEFAULT_DIRS.content) {
+  return loadDir(source, contentDir, "", "");
+}
+async function loadDir(source, dirPath, slug, treePath) {
+  const [entries, sort] = await Promise.all([source.list(dirPath), readSort(source, dirPath)]);
+  const childMap = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (entry.kind === "file") {
+      if (entry.name === SORT_FILE || entry.name === REDIRECTS_FILE || entry.name === SITE_CONFIG_FILE || !entry.name.endsWith(ITEM_EXT))
+        continue;
+      const childSlug = entry.name.slice(0, -ITEM_EXT.length);
+      childMap.set(
+        childSlug,
+        await loadItem(source, join(dirPath, entry.name), childSlug, treePath)
+      );
+    } else {
+      if (entry.name === ASSETS_DIR) continue;
+      const childPath = join(treePath, entry.name);
+      childMap.set(
+        entry.name,
+        await loadDir(source, join(dirPath, entry.name), entry.name, childPath)
+      );
+    }
+  }
+  const name = sort.name ?? (slug === "" ? "" : humanize(slug));
+  return {
+    kind: "dir",
+    slug,
+    name,
+    path: treePath,
+    children: orderChildren(childMap, sort.order),
+    ...sort.collection !== void 0 && { collection: sort.collection },
+    ...sort.defaultTemplate !== void 0 && { defaultTemplate: sort.defaultTemplate }
+  };
+}
+async function loadItem(source, filePath, slug, parentPath2) {
+  const raw = await source.readText(filePath);
+  try {
+    const item = parseContentItem(JSON.parse(raw));
+    return { kind: "item", slug, path: join(parentPath2, slug), item };
+  } catch (error) {
+    throw new Error(`Failed to load ${filePath}: ${error.message}`);
+  }
+}
+async function readSort(source, dirPath) {
+  const path = join(dirPath, SORT_FILE);
+  if (!await source.exists(path)) return { order: [] };
+  try {
+    return parseSortFile(JSON.parse(await source.readText(path)));
+  } catch {
+    return { order: [] };
+  }
+}
+async function loadRedirects(source, contentDir = DEFAULT_DIRS.content) {
+  const path = join(contentDir, REDIRECTS_FILE);
+  if (!await source.exists(path)) return [];
+  try {
+    return parseRedirects(JSON.parse(stripBom(await source.readText(path))));
+  } catch {
+    return [];
+  }
+}
+async function loadSiteConfig(source, contentDir = DEFAULT_DIRS.content) {
+  const path = join(contentDir, SITE_CONFIG_FILE);
+  if (!await source.exists(path)) return {};
+  try {
+    const raw = JSON.parse(stripBom(await source.readText(path)));
+    const baseUrl = typeof raw.baseUrl === "string" ? raw.baseUrl.trim() : "";
+    return baseUrl !== "" ? { baseUrl } : {};
+  } catch {
+    return {};
+  }
+}
+function orderChildren(map, order) {
+  const out = [];
+  const used = /* @__PURE__ */ new Set();
+  for (const slug of order) {
+    const node = map.get(slug);
+    if (node !== void 0) {
+      out.push(node);
+      used.add(slug);
+    }
+  }
+  for (const [slug, node] of map) {
+    if (!used.has(slug)) out.push(node);
+  }
+  return out;
+}
+function loadComponents(source, componentsDir = DEFAULT_DIRS.components) {
+  return loadComponentFiles(source, componentsDir, "html");
+}
+function loadComponentStyles(source, componentsDir = DEFAULT_DIRS.components) {
+  return loadComponentFiles(source, componentsDir, "css");
+}
+function loadComponentScripts(source, componentsDir = DEFAULT_DIRS.components) {
+  return loadComponentFiles(source, componentsDir, "js");
+}
+async function loadComponentFiles(source, componentsDir, extension) {
+  const suffix = `.${extension}`;
+  const map = /* @__PURE__ */ new Map();
+  const walk = async (dir) => {
+    if (!await source.exists(dir)) return;
+    for (const entry of await source.list(dir)) {
+      const full = join(dir, entry.name);
+      if (entry.kind === "dir") {
+        await walk(full);
+      } else if (entry.name.endsWith(suffix)) {
+        const key = entry.name.slice(0, -suffix.length).toLowerCase();
+        map.set(key, await source.readText(full));
+      }
+    }
+  };
+  await walk(componentsDir);
+  return map;
+}
+async function loadTemplate(source, name, templatesDir = DEFAULT_DIRS.templates) {
+  return source.readText(join(templatesDir, `${name}.html`));
+}
+function loadTemplateStyle(source, name, templatesDir = DEFAULT_DIRS.templates) {
+  return tryReadText(source, join(templatesDir, `${name}.css`));
+}
+function loadTemplateScript(source, name, templatesDir = DEFAULT_DIRS.templates) {
+  return tryReadText(source, join(templatesDir, `${name}.js`));
+}
+var DOCUMENT_SHELL = "document";
+function loadDocumentShell(source, templatesDir = DEFAULT_DIRS.templates) {
+  return tryReadText(source, join(templatesDir, `${DOCUMENT_SHELL}.html`));
+}
+async function tryReadText(source, path) {
+  try {
+    return await source.readText(path);
+  } catch {
+    return void 0;
+  }
+}
+
+// ../engine/src/template/registry.ts
+var FIELD_TYPES = {
+  image: { type: "image", valueKind: "asset", control: "image", multiline: false },
+  file: { type: "file", valueKind: "asset", control: "file", multiline: false },
+  url: { type: "url", valueKind: "url", control: "url", multiline: false },
+  email: { type: "email", valueKind: "text", control: "email", multiline: false },
+  phone: { type: "phone", valueKind: "text", control: "phone", multiline: false },
+  date: { type: "date", valueKind: "text", control: "date", multiline: false },
+  time: { type: "time", valueKind: "text", control: "time", multiline: false },
+  code: { type: "code", valueKind: "text", control: "code", multiline: true },
+  richtext: { type: "richtext", valueKind: "html", control: "richtext", multiline: true },
+  authors: { type: "authors", valueKind: "authors", control: "authors", multiline: false },
+  text: { type: "text", valueKind: "text", control: "text", multiline: true },
+  shorttext: { type: "shorttext", valueKind: "text", control: "shorttext", multiline: false }
+};
+function isFieldType(value) {
+  return Object.prototype.hasOwnProperty.call(FIELD_TYPES, value);
+}
+function valueKindOf(type) {
+  return FIELD_TYPES[type].valueKind;
+}
+
+// ../engine/src/template/inference.ts
+var SHORT_TEXT_ELEMENTS = /* @__PURE__ */ new Set([
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "title",
+  "label",
+  "th",
+  "caption",
+  "figcaption",
+  "legend",
+  "summary",
+  "option",
+  "dt",
+  "button"
+]);
+var CODE_ELEMENTS = /* @__PURE__ */ new Set(["code", "pre", "kbd", "samp"]);
+var PLAIN_TEXT_ELEMENTS = /* @__PURE__ */ new Set([
+  "p",
+  "span",
+  "li",
+  "td",
+  "dd",
+  "strong",
+  "em",
+  "b",
+  "i",
+  "small",
+  "time",
+  "a",
+  "figcaption",
+  "div",
+  "article",
+  "section",
+  "main",
+  "aside",
+  "blockquote"
+]);
+function inferControl(ctx) {
+  if (ctx.annotation !== void 0 && isFieldType(ctx.annotation)) {
+    return ctx.annotation;
+  }
+  if (ctx.attribute !== void 0) {
+    const attr = ctx.attribute;
+    const prefix = (ctx.valuePrefix ?? "").toLowerCase();
+    if (attr === "href") {
+      if (prefix.endsWith("mailto:")) return "email";
+      if (prefix.endsWith("tel:")) return "phone";
+      if (ctx.wholeValue) return ctx.download === true ? "file" : "url";
+    }
+    if (ctx.wholeValue && attr === "src") {
+      if (ctx.tag === "img") return "image";
+      return "file";
+    }
+    if (ctx.wholeValue && ctx.tag === "source" && attr === "srcset") return "file";
+    if (attr === "alt" || attr === "title") return "shorttext";
+    return "shorttext";
+  }
+  if (CODE_ELEMENTS.has(ctx.tag)) return "code";
+  if (SHORT_TEXT_ELEMENTS.has(ctx.tag)) return "shorttext";
+  if (PLAIN_TEXT_ELEMENTS.has(ctx.tag)) return "text";
+  return "shorttext";
+}
+
+// ../engine/src/template/token.ts
+var TOKEN = /\{([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*)\}/g;
+function findTokens(input) {
+  const out = [];
+  for (const match of input.matchAll(TOKEN)) {
+    const expr = match[1] ?? "";
+    const path = expr.split(".");
+    out.push({ raw: match[0], name: path[0] ?? "", path, dotted: path.length > 1 });
+  }
+  return out;
+}
+function wholeValueToken(input) {
+  const trimmed = input.trim();
+  const tokens = findTokens(trimmed);
+  if (tokens.length === 1 && tokens[0]?.raw === trimmed) return tokens[0];
+  return null;
+}
+function substituteTokens(input, resolve) {
+  return input.replace(/\{([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*)\}/g, (raw, expr) => {
+    const path = expr.split(".");
+    return resolve({ raw, name: path[0] ?? "", path, dotted: path.length > 1 });
+  });
+}
+function literalPrefix(input) {
+  const brace = input.indexOf("{");
+  return (brace === -1 ? input : input.slice(0, brace)).toLowerCase();
+}
+
+// ../engine/src/html/escape.ts
+function escapeHtmlText(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeHtmlAttribute(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function escapeJsonStringContent(value) {
+  const literal = JSON.stringify(value);
+  return literal.slice(1, -1);
+}
+function sanitizeUrl(url) {
+  let cleaned = "";
+  for (const ch of url) {
+    const code = ch.codePointAt(0);
+    if (code !== void 0 && code > 32) cleaned += ch;
+  }
+  const scheme = cleaned.toLowerCase();
+  if (scheme.startsWith("javascript:") || scheme.startsWith("vbscript:")) {
+    return "#";
+  }
+  return url;
+}
+
+// ../engine/src/authors/authors.ts
+function toAuthorRefs(value) {
+  if (!Array.isArray(value)) return [];
+  const refs = [];
+  for (const entry of value) {
+    if (entry === null || typeof entry !== "object") continue;
+    const record = entry;
+    const name = typeof record.name === "string" ? record.name : "";
+    if (name.trim() === "") continue;
+    refs.push({
+      name,
+      ...typeof record.user === "string" && record.user !== "" && { user: record.user },
+      ...typeof record.href === "string" && record.href !== "" && { href: record.href }
+    });
+  }
+  return refs;
+}
+function joinAuthors(names) {
+  if (names.length === 0) return "";
+  if (names.length === 1) return names[0] ?? "";
+  const last = names[names.length - 1] ?? "";
+  const head = names.slice(0, -1).join(", ");
+  return `${head} and ${last}`;
+}
+function renderAuthors(value, directory) {
+  const names = toAuthorRefs(value).map((ref) => {
+    const resolved = ref.user !== void 0 ? directory?.(ref.user) : void 0;
+    return escapeHtmlText(resolved?.displayName ?? ref.name);
+  });
+  return joinAuthors(names);
+}
+
+// ../engine/src/html/dom.ts
+import { parse, parseFragment, serialize as serialize2 } from "parse5";
+function isElement(node) {
+  return "tagName" in node;
+}
+function isTextNode(node) {
+  return node.nodeName === "#text";
+}
+function getAttribute(el, name) {
+  return el.attrs.find((attr) => attr.name === name)?.value;
+}
+function hasAttribute(el, name) {
+  return el.attrs.some((attr) => attr.name === name);
+}
+function setAttribute(el, name, value) {
+  const existing = el.attrs.find((attr) => attr.name === name);
+  if (existing) existing.value = value;
+  else el.attrs.push({ name, value });
+}
+function removeAttribute(el, name) {
+  el.attrs = el.attrs.filter((attr) => attr.name !== name);
+}
+function parseFragmentNodes(html) {
+  return parseFragment(html).childNodes;
+}
+function isFullDocument(html) {
+  const start = html.trimStart().toLowerCase();
+  return start.startsWith("<!doctype") || start.startsWith("<html");
+}
+function parseNodes(html) {
+  return isFullDocument(html) ? parse(html).childNodes : parseFragment(html).childNodes;
+}
+function serializeNodes(nodes) {
+  const fragment = parseFragment("");
+  fragment.childNodes = nodes;
+  return serialize2(fragment);
+}
+
+// ../engine/src/media/media.ts
+var DEFAULT_WIDTHS = [400, 800, 1200, 1600];
+var MIME = {
+  avif: "image/avif",
+  webp: "image/webp",
+  jpeg: "image/jpeg",
+  png: "image/png"
+};
+function extOf(format) {
+  return format === "jpeg" ? "jpg" : format;
+}
+function fallbackFormatFor(assetPath) {
+  const ext = assetPath.slice(assetPath.lastIndexOf(".") + 1).toLowerCase();
+  if (ext === "png") return "png";
+  if (ext === "webp") return "webp";
+  return "jpeg";
+}
+function contentHash(bytes) {
+  let hash = 2166136261;
+  for (let i = 0; i < bytes.length; i += 1) {
+    hash ^= bytes[i] ?? 0;
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(36);
+}
+async function processImage(input, assetPath, encoder) {
+  const fallbackFormat = fallbackFormatFor(assetPath);
+  const formats = [.../* @__PURE__ */ new Set(["avif", "webp", fallbackFormat])];
+  const encoded = await encoder.encode(input, { widths: DEFAULT_WIDTHS, formats });
+  const hash = contentHash(input);
+  const base = assetPath.slice(
+    0,
+    assetPath.lastIndexOf(".") >= 0 ? assetPath.lastIndexOf(".") : assetPath.length
+  );
+  const artifacts = [];
+  const urlOf = (variant) => {
+    const path = `${base}.${hash}-${variant.width}.${extOf(variant.format)}`;
+    artifacts.push({ path, contents: variant.bytes });
+    return `/${path}`;
+  };
+  const byFormat = /* @__PURE__ */ new Map();
+  for (const variant of [...encoded.variants].sort((a, b) => a.width - b.width)) {
+    const url = urlOf(variant);
+    const list = byFormat.get(variant.format) ?? [];
+    list.push({ url, width: variant.width });
+    byFormat.set(variant.format, list);
+  }
+  const srcsetOf = (format) => (byFormat.get(format) ?? []).map((entry) => `${entry.url} ${entry.width}w`).join(", ");
+  const sources = ["avif", "webp"].filter((format) => byFormat.has(format)).map((format) => ({ format, mime: MIME[format], srcset: srcsetOf(format) }));
+  const fallbackList = byFormat.get(fallbackFormat) ?? [];
+  const fallbackSrc = fallbackList[fallbackList.length - 1]?.url ?? `/${assetPath}`;
+  const info = {
+    width: encoded.sourceWidth,
+    height: encoded.sourceHeight,
+    sources,
+    fallbackSrc,
+    ...encoded.blurDataUri !== void 0 && { blurDataUri: encoded.blurDataUri }
+  };
+  return { artifacts, info };
+}
+function buildPictureMarkup(info, extraAttrs) {
+  const sources = info.sources.map(
+    (source) => `<source type="${source.mime}" srcset="${escapeHtmlAttribute(source.srcset)}">`
+  ).join("");
+  const carried = extraAttrs.filter(([name]) => name !== "src" && name !== "width" && name !== "height").map(([name, value]) => ` ${name}="${escapeHtmlAttribute(value)}"`).join("");
+  const img = `<img src="${escapeHtmlAttribute(info.fallbackSrc)}" width="${info.width}" height="${info.height}" loading="lazy" decoding="async"${carried}>`;
+  return `<picture>${sources}${img}</picture>`;
+}
+
+// ../engine/src/url/references.ts
+var REFERENCE_PREFIX = "ref:";
+function referenceTarget(value) {
+  return value.startsWith(REFERENCE_PREFIX) ? value.slice(REFERENCE_PREFIX.length) : void 0;
+}
+function collectHtmlReferences(html) {
+  const found = /* @__PURE__ */ new Set();
+  const visit = (nodes) => {
+    for (const node of nodes) {
+      if (!isElement(node)) continue;
+      for (const attr of node.attrs) {
+        const target = referenceTarget(attr.value);
+        if (target !== void 0) found.add(target);
+      }
+      visit(node.childNodes);
+    }
+  };
+  visit(parseNodes(html));
+  return [...found].sort();
+}
+
+// ../engine/src/compile/compiler.ts
+var LOOP_ATTRS = ["data-each-in", "data-each", "data-sort", "data-limit", "data-pick-from"];
+var AUTHORING_ATTRS = ["data-type", "data-field", "data-required", "data-help", "data-label"];
+function compileTemplate(input) {
+  const ctx = {
+    components: input.components,
+    usedComponents: /* @__PURE__ */ new Set(),
+    ...input.context !== void 0 && { context: input.context },
+    ...input.media !== void 0 && { media: input.media },
+    ...input.authorDirectory !== void 0 && { authorDirectory: input.authorDirectory },
+    ...input.componentStyles !== void 0 && { componentStyles: input.componentStyles }
+  };
+  const body = transformNodes(parseNodes(input.template), input.scope, ctx);
+  const out = input.document === void 0 ? body : fillSlots(transformNodes(parseNodes(input.document), input.scope, ctx), body);
+  injectPageAssets(out, input, ctx);
+  return serializeNodes(out);
+}
+function injectPageAssets(nodes, input, ctx) {
+  const style = input.templateStyle?.trim();
+  if (style) {
+    const styleNode = parseFragmentNodes(`<style>
+${style}
+</style>`);
+    const head = findElement(nodes, "head");
+    if (head) head.childNodes.push(...styleNode);
+    else nodes.unshift(...styleNode);
+  }
+  const scripts = [];
+  const templateScript = input.templateScript?.trim();
+  if (templateScript) scripts.push(templateScript);
+  for (const tag of [...ctx.usedComponents].sort()) {
+    const js = input.componentScripts?.get(tag)?.trim();
+    if (js) scripts.push(js);
+  }
+  if (scripts.length > 0) {
+    const scriptNodes = scripts.flatMap((js) => parseFragmentNodes(`<script>
+${js}
+</script>`));
+    const body = findElement(nodes, "body");
+    if (body) body.childNodes.push(...scriptNodes);
+    else nodes.push(...scriptNodes);
+  }
+}
+function findElement(nodes, tagName) {
+  for (const node of nodes) {
+    if (!isElement(node)) continue;
+    if (node.tagName === tagName) return node;
+    const found = findElement(node.childNodes, tagName);
+    if (found !== void 0) return found;
+  }
+  return void 0;
+}
+function isBoundItem(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && "url" in value;
+}
+function resolveToString(value) {
+  if (value === void 0 || value === null) return "";
+  if (Array.isArray(value)) {
+    return value.map((entry) => entry === null ? "" : String(entry)).join(", ");
+  }
+  return String(value);
+}
+function scopeResolver(scope) {
+  return (token) => {
+    const head = scope[token.name];
+    if (isBoundItem(head)) {
+      if (token.path.length === 1) return head.url;
+      const field = head.fields[token.path[1] ?? ""];
+      return isBoundItem(field) ? field.url : resolveToString(field);
+    }
+    if (token.dotted) return "";
+    return resolveToString(head);
+  };
+}
+function transformNodes(nodes, scope, ctx) {
+  const out = [];
+  for (const node of nodes) {
+    if (isElement(node)) {
+      out.push(...transformElement(node, scope, ctx));
+    } else if (isTextNode(node)) {
+      node.value = substituteTokens(node.value, scopeResolver(scope));
+      out.push(node);
+    } else {
+      out.push(node);
+    }
+  }
+  return out;
+}
+function transformElement(el, scope, ctx) {
+  if (hasAttribute(el, "data-each-in") || hasAttribute(el, "data-each")) {
+    return expandLoop(el, scope, ctx);
+  }
+  if (ctx.components.has(el.tagName)) {
+    return expandComponent(el, scope, ctx);
+  }
+  substituteAttributes(el, scope, ctx);
+  const annotation = getAttribute(el, "data-type");
+  for (const attr of AUTHORING_ATTRS) removeAttribute(el, attr);
+  if (el.tagName === "img" && ctx.media !== void 0) {
+    const info = ctx.media.image(getAttribute(el, "src") ?? "");
+    if (info !== void 0) {
+      const attrs = el.attrs.map((attr) => [attr.name, attr.value]);
+      return parseFragmentNodes(buildPictureMarkup(info, attrs));
+    }
+  }
+  if (isJsonLd(el)) {
+    substituteRawText(el, scope, "json");
+    return [el];
+  }
+  if (el.tagName === "script" || el.tagName === "style") {
+    substituteRawText(el, scope, "raw");
+    return [el];
+  }
+  const field = wholeValueFieldToken(el, annotation);
+  if (field?.kind === "html") {
+    const injected = parseFragmentNodes(resolveToString(scope[field.token.name]));
+    el.childNodes = transformRichMedia(injected, ctx);
+    return [el];
+  }
+  if (field?.kind === "authors") {
+    el.childNodes = parseFragmentNodes(
+      renderAuthors(scope[field.token.name], ctx.authorDirectory)
+    );
+    return [el];
+  }
+  el.childNodes = transformNodes(el.childNodes, scope, ctx);
+  return [el];
+}
+function transformRichMedia(nodes, ctx) {
+  const out = [];
+  for (const node of nodes) {
+    if (!isElement(node)) {
+      out.push(node);
+      continue;
+    }
+    node.childNodes = transformRichMedia(node.childNodes, ctx);
+    if (node.tagName === "img") {
+      const src = getAttribute(node, "src");
+      const info = src !== void 0 ? ctx.media?.image(src) : void 0;
+      if (info !== void 0) {
+        const attrs = node.attrs.map((attr) => [attr.name, attr.value]);
+        out.push(...parseFragmentNodes(buildPictureMarkup(info, attrs)));
+        continue;
+      }
+      if (src !== void 0) setAttribute(node, "src", resolveMediaUrl(src, ctx));
+    }
+    const href = getAttribute(node, "href");
+    if (href !== void 0) setAttribute(node, "href", resolveMediaUrl(href, ctx));
+    out.push(node);
+  }
+  return out;
+}
+function resolveMediaUrl(value, ctx) {
+  const referenced = resolveReference(value, ctx);
+  if (referenced !== void 0) return sanitizeUrl(referenced);
+  return sanitizeUrl(ctx.media?.file(value) ?? value);
+}
+function resolveReference(value, ctx) {
+  const path = referenceTarget(value);
+  if (path === void 0) return void 0;
+  return ctx.context?.reference(path)?.url ?? "#";
+}
+function expandLoop(el, scope, ctx) {
+  if (ctx.context === void 0) return [];
+  const eachIn = getAttribute(el, "data-each-in");
+  let items;
+  if (eachIn !== void 0) {
+    const limitText = getAttribute(el, "data-limit");
+    const limit = limitText !== void 0 ? Number.parseInt(limitText, 10) : void 0;
+    const sort = getAttribute(el, "data-sort");
+    items = ctx.context.collection(eachIn, {
+      ...sort !== void 0 && { sort },
+      ...limit !== void 0 && !Number.isNaN(limit) && { limit }
+    });
+  } else {
+    const fieldName = getAttribute(el, "data-each") ?? "";
+    const value = scope[fieldName];
+    const paths = Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : typeof value === "string" ? [value] : [];
+    items = paths.map((path) => ctx.context?.reference(path)).filter((bound) => bound !== void 0);
+  }
+  const out = [];
+  for (const item of items) {
+    const clone = cloneNode(el);
+    for (const attr of LOOP_ATTRS) removeAttribute(clone, attr);
+    out.push(...transformElement(clone, { ...scope, item }, ctx));
+  }
+  return out;
+}
+function cloneNode(node) {
+  if (isElement(node)) {
+    const clone = {
+      ...node,
+      attrs: node.attrs.map((attr) => ({ ...attr })),
+      childNodes: []
+    };
+    clone.childNodes = node.childNodes.map(cloneNode);
+    return clone;
+  }
+  return { ...node };
+}
+function substituteAttributes(el, scope, ctx) {
+  for (const attr of el.attrs) {
+    if (findTokens(attr.value).length === 0) {
+      const referenced2 = resolveReference(attr.value, ctx);
+      if (referenced2 !== void 0) attr.value = sanitizeUrl(referenced2);
+      continue;
+    }
+    const annotation = getAttribute(el, "data-type");
+    const whole = wholeValueToken(attr.value) !== null;
+    const type = inferControl({
+      tag: el.tagName,
+      attribute: attr.name,
+      wholeValue: whole,
+      valuePrefix: literalPrefix(attr.value),
+      download: hasAttribute(el, "download"),
+      ...annotation !== void 0 && { annotation }
+    });
+    let value = substituteTokens(attr.value, scopeResolver(scope));
+    const referenced = resolveReference(value, ctx);
+    if (referenced !== void 0) value = referenced;
+    const fileUrl = ctx.media?.file(value);
+    if (fileUrl !== void 0) value = fileUrl;
+    if (whole && valueKindOf(type) === "url") value = sanitizeUrl(value);
+    attr.value = value;
+  }
+}
+function substituteRawText(el, scope, mode) {
+  const resolve = scopeResolver(scope);
+  for (const child of el.childNodes) {
+    if (!isTextNode(child)) continue;
+    child.value = substituteTokens(child.value, (token) => {
+      const text = resolve(token);
+      return mode === "json" ? escapeJsonStringContent(text) : text;
+    });
+  }
+}
+function wholeValueFieldToken(el, annotation) {
+  const meaningful = el.childNodes.filter(
+    (child) => !(isTextNode(child) && child.value.trim() === "")
+  );
+  const only = meaningful[0];
+  if (meaningful.length !== 1 || only === void 0 || !isTextNode(only)) return null;
+  const token = wholeValueToken(only.value);
+  if (token === null || token.dotted) return null;
+  const type = inferControl({
+    tag: el.tagName,
+    wholeValue: true,
+    ...annotation !== void 0 && { annotation }
+  });
+  return { token, kind: valueKindOf(type) };
+}
+function isJsonLd(el) {
+  return el.tagName === "script" && getAttribute(el, "type")?.toLowerCase() === "application/ld+json";
+}
+function expandComponent(el, scope, ctx) {
+  const source = ctx.components.get(el.tagName);
+  if (source === void 0) return [el];
+  const resolve = scopeResolver(scope);
+  const propScope = {};
+  for (const attr of el.attrs) {
+    propScope[attr.name] = substituteTokens(attr.value, resolve);
+  }
+  const slotChildren = transformNodes(el.childNodes, scope, ctx);
+  const body = transformNodes(parseNodes(source), propScope, ctx);
+  const result = fillSlots(body, slotChildren);
+  ctx.usedComponents.add(el.tagName);
+  const css = ctx.componentStyles?.get(el.tagName)?.trim();
+  if (css) {
+    const root = result.find(isElement);
+    if (root !== void 0) {
+      const styleNode = parseFragmentNodes(`<style>@scope {
+${css}
+}</style>`);
+      root.childNodes = [...styleNode, ...root.childNodes];
+    }
+  }
+  return result;
+}
+function fillSlots(body, slotChildren) {
+  const named = /* @__PURE__ */ new Map();
+  const defaultSlot = [];
+  for (const child of slotChildren) {
+    const slotName = isElement(child) ? getAttribute(child, "slot") : void 0;
+    if (slotName !== void 0) {
+      if (isElement(child)) removeAttribute(child, "slot");
+      const group = named.get(slotName) ?? [];
+      group.push(child);
+      named.set(slotName, group);
+    } else {
+      defaultSlot.push(child);
+    }
+  }
+  return replaceSlots(body, named, defaultSlot);
+}
+function replaceSlots(nodes, named, defaultSlot) {
+  const out = [];
+  for (const node of nodes) {
+    if (isElement(node) && node.tagName === "slot") {
+      const name = getAttribute(node, "name");
+      const provided = name !== void 0 ? named.get(name) : defaultSlot;
+      if (provided && provided.length > 0) {
+        out.push(...provided);
+      } else {
+        out.push(...replaceSlots(node.childNodes, named, defaultSlot));
+      }
+    } else if (isElement(node)) {
+      node.childNodes = replaceSlots(node.childNodes, named, defaultSlot);
+      out.push(node);
+    } else {
+      out.push(node);
+    }
+  }
+  return out;
+}
+
+// ../engine/src/aggregate/aggregate.ts
+function joinUrl(baseUrl, sitePath) {
+  return baseUrl.replace(/\/+$/, "") + sitePath;
+}
+function textContent(html) {
+  const parts = [];
+  const visit = (nodes) => {
+    for (const node of nodes) {
+      if (isTextNode(node)) parts.push(node.value);
+      else if (isElement(node)) visit(node.childNodes);
+    }
+  };
+  visit(parseFragmentNodes(html));
+  return parts.join(" ").replace(/\s+/g, " ").trim();
+}
+function buildSitemap(entries, baseUrl) {
+  const urls = entries.map((entry) => {
+    const lastmod = entry.updated ?? entry.published;
+    const mod = lastmod !== void 0 ? `
+    <lastmod>${escapeHtmlText(lastmod)}</lastmod>` : "";
+    return `  <url>
+    <loc>${escapeHtmlText(joinUrl(baseUrl, entry.url))}</loc>${mod}
+  </url>`;
+  }).join("\n");
+  const contents = `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${urls}
+</urlset>
+`;
+  return { path: "sitemap.xml", contents };
+}
+function buildRss(entries, options) {
+  const items = [...entries].sort(
+    (a, b) => String(b.published ?? "").localeCompare(String(a.published ?? ""))
+  );
+  const lastBuild = items[0]?.published;
+  const rfc822 = (iso) => new Date(iso).toUTCString();
+  const itemXml = items.map((entry) => {
+    const link = joinUrl(options.baseUrl, entry.url);
+    const pub = entry.published !== void 0 ? `
+      <pubDate>${escapeHtmlText(rfc822(entry.published))}</pubDate>` : "";
+    const desc = entry.summary !== void 0 ? `
+      <description>${escapeHtmlText(entry.summary)}</description>` : "";
+    return `    <item>
+      <title>${escapeHtmlText(entry.title)}</title>
+      <link>${escapeHtmlText(link)}</link>
+      <guid>${escapeHtmlText(link)}</guid>${pub}${desc}
+    </item>`;
+  }).join("\n");
+  const built = lastBuild !== void 0 ? `
+    <lastBuildDate>${escapeHtmlText(rfc822(lastBuild))}</lastBuildDate>` : "";
+  const contents = `<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0">
+  <channel>
+    <title>${escapeHtmlText(options.title)}</title>
+    <link>${escapeHtmlText(options.baseUrl)}</link>
+    <description>${escapeHtmlText(options.description)}</description>${built}
+${itemXml}
+  </channel>
+</rss>
+`;
+  return { path: "feed.xml", contents };
+}
+function buildContentIndex(entries) {
+  const docs = entries.map((entry) => ({
+    url: entry.url,
+    title: entry.title,
+    ...entry.published !== void 0 && { published: entry.published },
+    ...entry.summary !== void 0 && { summary: entry.summary }
+  }));
+  return { path: "content.json", contents: JSON.stringify(docs) };
+}
+
+// ../engine/src/concurrency.ts
+async function mapWithConcurrency(items, limit, fn) {
+  const results = new Array(items.length);
+  const workers = Math.max(1, Math.min(Math.floor(limit), items.length));
+  let next = 0;
+  const run = async () => {
+    while (next < items.length) {
+      const index = next++;
+      results[index] = await fn(items[index], index);
+    }
+  };
+  await Promise.all(Array.from({ length: workers }, () => run()));
+  return results;
+}
+
+// ../engine/src/template/fields.ts
+function lengthConstraints(el) {
+  const min = parseLength(getAttribute(el, "data-minlength"));
+  const max = parseLength(getAttribute(el, "data-maxlength"));
+  return {
+    ...min !== void 0 && { minLength: min },
+    ...max !== void 0 && { maxLength: max }
+  };
+}
+function parseLength(raw) {
+  if (raw === void 0) return void 0;
+  const value = Number(raw);
+  return Number.isInteger(value) && value >= 0 ? value : void 0;
+}
+function deriveFields(template, components = /* @__PURE__ */ new Map()) {
+  return deriveFromSource(template, components, /* @__PURE__ */ new Set());
+}
+function componentPropTypes(tag, components, seen) {
+  if (seen.has(tag)) return /* @__PURE__ */ new Map();
+  const source = components.get(tag);
+  if (source === void 0) return /* @__PURE__ */ new Map();
+  const fields = deriveFromSource(source, components, new Set(seen).add(tag));
+  return new Map(fields.map((field) => [field.name, field.type]));
+}
+function deriveFromSource(source, components, seen) {
+  const order = [];
+  const fields = /* @__PURE__ */ new Map();
+  const ensure = (name) => {
+    const existing = fields.get(name);
+    if (existing !== void 0) return existing;
+    const created = {
+      name,
+      type: "shorttext",
+      label: humanize(name),
+      required: false,
+      multiline: false
+    };
+    fields.set(name, created);
+    order.push(name);
+    return created;
+  };
+  const record = (name, type) => {
+    if (fields.has(name)) return;
+    const field = ensure(name);
+    field.type = type;
+    field.multiline = FIELD_TYPES[type].multiline;
+  };
+  const applyAnnotations = (el) => {
+    const named = getAttribute(el, "data-field") ?? firstTokenName(el);
+    if (named === void 0) return;
+    const field = ensure(named);
+    if (hasAttribute(el, "data-required")) field.required = true;
+    const help = getAttribute(el, "data-help");
+    if (help !== void 0) field.help = help;
+    const label = getAttribute(el, "data-label");
+    if (label !== void 0) field.label = label;
+    const { minLength, maxLength } = lengthConstraints(el);
+    if (minLength !== void 0) field.minLength = minLength;
+    if (maxLength !== void 0) field.maxLength = maxLength;
+  };
+  const visit = (nodes) => {
+    for (const node of nodes) {
+      if (!isElement(node)) {
+        if (isTextNode(node)) continue;
+        continue;
+      }
+      const eachField = getAttribute(node, "data-each");
+      if (eachField !== void 0) {
+        const field = ensure(eachField);
+        field.type = "url";
+        field.multiple = true;
+        const pickFrom = getAttribute(node, "data-pick-from");
+        if (pickFrom !== void 0) field.pickFrom = pickFrom;
+        applyAnnotations(node);
+        continue;
+      }
+      if (hasAttribute(node, "data-each-in")) continue;
+      const annotation = getAttribute(node, "data-type");
+      const propTypes = components.has(node.tagName) ? componentPropTypes(node.tagName, components, seen) : void 0;
+      for (const attr of node.attrs) {
+        const whole = wholeValueToken(attr.value);
+        for (const token of findTokens(attr.value)) {
+          if (token.dotted) continue;
+          const isWhole = whole?.name === token.name;
+          const propType = isWhole ? propTypes?.get(attr.name) : void 0;
+          record(
+            token.name,
+            propType ?? inferControl({
+              tag: node.tagName,
+              attribute: attr.name,
+              wholeValue: isWhole,
+              valuePrefix: literalPrefix(attr.value),
+              download: hasAttribute(node, "download"),
+              ...annotation !== void 0 && { annotation }
+            })
+          );
+        }
+      }
+      for (const child of node.childNodes) {
+        if (!isTextNode(child)) continue;
+        const whole = wholeValueToken(child.value);
+        for (const token of findTokens(child.value)) {
+          if (token.dotted) continue;
+          record(
+            token.name,
+            inferControl({
+              tag: node.tagName,
+              wholeValue: whole?.name === token.name,
+              ...annotation !== void 0 && { annotation }
+            })
+          );
+        }
+      }
+      applyAnnotations(node);
+      visit(node.childNodes);
+    }
+  };
+  visit(parseNodes(source));
+  return order.map((name) => freeze(fields.get(name)));
+}
+function firstTokenName(el) {
+  for (const attr of el.attrs) {
+    const token = findTokens(attr.value).find((candidate) => !candidate.dotted);
+    if (token !== void 0) return token.name;
+  }
+  for (const child of el.childNodes) {
+    if (isTextNode(child)) {
+      const token = findTokens(child.value).find((candidate) => !candidate.dotted);
+      if (token !== void 0) return token.name;
+    }
+  }
+  return void 0;
+}
+function freeze(field) {
+  return {
+    name: field.name,
+    type: field.type,
+    label: field.label,
+    required: field.required,
+    multiline: field.multiline,
+    ...field.help !== void 0 && { help: field.help },
+    ...field.minLength !== void 0 && { minLength: field.minLength },
+    ...field.maxLength !== void 0 && { maxLength: field.maxLength },
+    ...field.multiple !== void 0 && { multiple: field.multiple },
+    ...field.pickFrom !== void 0 && { pickFrom: field.pickFrom }
+  };
+}
+
+// ../engine/src/template/analyze.ts
+function analyzeTemplate(source, components = /* @__PURE__ */ new Map()) {
+  const requiredFields = /* @__PURE__ */ new Set();
+  const queryLoopPaths = [];
+  const curatedLoopFields = [];
+  const imageFields = /* @__PURE__ */ new Set();
+  const fileFields = /* @__PURE__ */ new Set();
+  const richTextFields = /* @__PURE__ */ new Set();
+  const constraints = /* @__PURE__ */ new Map();
+  const references = /* @__PURE__ */ new Set();
+  const visit = (nodes) => {
+    for (const node of nodes) {
+      if (!isElement(node)) continue;
+      const richText = richTextFieldName(node);
+      if (richText !== void 0) richTextFields.add(richText);
+      const eachIn = getAttribute(node, "data-each-in");
+      if (eachIn !== void 0) queryLoopPaths.push(eachIn);
+      const each = getAttribute(node, "data-each");
+      if (each !== void 0) curatedLoopFields.push(each);
+      if (hasAttribute(node, "data-required")) {
+        const field = annotatedFieldName(node);
+        if (field !== void 0) requiredFields.add(field);
+      }
+      const bounds = lengthConstraints(node);
+      if (bounds.minLength !== void 0 || bounds.maxLength !== void 0) {
+        const field = annotatedFieldName(node);
+        if (field !== void 0) constraints.set(field, bounds);
+      }
+      const annotation = getAttribute(node, "data-type");
+      const propTypes = components.has(node.tagName) ? componentPropTypes(node.tagName, components, /* @__PURE__ */ new Set()) : void 0;
+      for (const attr of node.attrs) {
+        const reference = referenceTarget(attr.value);
+        if (reference !== void 0) references.add(reference);
+        const token = wholeValueToken(attr.value);
+        if (token === null || token.dotted) continue;
+        const type = propTypes?.get(attr.name) ?? inferControl({
+          tag: node.tagName,
+          attribute: attr.name,
+          wholeValue: true,
+          valuePrefix: literalPrefix(attr.value),
+          download: hasAttribute(node, "download"),
+          ...annotation !== void 0 && { annotation }
+        });
+        if (type === "image") imageFields.add(token.name);
+        else if (type === "file") fileFields.add(token.name);
+        else if (type === "richtext") richTextFields.add(token.name);
+      }
+      visit(node.childNodes);
+    }
+  };
+  visit(parseNodes(source));
+  return {
+    requiredFields: [...requiredFields],
+    queryLoopPaths,
+    curatedLoopFields,
+    imageFields: [...imageFields],
+    fileFields: [...fileFields],
+    richTextFields: [...richTextFields],
+    constraints,
+    references: [...references].sort()
+  };
+}
+function richTextFieldName(el) {
+  const meaningful = el.childNodes.filter(
+    (child) => !(isTextNode(child) && child.value.trim() === "")
+  );
+  const only = meaningful[0];
+  if (meaningful.length !== 1 || only === void 0 || !isTextNode(only)) return void 0;
+  const token = wholeValueToken(only.value);
+  if (token === null || token.dotted) return void 0;
+  const annotation = getAttribute(el, "data-type");
+  const type = inferControl({
+    tag: el.tagName,
+    wholeValue: true,
+    ...annotation !== void 0 && { annotation }
+  });
+  return valueKindOf(type) === "html" ? token.name : void 0;
+}
+function annotatedFieldName(el) {
+  const explicit = getAttribute(el, "data-field");
+  if (explicit !== void 0) return explicit;
+  for (const attr of el.attrs) {
+    const token = findTokens(attr.value).find((candidate) => !candidate.dotted);
+    if (token !== void 0) return token.name;
+  }
+  for (const child of el.childNodes) {
+    if (isTextNode(child)) {
+      const token = findTokens(child.value).find((candidate) => !candidate.dotted);
+      if (token !== void 0) return token.name;
+    }
+  }
+  return void 0;
+}
+
+// ../engine/src/url/urls.ts
+function segmentsOf(contentPath) {
+  return contentPath.split("/").filter((segment) => segment !== "");
+}
+function outputPathForItem(contentPath) {
+  const segments = segmentsOf(contentPath);
+  if (segments[segments.length - 1] === "index") {
+    return [...segments.slice(0, -1), "index.html"].join("/");
+  }
+  return [...segments, "index.html"].join("/");
+}
+function urlForItem(contentPath) {
+  const segments = segmentsOf(contentPath);
+  const dirSegments = segments[segments.length - 1] === "index" ? segments.slice(0, -1) : segments;
+  return dirSegments.length === 0 ? "/" : `/${dirSegments.join("/")}/`;
+}
+
+// ../engine/src/compile/site.ts
+var DEFAULT_IMAGE_CONCURRENCY = 4;
+async function compileSite(source, options = {}) {
+  const [
+    tree,
+    components,
+    componentStyles,
+    componentScripts,
+    documentShell,
+    redirects,
+    siteConfig
+  ] = await Promise.all([
+    loadContentTree(source),
+    loadComponents(source),
+    loadComponentStyles(source),
+    loadComponentScripts(source),
+    loadDocumentShell(source),
+    loadRedirects(source),
+    loadSiteConfig(source)
+  ]);
+  const context = buildResolveContext(tree);
+  const baseUrl = options.baseUrl ?? siteConfig.baseUrl;
+  const templateCache = /* @__PURE__ */ new Map();
+  const getTemplate = async (name) => {
+    const cached = templateCache.get(name);
+    if (cached !== void 0) return cached;
+    const loaded = await loadTemplate(source, name);
+    templateCache.set(name, loaded);
+    return loaded;
+  };
+  const styleCache = /* @__PURE__ */ new Map();
+  const scriptCache = /* @__PURE__ */ new Map();
+  const getStyle = async (name) => {
+    if (!styleCache.has(name)) styleCache.set(name, await loadTemplateStyle(source, name));
+    return styleCache.get(name);
+  };
+  const getScript = async (name) => {
+    if (!scriptCache.has(name)) scriptCache.set(name, await loadTemplateScript(source, name));
+    return scriptCache.get(name);
+  };
+  const analysisCache = /* @__PURE__ */ new Map();
+  const getAnalysis = (name, templateSource) => {
+    const cached = analysisCache.get(name);
+    if (cached !== void 0) return cached;
+    const analysis = analyzeTemplate(templateSource, components);
+    analysisCache.set(name, analysis);
+    return analysis;
+  };
+  const artifacts = [];
+  const entries = [];
+  const walk = async (dir, inheritedTemplate) => {
+    const dirTemplate = dir.defaultTemplate ?? inheritedTemplate;
+    for (const child of dir.children) {
+      if (child.kind === "dir") {
+        await walk(child, dirTemplate);
+        continue;
+      }
+      if (!child.item.isPublished) continue;
+      const templateName = child.item.template ?? dirTemplate;
+      if (templateName === void 0) {
+        throw new Error(
+          `Item "${child.path}" has no template (no per-item template and no folder default).`
+        );
+      }
+      const template = await getTemplate(templateName);
+      const analysis = getAnalysis(templateName, template);
+      const { media, mediaArtifacts } = await collectMedia(
+        source,
+        child,
+        analysis,
+        options.imageEncoder,
+        options.imageConcurrency ?? DEFAULT_IMAGE_CONCURRENCY
+      );
+      artifacts.push(...mediaArtifacts);
+      const templateStyle = await getStyle(templateName);
+      const templateScript = await getScript(templateName);
+      const contents = compileTemplate({
+        template,
+        scope: buildScope(child.item),
+        components,
+        context,
+        media,
+        componentStyles,
+        componentScripts,
+        ...options.authorDirectory !== void 0 && { authorDirectory: options.authorDirectory },
+        ...documentShell !== void 0 && { document: documentShell },
+        ...templateStyle !== void 0 && { templateStyle },
+        ...templateScript !== void 0 && { templateScript }
+      });
+      artifacts.push({ path: outputPathForItem(child.path), contents });
+      entries.push(toEntry(child));
+    }
+  };
+  await walk(tree, void 0);
+  const redirectArtifact = buildRedirects(redirects, new Set(entries.map((entry) => entry.url)));
+  if (redirectArtifact !== void 0) artifacts.push(redirectArtifact);
+  if (options.contentIndex !== false) artifacts.push(buildContentIndex(entries));
+  if (baseUrl !== void 0) {
+    artifacts.push(buildSitemap(entries, baseUrl));
+    const rss = options.rss;
+    if (rss !== void 0) {
+      const feed = entries.filter((entry) => inCollection(entry, rss.collection));
+      artifacts.push(
+        buildRss(feed, {
+          baseUrl,
+          title: rss.title,
+          description: rss.description ?? rss.title,
+          collection: rss.collection
+        })
+      );
+    }
+  }
+  return artifacts;
+}
+async function compilePage(source, itemPath, options = {}) {
+  const [tree, components, componentStyles, componentScripts] = await Promise.all([
+    loadContentTree(source),
+    loadComponents(source),
+    loadComponentStyles(source),
+    loadComponentScripts(source)
+  ]);
+  const found = findItem(tree, itemPath, void 0);
+  if (found === void 0) return void 0;
+  const item = options.draft ?? found.node.item;
+  const templateName = item.template ?? found.dirTemplate;
+  if (templateName === void 0) return void 0;
+  const [template, templateStyle, templateScript, documentShell] = await Promise.all([
+    loadTemplate(source, templateName),
+    loadTemplateStyle(source, templateName),
+    loadTemplateScript(source, templateName),
+    loadDocumentShell(source)
+  ]);
+  const analysis = analyzeTemplate(template, components);
+  const node = { ...found.node, item };
+  let media;
+  let mediaArtifacts = [];
+  if (options.media !== void 0) {
+    media = options.media;
+  } else {
+    const collected = await collectMedia(
+      source,
+      node,
+      analysis,
+      options.imageEncoder,
+      DEFAULT_IMAGE_CONCURRENCY
+    );
+    media = collected.media;
+    mediaArtifacts = collected.mediaArtifacts;
+  }
+  const html = compileTemplate({
+    template,
+    scope: buildScope(item),
+    components,
+    context: buildResolveContext(tree),
+    media,
+    componentStyles,
+    componentScripts,
+    ...options.authorDirectory !== void 0 && { authorDirectory: options.authorDirectory },
+    ...documentShell !== void 0 && { document: documentShell },
+    ...templateStyle !== void 0 && { templateStyle },
+    ...templateScript !== void 0 && { templateScript }
+  });
+  return { html, mediaArtifacts };
+}
+function findItem(dir, path, inherited) {
+  const dirTemplate = dir.defaultTemplate ?? inherited;
+  for (const child of dir.children) {
+    if (child.kind === "item") {
+      if (child.path === path) return { node: child, dirTemplate };
+    } else {
+      const found = findItem(child, path, dirTemplate);
+      if (found !== void 0) return found;
+    }
+  }
+  return void 0;
+}
+function toEntry(node) {
+  const fields = node.item.fields;
+  return {
+    path: node.path,
+    slug: node.slug,
+    url: urlForItem(node.path),
+    title: node.item.title,
+    ...node.item.published !== void 0 && { published: node.item.published },
+    ...node.item.updated !== void 0 && { updated: node.item.updated },
+    ...typeof fields.summary === "string" && { summary: fields.summary }
+  };
+}
+function inCollection(entry, collectionPath) {
+  if (entry.slug === "index") return false;
+  const collection = collectionPath.replace(/^\/+/, "").replace(/\/+$/, "");
+  if (collection === "") return true;
+  return entry.path === collection || entry.path.startsWith(`${collection}/`);
+}
+async function collectMedia(source, node, analysis, encoder, imageConcurrency) {
+  const itemDir = parentPath(node.path);
+  const fields = node.item.fields;
+  const images = /* @__PURE__ */ new Map();
+  const files = /* @__PURE__ */ new Map();
+  const mediaArtifacts = [];
+  for (const field of analysis.fileFields) {
+    for (const ref of assetRefs(fields[field])) {
+      const published = joinAsset(itemDir, ref);
+      const bytes = await tryReadBytes(source, `content/${published}`);
+      if (bytes === void 0) continue;
+      mediaArtifacts.push({ path: published, contents: bytes });
+      files.set(ref, `/${published}`);
+    }
+  }
+  if (encoder !== void 0) {
+    const imageRefs = /* @__PURE__ */ new Set();
+    for (const field of analysis.imageFields) {
+      for (const ref of assetRefs(fields[field])) imageRefs.add(ref);
+    }
+    for (const field of analysis.richTextFields) {
+      const value = fields[field];
+      if (typeof value === "string") {
+        for (const ref of inlineImageRefs(value)) imageRefs.add(ref);
+      }
+    }
+    const encoded = await mapWithConcurrency([...imageRefs], imageConcurrency, async (ref) => {
+      const published = joinAsset(itemDir, ref);
+      const bytes = await tryReadBytes(source, `content/${published}`);
+      if (bytes === void 0) return void 0;
+      return { ref, ...await processImage(bytes, published, encoder) };
+    });
+    for (const result of encoded) {
+      if (result === void 0) continue;
+      mediaArtifacts.push(...result.artifacts);
+      images.set(result.ref, result.info);
+    }
+  }
+  return {
+    media: { image: (ref) => images.get(ref), file: (ref) => files.get(ref) },
+    mediaArtifacts
+  };
+}
+async function tryReadBytes(source, path) {
+  try {
+    return await source.readBytes(path);
+  } catch {
+    return void 0;
+  }
+}
+function parentPath(path) {
+  const slash = path.lastIndexOf("/");
+  return slash === -1 ? "" : path.slice(0, slash);
+}
+function joinAsset(dir, ref) {
+  return [dir, ref.replace(/^\/+/, "")].filter((part) => part !== "").join("/");
+}
+function inlineImageRefs(html) {
+  const refs = [];
+  const walk = (nodes) => {
+    for (const node of nodes) {
+      if (!isElement(node)) continue;
+      if (node.tagName === "img") {
+        const src = getAttribute(node, "src");
+        if (src !== void 0 && isAssetRef(src)) refs.push(src);
+      }
+      walk(node.childNodes);
+    }
+  };
+  walk(parseFragmentNodes(html));
+  return refs;
+}
+function isAssetRef(value) {
+  if (value === "" || value.startsWith("/") || value.startsWith("data:")) return false;
+  return !/^[a-z][a-z0-9+.-]*:/i.test(value);
+}
+function assetRefs(value) {
+  if (typeof value === "string") return [value];
+  if (Array.isArray(value))
+    return value.filter((entry) => typeof entry === "string");
+  return [];
+}
+function buildScope(item) {
+  return {
+    ...item.fields,
+    title: item.title,
+    ...item.created !== void 0 && { created: item.created },
+    ...item.published !== void 0 && { published: item.published },
+    ...item.updated !== void 0 && { updated: item.updated }
+  };
+}
+function indexTree(tree) {
+  const items = /* @__PURE__ */ new Map();
+  const dirs = /* @__PURE__ */ new Map();
+  const walk = (dir) => {
+    dirs.set(dir.path, dir);
+    for (const child of dir.children) {
+      if (child.kind === "item") items.set(child.path, child);
+      else walk(child);
+    }
+  };
+  walk(tree);
+  return { items, dirs };
+}
+function normalizeCollectionPath(path) {
+  return path.replace(/^\/+/, "").replace(/\/+$/, "");
+}
+function buildResolveContext(tree) {
+  const { items, dirs } = indexTree(tree);
+  const bound = (node) => ({
+    url: urlForItem(node.path),
+    fields: buildScope(node.item)
+  });
+  return {
+    collection(path, query) {
+      const dir = dirs.get(normalizeCollectionPath(path));
+      if (dir === void 0) return [];
+      const recursive = dir.collection?.recursive ?? false;
+      const collected = [];
+      const gather = (current) => {
+        for (const child of current.children) {
+          if (child.kind === "item") {
+            if (child.slug !== "index" && child.item.isPublished) collected.push(child);
+          } else if (recursive) {
+            gather(child);
+          }
+        }
+      };
+      gather(dir);
+      const sorted = sortItems(collected, query.sort);
+      const limited = query.limit !== void 0 ? sorted.slice(0, query.limit) : sorted;
+      return limited.map(bound);
+    },
+    reference(path) {
+      const node = items.get(normalizeCollectionPath(path));
+      if (node === void 0 || !node.item.isPublished) return void 0;
+      return bound(node);
+    }
+  };
+}
+function sortItems(items, sort) {
+  if (sort === void 0) return [...items];
+  const [field = "published", direction] = sort.trim().split(/\s+/);
+  const keyOf = (node) => {
+    const value = buildScope(node.item)[field];
+    return value === void 0 || value === null ? "" : String(value);
+  };
+  const sorted = [...items].sort((a, b) => keyOf(a).localeCompare(keyOf(b)));
+  return direction === "desc" ? sorted.reverse() : sorted;
+}
+
+// ../engine/src/reference/reference.ts
+var FIELD_TYPE_DOCS = [
+  {
+    type: "shorttext",
+    summary: "A single line of plain text, the default for headings and any token not inferred as something more specific.",
+    example: "<h1>{title}</h1>"
+  },
+  {
+    type: "text",
+    summary: "Multi-line plain text with no formatting, inferred for paragraphs and block elements.",
+    example: "<p>{summary}</p>"
+  },
+  {
+    type: "richtext",
+    summary: "Formatted HTML from the rich-text editor (headings, links, lists, inline images). Opt-in, never inferred, so a plain block never becomes a surprise editor.",
+    example: '<div data-type="richtext">{body}</div>'
+  },
+  {
+    type: "code",
+    summary: "A monospaced code block, inferred inside <pre>, <code>, <kbd>, and <samp>.",
+    example: "<pre>{snippet}</pre>"
+  },
+  {
+    type: "image",
+    summary: "An image asset. On publish it runs the media pipeline (responsive <picture> variants). Inferred from <img src>.",
+    example: '<img src="{hero}" alt="{caption}">'
+  },
+  {
+    type: "file",
+    summary: "A downloadable file asset (PDF, zip\u2026). Inferred from a non-image src, or an <a href> marked download.",
+    example: '<a href="{brochure}" download>Download the brochure</a>'
+  },
+  {
+    type: "url",
+    summary: "A link target, an internal page reference or an external URL. Inferred from <a href>.",
+    example: '<a href="{cta_link}">{cta_label}</a>'
+  },
+  {
+    type: "email",
+    summary: "An email address. Inferred from an href that starts with mailto:.",
+    example: '<a href="mailto:{email}">{email}</a>'
+  },
+  {
+    type: "phone",
+    summary: "A phone number. Inferred from an href that starts with tel:.",
+    example: '<a href="tel:{phone}">{phone}</a>'
+  },
+  {
+    type: "date",
+    summary: "A calendar date, shown as a date picker. Opt-in via data-type, never inferred.",
+    example: '<time datetime="{published}" data-type="date">{published}</time>'
+  },
+  {
+    type: "time",
+    summary: "A time of day, shown as a time picker. Opt-in via data-type, never inferred.",
+    example: '<span data-type="time">{doors_open}</span>'
+  },
+  {
+    type: "authors",
+    summary: "A byline: an ordered list of authors the editor builds from your users\u2019 display names (or typed-in guests), rendered as one grammatical line, \u201CA\u201D, \u201CA and B\u201D, \u201CA, B and C\u201D (no Oxford comma). Opt-in via data-type, never inferred. A display-name change updates every past byline.",
+    example: '<p class="byline" data-type="authors">{authors}</p>'
+  }
+];
+function buildAuthoringReference(context = {}) {
+  return {
+    title: "nanoesis authoring reference",
+    intro: "Everything you can put in a template. A template is ordinary HTML with {tokens}; the set of tokens is the editor form, \u201Cthe template is the schema\u201D. This reference is generated from the engine, so it always matches the version you are running.",
+    sections: [
+      tokensSection(),
+      fieldTypesSection(),
+      annotationsSection(),
+      loopsSection(context),
+      componentsSection(context),
+      shellSection()
+    ]
+  };
+}
+function tokensSection() {
+  return {
+    title: "Tokens",
+    intro: "Wrap a field name in braces to print it. Each distinct token becomes one field in the editor; where the token sits decides the field\u2019s type.",
+    entries: [
+      {
+        name: "{field}",
+        summary: "Print a page field, the name in the braces is the field name.",
+        example: "<h1>{title}</h1>\n<p>{summary}</p>"
+      },
+      {
+        name: "{title}, {published}, {created}, {updated}",
+        summary: "Built-in fields every page has. {title} names the page in the tree; the others are ISO timestamps you can format or print."
+      },
+      {
+        name: "{item} and {item.field}",
+        summary: "Inside a loop, the current item: {item} is its URL, and {item.title} (or any field) is its content.",
+        example: '<a href="{item}">{item.title}</a>'
+      }
+    ]
+  };
+}
+function fieldTypesSection() {
+  return {
+    title: "Field types",
+    intro: "A token\u2019s control type is inferred from where it sits; the non-obvious ones (rich text, date, time, code) are opt-in with data-type. One entry per type, with the snippet that produces it.",
+    entries: FIELD_TYPE_DOCS.map(({ type, summary, example }) => ({
+      name: type,
+      summary,
+      example,
+      ...FIELD_TYPES[type].multiline && { detail: "Multi-line." }
+    }))
+  };
+}
+function annotationsSection() {
+  return {
+    title: "Field annotations",
+    intro: "Optional data-* attributes that refine a field. Put them on the element holding the token; use data-field to name the field when the element has none.",
+    entries: [
+      {
+        name: "data-field",
+        summary: "Says which field an element\u2019s annotations apply to. They default to the element\u2019s first token (attributes before text); use data-field to target a different one, e.g. make the link text required, not the URL. (Not needed when the element holds a single token.)",
+        example: '<a href="{url}" data-field="label" data-required>{label}</a>'
+      },
+      {
+        name: "data-label",
+        summary: "Set the label shown above the field in the editor (defaults to a humanised name).",
+        example: '<p data-label="Short summary">{summary}</p>'
+      },
+      {
+        name: "data-help",
+        summary: "Add a line of helper text beneath the field in the editor.",
+        example: '<p data-help="One or two sentences.">{summary}</p>'
+      },
+      {
+        name: "data-required",
+        summary: "Mark the field mandatory. Publishing is blocked until every page fills it.",
+        example: "<p data-required>{summary}</p>"
+      },
+      {
+        name: "data-minlength / data-maxlength",
+        summary: "Warn (it does not block) when the value is shorter or longer than N characters, e.g. a 50-160 character SEO meta description.",
+        example: '<p data-minlength="50" data-maxlength="160">{summary}</p>'
+      },
+      {
+        name: "data-type",
+        summary: "Force the control type, overriding inference, the escape hatch for rich text, date, time, and code.",
+        example: '<div data-type="richtext">{body}</div>'
+      }
+    ]
+  };
+}
+function loopsSection(context) {
+  const entries = [
+    {
+      name: "Automatic loop, data-each-in",
+      summary: "Repeat an element once per published page in a folder (and its subfolders), filling {item.\u2026} tokens automatically. Point it at a folder path.",
+      example: '<ul>\n  <li data-each-in="/blog" data-sort="published desc" data-limit="5">\n    <a href="{item}">{item.title}</a>\n  </li>\n</ul>'
+    },
+    {
+      name: "data-sort",
+      summary: 'Order an automatic loop by a field and direction, "field asc" or "field desc".',
+      example: '<li data-each-in="/blog" data-sort="published desc">\u2026</li>'
+    },
+    {
+      name: "data-limit",
+      summary: "Take at most N items (after sorting), e.g. a \u201Clatest 3\u201D list.",
+      example: '<li data-each-in="/blog" data-limit="3">\u2026</li>'
+    },
+    {
+      name: "Curated loop, data-each",
+      summary: "Repeat over a hand-picked, ordered list of references stored in a field; the author chooses the items in the editor.",
+      example: '<div data-each="featured" data-pick-from="/products">\n  <a href="{item}"><img src="{item.image}" alt="">{item.title}</a>\n</div>'
+    },
+    {
+      name: "data-pick-from",
+      summary: "Scope a curated loop\u2019s reference picker to one folder, so the author only sees the right pages.",
+      example: '<div data-each="featured" data-pick-from="/products">\u2026</div>'
+    }
+  ];
+  const collections = sortedUnique(context.collections);
+  if (collections.length > 0) {
+    entries.push({
+      name: "Your collections",
+      summary: "Folders in this site you can loop over or pick from:",
+      detail: collections.join(", ")
+    });
+  }
+  return {
+    title: "Loops",
+    intro: "Two ways to repeat content: automatic (every page in a folder) and curated (a chosen list).",
+    entries
+  };
+}
+function componentsSection(context) {
+  const entries = [
+    {
+      name: "Using a component",
+      summary: "A file in components/ named card.html becomes the tag <card>. Pass props as attributes; the component\u2019s own tokens are typed by how it uses them.",
+      example: '<card title="{name}" image="{photo}"></card>'
+    },
+    {
+      name: "Slots",
+      summary: "A <slot> inside a component renders whatever children a usage wraps around it.",
+      example: '<!-- components/panel.html -->\n<section class="panel"><slot></slot></section>'
+    }
+  ];
+  const components = sortedUnique(context.components);
+  if (components.length > 0) {
+    entries.push({
+      name: "Your components",
+      summary: "Components available in this site:",
+      detail: components.map((tag) => `<${tag}>`).join(", ")
+    });
+  }
+  return {
+    title: "Components",
+    intro: "Reusable fragments with their own scoped CSS and JS, used as custom tags.",
+    entries
+  };
+}
+function shellSection() {
+  return {
+    title: "The document shell",
+    intro: "templates/document.html wraps every page, the <head> and the chrome around <slot></slot>. Tokens here (meta description, Open Graph image\u2026) become each page\u2019s Meta & SEO fields, so annotations like data-required and data-maxlength on them apply to every page.",
+    entries: []
+  };
+}
+function sortedUnique(values) {
+  return [...new Set(values ?? [])].sort();
+}
+function renderReferenceMarkdown(reference) {
+  const lines = [`# ${reference.title}`, "", reference.intro, ""];
+  for (const section of reference.sections) {
+    lines.push(`## ${section.title}`, "", section.intro, "");
+    for (const entry of section.entries) {
+      lines.push(`### ${entry.name}`, "", entry.summary, "");
+      if (entry.detail !== void 0) lines.push(`*${entry.detail}*`, "");
+      if (entry.example !== void 0) lines.push("```html", entry.example, "```", "");
+    }
+  }
+  return `${lines.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd()}
+`;
+}
+
+// ../engine/src/validate/gate.ts
+async function validateSite(source) {
+  const [tree, components, documentShell] = await Promise.all([
+    loadContentTree(source),
+    loadComponents(source),
+    loadDocumentShell(source)
+  ]);
+  const { items, dirs, published } = indexTree2(tree);
+  let shellAnalysis = null;
+  if (documentShell !== void 0) {
+    try {
+      shellAnalysis = analyzeTemplate(documentShell, components);
+    } catch {
+      shellAnalysis = null;
+    }
+  }
+  const shellRequiredFields = shellAnalysis?.requiredFields ?? [];
+  const shellConstraints = shellAnalysis?.constraints ?? /* @__PURE__ */ new Map();
+  const diagnostics = [];
+  const add = (severity, code, message, path) => {
+    diagnostics.push({ severity, code, message, ...path !== void 0 && { path } });
+  };
+  const reportRef = (ref, owner, where) => {
+    const target = items.get(stripSlashes(ref));
+    if (target === void 0) {
+      add(
+        "error",
+        "reference-missing",
+        `"${owner}" references "${ref}" (${where}), which does not exist.`,
+        owner
+      );
+    } else if (!target.item.isPublished) {
+      add(
+        "error",
+        "reference-unpublished",
+        `"${owner}" references "${ref}" (${where}), which is not published.`,
+        owner
+      );
+    }
+  };
+  const checkLengths = (bounds, scope, path) => {
+    for (const [field, { minLength, maxLength }] of bounds) {
+      const value = scope[field];
+      if (typeof value !== "string" || value === "") continue;
+      const { length } = value;
+      if (minLength !== void 0 && length < minLength) {
+        add(
+          "warning",
+          "value-too-short",
+          `"${path}" field "${field}" is ${length} characters; the minimum is ${minLength}.`,
+          path
+        );
+      }
+      if (maxLength !== void 0 && length > maxLength) {
+        add(
+          "warning",
+          "value-too-long",
+          `"${path}" field "${field}" is ${length} characters; the maximum is ${maxLength}.`,
+          path
+        );
+      }
+    }
+  };
+  const analysisCache = /* @__PURE__ */ new Map();
+  const analyze = async (name) => {
+    const cached = analysisCache.get(name);
+    if (cached !== void 0 || analysisCache.has(name)) return cached ?? null;
+    let result;
+    try {
+      result = analyzeTemplate(await loadTemplate(source, name), components);
+    } catch {
+      result = null;
+    }
+    analysisCache.set(name, result);
+    return result;
+  };
+  const urlOwners = /* @__PURE__ */ new Map();
+  for (const { node, templateName } of published) {
+    const owners = urlOwners.get(urlForItem(node.path)) ?? [];
+    owners.push(node.path);
+    urlOwners.set(urlForItem(node.path), owners);
+    if (templateName === void 0) {
+      add(
+        "error",
+        "no-template",
+        `"${node.path}" has no template (no per-item or folder default).`,
+        node.path
+      );
+      continue;
+    }
+    const analysis = await analyze(templateName);
+    if (analysis === null) {
+      add(
+        "error",
+        "template-missing",
+        `"${node.path}" uses template "${templateName}", which does not exist.`,
+        node.path
+      );
+      continue;
+    }
+    const scope = buildScope2(node.item);
+    for (const field of analysis.requiredFields) {
+      if (isEmpty(scope[field])) {
+        add(
+          "error",
+          "required-empty",
+          `"${node.path}" is missing required field "${field}".`,
+          node.path
+        );
+      }
+    }
+    for (const field of shellRequiredFields) {
+      if (isEmpty(scope[field])) {
+        add(
+          "error",
+          "required-empty",
+          `"${node.path}" is missing required meta field "${field}" (document shell).`,
+          node.path
+        );
+      }
+    }
+    checkLengths(analysis.constraints, scope, node.path);
+    checkLengths(shellConstraints, scope, node.path);
+    for (const loopPath of analysis.queryLoopPaths) {
+      if (!dirs.has(stripSlashes(loopPath))) {
+        add(
+          "error",
+          "loop-target-missing",
+          `"${node.path}" loops over "${loopPath}", which is not a directory.`,
+          node.path
+        );
+      }
+    }
+    for (const field of analysis.curatedLoopFields) {
+      for (const ref of asPaths(node.item.fields[field])) {
+        reportRef(ref, node.path, `field "${field}"`);
+      }
+    }
+    for (const [field, value] of Object.entries(scope)) {
+      if (typeof value !== "string") continue;
+      const direct = referenceTarget(value);
+      if (direct !== void 0) reportRef(direct, node.path, `field "${field}"`);
+      if (analysis.richTextFields.includes(field)) {
+        for (const ref of collectHtmlReferences(value))
+          reportRef(ref, node.path, `field "${field}"`);
+      }
+    }
+  }
+  const templatesDir = DEFAULT_DIRS.templates;
+  if (shellAnalysis !== null) {
+    for (const ref of shellAnalysis.references) {
+      reportRef(ref, `${templatesDir}/${DOCUMENT_SHELL}.html`, "link");
+    }
+  }
+  for (const [name, analysis] of analysisCache) {
+    if (analysis === null) continue;
+    for (const ref of analysis.references) reportRef(ref, `${templatesDir}/${name}.html`, "link");
+  }
+  for (const [tag, html] of components) {
+    for (const ref of collectHtmlReferences(html)) {
+      reportRef(ref, `${DEFAULT_DIRS.components}/${tag}.html`, "link");
+    }
+  }
+  for (const [url, owners] of urlOwners) {
+    if (owners.length > 1) {
+      add(
+        "error",
+        "url-collision",
+        `URL ${url} is produced by multiple items: ${owners.join(", ")}.`
+      );
+    }
+  }
+  const tagToPaths = /* @__PURE__ */ new Map();
+  for (const relative of await listComponentFiles(source)) {
+    const file = relative.slice(relative.lastIndexOf("/") + 1);
+    const tag = file.slice(0, -".html".length).toLowerCase();
+    const owners = tagToPaths.get(tag) ?? [];
+    owners.push(`${DEFAULT_DIRS.components}/${relative}`);
+    tagToPaths.set(tag, owners);
+  }
+  for (const [tag, paths] of [...tagToPaths].sort(([a], [b]) => a.localeCompare(b))) {
+    if (paths.length > 1) {
+      add(
+        "error",
+        "component-tag-collision",
+        `Multiple components resolve to <${tag}>: ${paths.join(", ")}.`
+      );
+    }
+  }
+  const errors = diagnostics.filter((d) => d.severity === "error");
+  const warnings = diagnostics.filter((d) => d.severity === "warning");
+  return { diagnostics, errors, warnings, ok: errors.length === 0 };
+}
+function indexTree2(tree) {
+  const items = /* @__PURE__ */ new Map();
+  const dirs = /* @__PURE__ */ new Map();
+  const published = [];
+  const walk = (dir, inheritedTemplate) => {
+    dirs.set(dir.path, dir);
+    const dirTemplate = dir.defaultTemplate ?? inheritedTemplate;
+    for (const child of dir.children) {
+      if (child.kind === "dir") {
+        walk(child, dirTemplate);
+        continue;
+      }
+      items.set(child.path, child);
+      if (child.item.isPublished) {
+        published.push({ node: child, templateName: child.item.template ?? dirTemplate });
+      }
+    }
+  };
+  walk(tree, void 0);
+  return { items, dirs, published };
+}
+function buildScope2(item) {
+  return {
+    ...item.fields,
+    title: item.title,
+    ...item.created !== void 0 && { created: item.created },
+    ...item.published !== void 0 && { published: item.published },
+    ...item.updated !== void 0 && { updated: item.updated }
+  };
+}
+function isEmpty(value) {
+  if (value === void 0 || value === null || value === "") return true;
+  if (Array.isArray(value)) return value.length === 0;
+  return false;
+}
+function asPaths(value) {
+  if (typeof value === "string") return [value];
+  if (Array.isArray(value))
+    return value.filter((entry) => typeof entry === "string");
+  return [];
+}
+function stripSlashes(path) {
+  return path.replace(/^\/+/, "").replace(/\/+$/, "");
+}
+async function listComponentFiles(source) {
+  const root = DEFAULT_DIRS.components;
+  if (!await source.exists(root)) return [];
+  const out = [];
+  const walk = async (current, prefix) => {
+    for (const entry of await source.list(current)) {
+      const relative = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
+      if (entry.kind === "dir") await walk(`${current}/${entry.name}`, relative);
+      else if (entry.name.endsWith(".html")) out.push(relative);
+    }
+  };
+  await walk(root, "");
+  return out.sort();
+}
+
+// ../engine/src/publish/purge.ts
+var noopPurgeService = {
+  async purgeAll() {
+  }
+};
+
+// ../engine/src/publish/publish.ts
+var DEFAULT_WRITE_CONCURRENCY = 8;
+async function publishSite(source, sink, options = {}) {
+  const validation = await validateSite(source);
+  if (!validation.ok) {
+    return { ok: false, validation, written: [] };
+  }
+  const {
+    purge = noopPurgeService,
+    publicDir = DEFAULT_DIRS.public,
+    prebuild,
+    writeConcurrency = DEFAULT_WRITE_CONCURRENCY,
+    ...compileOptions
+  } = options;
+  if (prebuild !== void 0) {
+    await prebuild.run();
+  }
+  const artifacts = await compileSite(source, compileOptions);
+  const passthrough = await collectPublic(source, publicDir);
+  const byPath = /* @__PURE__ */ new Map();
+  for (const artifact of [...artifacts, ...passthrough])
+    byPath.set(artifact.path, artifact.contents);
+  await mapWithConcurrency(
+    [...byPath],
+    writeConcurrency,
+    ([path, contents]) => sink.write(path, contents)
+  );
+  await purge.purgeAll();
+  return { ok: true, validation, written: [...byPath.keys()].sort() };
+}
+async function collectPublic(source, publicDir) {
+  if (!await source.exists(publicDir)) return [];
+  const out = [];
+  const walk = async (dir, prefix) => {
+    const entries = [...await source.list(dir)].sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      const childPath = `${dir}/${entry.name}`;
+      const outPath = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
+      if (entry.kind === "dir") {
+        await walk(childPath, outPath);
+      } else {
+        out.push({ path: outPath, contents: await source.readBytes(childPath) });
+      }
+    }
+  };
+  await walk(publicDir, "");
+  return out;
+}
+
+// ../engine/src/publish/sink.ts
+function normalizePath2(path) {
+  return path.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "").replace(/\/+$/, "");
+}
+var InMemoryArtifactSink = class {
+  store = /* @__PURE__ */ new Map();
+  async write(path, contents) {
+    this.store.set(normalizePath2(path), contents);
+  }
+  /** The artifacts written so far, path→contents, for assertions in tests. */
+  get written() {
+    return this.store;
+  }
+};
+
+// ../engine/src/identity.ts
+function hasRole(principal, role) {
+  if (principal === null) return false;
+  if (principal.roles.includes("admin")) return true;
+  return principal.roles.includes(role);
+}
+function canEdit(principal) {
+  return hasRole(principal, "author") || hasRole(principal, "developer");
+}
+
+export {
+  slugify,
+  humanize,
+  contentTypeFor,
+  ContentParseError,
+  parseContentItem,
+  parseSortFile,
+  InMemoryBlobStore,
+  emptyIndex,
+  loadIndex,
+  saveIndex,
+  IndexedStore,
+  InMemoryContentSource,
+  parseRedirects,
+  buildRedirects,
+  DEFAULT_DIRS,
+  loadContentTree,
+  loadRedirects,
+  loadSiteConfig,
+  loadComponents,
+  loadComponentStyles,
+  loadComponentScripts,
+  loadTemplate,
+  DOCUMENT_SHELL,
+  loadDocumentShell,
+  FIELD_TYPES,
+  isFieldType,
+  valueKindOf,
+  inferControl,
+  findTokens,
+  wholeValueToken,
+  escapeHtmlText,
+  escapeHtmlAttribute,
+  escapeJsonStringContent,
+  sanitizeUrl,
+  toAuthorRefs,
+  joinAuthors,
+  renderAuthors,
+  contentHash,
+  processImage,
+  buildPictureMarkup,
+  compileTemplate,
+  textContent,
+  buildSitemap,
+  buildRss,
+  buildContentIndex,
+  deriveFields,
+  analyzeTemplate,
+  outputPathForItem,
+  urlForItem,
+  compileSite,
+  compilePage,
+  buildResolveContext,
+  buildAuthoringReference,
+  renderReferenceMarkdown,
+  validateSite,
+  noopPurgeService,
+  publishSite,
+  InMemoryArtifactSink,
+  hasRole,
+  canEdit
+};