@xtrable-ltd/nanoesis 0.1.9 → 0.1.11

package/dist/{chunk-J6VYOB47.js → chunk-XO3CT6GL.js}

@@ -154,785 +154,1029 @@ 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}`;
+// ../engine/src/html/dom.ts
+import { parse, parseFragment, serialize } from "parse5";
+function isElement(node) {
+  return "tagName" in node;
 }
-function emptyIndex() {
-  return freezeIndex(0, []);
+function isTextNode(node) {
+  return node.nodeName === "#text";
 }
-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();
+function getAttribute(el, name) {
+  return el.attrs.find((attr) => attr.name === name)?.value;
 }
-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 hasAttribute(el, name) {
+  return el.attrs.some((attr) => attr.name === name);
 }
-async function reconcileIndex(store, actualKeys) {
-  const prev = await loadIndex(store);
-  const keys = [...new Set(actualKeys.filter((key) => !key.startsWith(RESERVED_PREFIX)))].sort();
-  const prevKeys = new Set(prev.keys);
-  const nextKeys = new Set(keys);
-  const added = keys.filter((key) => !prevKeys.has(key));
-  const removed = prev.keys.filter((key) => !nextKeys.has(key));
-  if (added.length === 0 && removed.length === 0) return { index: prev, added, removed };
-  return { index: await saveIndex(store, prev, keys), added, removed };
+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 freezeIndex(version, keys) {
-  const sorted = [...new Set(keys)].sort();
-  return { version, keys: sorted, checksum: checksumOf(version, sorted) };
+function removeAttribute(el, name) {
+  el.attrs = el.attrs.filter((attr) => attr.name !== name);
 }
-function serialize(index) {
-  return new TextEncoder().encode(`${JSON.stringify(index, null, 2)}
-`);
+function parseFragmentNodes(html) {
+  return parseFragment(html).childNodes;
 }
-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 isFullDocument(html) {
+  const start = html.trimStart().toLowerCase();
+  return start.startsWith("<!doctype") || start.startsWith("<html");
 }
-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");
+function parseNodes(html) {
+  return isFullDocument(html) ? parse(html).childNodes : parseFragment(html).childNodes;
+}
+function serializeNodes(nodes) {
+  const fragment = parseFragment("");
+  fragment.childNodes = nodes;
+  return serialize(fragment);
 }
 
-// ../engine/src/store/indexed-store.ts
-var IndexedStore = class {
-  constructor(store) {
-    this.store = store;
-  }
-  store;
-  index;
-  loading;
-  /**
-   * Per-instance mutex (DESIGN §11d): every mutation (`write`/`delete`/`rename`/`reconcile`)
-   * runs through {@link serializeMutation}, which chains onto the previous mutation's
-   * completion. Without it, two concurrent mutations both read the cached `this.index`,
-   * each compute their "next" key set from that stale snapshot, and the second
-   * `saveIndex` clobbers the first — the file writes land in blob, but the index keeps
-   * stale references or loses fresh ones (the "I deleted it and it's still there" or
-   * "I added it and it didn't appear" bugs surfaced dogfooding the marketing site,
-   * 2026-05-28). Reads (`list`/`exists`/`readBytes`) are *not* serialised; an
-   * in-flight mutation simply means a reader sees the pre-mutation index, eventually
-   * consistent and safe. Crashes inside `work()` release the lock so a single failure
-   * does not deadlock subsequent operations.
-   */
-  mutationLock = Promise.resolve();
-  /** 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;
-  }
-  serializeMutation(work) {
-    const previous = this.mutationLock;
-    let release;
-    this.mutationLock = new Promise((resolve) => {
-      release = resolve;
-    });
-    return (async () => {
-      try {
-        await previous;
-        return await work();
-      } finally {
-        release();
-      }
-    })();
-  }
-  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`).
-   */
-  write(key, bytes) {
-    return this.serializeMutation(async () => {
-      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.
-   */
-  delete(key) {
-    return this.serializeMutation(async () => {
-      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.)
-   */
-  rename(from, to) {
-    return this.serializeMutation(async () => {
-      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 };
-    });
-  }
-  /**
-   * Rebuild this store's index from the *actual* keys the underlying store holds (DESIGN
-   * §11d), recovering files that arrived by a path that bypassed the index. A
-   * {@link BlobStore} cannot enumerate itself, so the caller supplies the real key set
-   * from an adapter that can (e.g. `BlobContainer.list`). Unlike calling
-   * {@link reconcileIndex} on a fresh store, this also refreshes the cached in-memory
-   * index, so this live instance sees the recovered files immediately.
-   */
-  reconcile(actualKeys) {
-    return this.serializeMutation(async () => {
-      const result = await reconcileIndex(this.store, actualKeys);
-      this.index = result.index;
-      return result;
-    });
-  }
+// ../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 guarded(key) {
-  if (key === "" || key.startsWith(RESERVED_PREFIX)) {
-    throw new Error(`Refusing to mutate a reserved key: ${key === "" ? "(root)" : key}`);
-  }
-  return key;
+function isFieldType(value) {
+  return Object.prototype.hasOwnProperty.call(FIELD_TYPES, value);
 }
-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));
+function valueKindOf(type) {
+  return FIELD_TYPES[type].valueKind;
 }
 
-// ../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;
+// ../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;
   }
-  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;
+  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";
     }
-    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");
+    if (ctx.wholeValue && attr === "src") {
+      if (ctx.tag === "img") return "image";
+      return "file";
     }
-    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;
+    if (ctx.wholeValue && ctx.tag === "source" && attr === "srcset") return "file";
+    if (attr === "alt" || attr === "title") return "shorttext";
+    return "shorttext";
   }
-  return target;
+  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";
 }
-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 });
+
+// ../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 });
   }
-  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 };
+  return out;
 }
-
-// ../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 wholeValueToken(input) {
+  const trimmed = input.trim();
+  const tokens = findTokens(trimmed);
+  if (tokens.length === 1 && tokens[0]?.raw === trimmed) return tokens[0];
+  return null;
 }
-function stripBom(text) {
-  return text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+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 });
+  });
 }
-async function loadContentTree(source, contentDir = DEFAULT_DIRS.content) {
-  return loadDir(source, contentDir, "", "");
+function literalPrefix(input) {
+  const brace = input.indexOf("{");
+  return (brace === -1 ? input : input.slice(0, brace)).toLowerCase();
 }
-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));
+
+// ../engine/src/template/fields.ts
+function lengthConstraints(el) {
+  const min = parseLength(getAttribute(el, "data-minlength"));
+  const max = parseLength(getAttribute(el, "data-maxlength"));
   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 }
+    ...min !== void 0 && { minLength: min },
+    ...max !== void 0 && { maxLength: max }
   };
 }
-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: [] };
-  }
+function parseLength(raw) {
+  if (raw === void 0) return void 0;
+  const value = Number(raw);
+  return Number.isInteger(value) && value >= 0 ? value : void 0;
 }
-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 [];
-  }
+function deriveFields(template, components = /* @__PURE__ */ new Map()) {
+  return deriveFromSource(template, components, /* @__PURE__ */ new Set());
 }
-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 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 recordFreeText = (text) => {
+    const whole = wholeValueToken(text);
+    for (const token of findTokens(text)) {
+      if (token.dotted) continue;
+      record(
+        token.name,
+        inferControl({
+          tag: "",
+          wholeValue: whole?.name === token.name
+        })
+      );
+    }
+  };
+  const visit = (nodes) => {
+    for (const node of nodes) {
+      if (!isElement(node)) {
+        if (isTextNode(node)) recordFreeText(node.value);
+        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 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);
+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/stamp.ts
+function isDestructiveTypeChange(from, to) {
+  if (from === to) return false;
+  const fromKind = valueKindOf(from);
+  const toKind = valueKindOf(to);
+  if (toKind === "html") return false;
+  if (fromKind === "html") return true;
+  if (from === "date" && to === "time" || from === "time" && to === "date") return true;
+  const isFreeText = (t) => t === "shorttext" || t === "text" || t === "code" || t === "email" || t === "phone";
+  if (isFreeText(from) && (to === "date" || to === "time")) return true;
+  if (fromKind === toKind) return false;
+  if (toKind === "text") return false;
+  return true;
+}
+function computeSchemaDelta(oldFields, newFields) {
+  const oldByName = new Map(oldFields.map((f) => [f.name, f]));
+  const newByName = new Map(newFields.map((f) => [f.name, f]));
+  const added = [];
+  const removed = [];
+  const typeChanged = [];
+  for (const [name, oldField] of oldByName) {
+    const newField = newByName.get(name);
+    if (newField === void 0) {
+      removed.push({ name, type: oldField.type });
+    } else if (newField.type !== oldField.type) {
+      typeChanged.push({
+        name,
+        from: oldField.type,
+        to: newField.type,
+        destructive: isDestructiveTypeChange(oldField.type, newField.type)
+      });
     }
   }
-  for (const [slug, node] of map) {
-    if (!used.has(slug)) out.push(node);
+  for (const [name, newField] of newByName) {
+    if (!oldByName.has(name)) added.push({ name, type: newField.type });
   }
-  return out;
+  return {
+    added: added.sort((a, b) => a.name.localeCompare(b.name)),
+    removed: removed.sort((a, b) => a.name.localeCompare(b.name)),
+    typeChanged: typeChanged.sort((a, b) => a.name.localeCompare(b.name))
+  };
 }
-function loadComponents(source, componentsDir = DEFAULT_DIRS.components) {
-  return loadComponentFiles(source, componentsDir, "html");
+function detectStamp(oldSource, newSource, components = /* @__PURE__ */ new Map()) {
+  const oldFields = deriveFields(oldSource, components);
+  const newFields = deriveFields(newSource, components);
+  const delta = computeSchemaDelta(oldFields, newFields);
+  const destructive = delta.removed.length > 0 || delta.typeChanged.some((change) => change.destructive);
+  return {
+    destructive,
+    removedTokens: delta.removed.map((r) => r.name),
+    addedTokens: delta.added.map((a) => a.name),
+    typeChanged: delta.typeChanged
+  };
 }
-function loadComponentStyles(source, componentsDir = DEFAULT_DIRS.components) {
-  return loadComponentFiles(source, componentsDir, "css");
+
+// ../engine/src/template/versions.ts
+var VERSION_PATTERN = /^(.+)@v([1-9]\d*)$/;
+function parseVersionedName(name) {
+  const match = VERSION_PATTERN.exec(name);
+  if (!match) return null;
+  const base = match[1];
+  if (VERSION_PATTERN.test(base)) return null;
+  return { base, version: Number.parseInt(match[2], 10) };
+}
+function isVersionedTemplateName(name) {
+  return parseVersionedName(name) !== null;
+}
+function baseTemplateName(name) {
+  const parsed = parseVersionedName(name);
+  return parsed ? parsed.base : name;
+}
+function versionNumber(name) {
+  const parsed = parseVersionedName(name);
+  return parsed ? parsed.version : null;
+}
+function snapshotName(base, version) {
+  if (!Number.isInteger(version) || version < 1) {
+    throw new Error(`Snapshot version must be a positive integer, got ${version}`);
+  }
+  if (isVersionedTemplateName(base)) {
+    throw new Error(`snapshotName base "${base}" is already versioned`);
+  }
+  return `${base}@v${version}`;
+}
+function nextVersionNumber(existingNames) {
+  let max = 0;
+  for (const name of existingNames) {
+    const n = versionNumber(name);
+    if (n !== null && n > max) max = n;
+  }
+  return max + 1;
+}
+function isReservedVersionedPath(path) {
+  if (!path.endsWith(".html")) return false;
+  if (!(path.startsWith("templates/") || path.startsWith("components/"))) return false;
+  const stem = path.slice(0, -".html".length);
+  const lastSlash = stem.lastIndexOf("/");
+  const baseName = stem.slice(lastSlash + 1);
+  return isVersionedTemplateName(baseName);
 }
-function loadComponentScripts(source, componentsDir = DEFAULT_DIRS.components) {
-  return loadComponentFiles(source, componentsDir, "js");
+
+// ../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}`;
 }
-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));
-      }
+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;
     }
-  };
-  await walk(componentsDir);
-  return map;
+  }
+  return best ?? emptyIndex();
 }
-async function loadTemplate(source, name, templatesDir = DEFAULT_DIRS.templates) {
-  return source.readText(join(templatesDir, `${name}.html`));
+async function saveIndex(store, prev, nextKeys) {
+  await store.put(backupKey(prev.version % BACKUP_RING_SIZE), serialize2(prev));
+  const next = freezeIndex(prev.version + 1, nextKeys);
+  await store.put(INDEX_KEY, serialize2(next));
+  return next;
 }
-function loadTemplateStyle(source, name, templatesDir = DEFAULT_DIRS.templates) {
-  return tryReadText(source, join(templatesDir, `${name}.css`));
+async function reconcileIndex(store, actualKeys) {
+  const prev = await loadIndex(store);
+  const keys = [...new Set(actualKeys.filter((key) => !key.startsWith(RESERVED_PREFIX)))].sort();
+  const prevKeys = new Set(prev.keys);
+  const nextKeys = new Set(keys);
+  const added = keys.filter((key) => !prevKeys.has(key));
+  const removed = prev.keys.filter((key) => !nextKeys.has(key));
+  if (added.length === 0 && removed.length === 0) return { index: prev, added, removed };
+  return { index: await saveIndex(store, prev, keys), added, removed };
 }
-function loadTemplateScript(source, name, templatesDir = DEFAULT_DIRS.templates) {
-  return tryReadText(source, join(templatesDir, `${name}.js`));
+function freezeIndex(version, keys) {
+  const sorted = [...new Set(keys)].sort();
+  return { version, keys: sorted, checksum: checksumOf(version, sorted) };
 }
-var DOCUMENT_SHELL = "document";
-function loadDocumentShell(source, templatesDir = DEFAULT_DIRS.templates) {
-  return tryReadText(source, join(templatesDir, `${DOCUMENT_SHELL}.html`));
+function serialize2(index) {
+  return new TextEncoder().encode(`${JSON.stringify(index, null, 2)}
+`);
 }
-async function tryReadText(source, path) {
+function parseIndex(bytes) {
+  if (bytes === void 0) return void 0;
+  let raw;
   try {
-    return await source.readText(path);
+    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;
 }
-
-// ../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;
+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/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;
+// ../engine/src/store/indexed-store.ts
+var IndexedStore = class {
+  constructor(store) {
+    this.store = store;
   }
-  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";
+  store;
+  index;
+  loading;
+  /**
+   * Per-instance mutex (DESIGN §11d): every mutation (`write`/`delete`/`rename`/`reconcile`)
+   * runs through {@link serializeMutation}, which chains onto the previous mutation's
+   * completion. Without it, two concurrent mutations both read the cached `this.index`,
+   * each compute their "next" key set from that stale snapshot, and the second
+   * `saveIndex` clobbers the first — the file writes land in blob, but the index keeps
+   * stale references or loses fresh ones (the "I deleted it and it's still there" or
+   * "I added it and it didn't appear" bugs surfaced dogfooding the marketing site,
+   * 2026-05-28). Reads (`list`/`exists`/`readBytes`) are *not* serialised; an
+   * in-flight mutation simply means a reader sees the pre-mutation index, eventually
+   * consistent and safe. Crashes inside `work()` release the lock so a single failure
+   * does not deadlock subsequent operations.
+   */
+  mutationLock = Promise.resolve();
+  /** 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;
   }
-  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 });
+  serializeMutation(work) {
+    const previous = this.mutationLock;
+    let release;
+    this.mutationLock = new Promise((resolve) => {
+      release = resolve;
+    });
+    return (async () => {
+      try {
+        await previous;
+        return await work();
+      } finally {
+        release();
+      }
+    })();
   }
-  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;
+  async list(dir) {
+    return childrenOf((await this.loaded()).keys, dir);
   }
-  const scheme = cleaned.toLowerCase();
-  if (scheme.startsWith("javascript:") || scheme.startsWith("vbscript:")) {
-    return "#";
+  async readText(path) {
+    return new TextDecoder().decode(await this.readBytes(path));
   }
-  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 }
+  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`).
+   *
+   * **Auto-stamp** (PROPOSAL §4.1): a destructive write to a template or component
+   * path (one that removes a token from the existing source) snapshots the prior
+   * bytes to `<base>@v<N+1>.html` before the new bytes land. Order is
+   * **current first, snapshot second** (§16.3): if the snapshot copy fails after
+   * the current write succeeded, the site stays consistent — only the migration
+   * UX's left-pane comparison is unavailable for items affected by this stamp,
+   * surfaced as `templates.stamp-incomplete`.
+   *
+   * Direct writes to a reserved-version path are refused (snapshots are
+   * immutable; the user retires them via `delete`, not by overwriting them).
+   */
+  write(key, bytes) {
+    return this.serializeMutation(async () => {
+      const target = guarded(normalize(key));
+      if (isReservedVersionedPath(target)) {
+        throw new Error(
+          `Refusing to write to a reserved-version path: ${target} (snapshots are immutable; retire via delete)`
+        );
+      }
+      const stampCandidate = stampTargetOf(target);
+      const previousBytes = stampCandidate !== void 0 ? await this.store.get(target) : void 0;
+      let stampDecision;
+      let schemaDelta;
+      if (stampCandidate !== void 0 && previousBytes !== void 0) {
+        const oldSource = new TextDecoder().decode(previousBytes);
+        const newSource = new TextDecoder().decode(bytes);
+        const oldFields = deriveFields(oldSource);
+        const newFields = deriveFields(newSource);
+        schemaDelta = computeSchemaDelta(oldFields, newFields);
+        const destructive = schemaDelta.removed.length > 0 || schemaDelta.typeChanged.some((change) => change.destructive);
+        if (destructive) {
+          const index2 = await this.loaded();
+          const siblings = index2.keys.filter((k) => k.startsWith(`${stampCandidate.dir}/`) && k.endsWith(".html")).map((k) => k.slice(stampCandidate.dir.length + 1, -".html".length));
+          const version = nextVersionNumber(siblings);
+          stampDecision = {
+            snapshotPath: `${stampCandidate.dir}/${stampCandidate.name}@v${version}.html`,
+            bytes: previousBytes,
+            version
+          };
+        }
+      }
+      await this.store.put(target, bytes);
+      const index = await this.loaded();
+      let nextIndex = index;
+      if (!nextIndex.keys.includes(target)) {
+        nextIndex = await saveIndex(this.store, nextIndex, [...nextIndex.keys, target]);
+      }
+      let stamped;
+      let stampIncomplete;
+      if (stampDecision !== void 0) {
+        try {
+          await this.store.put(stampDecision.snapshotPath, stampDecision.bytes);
+          if (!nextIndex.keys.includes(stampDecision.snapshotPath)) {
+            nextIndex = await saveIndex(this.store, nextIndex, [
+              ...nextIndex.keys,
+              stampDecision.snapshotPath
+            ]);
+          }
+          stamped = {
+            name: stampCandidate.name,
+            version: stampDecision.version,
+            snapshotPath: stampDecision.snapshotPath
+          };
+        } catch {
+          stampIncomplete = true;
+        }
+      }
+      this.index = nextIndex;
+      return {
+        ...stamped !== void 0 && { stamped },
+        ...stampIncomplete === true && { stampIncomplete: true },
+        ...schemaDelta !== void 0 && { schemaDelta }
+      };
     });
   }
-  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";
+  /**
+   * Manually stamp a snapshot of the current `<kind>/<name>.html` to the next available
+   * `<name>@v<N+1>.html` slot. Uses the same internal `this.store.put` pathway the
+   * auto-stamp uses (so the public `write`'s reserved-version refusal doesn't apply),
+   * and runs under the mutation mutex so a concurrent destructive auto-stamp can't
+   * race with a manual stamp.
+   */
+  stamp(name, kind) {
+    return this.serializeMutation(async () => {
+      if (isVersionedTemplateName(name)) {
+        throw new Error(`stamp: cannot stamp an already-versioned name (${name})`);
+      }
+      const dir = kind === "template" ? "templates" : "components";
+      const currentPath = `${dir}/${name}.html`;
+      const bytes = await this.store.get(currentPath);
+      if (bytes === void 0) {
+        throw new Error(`stamp: ${currentPath} does not exist (nothing to snapshot)`);
+      }
+      const index = await this.loaded();
+      const siblings = index.keys.filter((k) => k.startsWith(`${dir}/`) && k.endsWith(".html")).map((k) => k.slice(dir.length + 1, -".html".length));
+      const version = nextVersionNumber(siblings);
+      const snapshotPath = `${dir}/${name}@v${version}.html`;
+      await this.store.put(snapshotPath, bytes);
+      if (!index.keys.includes(snapshotPath)) {
+        this.index = await saveIndex(this.store, index, [...index.keys, snapshotPath]);
+      } else {
+        this.index = index;
+      }
+      return { name, version, snapshotPath };
+    });
+  }
+  /**
+   * 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.
+   */
+  delete(key) {
+    return this.serializeMutation(async () => {
+      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.)
+   */
+  rename(from, to) {
+    return this.serializeMutation(async () => {
+      const source = guarded(normalize(from));
+      const dest = guarded(normalize(to));
+      if (source === dest) return { ok: true };
+      if (isReservedVersionedPath(source) || isReservedVersionedPath(dest)) {
+        return { ok: false, reason: "reserved-version" };
+      }
+      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 };
+    });
+  }
+  /**
+   * Rebuild this store's index from the *actual* keys the underlying store holds (DESIGN
+   * §11d), recovering files that arrived by a path that bypassed the index. A
+   * {@link BlobStore} cannot enumerate itself, so the caller supplies the real key set
+   * from an adapter that can (e.g. `BlobContainer.list`). Unlike calling
+   * {@link reconcileIndex} on a fresh store, this also refreshes the cached in-memory
+   * index, so this live instance sees the recovered files immediately.
+   */
+  reconcile(actualKeys) {
+    return this.serializeMutation(async () => {
+      const result = await reconcileIndex(this.store, actualKeys);
+      this.index = result.index;
+      return result;
+    });
+  }
+};
+function stampTargetOf(target) {
+  if (!target.endsWith(".html")) return void 0;
+  const dir = target.startsWith("templates/") ? "templates" : target.startsWith("components/") ? "components" : void 0;
+  if (dir === void 0) return void 0;
+  const stem = target.slice(dir.length + 1, -".html".length);
+  if (stem === "" || stem.includes("@v")) return void 0;
+  return { dir, name: stem };
 }
-function getAttribute(el, name) {
-  return el.attrs.find((attr) => attr.name === name)?.value;
+function guarded(key) {
+  if (key === "" || key.startsWith(RESERVED_PREFIX)) {
+    throw new Error(`Refusing to mutate a reserved key: ${key === "" ? "(root)" : key}`);
+  }
+  return key;
 }
-function hasAttribute(el, name) {
-  return el.attrs.some((attr) => attr.name === name);
+function normalize(path) {
+  return path.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "").replace(/\/+$/, "");
 }
-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 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 })).sort((a, b) => a.name.localeCompare(b.name));
 }
-function removeAttribute(el, name) {
-  el.attrs = el.attrs.filter((attr) => attr.name !== name);
+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));
 }
-function parseFragmentNodes(html) {
-  return parseFragment(html).childNodes;
+
+// ../engine/src/content/source.ts
+function normalizePath(path) {
+  return path.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "").replace(/\/+$/, "");
 }
-function isFullDocument(html) {
-  const start = html.trimStart().toLowerCase();
-  return start.startsWith("<!doctype") || start.startsWith("<html");
+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 })).sort((a, b) => a.name.localeCompare(b.name));
+  }
+};
+
+// ../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 parseNodes(html) {
-  return isFullDocument(html) ? parse(html).childNodes : parseFragment(html).childNodes;
+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 serializeNodes(nodes) {
-  const fragment = parseFragment("");
-  fragment.childNodes = nodes;
-  return serialize2(fragment);
+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/media/media.ts
-var DEFAULT_WIDTHS = [400, 800, 1200, 1600];
-var MIME = {
-  avif: "image/avif",
-  webp: "image/webp",
-  jpeg: "image/jpeg",
-  png: "image/png"
+// ../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 extOf(format) {
-  return format === "jpeg" ? "jpg" : format;
+function join(...parts) {
+  return parts.filter((part) => part !== "").join("/");
 }
-function fallbackFormatFor(assetPath) {
-  const ext = assetPath.slice(assetPath.lastIndexOf(".") + 1).toLowerCase();
-  if (ext === "png") return "png";
-  if (ext === "webp") return "webp";
-  return "jpeg";
+function stripBom(text) {
+  return text.charCodeAt(0) === 65279 ? text.slice(1) : text;
 }
-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 loadContentTree(source, contentDir = DEFAULT_DIRS.content) {
+  return loadDir(source, contentDir, "", "");
 }
-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}`;
+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 }
   };
-  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);
+}
+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}`);
   }
-  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 }
+}
+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));
+      }
+    }
   };
-  return { artifacts, info };
+  await walk(componentsDir);
+  return map;
 }
-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>`;
+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/url/references.ts
@@ -956,35 +1200,418 @@ function collectHtmlReferences(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 }
+// ../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);
+        continue;
+      }
+      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()
   };
-  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();
+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/migrations/migrations.ts
+async function pendingMigrations(store) {
+  const components = await loadComponents(store).catch(() => /* @__PURE__ */ new Map());
+  const items = await collectItems(store);
+  const templateFieldsCache = /* @__PURE__ */ new Map();
+  const requiredFieldsCache = /* @__PURE__ */ new Map();
+  const snapshotFieldsCache = /* @__PURE__ */ new Map();
+  const fieldsFor = async (templateName) => {
+    const cached = templateFieldsCache.get(templateName);
+    if (cached !== void 0) return cached;
+    const html = await readTemplateOrNull(store, templateName);
+    const fields = new Set(html === null ? [] : deriveFields(html, components).map((f) => f.name));
+    templateFieldsCache.set(templateName, fields);
+    return fields;
+  };
+  const requiredFor = async (templateName) => {
+    const cached = requiredFieldsCache.get(templateName);
+    if (cached !== void 0) return cached;
+    const html = await readTemplateOrNull(store, templateName);
+    let required = [];
+    if (html !== null) {
+      try {
+        required = analyzeTemplate(html, components).requiredFields;
+      } catch {
+        required = [];
+      }
+    }
+    requiredFieldsCache.set(templateName, required);
+    return required;
+  };
+  const out = [];
+  const byTemplate = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const expected = await fieldsFor(item.template);
+    const itemFieldNames = Object.keys(item.fields);
+    const orphans = itemFieldNames.filter((name) => !expected.has(name));
+    const required = await requiredFor(item.template);
+    const missing = required.filter((name) => {
+      const value = item.fields[name];
+      return value === void 0 || value === null || value === "";
+    });
+    if (orphans.length === 0 && missing.length === 0) continue;
+    const base = baseTemplateName(item.template);
+    const bestFit = isVersionedTemplateName(item.template) ? null : await pickBestFitSnapshot(store, base, itemFieldNames, snapshotFieldsCache, components);
+    const finding2 = {
+      path: item.path,
+      boundTemplate: item.template,
+      currentTemplate: base,
+      orphanFields: orphans.sort(),
+      missingRequiredFields: [...missing].sort(),
+      bestFitSnapshot: bestFit
+    };
+    out.push(finding2);
+    const bucket = byTemplate.get(base);
+    if (bucket === void 0) byTemplate.set(base, [finding2]);
+    else bucket.push(finding2);
+  }
+  return { items: out, byTemplate };
+}
+async function bestFitSnapshot(store, base, itemFieldNames) {
+  const components = await loadComponents(store).catch(() => /* @__PURE__ */ new Map());
+  return pickBestFitSnapshot(store, base, itemFieldNames, /* @__PURE__ */ new Map(), components);
+}
+async function applyMigration(store, itemPath, resolution) {
+  const text = await store.readText(itemPath);
+  const raw = JSON.parse(text);
+  if (typeof raw !== "object" || raw === null) {
+    throw new Error(`applyMigration: ${itemPath} is not a JSON object`);
+  }
+  const obj = raw;
+  const fields = typeof obj["fields"] === "object" && obj["fields"] !== null ? { ...obj["fields"] } : {};
+  for (const [from, to] of Object.entries(resolution.rename)) {
+    if (Object.prototype.hasOwnProperty.call(fields, from)) {
+      fields[to] = fields[from];
+      delete fields[from];
+    }
+  }
+  for (const name of resolution.drop) delete fields[name];
+  for (const [name, value] of Object.entries(resolution.fill)) {
+    if (value !== "") fields[name] = value;
+  }
+  obj["fields"] = Object.fromEntries(Object.entries(fields).sort(([a], [b]) => a.localeCompare(b)));
+  await store.write(itemPath, new TextEncoder().encode(`${JSON.stringify(obj, null, 2)}
+`));
+}
+async function collectItems(store, dir = "content") {
+  const out = [];
+  let entries;
+  try {
+    entries = await store.list(dir);
+  } catch {
+    return out;
+  }
+  for (const entry of entries) {
+    const path = dir === "" ? entry.name : `${dir}/${entry.name}`;
+    if (entry.kind === "dir") {
+      out.push(...await collectItems(store, path));
+      continue;
+    }
+    if (!entry.name.endsWith(".json") || entry.name.startsWith("_")) continue;
+    let data;
+    try {
+      data = JSON.parse(await store.readText(path));
+    } catch {
+      continue;
+    }
+    if (typeof data !== "object" || data === null) continue;
+    const obj = data;
+    const template = obj["template"];
+    if (typeof template !== "string") continue;
+    const fields = obj["fields"];
+    out.push({
+      path,
+      template,
+      fields: typeof fields === "object" && fields !== null ? fields : {}
+    });
+  }
+  return out;
+}
+async function readTemplateOrNull(store, templateName) {
+  try {
+    return await store.readText(`templates/${templateName}.html`);
+  } catch {
+    return null;
+  }
+}
+async function pickBestFitSnapshot(store, base, itemFieldNames, cache, components) {
+  let entries;
+  try {
+    entries = await store.list("templates");
+  } catch {
+    return null;
+  }
+  const itemSet = new Set(itemFieldNames);
+  let bestVersion = 0;
+  let bestName = null;
+  for (const entry of entries) {
+    if (entry.kind !== "file" || !entry.name.endsWith(".html")) continue;
+    const stem = entry.name.slice(0, -".html".length);
+    if (baseTemplateName(stem) !== base || !isVersionedTemplateName(stem)) continue;
+    const version = versionNumber(stem);
+    if (version === null) continue;
+    let tokens = cache.get(stem);
+    if (tokens === void 0) {
+      try {
+        const html = await store.readText(`templates/${entry.name}`);
+        tokens = new Set(deriveFields(html, components).map((f) => f.name));
+      } catch {
+        tokens = /* @__PURE__ */ new Set();
+      }
+      cache.set(stem, tokens);
+    }
+    const covers = [...itemSet].every((name) => tokens.has(name));
+    if (covers && version > bestVersion) {
+      bestVersion = version;
+      bestName = stem;
+    }
+  }
+  return bestName;
+}
+
+// ../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/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/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();
@@ -1159,446 +1786,204 @@ function cloneNode(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()
-  };
+      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 richTextFieldName(el) {
+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 void 0;
+  if (meaningful.length !== 1 || only === void 0 || !isTextNode(only)) return null;
   const token = wholeValueToken(only.value);
-  if (token === null || token.dotted) return void 0;
-  const annotation = getAttribute(el, "data-type");
+  if (token === null || token.dotted) return null;
   const type = inferControl({
     tag: el.tagName,
     wholeValue: true,
     ...annotation !== void 0 && { annotation }
   });
-  return valueKindOf(type) === "html" ? token.name : void 0;
+  return { token, kind: valueKindOf(type) };
 }
-function annotatedFieldName(el) {
-  const explicit = getAttribute(el, "data-field");
-  if (explicit !== void 0) return explicit;
+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) {
-    const token = findTokens(attr.value).find((candidate) => !candidate.dotted);
-    if (token !== void 0) return token.name;
+    propScope[attr.name] = substituteTokens(attr.value, resolve);
   }
-  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;
+  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 void 0;
+  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/url/urls.ts
@@ -2036,7 +2421,8 @@ function buildAuthoringReference(context = {}) {
       annotationsSection(),
       loopsSection(context),
       componentsSection(context),
-      shellSection()
+      shellSection(),
+      guardrailsSection()
     ]
   };
 }
@@ -2181,6 +2567,41 @@ function componentsSection(context) {
     entries
   };
 }
+function guardrailsSection() {
+  return {
+    title: "Authoring guardrails for LLMs",
+    intro: "Common pitfalls when authoring through MCP, where you can't see the editor form's shape change. Most stem from the same root: data-* annotations bind to the element they sit on, not to the token inside it.",
+    entries: [
+      {
+        name: "data-* annotations are element-bound",
+        summary: "data-type, data-required, data-field, data-minlength, and data-maxlength apply to the *element* that carries them \u2014 moving a token outside its annotated container silently strips those properties from the schema.",
+        detail: 'Example: `<div data-type="richtext">{body}</div>` makes body a rich-text field. If you change it to `<div data-type="richtext"></div>{body}`, body drops back to plain shorttext. The compiler still substitutes the token at fragment root, but existing HTML content for body now renders escaped.',
+        example: '<!-- WRONG (drops the annotation) -->\n<div data-type="richtext"></div>{body}\n\n<!-- RIGHT -->\n<div data-type="richtext">{body}</div>'
+      },
+      {
+        name: "After write_file on a template, check `schemaDelta`",
+        summary: "Every write to templates/*.html or components/*.html returns a `schemaDelta` describing added/removed/typeChanged fields. If `typeChanged` contains `destructive: true` entries or `removed` is non-empty, an auto-stamp has been written and authored content may need migration \u2014 surface to the user before further edits.",
+        detail: "`schemaDelta` shape: `{added: [{name, type}], removed: [{name, type}], typeChanged: [{name, from, to, destructive}]}`. Empty arrays everywhere means the edit changed only whitespace, comments, or non-token markup \u2014 safe."
+      },
+      {
+        name: "After rename_path on a template, search content for the old name",
+        summary: 'Renaming `templates/article.html` to `templates/post.html` leaves every content item with `template: "article"` bound to a now-missing template. The validation gate will report these on publish, but the cheaper check is `list_pending_migrations` followed by editing the items\' `template` fields.'
+      },
+      {
+        name: "After delete_path on a template, expect publish-blocking errors",
+        summary: "Deleting a template that any item binds to will fail validation with `template-missing` per item. Use `list_pending_migrations` first to see who would be affected, and consider whether to rename items to a different template before deleting."
+      },
+      {
+        name: "Read describe_template before editing a content item",
+        summary: "A content item's `fields` object MUST match the bound template's schema (field names and value shapes). `describe_template` returns the field list with types so you build the right shape on the first try; mismatched keys become orphan fields the gate warns about."
+      },
+      {
+        name: "richtext values are HTML, shorttext/text are plain text",
+        summary: "For a `richtext` field, write the value as HTML (`<p>...</p>` etc). For `shorttext` or `text`, write plain text \u2014 any HTML you include is escaped at render time. If the gate emits a `content.type-drift` warning, a field's type changed destructively (commonly richtext \u2192 shorttext) and the old HTML content now renders as escaped text."
+      }
+    ]
+  };
+}
 function shellSection() {
   return {
     title: "The document shell",
@@ -2269,18 +2690,91 @@ async function validateSite(source) {
     }
   };
   const analysisCache = /* @__PURE__ */ new Map();
+  const sourceCache = /* @__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);
+      const html = await loadTemplate(source, name);
+      sourceCache.set(name, html);
+      result = analyzeTemplate(html, components);
     } catch {
       result = null;
     }
     analysisCache.set(name, result);
     return result;
   };
+  const expectedFieldsCache = /* @__PURE__ */ new Map();
+  const expectedFieldsFor = (templateName) => {
+    const cached = expectedFieldsCache.get(templateName);
+    if (cached !== void 0) return cached;
+    const html = sourceCache.get(templateName);
+    const fields = new Set(
+      html !== void 0 ? deriveFields(html, components).map((f) => f.name) : []
+    );
+    expectedFieldsCache.set(templateName, fields);
+    return fields;
+  };
+  const driftFieldsCache = /* @__PURE__ */ new Map();
+  const driftFieldsFor = async (templateName) => {
+    if (driftFieldsCache.has(templateName)) return driftFieldsCache.get(templateName) ?? null;
+    const highest = await highestSnapshotName(templateName);
+    if (highest === null) {
+      driftFieldsCache.set(templateName, null);
+      return null;
+    }
+    let snapshotHtml;
+    try {
+      snapshotHtml = await loadTemplate(source, highest);
+    } catch {
+      driftFieldsCache.set(templateName, null);
+      return null;
+    }
+    const currentHtml = sourceCache.get(templateName);
+    if (currentHtml === void 0) {
+      driftFieldsCache.set(templateName, null);
+      return null;
+    }
+    const delta = computeSchemaDelta(
+      deriveFields(snapshotHtml, components),
+      deriveFields(currentHtml, components)
+    );
+    const destructive = new Set(
+      delta.typeChanged.filter((change) => change.destructive).map((change) => change.name)
+    );
+    driftFieldsCache.set(templateName, destructive);
+    return destructive;
+  };
+  const snapshotNameCache = /* @__PURE__ */ new Map();
+  const highestSnapshotName = async (baseName) => {
+    if (snapshotNameCache.has(baseName)) return snapshotNameCache.get(baseName) ?? null;
+    const slash = baseName.lastIndexOf("/");
+    const dir = slash === -1 ? "templates" : `templates/${baseName.slice(0, slash)}`;
+    const stem = slash === -1 ? baseName : baseName.slice(slash + 1);
+    let entries;
+    try {
+      entries = await source.list(dir);
+    } catch {
+      snapshotNameCache.set(baseName, null);
+      return null;
+    }
+    let highest = 0;
+    let highestStem = null;
+    const prefix = `${stem}@v`;
+    for (const entry of entries) {
+      if (entry.kind !== "file" || !entry.name.endsWith(".html")) continue;
+      const entryStem = entry.name.slice(0, -".html".length);
+      if (!entryStem.startsWith(prefix)) continue;
+      const version = versionNumber(entryStem);
+      if (version !== null && version > highest) {
+        highest = version;
+        highestStem = slash === -1 ? entryStem : `${baseName.slice(0, slash)}/${entryStem}`;
+      }
+    }
+    snapshotNameCache.set(baseName, highestStem);
+    return highestStem;
+  };
   const urlOwners = /* @__PURE__ */ new Map();
   for (const { node, templateName } of published) {
     const owners = urlOwners.get(urlForItem(node.path)) ?? [];
@@ -2297,14 +2791,40 @@ async function validateSite(source) {
     }
     const analysis = await analyze(templateName);
     if (analysis === null) {
+      const snapshotHint = isVersionedTemplateName(templateName) ? ` (the snapshot may have been deleted while this item still pins to it \u2014 restore it, rebind the item to current via the Migrations workspace, or delete this item).` : "";
       add(
         "error",
         "template-missing",
-        `"${node.path}" uses template "${templateName}", which does not exist.`,
+        `"${node.path}" uses template "${templateName}", which does not exist.${snapshotHint}`,
         node.path
       );
       continue;
     }
+    if (!isVersionedTemplateName(templateName)) {
+      const expectedFields = expectedFieldsFor(templateName);
+      const itemFieldNames = Object.keys(node.item.fields);
+      const orphans = itemFieldNames.filter((name) => !expectedFields.has(name));
+      if (orphans.length > 0) {
+        add(
+          "warning",
+          "content.schema-drift",
+          `"${node.path}" has field${orphans.length === 1 ? "" : "s"} not rendered by template "${templateName}": ${orphans.map((o) => `"${o}"`).join(", ")}. Open the Migrations workspace to drop, rename, or keep them.`,
+          node.path
+        );
+      }
+      const driftFields = await driftFieldsFor(templateName);
+      if (driftFields !== null && driftFields.size > 0) {
+        const affected = itemFieldNames.filter((name) => driftFields.has(name));
+        if (affected.length > 0) {
+          add(
+            "warning",
+            "content.type-drift",
+            `"${node.path}" has field${affected.length === 1 ? "" : "s"} whose type changed destructively in template "${templateName}": ${affected.map((f) => `"${f}"`).join(", ")}. The value will render under the new type (commonly HTML escaped as text). Open the Migrations workspace to migrate.`,
+            node.path
+          );
+        }
+      }
+    }
     const scope = buildScope2(node.item);
     for (const field of analysis.requiredFields) {
       if (isEmpty(scope[field])) {
@@ -2590,10 +3110,10 @@ function createDiagnosticRegistry() {
       repairs.set(repair.id, repair);
     },
     runAll,
-    async runRepair(id, deps) {
+    async runRepair(id, deps, args = {}) {
       const repair = repairs.get(id);
       if (repair === void 0) throw new Error(`Unknown repair id: ${id}`);
-      await repair.run(deps);
+      await repair.run(deps, args);
       return runAll(deps);
     }
   };
@@ -2733,6 +3253,22 @@ export {
   parseContentItem,
   parseSortFile,
   InMemoryBlobStore,
+  FIELD_TYPES,
+  isFieldType,
+  valueKindOf,
+  inferControl,
+  findTokens,
+  wholeValueToken,
+  deriveFields,
+  isDestructiveTypeChange,
+  computeSchemaDelta,
+  detectStamp,
+  isVersionedTemplateName,
+  baseTemplateName,
+  versionNumber,
+  snapshotName,
+  nextVersionNumber,
+  isReservedVersionedPath,
   RESERVED_PREFIX,
   emptyIndex,
   loadIndex,
@@ -2752,12 +3288,10 @@ export {
   loadTemplate,
   DOCUMENT_SHELL,
   loadDocumentShell,
-  FIELD_TYPES,
-  isFieldType,
-  valueKindOf,
-  inferControl,
-  findTokens,
-  wholeValueToken,
+  analyzeTemplate,
+  pendingMigrations,
+  bestFitSnapshot,
+  applyMigration,
   escapeHtmlText,
   escapeHtmlAttribute,
   escapeJsonStringContent,
@@ -2773,8 +3307,6 @@ export {
   buildSitemap,
   buildRss,
   buildContentIndex,
-  deriveFields,
-  analyzeTemplate,
   outputPathForItem,
   urlForItem,
   compileSite,